舉個栗子
通過下面的例子我們一起來一步一步來剖析kotlin協程
界面
界面邏輯
```
class WanAndroidActivity:AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_wanandroid)
btnStart.setOnClickListener {
startLaunch()
}
}
private fun startLaunch() {
GlobalScope.launch {
println("啟動協程-- Thread name = ${Thread.currentThread().name}")
val wanAndroidApi = NetContext.get().create(WanAndroidApi::class.java)
val token = login()
println("token = $token")
val users = getUserList(token)
println("users = $users")
}
}
private suspend fun getUserList(token: String): List<String> {
delay(2000)
return listOf("abc","bcd","cde")
}
private suspend fun login(): String {
delay(2000)
return "token"
}
}
```
界面的布局和邏輯比較簡單
字節碼分析
對代碼進行反編譯,點擊AS Tools->kotlin->show kotlin bytecode
在上面的類定義了三個函數分別是 getUserList(token: String)
、login()
、startLaunch()
,我們逐個來看:
getUserList(token: String)
login()
startLaunch()
我們把startLaunch()
反編譯的代碼,其中Function2
的實現先抽出來,簡化一下代碼,如下:
private final void startLaunch() {
CoroutineScope coroutineScope = CoroutineScope.INSTANCE;
CoroutineContext context = null;
CoroutineStart coroutineStart = null;
Function2 function2 = SuspendLambda(){};
BuildersKt.launch$default(coroutineScope,context,coroutineStart,function2, null);
}
SuspendLambda
怎么來的:
為什么Function2
創建的實例是SuspendLambda
,這個我們可以在字節碼里可以看出
在字節碼里調用了指令 NEW com/maiml/pdfdemo/wanandroid/WanAndroidActivity$startLaunch$1
來創建對象
從上面的字節碼可以看出com/maiml/pdfdemo/wanandroid/WanAndroidActivity$startLaunch$1
對象繼承了SuspendLambda
并且實現了Function2
接口。
BuildersKt.launch$default
方法的實現:
直至此我們通過反編譯可以看到協程體生成的代碼內容是什么,即SuspendLambda
。
協程的創建、啟動、恢復
我們來看CoroutineScope.launch{}
的源碼,來看一下協程的創建、啟動和恢復
public fun CoroutineScope.launch(
context: CoroutineContext = EmptyCoroutineContext,
start: CoroutineStart = CoroutineStart.DEFAULT,
block: suspend CoroutineScope.() -> Unit
): Job {
val newContext = newCoroutineContext(context)
val coroutine = if (start.isLazy)
LazyStandaloneCoroutine(newContext, block) else
StandaloneCoroutine(newContext, active = true)
coroutine.start(start, coroutine, block)
return coroutine
}
其中 block: suspend CoroutineScope.() -> Unit
是SuspendLambda
//AbstractCoroutine.kt
//receiver:StandaloneCoroutine
//completion:StandaloneCoroutine<Unit>
public fun <R> start(start: CoroutineStart, receiver: R, block: suspend R.() -> T) {
initParentJob()
start(block, receiver, this)
}
start(block, receiver, this)
調用 CoroutineStart 中的 invoke 方法
//receiver:StandaloneCoroutine
//completion:StandaloneCoroutine<Unit>
@InternalCoroutinesApi
public operator fun <R, T> invoke(block: suspend R.() -> T, receiver: R, completion: Continuation<T>) =
when (this) {
CoroutineStart.DEFAULT -> block.startCoroutineCancellable(receiver, completion)
CoroutineStart.ATOMIC -> block.startCoroutine(receiver, completion)
CoroutineStart.UNDISPATCHED -> block.startCoroutineUndispatched(receiver, completion)
CoroutineStart.LAZY -> Unit // will start lazily
}
會走到CoroutineStart.DEFAULT
//Cacellable.kt
//receiver:StandaloneCoroutine
//completion:StandaloneCoroutine<Unit>
internal fun <R, T> (suspend (R) -> T).startCoroutineCancellable(receiver: R, completion: Continuation<T>) =
runSafely(completion) {
createCoroutineUnintercepted(receiver, completion).intercepted().resumeCancellableWith(Result.success(Unit))
}
調用3個方法,createCoroutineUnintercepted()
,intercepted()
,resumeCancellableWith()
先看看createCoroutineUnintercepted()
//IntrinsicsJvm.kt
@SinceKotlin("1.3")
public actual fun <R, T> (suspend R.() -> T).createCoroutineUnintercepted(
receiver: R,
completion: Continuation<T>
): Continuation<Unit> {
val probeCompletion = probeCoroutineCreated(completion)
return if (this is BaseContinuationImpl)
create(receiver, probeCompletion)
else {
createCoroutineFromSuspendFunction(probeCompletion) {
(this as Function2<R, Continuation<T>, Any?>).invoke(receiver, it)
}
}
}
可以看到是調用 BaseContinuationImpl
的 create
的方法
public open fun create(value: Any?, completion: Continuation<*>): Continuation<Unit> {
throw UnsupportedOperationException("create(Any?;Continuation) has not been overridden")
}
create方法具體實現是什么,在 com/maiml/pdfdemo/wanandroid/WanAndroidActivity$startLaunch$1
的字節碼找到相對應的實現
// access flags 0x11
// signature (Ljava/lang/Object;Lkotlin/coroutines/Continuation<*>;)Lkotlin/coroutines/Continuation<Lkotlin/Unit;>;
// declaration: kotlin.coroutines.Continuation<kotlin.Unit> create(java.lang.Object, kotlin.coroutines.Continuation<?>)
public final create(Ljava/lang/Object;Lkotlin/coroutines/Continuation;)Lkotlin/coroutines/Continuation;
@Lorg/jetbrains/annotations/NotNull;() // invisible
// annotable parameter count: 2 (visible)
// annotable parameter count: 2 (invisible)
@Lorg/jetbrains/annotations/Nullable;() // invisible, parameter 0
@Lorg/jetbrains/annotations/NotNull;() // invisible, parameter 1
L0
ALOAD 2
LDC "completion"
INVOKESTATIC kotlin/jvm/internal/Intrinsics.checkParameterIsNotNull (Ljava/lang/Object;Ljava/lang/String;)V
NEW com/maiml/pdfdemo/wanandroid/WanAndroidActivity$startLaunch$1
DUP
ALOAD 0
GETFIELD com/maiml/pdfdemo/wanandroid/WanAndroidActivity$startLaunch$1.this$0 : Lcom/maiml/pdfdemo/wanandroid/WanAndroidActivity;
ALOAD 2
INVOKESPECIAL com/maiml/pdfdemo/wanandroid/WanAndroidActivity$startLaunch$1.<init> (Lcom/maiml/pdfdemo/wanandroid/WanAndroidActivity;Lkotlin/coroutines/Continuation;)V
ASTORE 3
ALOAD 3
ARETURN
L1
LOCALVARIABLE this Lkotlin/coroutines/jvm/internal/BaseContinuationImpl; L0 L1 0
LOCALVARIABLE value Ljava/lang/Object; L0 L1 1
LOCALVARIABLE completion Lkotlin/coroutines/Continuation; L0 L1 2
MAXSTACK = 4
MAXLOCALS = 4
上面的代碼可以看到是創建出了 com/maiml/pdfdemo/wanandroid/WanAndroidActivity$startLaunch$1
并返回
在反編譯的Java類也可以看出
可能有疑問為什么BaseContinuationImpl
的 create
的方法的實現要在com/maiml/pdfdemo/wanandroid/WanAndroidActivity$startLaunch$1
字節碼找,在上面我們分析了com/maiml/pdfdemo/wanandroid/WanAndroidActivity$startLaunch$1
是SuspendLambda
,而SuspendLambda
的繼承關系是:SuspendLambda
->ContinuationImpl
->BaseContinuationImpl
。
intercepted()
//IntrinsicsJvm.kt
//這里的 this 是 `com/maiml/pdfdemo/wanandroid/WanAndroidActivity$startLaunch$1` 實例 - ContinuationImpl的子類
@SinceKotlin("1.3")
public actual fun <T> Continuation<T>.intercepted(): Continuation<T> =
(this as? ContinuationImpl)?.intercepted() ?: this
//ContinuationImpl
// context[ContinuationInterceptor]是 CoroutineDispatcher 實例
public fun intercepted(): Continuation<Any?> =
intercepted
?: (context[ContinuationInterceptor]?.interceptContinuation(this) ?: this)
.also { intercepted = it }
//CoroutineDispatcher
public final override fun <T> interceptContinuation(continuation: Continuation<T>): Continuation<T> =
DispatchedContinuation(this, continuation)
創建DispatchedContinuation
用于線程調度
resumeCancellableWith()
// this 是 DispatchedContinuation
public fun <T> Continuation<T>.resumeCancellableWith(result: Result<T>) = when (this) {
is DispatchedContinuation -> resumeCancellableWith(result)
else -> resumeWith(result)
}
inline fun resumeCancellableWith(result: Result<T>) {
val state = result.toState()
//判斷是否需要線程調度,我們這里需要
if (dispatcher.isDispatchNeeded(context)) {
_state = state
resumeMode = MODE_CANCELLABLE
dispatcher.dispatch(context, this)
} else {
executeUnconfined(state, MODE_CANCELLABLE) {
if (!resumeCancelled()) {
resumeUndispatchedWith(result)
}
}
}
}
dispatcher
是:
public actual fun CoroutineScope.newCoroutineContext(context: CoroutineContext): CoroutineContext {
val combined = coroutineContext + context
val debug = if (DEBUG) combined + CoroutineId(COROUTINE_ID.incrementAndGet()) else combined
return if (combined !== Dispatchers.Default && combined[ContinuationInterceptor] == null)
debug + Dispatchers.Default else debug
}
在 newCoroutineContext
創建
coroutine 的時候如果沒有指定Dispatchers會 添加默認Dispatchers.Default
@JvmStatic
public actual val Default: CoroutineDispatcher = createDefaultDispatcher()
internal const val COROUTINES_SCHEDULER_PROPERTY_NAME = "kotlinx.coroutines.scheduler"
internal val useCoroutinesScheduler = systemProp(COROUTINES_SCHEDULER_PROPERTY_NAME).let { value ->
when (value) {
null, "", "on" -> true
"off" -> false
else -> error("System property '$COROUTINES_SCHEDULER_PROPERTY_NAME' has unrecognized value '$value'")
}
}
internal actual fun createDefaultDispatcher(): CoroutineDispatcher =
if (useCoroutinesScheduler) DefaultScheduler else CommonPool
COROUTINES_SCHEDULER_PROPERTY_NAME
的值默認是on
,即會創建DefaultScheduler
,dispatcher.dispatch
是的 DefaultScheduler類的dispatch方法
//Dispatcher.kt
override fun dispatch(context: CoroutineContext, block: Runnable): Unit =
try {
coroutineScheduler.dispatch(block)
} catch (e: RejectedExecutionException) {
DefaultExecutor.dispatch(context, block)
}
//CoroutineScheduler.kt
fun dispatch(block: Runnable, taskContext: TaskContext = NonBlockingContext, fair: Boolean = false) {
trackTask() // this is needed for virtual time support
val task = createTask(block, taskContext)
// try to submit the task to the local queue and act depending on the result
val notAdded = submitToLocalQueue(task, fair)
if (notAdded != null) {
if (!addToGlobalQueue(notAdded)) {
// Global queue is closed in the last step of close/shutdown -- no more tasks should be accepted
throw RejectedExecutionException("$schedulerName was terminated")
}
}
// Checking 'task' instead of 'notAdded' is completely okay
if (task.mode == TaskMode.NON_BLOCKING) {
signalCpuWork()
} else {
signalBlockingWork()
}
}
internal fun createTask(block: Runnable, taskContext: TaskContext): Task {
val nanoTime = schedulerTimeSource.nanoTime()
if (block is Task) {
block.submissionTime = nanoTime
block.taskContext = taskContext
return block
}
return TaskImpl(block, nanoTime, taskContext)
}
任務調度到會執行TaskIpml
的run
方法,然后調用的是block.run()
,block是DispatchedContinuation并且繼承了DispatchedTask,因此調用到DispatchedTask的run方法
如果不出現異常會走到 continuation.resume()
// Continuation.kt
public inline fun <T> Continuation<T>.resume(value: T): Unit =
resumeWith(Result.success(value))
Continuation對象是分析的SuspendLambda
,它的繼承關系是:SuspendLambda
->ContinuationImpl
->BaseContinuationImpl
,最終會調用到BaseContinuationImpl的resumeWith方法
調用 SuspendLambda
的 invokeSuspend
方法
看到72-76行,判斷var10000
是否等于COROUTINE_SUSPENDED,如果等于COROUTINE_SUSPENDED代表沒有可用結果,需要掛起等待可用結果返回
看看調用的var13.login()
方法會返回什么
只貼關鍵代碼
public suspend fun delay(timeMillis: Long) {
if (timeMillis <= 0) return // don't delay
return suspendCancellableCoroutine sc@ { cont: CancellableContinuation<Unit> ->
cont.context.delay.scheduleResumeAfterDelay(timeMillis, cont)
}
}
返回suspendCancellableCoroutine即COROUTINE_SUSPENDED,需要掛起等待結果返回,DelayKt.delay()我們可以類比成Handler.postDelayed,執行完成后會調用會continuation.resume() ->BaseContinuationImpl.resumeWith()->SuspendLambda.invokeSuspend() 進行恢復。
總結
執行到
login()
方法時,login()
方法會返回COROUTINE_SUSPENDED
,在71行把label 設置為1,執行var10000 == var7 然后return。為什么login()
方法會返回COROUTINE_SUSPENDED
,因為在login()
方法調用delay()
方法,協程會被掛起,代表當前結果不可用。當
login()
方法執行結束,并有可用結果返回,回調到invokeSuspend
方法,此時的label=1,把結果賦值給var10000,然后break執行下面的邏輯。來到89行,token=var10000,并把label設置為2,執行
getUserList()
方法,因為getUserList()
方法內部也是調用delay()
方法,因此協程也會被掛起,返回COROUTINE_SUSPENDED
,執行var10000 == var7 然后return,繼續等待可用結果返回。當
getUserList()
方法執行結束,并有可用結果返回,回調到invokeSuspend
方法,此時的label=2,把結果賦值給var10000,并執行break label17,來到101行執行剩下的邏輯。
參考
Kotlin協程之深入理解協程工作原理 - 掘金 (juejin.cn)
Kotlin Coroutines(協程) 完全解析(二),深入理解協程的掛起、恢復與調度 - 簡書 (jianshu.com)