Kotlin中協(xié)程的創(chuàng)建過程詳析

更新時(shí)間：2022年01月23日 09:49:07 作者：ZzT

使用協(xié)程的專業(yè)開發(fā)者中有超過 50% 的人反映使用協(xié)程提高了工作效率,下面這篇文章主要給大家介紹了關(guān)于Kotlin中協(xié)程創(chuàng)建過程的相關(guān)資料,文中通過實(shí)例代碼介紹的非常詳細(xì),需要的朋友可以參考下

為什么需要協(xié)程？

協(xié)程可以簡化異步編程，可以順序地表達(dá)程序，協(xié)程也提供了一種避免阻塞線程并用更廉價(jià)、更可控的操作替代線程阻塞的方法 – 掛起函數(shù)。

Kotlin 的協(xié)程是依靠編譯器實(shí)現(xiàn)的, 并不需要操作系統(tǒng)和硬件的支持。編譯器為了讓開發(fā)者編寫代碼更簡單方便, 提供了一些關(guān)鍵字(例如suspend), 并在內(nèi)部自動生成了一些支持型的代碼。

創(chuàng)建并啟動協(xié)程

fun create.main() {
    //1. 創(chuàng)建協(xié)程體
    val coroutine = suspend {
        println("in coroutine")
        5
    }.createCoroutine(object: Continuation<Int> {
        override fun resumeWith(result: Result<Int>) {
            println("coroutine end: $result")
        }

        override val context: CoroutineContext
            get() = EmptyCoroutineContext

    })

    //2. 執(zhí)行協(xié)程
    coroutine.resume(Unit)
}

上面代碼的輸出結(jié)果：

in coroutine
coroutine end: Success(5)

協(xié)程的執(zhí)行過程

調(diào)用棧流程如下

我們通過 suspend block#createCoroutine 得到的 coroutine 實(shí)際是 SafeContinuation 對象
SafeContinuation 實(shí)際上是代理類，其中的 delegate 屬性才是真正的 Continuation 對象
suspend block 中的代碼在 BaseContinuationImpl 中執(zhí)行
我們的匿名內(nèi)部類對象 Continuation 被回調(diào)

suspend block 是如何變?yōu)閰f(xié)程體被執(zhí)行的？

我們分析調(diào)用棧得知，resumeWith 最終是在 BaseContinuationImpl 中執(zhí)行的，下面來看看代碼

@SinceKotlin("1.3")
internal abstract class BaseContinuationImpl(
    public val completion: Continuation<Any?>?
) : Continuation<Any?>, CoroutineStackFrame, Serializable {
    public final override fun resumeWith(result: Result<Any?>) {
        var current = this
        var param = result
        while (true) {
            probeCoroutineResumed(current)
            with(current) {
                val completion = completion!!
                val outcome: Result<Any?> =
                    try {
                        val outcome = invokeSuspend(param) //1.這里執(zhí)行了 suspend block
                        if (outcome === COROUTINE_SUSPENDED) return
                        Result.success(outcome)
                    } catch (exception: Throwable) {
                        Result.failure(exception)
                    }
                releaseIntercepted()
                if (completion is BaseContinuationImpl) {
                    current = completion
                    param = outcome
                } else {
                    completion.resumeWith(outcome) //2.這里回調(diào)了我們的匿名內(nèi)部類
                    return
                }
            }
        }
    }

    protected abstract fun invokeSuspend(result: Result<Any?>): Any? //3. 抽象方法
}

在代碼注釋 1. 處，調(diào)用 current.invokeSuspend，執(zhí)行了我們定義的協(xié)程體，證明 suspend block 其實(shí)是 BaseContinuationImpl 的子類

在 2. 處，協(xié)程體執(zhí)行完畢后，我們的代碼收到了完成回調(diào)

在 3. 處，可以發(fā)現(xiàn) invokeSuspend 是個(gè)抽象方法，suspend block 就是這個(gè)方法的具體實(shí)現(xiàn)

下面我通過斷點(diǎn)，進(jìn)一步分析 suspend block 是通過哪個(gè)子類執(zhí)行的。

可以看到 current 是名為 {文件}${方法}${變量}$1 格式的對象，證明 kotlin 編譯器遇到 suspend 關(guān)鍵字后會幫我們生成一個(gè) BaseContinuationImpl 的子類

那么，這個(gè)子類到底是什么呢？將 kt 編譯為 .class 再通過 jadx 打開后，得到的 java 代碼如下

public final class CreateCoroutineKt {
    public static final void create.main() {
        Continuation coroutine = ContinuationKt.createCoroutine(new CreateCoroutineKt$create.main$coroutine$1(null), new CreateCoroutineKt$create.main$coroutine$2());
        Unit unit = Unit.INSTANCE;
        Result.Companion companion = Result.Companion;
        coroutine.resumeWith(Result.constructor-impl(unit));
    }
}

final class CreateCoroutineKt$create.main$coroutine$1 extends SuspendLambda implements Function1<Continuation<? super Integer>, Object> {
    int label;

    CreateCoroutineKt$create.main$coroutine$1(Continuation<? super CreateCoroutineKt$create.main$coroutine$1> continuation) {
        super(1, continuation);
    }

    @NotNull
    public final Continuation<Unit> create(@NotNull Continuation<?> continuation) {
        return new CreateCoroutineKt$create.main$coroutine$1(continuation);
    }

    @Nullable
    public final Object invoke(@Nullable Continuation<? super Integer> continuation) {
        return create(continuation).invokeSuspend(Unit.INSTANCE);
    }

    @Nullable
    public final Object invokeSuspend(@NotNull Object obj) {
        IntrinsicsKt.getCOROUTINE_SUSPENDED();
        switch (this.label) {
            case 0:
                ResultKt.throwOnFailure(obj);
                System.out.println((Object) "in coroutine"); //協(xié)程體的邏輯
                return Boxing.boxInt(5);
            default:
                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
        }
    }
}

明顯看出，kt 編譯器幫助我們把 suspend 關(guān)鍵字變?yōu)榱?SuspendLambda 的子類，并重寫了 invokeSuspend 方法，不難猜出 SuspendLambda 繼承自 BaseContinuationImp