简介
使用kotlin携程，难免会使用到携程的挂起特性，正因为这些特性解决了kotlin等待异步执行结果的回调地狱，下面将从源码的角度来分析携程的挂起和恢复原理。
技巧
方法执行可以通过打印线程堆栈来看
public static void printStackTrace(String msg) {
StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
println(Thread.currentThread() + ", message: [" + msg + "]");
if (stackTrace == null || stackTrace.length < 2) {
println("empty stack");
return;
}
for (int i = 2; i < stackTrace.length; i++) {
println("\tat " + stackTrace[i]);
}
}
private static void println(Object object) {
System.out.println(object);
}
例子先行
- 公用代码
fun treadName(): String = Thread.currentThread().name suspend fun doSuspendOne(): Int { delay(1000L) // 假设我们在这里做了一些有用的事 println("${treadName()}======doSuspendOne") return 13 } suspend fun doSuspendTwo(): Int { delay(500L) // 假设我们在这里也做了一些有用的事 println("${treadName()}======doSuspendTwo") return 29 } - 第一个例子
输出如下：fun main() { runBlocking { doSuspendOne() doSuspendTwo() } println("${treadName()}======main") }main======doSuspendOne main======doSuspendTwo main======main Process finished with exit code 0 - 第二个例子
输出如下：suspend fun main() { doSuspendOne() doSuspendTwo() println("${treadName()}======main") }kotlinx.coroutines.DefaultExecutor======doSuspendOne kotlinx.coroutines.DefaultExecutor======doSuspendTwo kotlinx.coroutines.DefaultExecutor======main Process finished with exit code 0 - 第三个例子
输出如下：suspend fun main() { GlobalScope.launch { println("${treadName()}======launch1111") delay(300) println("${treadName()}======launch") } runBlocking { println("${treadName()}======runBlocking") doSuspendOne() doSuspendTwo() } println("${treadName()}======main") }DefaultDispatcher-worker-1======launch1111 main======runBlocking DefaultDispatcher-worker-1======launch main======doSuspendOne main======doSuspendTwo main======main Process finished with exit code 0 - 第四个例子
输出如下suspend fun main() { GlobalScope.launch { println("${treadName()}======launch1111") delay(300) println("${treadName()}======launch") } println("${treadName()}======main") Thread.sleep(3000) }main======main DefaultDispatcher-worker-1======launch1111 DefaultDispatcher-worker-1======launch Process finished with exit code 0
挂起
特点是：挂起而不阻塞线程，这里要清楚一点，挂起的本质是切线程，并且在相应的逻辑处理完成之后，再重新切回线程。挂起使协程体的操作被return而停止，等待恢复，它阻塞的是协程体的操作，并未阻塞线程。
挂起函数底层实现
刚开始学习kotlin的同学可能不知道怎么分析kotlin相关功能代码，特别是语法糖相关的，其实不管kotlin语法糖再多，它最终要通过编译，脱糖生成字节码，总是能够分析的。
下面将通过源码层面进行携程挂起和恢复的讲解，这里只给出关键的源码位置，如果大家想一步步跟踪代码的执行逻辑，可以写一个简单的apk，里面包含简单的携程代码，利用Android Studio进行编译和脱糖相关处理，在用jadx进程反编译，查看。
通过 jdax发现部分代码不能反编译，那么我们可以结合Android Studio提供的kotlin反编译工具进行查看。
-
负责协程体逻辑的处理（BaseContinuationImpl）internal abstract class BaseContinuationImpl( // completion：实参是一个AbstractCoroutine public val completion: Continuation<Any?>? ) : Continuation<Any?>, CoroutineStackFrame, Serializable { public final override fun resumeWith(result: Result<Any?>) { ... try { // 调用invokeSuspend方法，协程体真正开始执行 val outcome = invokeSuspend(param) // invokeSuspend方法返回值为COROUTINE_SUSPENDED，resumeWith方法被return，结束执行，说明执行了挂起操作 if (outcome === COROUTINE_SUSPENDED) return // 协程体执行成功的结果 Result.success(outcome) } catch (exception: Throwable) { // 协程体出现异常的结果 Result.failure(exception) } releaseIntercepted() if (completion is BaseContinuationImpl) { ... } else { completion.resumeWith(outcome) return ...invokeSuspend()的执行就是协程体的执行，当invokeSuspend()返回值为COROUTINE_SUSPENDED时，会执行return操作，resumeWith()的执行被结束掉，协程体的操作也被结束掉了，而COROUTINE_SUSPENDED代表协程发生挂起。
通过反编译可以发现我们编写的携程体会被转换成invokeSuspend方法调用 ，以这个例子进行反编译（
我用的Android Studio自带的kotlin工具，和通过jadx反编译出来有所不同，但是挂起和恢复的逻辑都一样的）。suspend fun doSuspendOne(): Int { delay(1000) // 假设我们在这里做了一些有用的事 println("${treadName()}======doSuspendOne") return 13 } fun main(): Unit = runBlocking{ doSuspendOne() }看一下invokeSuspend方法:
public final Object invokeSuspend(@NotNull Object $result) { ... switch(this.label) { case 0: ... this.label = 1; if (TestKt.doSuspendOne(this) == var2) { return var2; } break; ... } ... }doSuspendOne函数实现：
public static final Object doSuspendOne(@NotNull Continuation var0) { Object $continuation; ... Object var5 = IntrinsicsKt.getCOROUTINE_SUSPENDED(); switch(((<undefinedtype>)$continuation).label) { case 0: ResultKt.throwOnFailure($result); ((<undefinedtype>)$continuation).label = 1; if (DelayKt.delay(1000L, (Continuation)$continuation) == var5) { return var5; } break; case 1: ResultKt.throwOnFailure($result); break; default: throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine"); } String var1 = KotlinCoroutinesTestKt.treadName() + "======doSuspendOne"; boolean var2 = false; System.out.println(var1); return Boxing.boxInt(13); }结合源码看一下，默认情况下label==0，i==0,执行label = 1赋值操作，及调用挂起函数
delay(...)，此处判断delay(...)方法返回值为coroutine_suspended时，就会返回coroutine_suspended，也就是当delay(...)内存在挂起操作的时候它的返回值就是coroutine_suspended。假设
delay(...)挂起函数内执行了挂起操作，delay(...)方法结束并返回coroutine_suspended，resumeWith()方法在收到返回值coroutine_suspended也进行了return操作，resumeWith()和invokeSuspend()方法执行都结束了，println日志打印并没有得到执行，协程挂起并不是阻塞了当前的线程（通过上面第三个例子输出可以看出），而是执行了return操作，结束了协程体的调用。挂起函数内执行挂起操作的时候会返回coroutine_suspended标志，结束协程体的运行，使协程挂起，接下来看下协程提供的挂起函数中是如何操作的。 -
携程恢复
恢复外部协程时，通过线程调度，将协程在指定线程运行，这样也就可以在挂起恢复时，重新切回线程,再次触发invokeSuspend()，根据label状态值，执行下一个代码片。结论
在DispatchedCoroutine中，重写了afterCompletion()及afterResume()，并且afterCompletion()调用afterResume()，而afterResume()中首先判断了协程是否被挂起，如已挂起则恢复外部的协程。恢复外部协程时，同样是通过线程调度，将协程在指定线程运行，这样也就可以在挂起恢复时，重新切回线程,再次触发invokeSuspend()，根据label状态值，执行下一个代码片。本质就是：将携程体代码分成一个个执行代码块，通过label控制执行那一个代码块，当执行到需要挂起的代码块会挂起，然后返回结束协调体执行，当挂起部分恢复时，重新在指定线程调用invokeSuspend方法，这是label变成下一个要执行的代码块的值。
