Kotlin協程launch啟動流程原理詳解
更新時間：2022年12月08日 09:01:09 作者：無糖可樂愛好者
這篇文章主要為大家介紹了Kotlin協程launch啟動流程原理詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪
1.launch啟動流程
已知協程的啟動方式之一是Globalscope.launch，那么Globalscope.launch的流程是怎樣的呢，直接進入launch的源碼開始看起。
fun main() {
coroutineTest()
Thread.sleep(2000L)
}
val block = suspend {
println("Hello")
delay(1000L)
println("Kotlin")
}
private fun coroutineTest() {
CoroutineScope(Job()).launch {
withContext(Dispatchers.IO) {
block.invoke()
}
}
}
反編譯后的Java代碼
public final class CoroutineDemoKt {
@NotNull
private static final Function1 block;
public static final void main() {
coroutineTest();
Thread.sleep(2000L);
}
// $FF: synthetic method
public static void main(String[] var0) {
main();
}
@NotNull
public static final Function1 getBlock() {
return block;
}
private static final void coroutineTest() {
BuildersKt.launch$default(CoroutineScopeKt.CoroutineScope((CoroutineContext)JobKt.Job$default((Job)null, 1, (Object)null)), (CoroutineContext)null, (CoroutineStart)null, (Function2)(new Function2((Continuation)null) {
int label;
@Nullable
public final Object invokeSuspend(@NotNull Object $result) {
Object var2 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
switch(this.label) {
case 0:
ResultKt.throwOnFailure($result);
CoroutineContext var10000 = (CoroutineContext)Dispatchers.getIO();
Function2 var10001 = (Function2)(new Function2((Continuation)null) {
int label;
@Nullable
public final Object invokeSuspend(@NotNull Object $result) {
Object var2 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
switch(this.label) {
case 0:
ResultKt.throwOnFailure($result);
Function1 var10000 = CoroutineDemoKt.getBlock();
this.label = 1;
if (var10000.invoke(this) == var2) {
return var2;
}
break;
case 1:
ResultKt.throwOnFailure($result);
break;
default:
throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
}
return Unit.INSTANCE;
}
@NotNull
public final Continuation create(@Nullable Object value, @NotNull Continuation completion) {
Intrinsics.checkNotNullParameter(completion, "completion");
Function2 var3 = new <anonymous constructor>(completion);
return var3;
}
public final Object invoke(Object var1, Object var2) {
return ((<undefinedtype>)this.create(var1, (Continuation)var2)).invokeSuspend(Unit.INSTANCE);
}
});
this.label = 1;
if (BuildersKt.withContext(var10000, var10001, this) == var2) {
return var2;
}
break;
case 1:
ResultKt.throwOnFailure($result);
break;
default:
throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
}
return Unit.INSTANCE;
}
@NotNull
public final Continuation create(@Nullable Object value, @NotNull Continuation completion) {
Intrinsics.checkNotNullParameter(completion, "completion");
Function2 var3 = new <anonymous constructor>(completion);
return var3;
}
public final Object invoke(Object var1, Object var2) {
return ((<undefinedtype>)this.create(var1, (Continuation)var2)).invokeSuspend(Unit.INSTANCE);
}
}), 3, (Object)null);
}
static {
Function1 var0 = (Function1)(new Function1((Continuation)null) {
int label;
@Nullable
public final Object invokeSuspend(@NotNull Object $result) {
Object var3 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
String var2;
switch(this.label) {
case 0:
ResultKt.throwOnFailure($result);
var2 = "Hello";
System.out.println(var2);
this.label = 1;
if (DelayKt.delay(1000L, this) == var3) {
return var3;
}
break;
case 1:
ResultKt.throwOnFailure($result);
break;
default:
throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
}
var2 = "Kotlin";
System.out.println(var2);
return Unit.INSTANCE;
}
@NotNull
public final Continuation create(@NotNull Continuation completion) {
Intrinsics.checkNotNullParameter(completion, "completion");
Function1 var2 = new <anonymous constructor>(completion);
return var2;
}
public final Object invoke(Object var1) {
return ((<undefinedtype>)this.create((Continuation)var1)).invokeSuspend(Unit.INSTANCE);
}
});
block = var0;
}
}
先分析一下上面代碼的流程：
- 首先聲明了一個Function1類型的block變量，這個變量就是demo中的block，然后會在static函數中會被賦值。
- 接下來就是coroutineTest函數的調用。這個函數中的第一行代碼就是CoroutineScope的傳參和一些默認值
- 然后通過89行的invoke進入到了外層狀態(tài)機流轉的過程
- 95行的static表示的是內部的掛起函數就是demo中的block.invoke，它是以匿名內部類的方式實現，然后執(zhí)行內部的狀態(tài)機流轉過程，最后給block賦值。
- block被賦值后最終在
Function1 var10000 = CoroutineDemoKt.getBlock();被調用
那么這個過程又是如何實現的，進入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指的就是demo中的block代碼段
再來看一下里面的幾行代碼的含義：
- newCoroutineContext： 通過默認的或者傳入的context創(chuàng)建一個新的Context；
- coroutine： launch 會根據傳入的啟動模式來創(chuàng)建對應的協程對象。這里有兩種，一種是標準的，一種是懶加載的。
- coroutine.start： 嘗試啟動協程
2.協程是如何被啟動的
通過launch的源碼可知協程的啟動是通過coroutine.start啟動的，那么協程的啟動流程又是怎樣的？
public abstract class AbstractCoroutine<in T>(
parentContext: CoroutineContext,
initParentJob: Boolean,
active: Boolean
) : JobSupport(active), Job, Continuation<T>, CoroutineScope {
...
/**
* 用給定的代碼塊啟動這個協程并啟動策略。這個函數在這個協程上最多調用一次。
*/
public fun <R> start(start: CoroutineStart, receiver: R, block: suspend R.() -> T) {
start(block, receiver, this)
}
}
start函數中傳入了三個參數，只需要關注第一個參數即可。
public enum class CoroutineStart {
...
/**
* 用這個協程的啟動策略啟動相應的塊作為協程。
*/
public operator fun <T> invoke(block: suspend () -> T, completion: Continuation<T>): Unit =
when (this) {
DEFAULT -> block.startCoroutineCancellable(completion)
ATOMIC -> block.startCoroutine(completion)
UNDISPATCHED -> block.startCoroutineUndispatched(completion)
LAZY -> Unit // will start lazily
}
}
啟動策略的具體實現有三種方式，這里只需要分析startCoroutine，另外兩個其實就是它的基礎上增加了一些功能，其中前者代表啟動協程以后可以在等待調度時取消，后者表示協程啟動后不會被分發(fā)。
/**
* 創(chuàng)建沒有接收方且結果類型為T的協程，這個函數每次調用時都會創(chuàng)建一個新的可掛起的實例。
*/
public fun <T> (suspend () -> T).startCoroutine(
completion: Continuation<T>
) {
createCoroutineUnintercepted(completion).intercepted().resume(Unit)
}
createCoroutineUnintercepted在源代碼中只是一個聲明，它的具體實現是在IntrinsicsJvm.kt文件中。
//IntrinsicsJvm.kt#createCoroutineUnintercepted
/**
* 創(chuàng)建沒有接收方且結果類型為T的非攔截協程。這個函數每次調用時都會創(chuàng)建一個新的可掛起的實例。
*/
public actual fun <T> (suspend () -> T).createCoroutineUnintercepted(
completion: Continuation<T>
): Continuation<Unit> {
val probeCompletion = probeCoroutineCreated(completion)
return if (this is BaseContinuationImpl)
create(probeCompletion)
else
createCoroutineFromSuspendFunction(probeCompletion) {
(this as Function1<Continuation<T>, Any?>).invoke(it)
}
}
actual代表了 createCoroutineUnintercepted() 在 JVM 平臺的實現。
createCoroutineUnintercepted是一個擴展函數，接收者類型是一個無參數，返回值為 T 的掛起函數或者 Lambda。
第9行代碼中的this代表的是(suspend () -> T)也就是invoke函數中的block變量，這個block變量就是demo中的block代碼段。
第9行的BaseContinuationImpl是一個抽象類它實現了Continuation。
關于if (this is BaseContinuationImpl)的結果暫且不分析，先分析兩種情況下的create函數：
- create(probeCompletion)：
//ContinuationImpl.kt#create
public open fun create(completion: Continuation<*>): Continuation<Unit> {
throw UnsupportedOperationException("create(Continuation) has not been overridden")
}
public open fun create(value: Any?, completion: Continuation<*>): Continuation<Unit> {
throw UnsupportedOperationException("create(Any?;Continuation) has not been overridden")
}
這個create函數拋出一個異常，意思就是這個create()沒有被重寫，而這個create()的重寫就是在反編譯后的Java代碼中的create函數
@NotNull
public final Continuation create(@Nullable Object value, @NotNull Continuation completion) {
Intrinsics.checkNotNullParameter(completion, "completion");
Function2 var3 = new <anonymous constructor>(completion);
return var3;
}
- createCoroutineFromSuspendFunction(probeCompletion)：
//IntrinsicsJvm.kt#createCoroutineFromSuspendFunction
/**
* 當一個被suspend修飾的lambda表達式沒有繼承BaseContinuationImpl類時，則通過此方法創(chuàng)建協程。
*
* 它發(fā)生在兩種情況下:
* 1.lambda表達式中調用了其他的掛起方法
* 2.掛起方法是通過Java實現的
*
* 必須將它封裝到一個擴展[BaseContinuationImpl]的實例中，因為這是所有協程機制的期望。
*/
private inline fun <T> createCoroutineFromSuspendFunction(
completion: Continuation<T>,
crossinline block: (Continuation<T>) -> Any?
): Continuation<Unit> {
val context = completion.context
// context為空創(chuàng)建一個受限協程
return if (context === EmptyCoroutineContext)
//受限協程：只能調用協程作用域中提供的掛起方式掛起，其他掛起方法不能調用
object : RestrictedContinuationImpl(completion as Continuation<Any?>) {
private var label = 0
override fun invokeSuspend(result: Result<Any?>): Any? =
when (label) {
0 -> {
label = 1
result.getOrThrow() // 如果試圖以異常開始，則重新拋出異常(將被BaseContinuationImpl.resumeWith捕獲)
block(this) // 運行塊，可以返回或掛起
}
1 -> {
label = 2
result.getOrThrow() // 這是block掛起的結果
}
else -> error("This coroutine had already completed")
}
}
else
//創(chuàng)建一個正常的協程
object : ContinuationImpl(completion as Continuation<Any?>, context) {
private var label = 0
override fun invokeSuspend(result: Result<Any?>): Any? =
when (label) {
0 -> {
label = 1
result.getOrThrow() // 如果試圖以異常開始，則重新拋出異常(將被BaseContinuationImpl.resumeWith捕獲)
block(this) // 運行塊，可以返回或掛起
}
1 -> {
label = 2
result.getOrThrow() // 這是block掛起的結果
}
else -> error("This coroutine had already completed")
}
}
}
createCoroutineFromSuspendFunction就是當一個被suspend修飾的Lambda表達式沒有繼承BaseContinuationImpl是才會被調用，然后根據上下文是否為空創(chuàng)建不同類型的協程。
兩種情況都已經分析完了，那么現在if (this is BaseContinuationImpl)會執(zhí)行哪一個呢，首先這里的this所指的就是demo中的block代碼段，Kotlin編譯器編譯后會自動生成一個類就是上面的static，它會繼承SuspendLambda類，而這個SuspendLambda類繼承自ContinuationImpl，ContinuationImpl繼承自BaseContinuationImpl，因此可以得到判斷結果為true，
createCoroutineUnintercepted的過程就是協程創(chuàng)建的過程。
然后就是intercepted函數，這個函數的具體實現也在IntrinsicsJvm.kt中，那么intercepted又做了什么呢
public expect fun <T> Continuation<T>.intercepted(): Continuation<T>
//具體實現
//IntrinsicsJvm.kt#intercepted
public actual fun <T> Continuation<T>.intercepted(): Continuation<T> =
(this as? ContinuationImpl)?.intercepted() ?: this
首先有個強轉，通過上面的分析這個強轉是一定會成功的，到這里intercepted就進入到了ContinuationImpl中了
internal abstract class ContinuationImpl(
completion: Continuation<Any?>?,
private val _context: CoroutineContext?
) : BaseContinuationImpl(completion) {
...
@Transient
private var intercepted: Continuation<Any?>? = null
//如果沒有緩存，則從上下文獲取攔截器，調用interceptContinuation進行攔截
//將獲取到的內容保存到全局變量
public fun intercepted(): Continuation<Any?> =
intercepted
?: (context[ContinuationInterceptor]?.interceptContinuation(this) ?: this)
.also { intercepted = it }
}
這里的ContinuationInterceptor指的就是Demo中傳輸的Dispatcher.IO，默認值時Dispatcher.Default。
再回到startContinue中還剩最后一個resume：
/**
* 恢復執(zhí)行相應的協程傳遞值作為最后一個掛起點的返回值。
*/
public inline fun <T> Continuation<T>.resume(value: T): Unit =
resumeWith(Result.success(value))
public interface Continuation<in T> {
/**
* 與此延續(xù)相對應的協程的上下文。
*/
public val context: CoroutineContext
/**
* 恢復執(zhí)行相應的協程傳遞值作為最后一個掛起點的返回值。
*/
public fun resumeWith(result: Result<T>)
}
這里的resume(Unit)作用就相當與啟動了一個協程。
上面的啟動流程中為了方便分析的是CoroutineStart.ATOMIC,而默認的是CoroutineStart.DEFAULT，下面分析一下DEFAULT的流程
//Cancellable.kt#startCoroutineCancellable
public fun <T> (suspend () -> T).startCoroutineCancellable(completion: Continuation<T>): Unit = runSafely(completion) {
createCoroutineUnintercepted(completion).intercepted().resumeCancellableWith(Result.success(Unit))
}
startCoroutineCancellable對于協程的創(chuàng)建和攔截與ATOMIC是一樣的，區(qū)別就在于resumeCancellableWith
//DispatchedContinuation#resumeCancellableWith
public fun <T> Continuation<T>.resumeCancellableWith(
result: Result<T>,
onCancellation: ((cause: Throwable) -> Unit)? = null
): Unit = when (this) {
is DispatchedContinuation -> resumeCancellableWith(result, onCancellation)
else -> resumeWith(result)
}
// 我們內聯它來保存堆棧上的一個條目，在它顯示的情況下(無限制調度程序)
// 它只在Continuation<T>.resumeCancellableWith中使用
@Suppress("NOTHING_TO_INLINE")
inline fun resumeCancellableWith(
result: Result<T>,
noinline onCancellation: ((cause: Throwable) -> Unit)?
) {
val state = result.toState(onCancellation)
//是否需要分發(fā)
if (dispatcher.isDispatchNeeded(context)) {
_state = state
resumeMode = MODE_CANCELLABLE
//將可運行塊的執(zhí)行分派給給定上下文中的另一個線程
dispatcher.dispatch(context, this)
} else {
executeUnconfined(state, MODE_CANCELLABLE) {
//協程未被取消
if (!resumeCancelled(state)) {
// 恢復執(zhí)行
resumeUndispatchedWith(result)
}
}
}
}
//恢復執(zhí)行前判斷協程是否已經取消執(zhí)行
inline fun resumeCancelled(state: Any?): Boolean {
//獲取當前協程任務
val job = context[Job]
//如果不為空且不活躍
if (job != null && !job.isActive) {
val cause = job.getCancellationException()
cancelCompletedResult(state, cause)
//拋出異常
resumeWithException(cause)
return true
}
return false
}
//我們需要內聯它來在堆棧中保存一個條目
inline fun resumeUndispatchedWith(result: Result<T>) {
withContinuationContext(continuation, countOrElement) {
continuation.resumeWith(result)
}
}以上就是Kotlin協程launch啟動流程原理詳解的詳細內容，更多關于Kotlin協程launch啟動流程的資料請關注腳本之家其它相關文章！
相關文章
本篇文章主要介紹了用RxJava實現事件總線(Event Bus)，小編覺得挺不錯的，現在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2017-11-11
這篇文章主要為大家詳細介紹了Android Zxing二維碼掃描圖片拉伸問題的解決方法，具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-06-06
這篇文章主要為大家詳細介紹了Android側滑效果簡單實現代碼,具有一定的參考價值，感興趣的小伙伴們可以參考一下2016-11-11
這篇文章主要給大家介紹了關于通過源碼角度看看AccessibilityService的相關資料，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2018-06-06
這篇文章主要介紹了Jsoup 抓取頁面的數據實例詳解的相關資料,需要的朋友可以參考下2016-12-12
霍夫變換利用點與線之間的對偶性，將圖像空間中直線上離散的像素點通過參數方程映射為霍夫空間中的曲線，并將霍夫空間中多條曲線的交點作為直線方程的參數映射為圖像空間中的直線。給定直線的參數方程，可以利用霍夫變換來檢測圖像中的直線。本文簡單講解Android的實現2021-06-06
Android開發(fā)中Launcher3常見默認配置修改方法總結
這篇文章主要介紹了Android開發(fā)中Launcher3常見默認配置修改方法,結合實例形式分析了Android Launcher3的功能與配置修改相關操作技巧,需要的朋友可以參考下2017-11-11
這篇文章主要介紹了Android編程ViewPager回彈效果,以實例形式較為詳細的分析了ViewPager回彈效果的相關使用技巧,具有一定參考借鑒價值,需要的朋友可以參考下2015-10-10
這篇文章主要為大家詳細介紹了android短信管理器SmsManager實例，具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-11-11
這篇文章主要為大家詳細介紹了Android圓形控件實現畫圓效果，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-05-05