Kotlin協(xié)程launch啟動流程原理詳解

更新時間：2022年12月08日 09:01:09 作者：無糖可樂愛好者

這篇文章主要為大家介紹了Kotlin協(xié)程launch啟動流程原理詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪

1.launch啟動流程

已知協(xié)程的啟動方式之一是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函數(shù)中會被賦值。
接下來就是coroutineTest函數(shù)的調用。這個函數(shù)中的第一行代碼就是CoroutineScope的傳參和一些默認值
然后通過89行的invoke進入到了外層狀態(tài)機流轉的過程
95行的static表示的是內部的掛起函數(shù)就是demo中的block.invoke，它是以匿名內部類的方式實現(xiàn)，然后執(zhí)行內部的狀態(tài)機流轉過程，最后給block賦值。
block被賦值后最終在Function1 var10000 = CoroutineDemoKt.getBlock();被調用

那么這個過程又是如何實現(xiàn)的，進入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 會根據(jù)傳入的啟動模式來創(chuàng)建對應的協(xié)程對象。這里有兩種，一種是標準的，一種是懶加載的。
coroutine.start： 嘗試啟動協(xié)程

2.協(xié)程是如何被啟動的

通過launch的源碼可知協(xié)程的啟動是通過coroutine.start啟動的，那么協(xié)程的啟動流程又是怎樣的？

public abstract class AbstractCoroutine<in T>(
    parentContext: CoroutineContext,
    initParentJob: Boolean,
    active: Boolean
) : JobSupport(active), Job, Continuation<T>, CoroutineScope {
    ...
    /**
     * 用給定的代碼塊啟動這個協(xié)程并啟動策略。這個函數(shù)在這個協(xié)程上最多調用一次。
     */
    public fun <R> start(start: CoroutineStart, receiver: R, block: suspend R.() -> T) {
        start(block, receiver, this)
    }
}

start函數(shù)中傳入了三個參數(shù)，只需要關注第一個參數(shù)即可。

public enum class CoroutineStart {
    ...
    /**
     * 用這個協(xié)程的啟動策略啟動相應的塊作為協(xié)程。
     */
    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
    }
}

啟動策略的具體實現(xiàn)有三種方式，這里只需要分析startCoroutine，另外兩個其實就是它的基礎上增加了一些功能，其中前者代表啟動協(xié)程以后可以在等待調度時取消，后者表示協(xié)程啟動后不會被分發(fā)。

/**
 * 創(chuàng)建沒有接收方且結果類型為T的協(xié)程，這個函數(shù)每次調用時都會創(chuàng)建一個新的可掛起的實例。
 */ 
public fun <T> (suspend () -> T).startCoroutine(
    completion: Continuation<T>
) {
    createCoroutineUnintercepted(completion).intercepted().resume(Unit)
}

createCoroutineUnintercepted在源代碼中只是一個聲明，它的具體實現(xiàn)是在IntrinsicsJvm.kt文件中。

//IntrinsicsJvm.kt#createCoroutineUnintercepted
/**
 * 創(chuàng)建沒有接收方且結果類型為T的非攔截協(xié)程。這個函數(shù)每次調用時都會創(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 平臺的實現(xiàn)。

createCoroutineUnintercepted是一個擴展函數(shù)，接收者類型是一個無參數(shù)，返回值為 T 的掛起函數(shù)或者 Lambda。

第9行代碼中的this代表的是(suspend () -> T)也就是invoke函數(shù)中的block變量，這個block變量就是demo中的block代碼段。

第9行的BaseContinuationImpl是一個抽象類它實現(xiàn)了Continuation。

關于if (this is BaseContinuationImpl)的結果暫且不分析，先分析兩種情況下的create函數(shù)：

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函數(shù)拋出一個異常，意思就是這個create()沒有被重寫，而這個create()的重寫就是在反編譯后的Java代碼中的create函數(shù)

@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表達式?jīng)]有繼承BaseContinuationImpl類時，則通過此方法創(chuàng)建協(xié)程。
 *
 * 它發(fā)生在兩種情況下:
 * 1.lambda表達式中調用了其他的掛起方法
 * 2.掛起方法是通過Java實現(xiàn)的
 *
 * 必須將它封裝到一個擴展[BaseContinuationImpl]的實例中，因為這是所有協(xié)程機制的期望。 
 */
private inline fun <T> createCoroutineFromSuspendFunction(
	completion: Continuation<T>,
	crossinline block: (Continuation<T>) -> Any?
		): Continuation<Unit> {
	val context = completion.context
	// context為空創(chuàng)建一個受限協(xié)程
	return if (context === EmptyCoroutineContext)
	//受限協(xié)程：只能調用協(xié)程作用域中提供的掛起方式掛起，其他掛起方法不能調用
	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)建一個正常的協(xié)程
	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表達式?jīng)]有繼承BaseContinuationImpl是才會被調用，然后根據(jù)上下文是否為空創(chuàng)建不同類型的協(xié)程。

兩種情況都已經(jīng)分析完了，那么現(xiàn)在if (this is BaseContinuationImpl)會執(zhí)行哪一個呢，首先這里的this所指的就是demo中的block代碼段，Kotlin編譯器編譯后會自動生成一個類就是上面的static，它會繼承SuspendLambda類，而這個SuspendLambda類繼承自ContinuationImpl，ContinuationImpl繼承自BaseContinuationImpl，因此可以得到判斷結果為true，

createCoroutineUnintercepted的過程就是協(xié)程創(chuàng)建的過程。

然后就是intercepted函數(shù)，這個函數(shù)的具體實現(xiàn)也在IntrinsicsJvm.kt中，那么intercepted又做了什么呢

public expect fun <T> Continuation<T>.intercepted(): Continuation<T>
//具體實現(xiàn)
//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中傳輸?shù)?code>Dispatcher.IO，默認值時Dispatcher.Default。

再回到startContinue中還剩最后一個resume：

/**
 * 恢復執(zhí)行相應的協(xié)程傳遞值作為最后一個掛起點的返回值。
 */
public inline fun <T> Continuation<T>.resume(value: T): Unit =
	resumeWith(Result.success(value))
public interface Continuation<in T> {
	/**
     * 與此延續(xù)相對應的協(xié)程的上下文。
     */
	public val context: CoroutineContext
	/**
     * 恢復執(zhí)行相應的協(xié)程傳遞值作為最后一個掛起點的返回值。
     */
	public fun resumeWith(result: Result<T>)
}

這里的resume(Unit)作用就相當與啟動了一個協(xié)程。

上面的啟動流程中為了方便分析的是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對于協(xié)程的創(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)
}
// 我們內聯(lián)它來保存堆棧上的一個條目，在它顯示的情況下(無限制調度程序)
// 它只在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) {
			//協(xié)程未被取消
			if (!resumeCancelled(state)) {
				// 恢復執(zhí)行
				resumeUndispatchedWith(result)
			}
		}
	}
}
//恢復執(zhí)行前判斷協(xié)程是否已經(jīng)取消執(zhí)行
inline fun resumeCancelled(state: Any?): Boolean {
	//獲取當前協(xié)程任務
	val job = context[Job]
	//如果不為空且不活躍
	if (job != null && !job.isActive) {
		val cause = job.getCancellationException()
		cancelCompletedResult(state, cause)
		//拋出異常
		resumeWithException(cause)
		return true
	}
	return false
}
//我們需要內聯(lián)它來在堆棧中保存一個條目
inline fun resumeUndispatchedWith(result: Result<T>) {
	withContinuationContext(continuation, countOrElement) {
		continuation.resumeWith(result)
	}
}

以上就是Kotlin協(xié)程launch啟動流程原理詳解的詳細內容，更多關于Kotlin協(xié)程launch啟動流程的資料請關注腳本之家其它相關文章！

您可能感興趣的文章:

Android指紋登錄工具類封裝
這篇文章主要為大家詳細介紹了Android指紋登錄工具類的封裝，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下
2020-09-09
Kotlin擴展函數(shù)及實現(xiàn)機制的深入探索
擴展函數(shù)與擴展屬性的神奇之處在于，可以在不修改原來類的條件下，使用函數(shù)和屬性，表現(xiàn)得就像是屬于這個類的一樣。下面這篇文章主要給大家介紹了關于Kotlin擴展函數(shù)及實現(xiàn)機制的相關資料，需要的朋友可以參考下
2018-06-06
Android開發(fā)之使用GridView展示圖片的方法
這篇文章主要介紹了Android開發(fā)之使用GridView展示圖片的方法,涉及Android使用GridView操作圖片的布局與圖片調用功能實現(xiàn)技巧,需要的朋友可以參考下
2016-01-01
Android 實現(xiàn)仿網(wǎng)絡直播彈幕功能詳解及實例
這篇文章主要介紹了Android 實現(xiàn)仿網(wǎng)絡直播彈幕功能詳解的相關資料,并附實例代碼及實現(xiàn)效果圖，需要的朋友可以參考下
2016-11-11
Android :okhttp+Springmvc文件解析器實現(xiàn)android向服務器上傳照片
這篇文章主要介紹了Android :okhttp+Springmvc文件解析器實現(xiàn)android向服務器上傳照片,需要的朋友可以參考下
2020-05-05
Android解析JSON數(shù)據(jù)的方法分析
這篇文章主要介紹了Android解析JSON數(shù)據(jù)的方法,結合實例形式演示了Android解析json格式數(shù)據(jù)的原理與相關技巧,具有一定參考借鑒價值,需要的朋友可以參考下
2016-06-06
TextView顯示文本控件兩種方法 TextView顯示link的方法
這篇文章主要為大家詳細介紹了TextView顯示文本控件兩種方法，TextView顯示link的方法，具有一定的參考價值，感興趣的小伙伴們可以參考一下
2017-08-08
android獲取當前手機號示例程序
這篇文章主要介紹了android如何獲取當前手機號的方法，大家參考使用吧
2013-11-11
Flutter質感設計之直接輸入
這篇文章主要為大家詳細介紹了Flutter質感設計之直接輸入，具有一定的參考價值，感興趣的小伙伴們可以參考一下
2018-08-08
Android簡單記錄和恢復ListView滾動位置的方法
這篇文章主要介紹了Android簡單記錄和恢復ListView滾動位置的方法,涉及Android針對ListView位置屬性的相關操作技巧,需要的朋友可以參考下
2016-08-08