关注
Android协程(Coroutines)系列-深入理解suspend(挂起函数)关键字
Kotlin 协程把suspend 修饰符
引入到了我们 Android 开发者的日常开发中。您是否好奇它的底层工作原理呢?编译器是如何转换我们的代码,使其能够挂起和恢复协程操作的呢?
suspend
挂起函数,是指把协程代码挂起不继续执行的函数,也叫协程被函数挂起了。协程中调用挂起函数时,协程所在的线程不会挂起也不会阻塞,但是协程被挂起了。也就是说,协程内挂起函数之后的代码停止执行了,直到挂起函数完成后恢复协程,协程才继续执行后续的代码。所有挂起函数都会通过suspend
修饰符修饰。
suspend
是协程的关键字,每一个被suspend修饰的方法都必须在另一个suspend函数或者Coroutine协程程序中进行调用。
挂起函数(由suspend
关键字修饰)的目的是用来挂起协程的执行等待异步计算的结果,所以一个挂起函数通常有两个要点:挂起 和异步
这里涉及到一种机制俗称CPS(Continuation-Passing-Style:续体传递风格)
。每一个suspend修饰的方法或者lambda表达式都会在代码调用的时候为其额外添加Continuation(续体)
类型的参数。
Kotlin协程中使用了状态机,编译器会将协程体编译成一个匿名内部类,每一个挂起函数的调用位置对应一个挂起点。
挂起函数 意义 解释 join 挂起当前协程,直到等待的子协程执行完毕 通过当前协程返回的Job接口的join方法,可以单纯的挂起当前协程,等待子协程完成后再恢复继续执行 await 挂起当前协程,直到等待的子协程返回结果 和join的区别是,它属于Job接口的子接口Deferred的方法,可以等待子协程完成后,带着返回值恢复当前协程 delay 挂起当前协程,直到指定时间后恢复当前协程 单纯挂起当前协程,指定时长后恢复协程执行 withContext() 挂起外部协程,直到自己内部协程全部返回后,才会恢复外部的协程。 没有创建新的协程,在指定协程上运行挂起代码块,并挂起该协程直至代码块运行完成并返回结果。类似async.await的效果
协程挂起流程详解 协程实现异步的核心原理就是通过挂起函数实现协程体的挂起,还不阻塞协程体所在的线程。
fun testInMain () {
Log.d("[" +Thread.currentThread().name+"]testInMain start" )var job = CoroutineScope(Dispatchers.Main).launch {
Log.d("[" + Thread.currentThread().name+"]job start" )var job1 = async(Dispatchers.IO) {
Log.d("[" +Thread.currentThread().name+"]job1 start" )
delay(3000 )
Log.d("[" +Thread.currentThread().name+"]job1 end " )"job1-Return"
}
Log.d("[" +Thread.currentThread().name+"]job2 start" )
delay(1000 )
Log.d("[" +Thread.currentThread().name+"]job2 end" )"job2-Return"
}
Log.d("[" +Thread.currentThread().name+"]before job1 return" )
Log.d("[" +Thread.currentThread().name+"]job1 result = " + job1.await())
Log.d("[" +Thread.currentThread().name+"]before job2 return" )
Log.d("[" +Thread.currentThread().name+"]job2 result = " + job2.await())
Log.d("[" +Thread.currentThread().name+"]job end " )
}
Log.d("[" +Thread.currentThread().name+"]testInMain end" ) }
示例代码的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续体结束执行。
从图中,我们可以清晰的得到几点结论:
job协程内部,通过await 阻塞了后续代码的执行。job1和job2协程,通过delay阻塞了后续代码的执行。
协程job1,job2 启动后,保持并行执行。job2 并没有等待job1执行完才启动执行和恢复,而是在各自线程并行执行。
job的后续代码被await 阻塞后,并没有阻塞main线程,main线程中其它模块的代码能同时被执行,并打印出"[main]button 2 onclick now"。
job1 被delay阻塞后续代码执行时,并没有阻塞所在线程[DefaultDispatcher-worker-1],job2中的后续代码被恢复到此[DefaultDispatcher-worker-1]子线程中执行。
job1 和 job2 协程在恢复执行时,并不能确保在原线程中执行后续代码。如log所示,job2在DefaultDispatcher-worker-2中启动和阻塞后,却在DefaultDispatcher-worker-1中恢复了后续的代码执行。
所以可以看出,协程的挂起,并不会阻塞协程所在的线程,而只是中断了协程后面的代码执行。然后等待挂起函数完成后,恢复协程的后续代码执行。这就是协程挂起最最基本的关键点。
协程挂起的实现原理 上节中的示例代码,经过反编译后的核心代码如下:
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()); }
... ...
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;
}
}
Log.d(var5, var6.append((String)var7).toString());
Log.d("cjf---" , var10001.append("job end " ).toString());return Unit .INSTANCE; }
反编译后的主要区别在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 > {public val context: CoroutineContextpublic fun resumeWith (result: Result <T >) }
其具体实现在SuspendLambda的父类BaseContinuationImpl中:
probeCoroutineResumed(current)
with(current) {val completion = completion!!val outcome: Result<Any?> =
Result.success(outcome)
} catch (exception : Throwable) {
Result.failure(exception )
}
releaseIntercepted()
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放入stateval node = nodeCache ?: makeNode(handler, onCancelling).also { nodeCache = it }if (_state.compareAndSet(state , node)) return nod
}is Incomplete -> {// 有completion handlers,加入到node list列表val list = state.listval node = nodeCache ?: makeNode(handler, onCancelling).also { nodeCache = it }if (!addLastAtomic(state , list, node)) return @loopOnState /
}else -> { // 已经完成,不需要加入结果监听Nodeif (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恢复链,协程得以实现挂起和恢复的核心流程。