协程基础元素原理及在 Android 开发中的应用

往期文章：

《00. 文章合集目录》

《10. 揭秘 Compose 原理》

《2 小时入门 Jetpack Compose》

你好，我是朱涛。今天这节课，我们来研究一下Kotlin协程的“基础元素”。

在上一讲当中，我们深入研究了Kotlin挂起函数的原理，下一讲，我们将会开始研究协程启动的原理。在上一讲当中，我们更多的是在了解协程的“基础层”，而下一讲，我们则是要开始探索协程的“中间层”了。

在第26讲当中，我曾提到过，Kotlin的协程框架，其实就是协程基础元素组合出来的框架。如果我们想要弄懂Kotlin协程，首先就要将它的“基础层”理解透彻。

因此，在进入第28讲之前，我还是决定来一次加餐，带你来深入认识一下Kotlin协程当中的“基础元素”。等你对协程的“基础层”有了深入认识以后，下节课研究协程启动原理就会轻松一些。

协程基础元素

在第26讲当中，我曾介绍过，Kotlin协程的基础元素大致有这些：Continuation、SafeContinuation、CoroutineContext、CombinedContext、CancellationException、intrinsics。

其中的CoroutineContext、CancellationException我们都已经介绍过了，CombinedContext呢，其实就是CoroutineContext的一个实现类，而SafeContinuation则是Continuation的实现类。

所以，整个协程基础元素当中，我们最需要关心的，其实就是Continuation和intrinsics。关于Continuation，虽然我们在前面已经介绍过它是什么，但我们还没有系统讲解过它的用法，而intrinsics当中，还有一个重要的高阶函数suspendCoroutineUninterceptedOrReturn{}。

接下来，我们先来系统了解一下Continuation的两种用法。

Continuation 在 Android 中的应用

Continuation 在 Android 最常见的应用，就是把 Callback 变成挂起函数（Suspend Function）。

在前面第18讲当中，我们已经学过Continuation其中的一种用法了：

// 代码段1

suspend fun <T : Any> KtCall<T>.await(): T =
    suspendCancellableCoroutine { continuation ->
        val call = call(object : Callback<T> {
            override fun onSuccess(data: T) {
                // 注意这里
                continuation.resume(data)
            }

            override fun onFail(throwable: Throwable) {
                // 注意这里
                continuation.resumeWithException(throwable)
            }
        })


        continuation.invokeOnCancellation {
            println("Call cancelled!")
            call.cancel()
        }
    }

当我们想要实现挂起函数的时候，我们可以使用suspendCoroutine{}、suspendCancellableCoroutine{}这两个高阶函数，在它们的Lambda当中，我们可以使用它暴露出来的continuation对象将程序的执行结果或异常传到外部去。

这种方式，往往是用于实现挂起函数内部逻辑的。

比如说，我们可以用suspendCoroutine{}写一个更加简单的例子：

// 代码段2

fun main() = runBlocking {
    val result = getLengthSuspend("Kotlin")
    println(result)
}

suspend fun getLengthSuspend(text: String): Int = suspendCoroutine { continuation->
    thread {
        // 模拟耗时
        Thread.sleep(1000L)
        continuation.resume(text.length)
    }
}

/*
输出结果：
等待1秒
6
*/

在上面的代码中，我们使用了suspendCoroutine{}实现了挂起函数，在它的内部，我们使用了continuation.resume()的方式传出了挂起函数的返回值。

有很多初学者会觉得奇怪，为什么我们以continuation.resume()这样异步的方式传出结果以后，挂起函数就能接收到结果呢？其实，当我们把main()函数当中的调用逻辑改一下，这一切就会清晰明了。

// 代码段3

// 变化在这里
fun main()  {
    val func = ::getLengthSuspend as (String, Continuation<Int>) -> Any?

    func("Kotlin", object: Continuation<Int>{
        override val context: CoroutineContext
            get() = EmptyCoroutineContext

        override fun resumeWith(result: Result<Int>) {
            println(result.getOrNull())
        }
    })
    
    // 防止程序提前结束
    Thread.sleep(2000L)
}

suspend fun getLengthSuspend(text: String): Int = suspendCoroutine { continuation->
    thread {
        // 模拟耗时
        Thread.sleep(1000L)
        continuation.resume(text.length)
    }
}
/*
输出结果：
等待1秒
6
*/

在上面的代码3中，我们借助上节课的知识，将getLengthSuspend()这个函数强转成了带有Continuation的函数类型，然后通过匿名内部类的方式创建了一个Continuation对象传了进去。最终，程序的执行结果和代码段2是一致的。

还记得我在第15讲层提到过的观点吗？

挂起函数的本质，就是Callback!

让我们把Continuation改为Callback，看看代码会变成什么样子。

// 代码段4

// 变化在这里
fun main()  {
    func("Kotlin", object: Callback<Int>{
        override fun resume(result: Int) {
            println(result)
        }
    })
    
    // 防止程序提前结束
    Thread.sleep(2000L)
}

fun func(text: String, callback: Callback<Int>) {
    thread {
        // 模拟耗时
        Thread.sleep(1000L)
        callback.resume(text.length)
    }
}

interface Callback<T> {
    fun resume(value: T)
}

/*
输出结果：
等待1秒
6
*/

可以看到，当我们把Continuation改成Callback以后，整个代码就变成了我们曾经最熟悉的异步回调代码了。调用方，可以使用匿名内部类创建Callback用于接收异步结果；异步函数内部，使用callback.resume()将结果传出去。

综上所述，Kotlin协程当中的Continuation，它的作用其实就相当于Callback，它既可以用于实现挂起函数，往挂起函数的外部传递结果；也可以用于调用挂起函数，我们可以创建Continuation的匿名内部类，用于接收挂起函数传递出来的结果。

那么，到现在，我们就可以轻松回答第27讲的思考题了：

我们都知道挂起函数是Kotlin协程里才有的概念，请问，Java代码中可以调用Kotlin的挂起函数吗？比如，下面这个函数，我们可以在Java当中调用吗？

// 代码段5

// 需要在Java中调用的Kotlin挂起函数
object SuspendFromJavaExample {
    // 在Java当中如何调用这个方法？
    suspend fun getUserInfo(id: Long):String {
        delay(1000L)
        return "Kotlin"
    }
}

答案当然是肯定的，Java当中调用挂起函数的方式，其实跟我们的代码段3是一样的：

// 代码段6

public static void main(String[] args) throws InterruptedException {
    SuspendFromJavaExample.INSTANCE.getUserInfo(100L, new Continuation<String>() {
        @NotNull
        @Override
        public CoroutineContext getContext() {
            return EmptyCoroutineContext.INSTANCE;
        }

        @Override
        public void resumeWith(@NotNull Object o) {
            System.out.println(o+"");
        }
    });

    // 防止程序提前结束
    Thread.sleep(2000L);
}

/*
输出结果
Kotlin
*/

在上面的代码中，你只是将代码段3的思想应用到了Java代码中而已，唯一需要注意的，就是：在Java当中访问Kotlin的object单例，是需要需要加上INSTANCE后缀的。这一点，我们在第5讲当中就已经了解过。

看到这里，可以发现，我们在实现挂起函数逻辑的时候，总是离不开suspendCoroutine{}、suspendCancellableCoroutine{}。其实，这两个高阶函数也是Kotlin协程的“基础元素”，让我们来进一步认识这两个高阶函数。

suspendCoroutineUninterceptedOrReturn

其实，suspendCoroutine{}、suspendCancellableCoroutine{}这两个高阶函数的实现原理是类似的，因此，这里我们仅解释suspendCoroutine{}。

如果你去看suspendCoroutine{}的源代码，你会发现，它其实也在Continuation.kt这个文件当中。

// 代码段7

public interface Continuation<in T> {
    public val context: CoroutineContext    
    public fun resumeWith(result: Result<T>)
}

public suspend inline fun <T> suspendCoroutine(crossinline block: (Continuation<T>) -> Unit): T {

    // 注意这里
    return suspendCoroutineUninterceptedOrReturn { c: Continuation<T> ->
        val safe = SafeContinuation(c.intercepted())
        block(safe)
        safe.getOrThrow()
    }
}

在上面的代码中，我们第一眼就能看到一个名字特别长的高阶函数suspendCoroutineUninterceptedOrReturn{}。它其实就是实现suspendCoroutine{}的关键。除了它之外，其他部分的代码都很好理解：

• SafeContinuation(c.intercepted())这行代码的作用就是将原本的Continuation包裹一遍。
• block(safe)，这行代码其实就是在调用Lambda当中的逻辑。
• safe.getOrThrow()，就是在取出block(safe)的运行结果，我们在第27讲当中提到过，Continuation当中是可以存储result的。这个Result可能是正确的结果，也可能是异常。

接下来，我们重点来看看suspendCoroutineUninterceptedOrReturn{}这个高阶函数的作用。如果你去看它的源代码，那么你看到的源代码大概率会是这样的：

// 代码段8

public suspend inline fun <T> suspendCoroutineUninterceptedOrReturn(crossinline block: (Continuation<T>) -> Any?): T {
    contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
    throw NotImplementedError("Implementation of suspendCoroutineUninterceptedOrReturn is intrinsic")
}

大部分人看到这样的代码都会觉得奇怪，为什么这个高阶函数的源代码会是抛出异常呢？如果你看了前面的加餐二“表达式思维”，你应该能理解这样的代码也是符合函数返回值的规范的。不过，如果它总是抛异常的话，我们用suspendCoroutine{}写代码的时候，为什么不会产生崩溃呢？这个异常信息里的提示内容又是什么意思？

"Implementation of suspendCoroutineUninterceptedOrReturn is intrinsic."

其实，理解这句话的关键在于“intrinsic”这个单词，它有“固有”、“本质”的意思，不过在上面这句话的语境下，intrinsic并不是这些意思。

这里的intrinsic其实是在编译器领域的一个术语，我们可以把它理解为“内建”的意思。因此，上面我们看到的异常提示信息的意思是：suspendCoroutineUninterceptedOrReturn是一个编译器内建函数，它是由Kotlin编译器来实现的。

在这里，为了不偏离主题，我们就不去深究Kotlin编译器当中的逻辑了，感兴趣的同学可以自行研究这个链接。接下来，我们可以换一个角度，写一些Demo代码，通过运行调试来看看这个内建函数的功能和作用。

让我们先来看看suspendCoroutineUninterceptedOrReturn这个高阶函数的参数，它会接收一个Lambda，它的类型是(Continuation<T>) -> Any?，经过第27讲的学习，你是否觉得这个类型有些眼熟呢？这里的“Any?”类型，其实就能代表当前这个挂起函数是否真正挂起。

因此，我们可以写出下面这样的代码：

// 代码段9

fun main() = runBlocking {
    val result = testNoSuspendCoroutine()
    println(result)
}

private suspend fun testNoSuspendCoroutine() = suspendCoroutineUninterceptedOrReturn<String> {
        continuation ->
    return@suspendCoroutineUninterceptedOrReturn "Hello!"
}

/*
输出结果：
Hello!
*/

在上面的代码中，我们直接使用suspendCoroutineUninterceptedOrReturn实现了挂起函数，并且，在它的Lambda当中，我们并没有调用continuation.resume()，而是直接直接返回了结果“Hello!”。根据程序的运行结果，我们可以看到，我们在挂起函数的外部确实也可以接收到这个结果。

这时候，如果我们将上面的代码反编译，会看到类似这样的代码：

private static final Object testNoSuspendCoroutine(Continuation $completion) {
  int var2 = false;
  if ("Hello!" == IntrinsicsKt.getCOROUTINE_SUSPENDED()) {
     DebugProbesKt.probeCoroutineSuspended($completion);
  }

  return "Hello!";
}

从反编译的结果来看，testNoSuspendCoroutine()这个函数其实就是一个“伪挂起函数”，它的内部并不会真正挂起，当我们从外部调用这个函数的时候，这个函数会立即返回结果“Hello!”。

这时候，我们可以再写一个真正的挂起函数：

fun main() = runBlocking {
    val result = testSuspendCoroutine()
    println(result)
}

private suspend fun testSuspendCoroutine() = suspendCoroutineUninterceptedOrReturn<String> {
    continuation ->
    thread {
        Thread.sleep(1000L)
        continuation.resume("Hello!")

    }
    return@suspendCoroutineUninterceptedOrReturn kotlin.coroutines.intrinsics.COROUTINE_SUSPENDED
}


/*
输出结果：
等待1秒
Hello!
*/

这一次，我们并没有使用return返回结果，而是使用了continuation.resume()。通过程序运行结果，我们可以看到挂起函数的外部也能接收到这个结果。这时候，我们再来反编译看看它对应的Java代码：

private static final Object testSuspendCoroutine(Continuation $completion) {
    int var2 = false;
    // 1
    ThreadsKt.thread$default(false, false, (ClassLoader)null, (String)null, 0, (Function0)(new CoroutineBasicElementsKt$testSuspendCoroutine$2$1($completion)), 31, (Object)null);
    // 2
    Object var10000 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
    if (var10000 == IntrinsicsKt.getCOROUTINE_SUSPENDED()) {
     DebugProbesKt.probeCoroutineSuspended($completion);
    }
    // 3
    return var10000;
}

final class CoroutineBasicElementsKt$testSuspendCoroutine$2$1 extends Lambda implements Function0 {

   final Continuation $it;

   public Object invoke() {
      this.invoke();
      return Unit.INSTANCE;
   }

   public final void invoke() {
      // 4
      Thread.sleep(1000L);
      Continuation var1 = this.$it;
      String var2 = "Hello!";
      Companion var3 = Result.Companion;
      var1.resumeWith(Result.constructor-impl(var2));
   }

   CoroutineBasicElementsKt$testSuspendCoroutine$2$1(Continuation var1) {
      super(0);
      this.$it = var1;
   }
}

以上的代码，一共有4个注释，我们一个个看：

• 注释1、4，创建了一个新的线程，执行了thread{}当中的代码。
• 注释2、将var10000赋值为COROUTINE_SUSPENDED这个挂起标志位。
• 注释3，返回挂起标志位，代表testSuspendCoroutine()这个函数会真正挂起。

以上的两个例子其实也从侧面证明了我们在第27讲当中的结论：

由于 suspend 修饰的函数，既可能返回 CoroutineSingletons.COROUTINE_SUSPENDED，也可能返回实际结果，甚至可能返回 null，为了适配所有的可能性，CPS 转换后的函数返回值类型就只能是 Any?了。

那么，到这里，我们其实就可以总结出suspendCoroutineUninterceptedOrReturn{}这个高阶函数的作用了：它可以将挂起函数当中的Continuation以参数的形式暴露出来，在它的Lambda当中，我们可以直接返回结果，这时候它就是一个“伪挂起函数”；或者，我们也可以返回COROUTINE_SUSPENDED这个挂起标志位，然后使用continuation.resume()传递结果。

相应的，suspendCoroutine{}、suspendCancellableCoroutine{}这两个高阶函数，只是对它的一种封装而已。

小结

好，这节课的内容就到这里，我们来做一个简单的总结。

这节课，我们学习了Kotlin协程当中，与挂起函数密切相关的两个基础元素，Continuation、suspendCoroutine{}。

在 Android 开发当中，这两个元素也会经常帮我们牵线搭桥，把异步的 Callback 编程挂起函数，从而简化我们的代码逻辑和复杂度。

Continuation是整个协程当中最重要的基础元素，我们可以将其看做是一个Callback。它主要有两个使用场景，一种是在实现挂起函数的时候，用于传递挂起函数的执行结果；另一种是在调用挂起函数的时候，以匿名内部类的方式，用于接收挂起函数的执行结果。借助这种思路，我们也完全可以在Java当中调用挂起函数。

当我们想要实现挂起函数的时候，我们往往需要使用suspendCoroutine{}、suspendCancellableCoroutine{}这两个高阶函数。它们两个都是对suspendCoroutineUninterceptedOrReturn{}的封装，这个高阶函数的作用其实就是暴露挂起函数的Continuation对象。在它的Lambda当中，我们既可以直接返回执行结果，也可以返回COROUTINE_SUSPENDED这个挂起标志位，然后使用continuation.resume()传递结果。

思考题

你觉得，suspendCoroutine{}、suspendCancellableCoroutine{}这两个高阶函数，它对比suspendCoroutineUninterceptedOrReturn{}的优势在哪里？Kotlin官方为什么要进行这样的封装呢？