Kotlin 协程把suspend 修饰符引入到了我们 Android 开发者的日常开发中。您是否好奇它的底层工作原理呢？编译器是如何转换我们的代码，使其能够挂起和恢复协程操作的呢？

suspend

挂起函数，是指把协程代码挂起不继续执行的函数，也叫协程被函数挂起了。协程中调用挂起函数时，协程所在的线程不会挂起也不会阻塞，但是协程被挂起了。也就是说，协程内挂起函数之后的代码停止执行了，直到挂起函数完成后恢复协程，协程才继续执行后续的代码。所有挂起函数都会通过suspend修饰符修饰。

suspend是协程的关键字，每一个被suspend修饰的方法都必须在另一个suspend函数或者Coroutine协程程序中进行调用。

挂起函数(由suspend关键字修饰)的目的是用来挂起协程的执行等待异步计算的结果，所以一个挂起函数通常有两个要点：挂起和异步

这里涉及到一种机制俗称CPS(Continuation-Passing-Style:续体传递风格)。每一个suspend修饰的方法或者lambda表达式都会在代码调用的时候为其额外添加Continuation(续体)类型的参数。

Kotlin协程中使用了状态机，编译器会将协程体编译成一个匿名内部类，每一个挂起函数的调用位置对应一个挂起点。

协程挂起流程详解

协程实现异步的核心原理就是通过挂起函数实现协程体的挂起，还不阻塞协程体所在的线程。

fun testInMain() {

    Log.d("["+Thread.currentThread().name+"]testInMain start")
var job = CoroutineScope(Dispatchers.Main).launch { //启动协程job

        Log.d("[" + Thread.currentThread().name+"]job start")
var job1 = async(Dispatchers.IO) { //启动协程job1

            Log.d("["+Thread.currentThread().name+"]job1 start")

            delay(3000) //挂起job1协程 3秒

            Log.d("["+Thread.currentThread().name+"]job1 end ")
"job1-Return"

        } //job1协程 续体执行完毕

var job2 = async(Dispatchers.Default) {

            Log.d("["+Thread.currentThread().name+"]job2 start" )

            delay(1000) //挂起job2协程 1秒

            Log.d("["+Thread.currentThread().name+"]job2 end")
"job2-Return"

        } //job2协程 续体执行完毕


        Log.d("["+Thread.currentThread().name+"]before job1 return")

        Log.d("["+Thread.currentThread().name+"]job1 result = " + job1.await()) //挂起job协程，等待job1返回结果；如果已有结果，不挂起，直接返回


        Log.d("["+Thread.currentThread().name+"]before job2 return")

        Log.d("["+Thread.currentThread().name+"]job2 result = " + job2.await()) //挂起job协程，等待job2返回结果；如果已有结果，不挂起，直接返回


        Log.d("["+Thread.currentThread().name+"]job end ")

    } //job协程 续体执行完毕


    Log.d("["+Thread.currentThread().name+"]testInMain end")

} //testInMain
 

示例代码的log输出如下，我们需要重点关注Log输出的次序，和时间间隔：

10:15:04.046 26079-26079/com.example.myapplication D/TC: [main]testInMain start
10:15:04.067 26079-26079/com.example.myapplication D/TC: [main]testInMain end
10:15:04.080 26079-26079/com.example.myapplication D/TC:

[main]job start
10:15:04.083 26079-26079/com.example.myapplication D/TC:

[main]before job1 return
10:15:04.086 26079-26683/com.example.myapplication D/TC: [DefaultDispatcher-worker-1]job1 start
10:15:04.087 26079-26684/com.example.myapplication D/TC: [DefaultDispatcher-worker-2]job2 start
10:15:05.090 26079-26683/com.example.myapplication D/TC: [DefaultDispatcher-worker-1]job2 end
10:15:05.095 26079-26079/com.example.myapplication D/TC:

[main]button-2 onclick now
10:15:07.090 26079-26685/com.example.myapplication D/TC: [DefaultDispatcher-worker-3]job1 end
10:15:07.091 26079-26079/com.example.myapplication D/TC:

[main]job1 result = job1-Return
10:15:07.091 26079-26079/com.example.myapplication D/TC:

[main]before job2 return
10:15:07.091 26079-26079/com.example.myapplication D/TC:

[main]job2 result = job2-Return
10:15:07.091 26079-26079/com.example.myapplication D/TC:

[main]job end
 

• 步骤一：在主线程调用TestInMain，直接打印“[main]testInMain start”的log
• 步骤二：TestInMain方法继续执行完毕，打印“[main]testInMain end”的log
• 步骤三：job协程被主线程调度执行，打印“[main]job start”的log
• 步骤四：job协程继续执行，打印“[main]before job1 return”的log
• 步骤五：job协程被job1.await挂起函数中断执行，退出main线程，等待job1返回结果后再恢复执行
• 步骤六：job1协程被异步调度到work-1子线程执行，打印“[DefaultDispatcher-worker-1]job1 start”的log，接着被delay挂起函数中断执行，退出work-1子线程，等待delay 3秒结束后再恢复执行
• 步骤七：job2协程被异步调度到work-2子线程执行，打印“[DefaultDispatcher-worker-2]job2 start”的log，接着被delay挂起函数中断执行，退出work-2子线程，等待delay 1秒结束后再恢复执行
• 步骤八：1秒钟后(从04秒-05秒)，job2协程被delay挂起函数异步调度到[DefaultDispatcher-worker-1]子线程恢复执行，打印“[DefaultDispatcher-worker-1]job2 end”的log，job2续体结束执行，同时将结果存储到job2协程的result字段中。
• 步骤九：main线程中button-2点击事件被处理，打印“[main]button-2 onclick now”的log
• 步骤十：3秒钟后(从04秒-07秒)，job1协程被delay挂起函数异步调度到[DefaultDispatcher-worker-3]子线程恢复执行，打印“[DefaultDispatcher-worker-3]job1 end”的log，job1续体结束执行，同时将结果存储到job1协程的result字段中。
• 步骤十一：job1.await挂起函数得到结果，job协程被await挂起函数异步调度到main线程恢复执行，打印“[main]job1 result = job1-Return”的log
• 步骤十二：job协程继续执行，打印“[main]before job2 return”的log
• 步骤十三：job协程继续调用job2.await挂起函数，此时job2协程已经有result结果，所有它不会中断job协程的执行，而是直接返回结果，打印“[main]job2 result = job2-Return”的log
• 步骤十四：job协程继续执行，打印“[main]job end”的log，job续体结束执行。

 从图中，我们可以清晰的得到几点结论：

1. job协程内部，通过await 阻塞了后续代码的执行。job1和job2协程，通过delay阻塞了后续代码的执行。
2. 协程job1，job2 启动后，保持并行执行。job2 并没有等待job1执行完才启动执行和恢复，而是在各自线程并行执行。
3. job的后续代码被await 阻塞后，并没有阻塞main线程，main线程中其它模块的代码能同时被执行，并打印出"[main]button 2 onclick now"。
4. job1 被delay阻塞后续代码执行时，并没有阻塞所在线程[DefaultDispatcher-worker-1]，job2中的后续代码被恢复到此[DefaultDispatcher-worker-1]子线程中执行。
5. job1 和 job2 协程在恢复执行时，并不能确保在原线程中执行后续代码。如log所示，job2在DefaultDispatcher-worker-2中启动和阻塞后，却在DefaultDispatcher-worker-1中恢复了后续的代码执行。

所以可以看出，协程的挂起，并不会阻塞协程所在的线程，而只是中断了协程后面的代码执行。然后等待挂起函数完成后，恢复协程的后续代码执行。这就是协程挂起最最基本的关键点。

协程挂起的实现原理

上节中的示例代码，经过反编译后的核心代码如下：

//TestCoroutin.decompiled.java
public final void testInMain() {

    Log.d("cjf---", var10001.append("testInMain start").toString());


    Job job = BuildersKt.launch$default( CoroutineScopeKt.CoroutineScope((CoroutineContext)Dispatchers.getMain()),  (CoroutineContext)null, (CoroutineStart)null, (Function2)(new Function2((Continuation)null) {
@Nullable
public final Object invokeSuspend(@NotNull Object $result) {
//单独拆分到下面，需要详细讲解

    }

public final Continuation create(@Nullable Object value, @NotNull Continuation completion) {/......./}

public final Object invoke(Object var1, Object var2){/......./}


    }), 3, (Object)null);


    Log.d("cjf---", var10001.append("testInMain end ").toString());

}

//job协程的SuspendLambda续体，其invokeSuspend方法代码
public final Object invokeSuspend(@NotNull Object $result) {

    ... ...

    label17: {

        Object var8 = IntrinsicsKt.getCOROUTINE_SUSPENDED();

        switch(this.label) {

            case 0:

            Log.d(var10001.append("job start ").toString());

            Deferred job1 = BuildersKt.async$default(/......./);

            job2 = BuildersKt.async$defaultdefault(/......./);

            Log.d(var10001.append("before job1 return").toString());

            var6 = var10001.append("job1 result =");
this.L$0 = job2;
this.L$1 = var5;
this.L$2 = var6;
this.label = 1;

            var10000 = job1.await(this);
if (var10000 == var8) {
return var8;

            }
break;

            case 1:

            var6 = (StringBuilder)this.L$2;

            var5 = (String)this.L$1;

            job2 = (Deferred)this.L$0;

            ResultKt.throwOnFailure($result);

            var10000 = $result;
break;

            case 2:

            var6 = (StringBuilder)this.L$1;

            var5 = (String)this.L$0;

            ResultKt.throwOnFailure($result);

            var10000 = $result;
break label17;

            default:
throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");

        }


        var7 = var10000;

        Log.d(var5, var6.append((String)var7).toString());

        Log.d(var10001.append("before wait job2 return").toString());

        var6 = var10001.append("job2 result = ");
this.L$0 = var5;
this.L$1 = var6;
this.L$2 = null;
this.label = 2;

        var10000 = job2.await(this);
if (var10000 == var8) {
return var8;

        }

    } //end of label17


    Log.d(var5, var6.append((String)var7).toString());

    Log.d("cjf---", var10001.append("job end ").toString());
return Unit.INSTANCE;

} //end of invokeSuspend
 

反编译后的主要区别在job协程，其Lambda代码块转换成了Function2 实现。

我们借助APK反编译工具，可以看到执行代码中，Function2 实际上被SuspendLambda 类继承实现。

SuspendLambda实现类的关键逻辑在invokeSuspend方法中，而invokeSuspend方法中采用了CPS(Continuation-Passing-Style) 续体传递风格。

续体传递风格会将job协程的Lambda代码块，通过label标签和switch分割成多个代码块。代码块分割的点，就是协程中调用suspend挂起函数的地方。

分支代码调用到await挂起函数时，如果返回了COROUTINE_SUSPENDED，就退出invokeSuspend，进入挂起状态。

我们用流程图来描述上面示例代码，转换后的续体传递风格代码，如下：

我们可以看到，整个示例代码，被分割成了5个代码块。其中case1 代码块主要负责为label17 代码块进行参数转换；case2 代码块主要负责为最外层代码块进行参数转换；所以相当于2个await挂起函数，将lambda代码块分割成了3个实际执行的代码块。

而且job1.await和job2.await会根据挂起函数的返回值进行不同处理，如果返回挂起，则进行协程挂起，当前协程退出执行；如果返回其它值，则协程继续后续代码块的执行。

编译器在编译期间，会对所有suspend修饰的函数调用处进行续体传递风格变换, Continuation可以称之为协程续体，它提供了协程恢复的基本方法：resumeWith。Continuation续体声明很简单：

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>)

}
 

其具体实现在SuspendLambda的父类BaseContinuationImpl中：

//class BaseContinuationImpl 中 fun resumeWith 内部核心代码
while (true) {

    probeCoroutineResumed(current)

    with(current) {
val completion = completion!!
val outcome: Result<Any?> = //协程返回了结果，说明协程执行完毕
try {
val outcome = invokeSuspend(param)//执行协程的续体代码块
if (outcome === COROUTINE_SUSPENDED) return //挂起函数返回挂起标志，退出后续代码执行

                Result.success(outcome) //没有返回挂起标志，将返回值outcome封装为Result返给外层outcome

            } catch (exception: Throwable) {

                Result.failure(exception)//将异常Result返给外层outcome

            }

        releaseIntercepted() // 释放当前协程的拦截器
if (completion is BaseContinuationImpl) {//如果上一层续体是一个单纯的续体，则将结果作为上一层续体的恢复参数，进行上一层续体的恢复

            current = completion

            param = outcome

        } else {//上一层续体是一个协程，则调用协程的恢复函数，进行上一层的协程恢复

            completion.resumeWith(outcome)
return

        }

    }

}
 

如果invokeSuspend函数返回中断标志时，会直接从函数中返回，等待后续继续被恢复执行。

如果invokeSuspend函数返回的是结果，且上一层续体不是单纯的续体而是协程体，它会调用参数completion的resumeWith函数，恢复上一层协程的invokeSuspend代码的执行。

协程被resumeWith恢复后，会继续调用invokeSuspend函数，根据label值执行下一个case分支代码块。按照这个恢复流程，直到所有invokeSuspend代码执行完，返回非COROUTINE_SUSPENDED的结果，协程就执行结束。

我们继续看job续体在invokeSuspend中调用到job1.await函数时，await是怎么实现返回挂起标志，和后续恢复job协程的。核心代码可以在awaitSuspend中查看：

// JobSupport.kt中 awaitSuspend方法
private suspend fun awaitSuspend(): Any? = suspendCoroutineUninterceptedOrReturn { uCont ->
val cont = AwaitContinuation(uCont.intercepted(), this)

    cont.disposeOnCancellation(invokeOnCompletion(

        ResumeAwaitOnCompletion(this, cont).asHandler))

    cont.getResult()

}

// JobSupport.kt中 invokeOnCompletion方法
public final override fun invokeOnCompletion(...):DisposableHandle {
var nodeCache: JobNode<*>? = null

    loopOnState { state ->
when (state) {
is Empty -> { // 没有completion handlers，直接创建Node放入state
val node = nodeCache ?: makeNode(handler, onCancelling).also { nodeCache = it }
if (_state.compareAndSet(state, node)) return nod

            }
is Incomplete -> {// 有completion handlers，加入到node list列表
val list = state.list
val node = nodeCache ?: makeNode(handler, onCancelling).also { nodeCache = it }
if (!addLastAtomic(state, list, node)) return@loopOnState /

            }
else -> { // 已经完成，不需要加入结果监听Node
if (invokeImmediately) handler.invokeIt((state as? CompletedExceptionally)?.cause) return NonDisposableHandle

            }

        }

    }

}

// AbstractCoroutine.kt 中 resumeWith方法
// 通知state node，进行恢复
public final override fun resumeWith(result: Result<T>) {
// makeCompletingOnce 大致实现是修改协程状态，如果需要的话还会将结果返回给调用者协程，并恢复调用者协程

    makeCompletingOnce(result.toState(), defaultResumeMode)

}
 

可以看出，job1.await()首先会通过getResult()去获取job1的结果，如果有结果则直接返回结果，否则立即返回中断标志，这样就实现了await挂起点挂起job协程了。await()挂起函数恢复job协程的流程是，将job 协程封装为 ResumeAwaitOnCompletion，并将其再次封装成handler 节点，添加job1协程的 state.list。

等job1协程完成后，会通知 handler 节点调用job协程的 resumeWith(result) 方法，从而恢复 job协程await 挂起点之后的代码块的执行。

我们再次结合示例代码， 来梳理这个挂起和恢复流程：

note：绿色底色，表示在主线程执行；红色字体，表示调用挂起函数；

可以看到整个过程：

• job协程没有阻塞调用者TestInMain，job协程会被post到主线程执行；
• 子协程job1，job2会同时调度到不同子线程中执行，会并行执行；
• job协程通过job1，和job2 的 await挂起函数等待异步结果。等待异步结果的时候，job协程也没有阻塞主线程。

通过续体传递风格的invokeSuspend代码，和续体之间形成的resumewith恢复链，协程得以实现挂起和恢复的核心流程。