哈喽比特
注册  |  登录
0
0

Kotlin Coroutine suspend 原理解析

发表于 3年以前  | 总阅读数：253 次

一. 回调地狱

1.1 同步操作

假如我们有这样一个需求:

fun childFun1(): Int {
    return 10
}

fun childFun2(): Int {
    return 20
}

fun childFun3(num1: Int, num2: Int): Int {
    return num1 + num2
}

fun parentFun() : Int {
    val num1 = childFun1()
    val num2 = childFun2()
    val sum = childFun3(num1, num2)
    return sum
}

即: 从多个操作中(childFun1, childFun2) 获取值，然后再对这些值进行处理(childFun3)，程序逻辑非常直观易懂。

例如，先上传用户选择的图片到服务端储存，获取服务端返回的图片对应的地址，然后这些地址设置到对应位置。

1.2 异步操作

如果这些操作都是耗时操作，为了不阻塞线程，需要将这些耗时操作放到其他线程中，即

val executor: ExecutorService = Executors.newFixedThreadPool(2)

fun childFun1(callback: (Int) -> Unit): Unit {
    executor.execute {
        Thread.sleep(1000)
        callback(10)
    }
}

fun childFun2(callback: (Int) -> Unit): Unit {
    executor.execute {
        Thread.sleep(2000)
        callback(20)
    }
}

fun childFun3(num1: Int, num2: Int, callback: (Int) -> Unit): Unit {
    executor.execute {
        Thread.sleep(500)
        callback(num1 + num2)
    }
}

fun parentFun(callback: (Int) -> Unit) : Unit {
    childFun1(fun(num1) {
        childFun2(fun(num2) {
            childFun3(num1, num2, callback)
        })
    })
}

因为是异步操作，结果值不能直接返回，只能通过 callback 方式异步回传，所以当异步操作很多的时候，整个回调链就很长了，让代码逻辑显得不清晰。

1.3 协程

suspend fun childFun1(): Int {
    delay(1000)
    return 10
}

suspend fun childFun2(): Int {
    delay(2000)
    return 20
}

suspend fun childFun3(num1: Int, num2: Int): Int {
    delay(500)
    return num1 + num2
}

suspend fun parentFun() : Int {
    val num1 = childFun1()
    val num2 = childFun2()
    val sum = childFun3(num1, num2)
    return sum
}

我们可以看到和同步方式操作一模一样，只不过方法上多了 suspend 关键字而已。

注: 这里的 delay 方法，不会像 Thread.sleep 阻塞当前线程。

二. suspend 原理

上面说过，suspend 不会阻塞当前线程，那么它怎么将异步操作的数据，同步传递回来呢？答案其实也是回调，只不过隐藏的很深，我们慢慢分析。

suspend fun childFun1(): Int {
    Thread.sleep(1000)
    return 10
}

suspend fun childFun2(): Int {
    Thread.sleep(2000)
    return 20
}

suspend fun childFun3(num1: Int, num2: Int): Int {
    Thread.sleep(500)
    return num1 + num2
}

suspend fun parentFun() : Int {
    val num1 = childFun1()
    val num2 = childFun2()
    val sum = childFun3(num1, num2)
    return sum
}

这里将 delay 换成 Thread.sleep ,先看 suspend 反编译的 java 代码

public final class CoroutineKt {
   @Nullable
   public static final Object childFun1(@NotNull Continuation $completion) {
      Thread.sleep(1000L);
      return Boxing.boxInt(10);
   }

   @Nullable
   public static final Object childFun2(@NotNull Continuation $completion) {
      Thread.sleep(2000L);
      return Boxing.boxInt(20);
   }

   @Nullable
   public static final Object childFun3(int num1, int num2, @NotNull Continuation $completion) {
      Thread.sleep(500L);
      return Boxing.boxInt(num1 + num2);
   }

   @Nullable
   public static final Object parentFun(@NotNull Continuation $completion) {
      Object $continuation;
      label37: {
         if ($completion instanceof <undefinedtype>) {
            $continuation = (<undefinedtype>)$completion;
            if ((((<undefinedtype>)$continuation).label & Integer.MIN_VALUE) != 0) {
               ((<undefinedtype>)$continuation).label -= Integer.MIN_VALUE;
               break label37;
            }
         }

         $continuation = new ContinuationImpl($completion) {
            // $FF: synthetic field
            Object result;
            int label;
            int I$0;
            int I$1;

            @Nullable
            public final Object invokeSuspend(@NotNull Object $result) {
               this.result = $result;
               this.label |= Integer.MIN_VALUE;
               return CoroutineKt.parentFun(this);
            }
         };
      }

      Object var10000;
      label31: {
         int num1;
         int num2;
         Object var6;
         label30: {
            Object $result = ((<undefinedtype>)$continuation).result;
            var6 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
            switch(((<undefinedtype>)$continuation).label) {
            case 0:
               ResultKt.throwOnFailure($result);
               ((<undefinedtype>)$continuation).label = 1;
               var10000 = childFun1((Continuation)$continuation);
               if (var10000 == var6) {
                  return var6;
               }
               break;
            case 1:
               ResultKt.throwOnFailure($result);
               var10000 = $result;
               break;
            case 2:
               num1 = ((<undefinedtype>)$continuation).I$0;
               ResultKt.throwOnFailure($result);
               var10000 = $result;
               break label30;
            case 3:
               num2 = ((<undefinedtype>)$continuation).I$1;
               num1 = ((<undefinedtype>)$continuation).I$0;
               ResultKt.throwOnFailure($result);
               var10000 = $result;
               break label31;
            default:
               throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
            }

            num1 = ((Number)var10000).intValue();
            ((<undefinedtype>)$continuation).I$0 = num1;
            ((<undefinedtype>)$continuation).label = 2;
            var10000 = childFun2((Continuation)$continuation);
            if (var10000 == var6) {
               return var6;
            }
         }

         num2 = ((Number)var10000).intValue();
         ((<undefinedtype>)$continuation).I$0 = num1;
         ((<undefinedtype>)$continuation).I$1 = num2;
         ((<undefinedtype>)$continuation).label = 3;
         var10000 = childFun3(num1, num2, (Continuation)$continuation);
         if (var10000 == var6) {
            return var6;
         }
      }

      int sum = ((Number)var10000).intValue();
      return Boxing.boxInt(sum);
   }
}

2.1 Continuation

我们注意到 suspend 修饰的方法，转成 java 方法时，会在方法最后面添加上 Continuation 类型的参数：

suspend fun childFun3(num1: Int, num2: Int): Int {
    Thread.sleep(500)
    return num1 + num2
}
//  变成了
@Nullable
public static final Object childFun3(int num1, int num2, @NotNull Continuation $completion) {
      Thread.sleep(500L);
      return Boxing.boxInt(num1 + num2);
}

这个 Continuation 实例非常重要，它是协程能够实现异步回调的关键对象。

/**
 * Interface representing a continuation after a suspension point that returns a value of type `T`.
 */
@SinceKotlin("1.3")
public interface Continuation<in T> {
    /**
     * The context of the coroutine that corresponds to this continuation.
     */
    public val context: CoroutineContext

    /**
     * Resumes the execution of the corresponding coroutine passing a successful or failed [result] as the
     * return value of the last suspension point.
     */
    public fun resumeWith(result: Result<T>)
}
  • context : 协程的上下文对象，里面储存着协程上下文环境信息，比如父协程，线程协调器等
  • resumeWith 方法: 唤醒协程继续执行的方法

注: 这里的唤醒，并不是说协程被线程阻塞了

2.2 协程体

观察 childFun1 、 childFun2 和 childFun3 方法，除了参数上多了一个 $completion 参数，并没有其他变化，那是因为这三个方法中，没有调用其他 suspend 方法，所以和普通函数没有多大区别。

suspend fun parentFun() : Int {
    val num1 = childFun1()
    val num2 = childFun2()
    val sum = childFun3(num1, num2)
    return sum
}

// 转变成了

 @Nullable
   public static final Object parentFun(@NotNull Continuation $completion) {
      Object $continuation;
      label37: {
         if ($completion instanceof <undefinedtype>) {
            $continuation = (<undefinedtype>)$completion;
            if ((((<undefinedtype>)$continuation).label & Integer.MIN_VALUE) != 0) {
               ((<undefinedtype>)$continuation).label -= Integer.MIN_VALUE;
               break label37;
            }
         }

         $continuation = new ContinuationImpl($completion) {
            // $FF: synthetic field
            Object result;
            int label;
            int I$0;
            int I$1;

            @Nullable
            public final Object invokeSuspend(@NotNull Object $result) {
               this.result = $result;
               this.label |= Integer.MIN_VALUE;
               return CoroutineKt.parentFun(this);
            }
         };
      }

      Object var10000;
      label31: {
         int num1;
         int num2;
         Object var6;
         label30: {
            Object $result = ((<undefinedtype>)$continuation).result;
            var6 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
            switch(((<undefinedtype>)$continuation).label) {
            case 0:
               ResultKt.throwOnFailure($result);
               ((<undefinedtype>)$continuation).label = 1;
               var10000 = childFun1((Continuation)$continuation);
               if (var10000 == var6) {
                  return var6;
               }
               break;
            case 1:
               ResultKt.throwOnFailure($result);
               var10000 = $result;
               break;
            case 2:
               num1 = ((<undefinedtype>)$continuation).I$0;
               ResultKt.throwOnFailure($result);
               var10000 = $result;
               break label30;
            case 3:
               num2 = ((<undefinedtype>)$continuation).I$1;
               num1 = ((<undefinedtype>)$continuation).I$0;
               ResultKt.throwOnFailure($result);
               var10000 = $result;
               break label31;
            default:
               throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
            }

            num1 = ((Number)var10000).intValue();
            ((<undefinedtype>)$continuation).I$0 = num1;
            ((<undefinedtype>)$continuation).label = 2;
            var10000 = childFun2((Continuation)$continuation);
            if (var10000 == var6) {
               return var6;
            }
         }

         num2 = ((Number)var10000).intValue();
         ((<undefinedtype>)$continuation).I$0 = num1;
         ((<undefinedtype>)$continuation).I$1 = num2;
         ((<undefinedtype>)$continuation).label = 3;
         var10000 = childFun3(num1, num2, (Continuation)$continuation);
         if (var10000 == var6) {
            return var6;
         }
      }

      int sum = ((Number)var10000).intValue();
      return Boxing.boxInt(sum);
   }

我们发现 parentFun 方法转成的 java 代码，比我们想象中的要多，这个就是协程实现的秘密。

方法流程分析:

  1. 创建 completion 实例，作用是当本协程体(parentFun 方法) 执行完毕之后，会回调 $completion 实例的 resumeWith 方法，唤醒调用方的协程。

注: 当调用 $continuation 对象的 resumeWith 方法会调用 invokeSuspend 方法，就会再次调用 parentFun 方法。

2 . 当 label 不同的时候，执行的逻辑不同: 1 . 当 label = 0 时，先将 label 设置成 1 ，并调用 childFun1 方法，参数就是当前协程体 continuation 的 resumeWith 方法回调来的，得到 childFun1 方法异步结果值。我们的例子中，不会走到这一步，因为我们直接返回了结果值。3 . 当 label = 2 时, 同上，是 childFun2 方法内部通过 $continuation 的 resumeWith 方法回调来的，得到 childFun2 方法异步结果值。4 . 当 label = 3 时, 同上原理。

即: label = 1 表示调用了 childFun1 方法；label = 2 表示调用了 childFun2 方法；label = 3 表示调用了 childFun3 方法。并等待 resumeWith 回调带来的结果值。

这种实现方式，我们称之为状态机。

2.3 协程函数的原理

通过上面的分析，我们了解到协程是如何实现挂起和恢复的。

不同于线程的阻塞和唤醒，协程的挂起是方法直接返回，不执行接下来的代码，它的恢复是通过被调用放来实现的。以上面的例子为例：

  1. parentFun 方法先调用了 childFun1 协程方法，并将自己的协程体 $continuation 传递给 childFun1 方法
  2. 如果 childFun1 方法返回值是 COROUTINE_SUSPENDED ，那么 parentFun 方法直接退出，不会执行 childFun2 方法；直到 childFun1 方法调用 $continuation 的 resumeWith 方法，就会重新调用 parentFun 方法，并因为 label = 1，直接获取结果值，再调用 childFun2 方法。
  3. 如果 childFun1 方法返回值不是 COROUTINE_SUSPENDED，即不需要挂起，那么就继续调用 childFun2 方法。
  4. childFun2 和 childFun3 方法调用过程和 childFun1 方法逻辑一样。

因此我们可以总结:

  1. 当在协程函数内部调用其他协程函数时，都会生成一个挂起点，即这里的 childFun1 childFun2 和 childFun3 ,都对应一个 label 。
  2. 调用其他协程函数的时候，都会将本协程函数的协程体 $continuation 传递给被调用的协程函数，以便被调用的协程函数可以回调恢复本协程函数。
  3. 当被调用的协程函数返回 COROUTINE_SUSPENDED，即表明被调用的协程函数是一个异步操作，希望本协程函数挂起，等待被调用的协程函数执行完成回调它。本协程函数就会从这个挂起点直接返回，不再执行下面的代码，直到被调用的协程函数通过 $continuation 的 resumeWith 方法来恢复本协程函数，并继续执行下面代码，直到遇到下一个挂起点。

本质上协程也是通过回调实现异步操作的，只不过 kotlin 编译器将协程函数变成状态机。也明白了为什么 suspend 函数为什么只能在 suspend 函数内部调用，而不能在普通函数内部执行，因为没有隐藏的 $continuation 对象。

三. 创建协程

上面分析了 suspend 函数，但是现在这个函数，没办法执行，因为 suspend 函数都需要 Continuation 实例，那么第一个 Continuation 实例该如何创建呢？

kotlin 标准库中提供了两个函数来创建 Continuation 实例

3.1 createCoroutine 方法

@SinceKotlin("1.3")
@Suppress("UNCHECKED_CAST")
public fun <T> (suspend () -> T).createCoroutine(
    completion: Continuation<T>
): Continuation<Unit> =
    SafeContinuation(createCoroutineUnintercepted(completion).intercepted(), COROUTINE_SUSPENDED)

@SinceKotlin("1.3")
@Suppress("UNCHECKED_CAST")
public fun <R, T> (suspend R.() -> T).createCoroutine(
    receiver: R,
    completion: Continuation<T>
): Continuation<Unit> =
    SafeContinuation(createCoroutineUnintercepted(receiver, completion).intercepted(), COROUTINE_SUSPENDED)

通过 suspend 函数去创建 Continuation 对象，返回 SafeContinuation 类的实例，这个类以后我们有机会分析。completion 当协程完成之后，会调用它的 resumeWith 方法。

例如:

fun main() {
    val coroutine = (::parentFun).createCoroutine(object : Continuation<Int>{
        override val context: CoroutineContext
            get() = EmptyCoroutineContext

        override fun resumeWith(result: Result<Int>) {
            println("result:$result")
        }
    })
    // 执行
    coroutine.resume(Unit)
}

3.2 startCoroutine 方法

@SinceKotlin("1.3")
@Suppress("UNCHECKED_CAST")
public fun <T> (suspend () -> T).startCoroutine(
    completion: Continuation<T>
) {
    createCoroutineUnintercepted(completion).intercepted().resume(Unit)
}

@SinceKotlin("1.3")
@Suppress("UNCHECKED_CAST")
public fun <R, T> (suspend R.() -> T).startCoroutine(
    receiver: R,
    completion: Continuation<T>
) {
    createCoroutineUnintercepted(receiver, completion).intercepted().resume(Unit)
}

这个方法不仅创建了 Continuation 对象，并且还直接执行了协程函数。例如:

fun main() {
    (::parentFun).startCoroutine(object : Continuation<Int>{
        override val context: CoroutineContext
            get() = EmptyCoroutineContext

        override fun resumeWith(result: Result<Int>) {
            println("result:$result")
        }
    })
}

3.3 suspendCoroutine 方法

上面的例子中 childFun1 这些方法，我们并没有实现异步操作，这里有两个难点:

  1. 没有办法返回 COROUTINE_SUSPENDED 值，因为它不是 Int 类型，且外部获取不到这个值。
  2. 获取不到调用方的 Continuation 对象，来恢复调用方。

针对这种情况，kotlin 提供了 suspendCoroutine 方法来解决这个问题。

@SinceKotlin("1.3")
@InlineOnly
public suspend inline fun <T> suspendCoroutine(crossinline block: (Continuation<T>) -> Unit): T =
    suspendCoroutineUninterceptedOrReturn { c: Continuation<T> ->
        val safe = SafeContinuation(c.intercepted())
        block(safe)
        safe.getOrThrow()
    }

将 childFun1 方法进行改变

suspend fun childFun1(): Int {
    Thread.sleep(1000)
    return 10
}

// 转变成
val executor = Executors.newScheduledThreadPool(1) 

suspend fun childFun1(): Int = suspendCoroutine { continuation ->
    executor.schedule(fun() { continuation.resume(10) }, 1000, TimeUnit.MILLISECONDS)
}

这里我们并没有直接返回，而是通过 executor 线程池，延迟 1 秒钟之后再返回值，模拟异步操作。

转成的 java 代码

   @Nullable
   public static final Object childFun1(@NotNull Continuation $completion) {
      boolean var1 = false;
      boolean var3 = false;
      SafeContinuation var4 = new SafeContinuation(IntrinsicsKt.intercepted($completion));
      Continuation continuation = (Continuation)var4;
      int var6 = false;
      executor.schedule((Runnable)(new CoroutineKt$childFun1$2$1(continuation)), 1000L, TimeUnit.MILLISECONDS);
      Object var10000 = var4.getOrThrow();
      if (var10000 == IntrinsicsKt.getCOROUTINE_SUSPENDED()) {
         DebugProbesKt.probeCoroutineSuspended($completion);
      }

      return var10000;
   }

因为 suspendCoroutine 函数时内联函数，因此函数内容直接复制到 childFun1 函数中。

SafeContinuation 的 getOrThrow 方法

    @PublishedApi
    internal actual fun getOrThrow(): Any? {
        var result = this.result // atomic read
        if (result === UNDECIDED) {
            if (RESULT.compareAndSet(this, UNDECIDED, COROUTINE_SUSPENDED)) return COROUTINE_SUSPENDED
            result = this.result // reread volatile var
        }
        return when {
            result === RESUMED -> COROUTINE_SUSPENDED // already called continuation, indicate COROUTINE_SUSPENDED upstream
            result is Result.Failure -> throw result.exception
            else -> result // either COROUTINE_SUSPENDED or data
        }
    }

可以看出在没有调用 resumeWith 方法时，就返回 COROUTINE_SUSPENDED

val executor = Executors.newScheduledThreadPool(2)

suspend fun childFun1(): Int = suspendCoroutine { continuation ->
    executor.schedule(fun() { continuation.resume(10) }, 1000, TimeUnit.MILLISECONDS)
}

suspend fun childFun2(): Int = suspendCoroutine { continuation ->
    executor.schedule(fun() { continuation.resume(20) }, 2000, TimeUnit.MILLISECONDS)
}

suspend fun childFun3(num1: Int, num2: Int): Int = suspendCoroutine { continuation ->
    executor.schedule(fun() { continuation.resume(num1 + num2) }, 1000, TimeUnit.MILLISECONDS)
}

suspend fun parentFun() : Int {
    val num1 = childFun1()
    val num2 = childFun2()
    val sum = childFun3(num1, num2)
    return sum
}

fun main() {
    (::parentFun).startCoroutine(object : Continuation<Int>{
        override val context: CoroutineContext
            get() = EmptyCoroutineContext

        override fun resumeWith(result: Result<Int>) {
            println("result:$result")
        }
    })
}

本文由哈喽比特于3年以前收录，如有侵权请联系我们。
文章来源：https://mp.weixin.qq.com/s/nte-W3hCCQBOI6c0gf-4-g

 相关推荐

刘强东夫妇：“移民美国”传言被驳斥

京东创始人刘强东和其妻子章泽天最近成为了互联网舆论关注的焦点。有关他们“移民美国”和在美国购买豪宅的传言在互联网上广泛传播。然而，京东官方通过微博发言人发布的消息澄清了这些传言，称这些言论纯属虚假信息和蓄意捏造。

发布于：1年以前  |  808次阅读  |  详细内容 »

博主曝三大运营商，将集体采购百万台华为Mate60系列

日前，据博主“@超能数码君老周”爆料，国内三大运营商中国移动、中国电信和中国联通预计将集体采购百万台规模的华为Mate60系列手机。

发布于：1年以前  |  770次阅读  |  详细内容 »

ASML CEO警告：出口管制不是可行做法，不要“逼迫中国大陆创新”

据报道，荷兰半导体设备公司ASML正看到美国对华遏制政策的负面影响。阿斯麦（ASML）CEO彼得·温宁克在一档电视节目中分享了他对中国大陆问题以及该公司面临的出口管制和保护主义的看法。彼得曾在多个场合表达了他对出口管制以及中荷经济关系的担忧。

发布于：1年以前  |  756次阅读  |  详细内容 »

抖音中长视频App青桃更名抖音精选，字节再发力对抗B站

今年早些时候，抖音悄然上线了一款名为“青桃”的 App，Slogan 为“看见你的热爱”，根据应用介绍可知，“青桃”是一个属于年轻人的兴趣知识视频平台，由抖音官方出品的中长视频关联版本，整体风格有些类似B站。

发布于：1年以前  |  648次阅读  |  详细内容 »

威马CDO：中国每百户家庭仅17户有车

日前，威马汽车首席数据官梅松林转发了一份“世界各国地区拥车率排行榜”，同时，他发文表示：中国汽车普及率低于非洲国家尼日利亚，每百户家庭仅17户有车。意大利世界排名第一，每十户中九户有车。

发布于：1年以前  |  589次阅读  |  详细内容 »

研究发现维生素 C 等抗氧化剂会刺激癌症生长和转移

近日，一项新的研究发现，维生素 C 和 E 等抗氧化剂会激活一种机制，刺激癌症肿瘤中新血管的生长，帮助它们生长和扩散。

发布于：1年以前  |  449次阅读  |  详细内容 »

苹果据称正引入3D打印技术，用以生产智能手表的钢质底盘

据媒体援引消息人士报道，苹果公司正在测试使用3D打印技术来生产其智能手表的钢质底盘。消息传出后，3D系统一度大涨超10%，不过截至周三收盘，该股涨幅回落至2%以内。

发布于：1年以前  |  446次阅读  |  详细内容 »

千万级抖音网红秀才账号被封禁

9月2日，坐拥千万粉丝的网红主播“秀才”账号被封禁，在社交媒体平台上引发热议。平台相关负责人表示，“秀才”账号违反平台相关规定，已封禁。据知情人士透露，秀才近期被举报存在违法行为，这可能是他被封禁的部分原因。据悉，“秀才”年龄39岁，是安徽省亳州市蒙城县人，抖音网红，粉丝数量超1200万。他曾被称为“中老年...

发布于：1年以前  |  445次阅读  |  详细内容 »

亚马逊股东起诉公司和贝索斯，称其在购买卫星发射服务时忽视了 SpaceX

9月3日消息，亚马逊的一些股东，包括持有该公司股票的一家养老基金，日前对亚马逊、其创始人贝索斯和其董事会提起诉讼，指控他们在为 Project Kuiper 卫星星座项目购买发射服务时“违反了信义义务”。

发布于：1年以前  |  444次阅读  |  详细内容 »

苹果上线AppsbyApple网站，以推广自家应用程序

据消息，为推广自家应用，苹果现推出了一个名为“Apps by Apple”的网站，展示了苹果为旗下产品（如 iPhone、iPad、Apple Watch、Mac 和 Apple TV）开发的各种应用程序。

发布于：1年以前  |  442次阅读  |  详细内容 »

特斯拉美国降价引发投资者不满：“这是短期麻醉剂”

特斯拉本周在美国大幅下调Model S和X售价，引发了该公司一些最坚定支持者的不满。知名特斯拉多头、未来基金（Future Fund）管理合伙人加里·布莱克发帖称，降价是一种“短期麻醉剂”，会让潜在客户等待进一步降价。

发布于：1年以前  |  441次阅读  |  详细内容 »

光刻机巨头阿斯麦：拿到许可，继续对华出口

据外媒9月2日报道，荷兰半导体设备制造商阿斯麦称，尽管荷兰政府颁布的半导体设备出口管制新规9月正式生效，但该公司已获得在2023年底以前向中国运送受限制芯片制造机器的许可。

发布于：1年以前  |  437次阅读  |  详细内容 »

马斯克与库克首次隔空合作：为苹果提供卫星服务

近日，根据美国证券交易委员会的文件显示，苹果卫星服务提供商 Globalstar 近期向马斯克旗下的 SpaceX 支付 6400 万美元（约 4.65 亿元人民币）。用于在 2023-2025 年期间，发射卫星，进一步扩展苹果 iPhone 系列的 SOS 卫星服务。

发布于：1年以前  |  430次阅读  |  详细内容 »

𝕏（推特）调整隐私政策，可拿用户发布的信息训练 AI 模型

据报道，马斯克旗下社交平台𝕏（推特）日前调整了隐私政策，允许 𝕏 使用用户发布的信息来训练其人工智能（AI）模型。新的隐私政策将于 9 月 29 日生效。新政策规定，𝕏可能会使用所收集到的平台信息和公开可用的信息，来帮助训练 𝕏 的机器学习或人工智能模型。

发布于：1年以前  |  428次阅读  |  详细内容 »

荣耀CEO谈华为手机回归：替老同事们高兴，对行业也是好事

9月2日，荣耀CEO赵明在采访中谈及华为手机回归时表示，替老同事们高兴，觉得手机行业，由于华为的回归，让竞争充满了更多的可能性和更多的魅力，对行业来说也是件好事。

发布于：1年以前  |  423次阅读  |  详细内容 »

AI操控无人机能力超越人类冠军

《自然》30日发表的一篇论文报道了一个名为Swift的人工智能（AI）系统，该系统驾驶无人机的能力可在真实世界中一对一冠军赛里战胜人类对手。

发布于：1年以前  |  423次阅读  |  详细内容 »

AI生成的蘑菇科普书存在可致命错误

近日，非营利组织纽约真菌学会（NYMS）发出警告，表示亚马逊为代表的电商平台上，充斥着各种AI生成的蘑菇觅食科普书籍，其中存在诸多错误。

发布于：1年以前  |  420次阅读  |  详细内容 »

社交媒体平台𝕏计划收集用户生物识别数据与工作教育经历

社交媒体平台𝕏（原推特）新隐私政策提到：“在您同意的情况下，我们可能出于安全、安保和身份识别目的收集和使用您的生物识别信息。”

发布于：1年以前  |  411次阅读  |  详细内容 »

国产扫地机器人热销欧洲，国产割草机器人抢占欧洲草坪

2023年德国柏林消费电子展上，各大企业都带来了最新的理念和产品，而高端化、本土化的中国产品正在不断吸引欧洲等国际市场的目光。

发布于：1年以前  |  406次阅读  |  详细内容 »

罗永浩吐槽iPhone15和14不会有区别，除了序列号变了

罗永浩日前在直播中吐槽苹果即将推出的 iPhone 新品，具体内容为：“以我对我‘子公司’的了解，我认为 iPhone 15 跟 iPhone 14 不会有什么区别的，除了序（列）号变了，这个‘不要脸’的东西，这个‘臭厨子’。

发布于：1年以前  |  398次阅读  |  详细内容 »

扫码在手机上访问

为您提供高质量的文档
 相关文章
Android插件化方案 5年以前  |  237231次阅读
vscode超好用的代码书签插件Bookmarks 2年以前  |  8065次阅读
 目录

去登录