舉個栗子

通過下面的例子我們一起來一步一步來剖析kotlin協程

界面

image.png

界面邏輯

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

image.png

login()

image.png

startLaunch()

image.png

我們把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，這個我們可以在字節碼里可以看出

image.png

在字節碼里調用了指令 NEW com/maiml/pdfdemo/wanandroid/WanAndroidActivity$startLaunch$1 來創建對象

image.png

從上面的字節碼可以看出com/maiml/pdfdemo/wanandroid/WanAndroidActivity$startLaunch$1對象繼承了SuspendLambda并且實現了Function2接口。

BuildersKt.launch$default 方法的實現：

image.png

直至此我們通過反編譯可以看到協程體生成的代碼內容是什么，即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類也可以看出

image.png

可能有疑問為什么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)
}

image.png

任務調度到會執行TaskIpml的run方法，然后調用的是block.run(),block是DispatchedContinuation并且繼承了DispatchedTask，因此調用到DispatchedTask的run方法

image.png

如果不出現異常會走到 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方法

image.png

調用 SuspendLambda 的 invokeSuspend方法

image.png

看到72-76行，判斷var10000是否等于COROUTINE_SUSPENDED，如果等于COROUTINE_SUSPENDED代表沒有可用結果，需要掛起等待可用結果返回

看看調用的var13.login()方法會返回什么

只貼關鍵代碼

image.png

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() 進行恢復。

總結

image.png

執行到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)

Kotlin協程掛起(3)_十一月Siy的博客-CSDN博客

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

深入理解kotlin協程

深入理解kotlin協程

舉個栗子

字節碼分析

協程的創建、啟動、恢復

總結

參考

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

深入理解kotlin協程

舉個栗子

字節碼分析

協程的創建、啟動、恢復

總結

參考

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频