Kotlin协程解析系列（上）：协程调度与挂起

//获取账号tokenWalletHttp.target(Account.class).setTag(tag)        .setFullUrl(Constants.ACCOUNT_URL).setParams(params)        .callback(new HttpCallback<Account>() {            @Override            public void onSuccess(Account account) {                super.onSuccess(account);                //根据账号token进行支付操作                WalletHttp.target(Pay.class).setFullUrl(Constants.PAY_URL).addToken(account.getToken()).callback(new HttpCallback<Pay>() {                    @Override                    public void onSuccess(Pay pay){                        super.onSuccess(pay);                        //根据支付操作返回查询支付结果                        WalletHttp.target(PayResult.class).setFullUrl(Constants.RESULT_URL).addResultCode(pay.getResultCode()).callback(new HttpCallback<PayResult>() {                            @Override                            public void onSuccess(PayResult result){                                 super.onSuccess(result);                                //......                            }                        }).post();                    }                }).post();            }        }).post();

fun postItem(tag: String, params: Map<String, Any?>) = viewModelScope.launch {    // 获取账号信息    val account = repository.queryAccount(tag, params)    // 进行支付操作    val pay = repository.paySubmit(tag,account.token)    //查询支付结果    val result = repository.queryPayResult(tag,pay.resultCode)    //......}

buildscript {    ...    ext.kotlin_coroutines = 'xxx'    ...}

dependencies {    ...    //协程标准库    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_coroutines"    //依赖协程核心库，包含协程公共API部分    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlin_coroutines"    //依赖android支持库，协程Android平台的具体实现方式    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$kotlin_coroutines"   ...}

new Thread(new Runnable() {    @Override    public void run() {        //... do what you want    }}).start();

val myThread = thread {    //.......}

val myThread = thread(start = false) {    //......} myThread.start()

GlobalScope.launch {    //......}

public fun <T> runBlocking(context: CoroutineContext = EmptyCoroutineContext, block: suspend CoroutineScope.() -> T): T

//main函数中应用fun main() = runBlocking {    launch { // 创建一个新协程，runBlocking会阻塞线程，但内部运行的协程是非阻塞的        delay(1000L)        println("World!")    }    println("Hello,")    delay(2000L)      // 延时2s，保证JVM存活} //测试中应用class MyTest {    @Test    fun testMySuspendingFunction() = runBlocking {        // ......    }}

public fun CoroutineScope.launch(    context: CoroutineContext = EmptyCoroutineContext,    start: CoroutineStart = CoroutineStart.DEFAULT,    block: suspend CoroutineScope.() -> Unit): Job

fun launchTest2() {    print("start")    val job = CoroutineScope(Dispatchers.IO).launch {        delay(1000)        print("CoroutineScope.launch")    }    print("end")}

fun launchTest3() {    print("start")    GlobalScope.launch {        delay(1000)        print("CoroutineScope.launch")        //在协程内创建子协程        launch {            delay(1500)            print("launch 子协程")        }    }    print("end")} /**** 打印结果startendCoroutineScope.launchlaunch 子协程*/

public fun <T> CoroutineScope.async(    context: CoroutineContext = EmptyCoroutineContext,    start: CoroutineStart = CoroutineStart.DEFAULT,    block: suspend CoroutineScope.() -> T): Deferred<T>

fun asyncTest1() {    print("start")    GlobalScope.launch {        val deferred: Deferred<String> = async {            delay(2000)            print("asyncOne")            "HelloWorld"    //返回值为HelloWorld        }        val result = deferred.await()        print("result == $result")    }    print("end")} /**startendasyncOneresult == HelloWorld*/

val job = launch(start = CoroutineStart.LAZY) {    println("Active")}println("New")job.join()println("Completed") /**打印结果**/NewActiveCompleted /*********** 1. 以 lazy 方式创建出来的协程 state 为 New* 2. 对应的 job 调用 join 函数后，协程进入 Active 状态，并开始执行协程对应的具体代码* 3. 当协程执行完毕后，由于没有需要等待的子协程，协程直接进入 Completed 状态*/

//活跃的，是否仍在执行public val isActive: Boolean //启动协程，如果启动了协程，则为true;如果协程已经启动或完成，则为falsepublic fun start(): Boolean //取消Job，可通过传入Exception说明具体原因public fun cancel(cause: CancellationException? = null) //挂起协程直到此Job完成public suspend fun join() //取消任务并等待任务完成，结合了[cancel]和[join]的调用public suspend fun Job.cancelAndJoin() //给Job设置一个完成通知，当Job执行完成的时候会同步执行这个函数public fun invokeOnCompletion(handler: CompletionHandler): DisposableHandle

public interface Deferred<out T> : Job

fun scopeTest() {    GlobalScope.launch {//父协程        launch {//子协程            print("GlobalScope的子协程")        }        launch {//第二个子协程            print("GlobalScope的第二个子协程")        }    }     val mainScope = MainScope()    mainScope.launch {//启动协程        //todo    }}

/**可能的运行结果一****/[main]：1[main]：3[main]：2 /**可能的运行结果二****/[main]：1[main]：2[main]：3

suspend fun main() {    log(1)    val job = GlobalScope.launch(start = CoroutineStart.LAZY){        log(2)    }    log(3)    job.join()    log(4)}fun log(o: Any?) {    println("[${Thread.currentThread().name}]：$o")}

[main]：1[main]：3[DefaultDispatcher-worker-1]：2[main]：4

suspend fun main() {    log(1)    val job = GlobalScope.launch(start = CoroutineStart.ATOMIC) {        log(2)        delay(1000)        log(3)    }    job.cancel()    log(4)    job.join()    Thread.sleep(2000)}fun log(o: Any?) {    println("[${Thread.currentThread().name}]：$o")} /**打印输出结果可能如下****/[main]：1[DefaultDispatcher-worker-1]：2[main]：4

[main]：1[main]：2[main]：4[DefaultDispatcher-worker-1]：3[DefaultDispatcher-worker-1]：5

public suspend fun <T> withContext(    context: CoroutineContext,    block: suspend CoroutineScope.() -> T): T

public fun CoroutineScope.launch(    context: CoroutineContext = EmptyCoroutineContext,    start: CoroutineStart = CoroutineStart.DEFAULT,    block: suspend CoroutineScope.() -> Unit): Job public fun <T> CoroutineScope.async(    context: CoroutineContext = EmptyCoroutineContext,    start: CoroutineStart = CoroutineStart.DEFAULT,    block: suspend CoroutineScope.() -> T): Deferred<T>

public interface CoroutineScope {    public val coroutineContext: CoroutineContext}

public interface CoroutineContext {         //操作符[]重载，可以通过CoroutineContext[Key]这种形式来获取与Key关联的Element    public operator fun <E : Element> get(key: Key<E>): E?     //提供遍历CoroutineContext中每一个Element的能力，并对每一个Element做operation操作    public fun <R> fold(initial: R, operation: (R, Element) -> R): R     //操作符+重载，可以CoroutineContext + CoroutineContext这种形式把两个CoroutineContext合并成一个    public operator fun plus(context: CoroutineContext): CoroutineContext = .......         //返回一个新的CoroutineContext，这个CoroutineContext删除了Key对应的Element    public fun minusKey(key: Key<*>): CoroutineContext         //Key定义，空实现，仅仅做一个标识    public interface Key<E : Element>     ///Element定义，每个Element都是一个CoroutineContext    public interface Element : CoroutineContext {                 //每个Element都有一个Key实例        public val key: Key<*>        ......    }}

/** * Persistent context for the coroutine. It is an indexed set of [Element] instances. * An indexed set is a mix between a set and a map. * Every element in this set has a unique [Key]. */

@SinceKotlin("1.3")internal class CombinedContext(    //左上下文    private val left: CoroutineContext,    //右元素    private val element: Element) : CoroutineContext, Serializable {     override fun <E : Element> get(key: Key<E>): E? {        var cur = this        while (true) {            //如果输入 key 和右元素的 key 相同，则返回右元素            cur.element[key]?.let { return it }            // 若右元素不匹配，则向左继续查找            val next = cur.left            if (next is CombinedContext) {                cur = next            } else { // 若左上下文不是混合上下文，则结束递归                return next[key]            }        }    }    ......} public interface Element : CoroutineContext {    public val key: Key<*>     public override operator fun <E : Element> get(key: Key<E>): E? =    @Suppress("UNCHECKED_CAST")    // 如果给定键和元素本身键相同，则返回当前元素，否则返回空    if (this.key == key) this as E else null    ......} public object EmptyCoroutineContext : CoroutineContext, Serializable {    //返回空    public override fun <E : Element> get(key: Key<E>): E? = null}

//使用示例println(coroutineContext[CoroutineName])println(Dispatchers.Main[CoroutineName])

internal class CombinedContext(    //左上下文    private val left: CoroutineContext,    //右元素    private val element: Element) : CoroutineContext, Serializable {     //先对left做fold操作，把left做完fold操作的的返回结果和element做operation操作    public override fun <R> fold(initial: R, operation: (R, Element) -> R): R =    operation(left.fold(initial, operation), element)    ......} public object EmptyCoroutineContext : CoroutineContext, Serializable {    public override fun <R> fold(initial: R, operation: (R, Element) -> R): R = initial    ......} public interface Element : CoroutineContext {    //对传入的initial和自己做operation操作    public override fun <R> fold(initial: R, operation: (R, Element) -> R): R =    operation(initial, this)    ......}

public data class CoroutineName(    val name: String) : AbstractCoroutineContextElement(CoroutineName) {

GlobalScope.launch(CoroutineName("GlobalScope")) {    launch(CoroutineName("CoroutineA")) {//指定协程名称        val coroutineName = coroutineContext[CoroutineName]//获取协程名称        print(coroutineName)    }} /** 打印结果CoroutineName(CoroutineA)*/

GlobalScope.launch {    //通过+号运算添加多个上下文元素    var context = CoroutineName("协程1") + Dispatchers.Main    print("context == $context")     context += Dispatchers.IO //添加重复Dispatchers元素，Dispatchers.IO 会替换 ispatchers.Main    print("context == $context")     val contextResult = context.minusKey(context[CoroutineName]!!.key)//移除CoroutineName元素    print("contextResult == $contextResult")} /**打印结果context == [CoroutineName(协程1), Dispatchers.Main]context == [CoroutineName(协程1), Dispatchers.IO]contextResult == Dispatchers.IO*/

val newContext = newCoroutineContext(context)

@ExperimentalCoroutinesApipublic actual fun CoroutineScope.newCoroutineContext(context: CoroutineContext): CoroutineContext {    val combined = coroutineContext + context   //CoroutineContext拼接组合    val debug = if (DEBUG) combined + CoroutineId(COROUTINE_ID.incrementAndGet()) else combined    return if (combined !== Dispatchers.Default && combined[ContinuationInterceptor] == null)        debug + Dispatchers.Default else debug}

public abstract class AbstractCoroutine<in T>(    parentContext: CoroutineContext,    initParentJob: Boolean,    active: Boolean) : JobSupport(active), Job, Continuation<T>, CoroutineScope {    /**     * The context of this coroutine that includes this coroutine as a [Job].     */    public final override val context: CoroutineContext = parentContext + this    //重写了父类的coroutineContext属性    public override val coroutineContext: CoroutineContext get() = context}

launch( Dispatchers.Main + Job() + CoroutineName("HelloCoroutine") + CoroutineExceptionHandler { _, _ -> /* ... */ }) {/* ... */}

abstract class ScopedAppActivity:AppCompatActivity(),CoroutineScope{    protected lateinit var job: Job    override val coroutineContext: CoroutineContext    get() = job + Dispatchers.Main // 注意这里使用+拼接CoroutineContext     override fun onCreate(savedInstanceState: Bundle?) {        super.onCreate(savedInstanceState)        job = Job()    }     override fun onDestroy() {        super.onDestroy()        job.cancel()    }}

withContext(NonCancellable) {    /* ... */}

println("Running in ${coroutineContext[CoroutineName]}")

// 错误的做法，在主线程中直接调用async，若耗时过长则阻塞UIGlobalScope.launch(Dispatchers.Main) {    val deferred = async {        /* ... */    }    /* ... */} // 正确的做法，在工作线程执行协程任务GlobalScope.launch(Dispatchers.Main) {    val deferred = async(Dispatchers.Default) {        /* ... */    }    /* ... */}

@SinceKotlin("1.3")public interface ContinuationInterceptor : CoroutineContext.Element {    companion object Key : CoroutineContext.Key<ContinuationInterceptor>         public fun <T> interceptContinuation(continuation: Continuation<T>): Continuation<T>    //......     }

public operator fun plus(context: CoroutineContext): CoroutineContext =//如果要相加的CoroutineContext为空，那么不做任何处理，直接返回if (context === EmptyCoroutineContext) this else//如果要相加的CoroutineContext不为空，那么对它进行fold操作,可以把acc理解成+号左边的CoroutineContext，element理解成+号右边的CoroutineContext的某一个elementcontext.fold(this) { acc, element ->                    //首先从左边CoroutineContext中删除右边的这个element                    val removed = acc.minusKey(element.key)                    //如果removed为空，说明左边CoroutineContext删除了和element相同的元素后为空，那么返回右边的element即可                    if (removed === EmptyCoroutineContext) element else {                        //如果removed不为空，说明左边CoroutineContext删除了和element相同的元素后还有其他元素，那么构造一个新的CombinedContext返回                        val interceptor = removed[ContinuationInterceptor]                        if (interceptor == null) CombinedContext(removed, element) else {                            val left = removed.minusKey(ContinuationInterceptor)                            if (left === EmptyCoroutineContext) CombinedContext(element, interceptor) else                            CombinedContext(CombinedContext(left, element), interceptor)                        }                    }                   }

    start(block, receiver, this)} 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        }

public fun <T> (suspend () -> T).startCoroutineCancellable(completion: Continuation<T>): Unit = runSafely(completion) {    createCoroutineUnintercepted(completion).intercepted().resumeCancellableWith(Result.success(Unit))}

public actual fun <T> Continuation<T>.intercepted(): Continuation<T> =    (this as? ContinuationImpl)?.intercepted() ?: this

public fun intercepted(): Continuation<Any?> =        intercepted            ?: (context[ContinuationInterceptor]?.interceptContinuation(this) ?: this)                .also { intercepted = it }

/******打印结果******/main// 第一次launchintercept todo something. change run to threadcreate new threadlaunch start. current thread: Thread-2new continuation todo something in the main thread. current thread: maincreate new thread// 第二次launchintercept todo something. change run to threadcreate new threadlaunch end. current thread: Thread-7new continuation todo something. current thread: Thread-8

public abstract class CoroutineDispatcher :    AbstractCoroutineContextElement(ContinuationInterceptor), ContinuationInterceptor {                 //将可运行块的执行分派到给定上下文中的另一个线程上        public abstract fun dispatch(context: CoroutineContext, block: Runnable)                 //返回一个continuation，它封装了提供的[continuation]，拦截了所有的恢复        public final override fun <T> interceptContinuation(continuation: Continuation<T>): Continuation<T>        //......    }

public abstract class MainCoroutineDispatcher : CoroutineDispatcher() public abstract class CoroutineDispatcher :AbstractCoroutineContextElement(ContinuationInterceptor), ContinuationInterceptor {    public open fun isDispatchNeeded(context: CoroutineContext): Boolean = true         public abstract fun dispatch(context: CoroutineContext, block: Runnable)     public open fun dispatchYield(context: CoroutineContext, block: Runnable): Unit = dispatch(context, block)         public final override fun <T> interceptContinuation(continuation: Continuation<T>): Continuation<T> =        DispatchedContinuation(this, continuation)    ......}

getUserBtn.setOnClickListener {    getUser { user ->        handler.post {            userNameView.text = user.name        }    }}typealias Callback = (User) -> Unit fun getUser(callback: Callback){    ...}

suspend fun getUserCoroutine() = suspendCoroutine<User> {    continuation ->    getUser {        continuation.resume(it)    }} getUserBtn.setOnClickListener {    GlobalScope.launch(Dispatchers.Main) {        userNameView.text = getUserCoroutine().name    }}

suspend fun main() {    val myDispatcher= Executors.newSingleThreadExecutor{ r -> Thread(r, "MyThread") }.asCoroutineDispatcher()    GlobalScope.launch(myDispatcher) {        log(1)    }.join()    log(2)}

GlobalScope.launch(newSingleThreadContext("Dispather")) {    //......}.join()

Executors.newScheduledThreadPool(10)    .asCoroutineDispatcher().use { dispatcher ->        GlobalScope.launch(dispatcher) {            //......        }.join

private suspend fun a() {  println("aa")}

public interface Continuation<in T> {    //对应这个Continuation的协程上下文    public val context: CoroutineContext    //恢复相应协程的执行，传递一个成功或失败的结果作为最后一个挂起点的返回值。    public fun resumeWith(result: Result<T>)} //将[value]作为最后一个挂起点的返回值，恢复相应协程的执行。@SinceKotlin("1.3")@InlineOnlypublic inline fun <T> Continuation<T>.resume(value: T): Unit =    resumeWith(Result.success(value)) //恢复相应协程的执行，以便在最后一个挂起点之后重新抛出[异常]。@SinceKotlin("1.3")@InlineOnlypublic inline fun <T> Continuation<T>.resumeWithException(exception: Throwable): Unit =    resumeWith(Result.failure(exception))

@FormUrlEncoded@POST("/api/common/countryList")@NullableObject fetchCountryList(@FieldMap @NotNull Map var1, @NotNull Continuation var2);

public fun <R> start(start: CoroutineStart, receiver: R, block: suspend R.() -> T) {    start(block, receiver, this)}

//CoroutineStart的invoke方法出现了Continuationpublic operator fun <R, T> invoke(block: suspend R.() -> T, receiver: R, completion: Continuation<T>): Unit =when (this) {    DEFAULT -> block.startCoroutineCancellable(receiver, completion)    ATOMIC -> block.startCoroutine(receiver, completion)    UNDISPATCHED -> block.startCoroutineUndispatched(receiver, completion)    LAZY -> Unit // will start lazily}@InternalCoroutinesApipublic fun <T> (suspend () -> T).startCoroutineCancellable(completion: Continuation<T>): Unit = runSafely(completion) {     createCoroutineUnintercepted(completion).intercepted().resumeCancellableWith(Result.success(Unit))}

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

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)//1        }    }}

private inline fun <T> createCoroutineFromSuspendFunction(    completion: Continuation<T>,    crossinline block: (Continuation<T>) -> Any?): Continuation<Unit> {    val context = completion.context    // label == 0 when coroutine is not started yet (initially) or label == 1 when it was    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() // Rethrow exception if trying to start with exception (will be caught by BaseContinuationImpl.resumeWith                        block(this) // run the block, may return or suspend                    }                    1 -> {                        label = 2                        result.getOrThrow() // this is the result if the block had suspended                    }                    else -> error("This coroutine had already completed")                }        }    else        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() // Rethrow exception if trying to start with exception (will be caught by BaseContinuationImpl.resumeWith                        block(this) // run the block, may return or suspend                    }                    1 -> {                        label = 2                        result.getOrThrow() // this is the result if the block had suspended                    }                    else -> error("This coroutine had already completed")                }        }}

suspend fun main() {    log(1)    log(returnSuspended())    log(2)    delay(1000)    log(3)    log(returnImmediately())    log(4)} suspend fun returnSuspended() = suspendCoroutineUninterceptedOrReturn<String>{        continuation ->    thread {        Thread.sleep(1000)        continuation.resume("Return suspended.")    }    COROUTINE_SUSPENDED} suspend fun returnImmediately() = suspendCoroutineUninterceptedOrReturn<String>{    log(5)    "Return immediately."}

[main]：1[Thread-2]：Return suspended.[Thread-2]：2[kotlinx.coroutines.DefaultExecutor]：3[kotlinx.coroutines.DefaultExecutor]：5[kotlinx.coroutines.DefaultExecutor]：Return immediately.[kotlinx.coroutines.DefaultExecutor]：4

public class ContinuationImpl implements Continuation<Object> {     private int label = 0;    private final Continuation<Unit> completion;     public ContinuationImpl(Continuation<Unit> completion) {        this.completion = completion;    }     @Override    public CoroutineContext getContext() {        return EmptyCoroutineContext.INSTANCE;    }     @Override    public void resumeWith(@NotNull Object o) {        try {            Object result = o;            switch (label) {                case 0: {                    LogKt.log(1);                    result = SuspendFunctionsKt.returnSuspended( this);                    label++;                    if (isSuspended(result)) return;                }                case 1: {                    LogKt.log(result);                    LogKt.log(2);                    result = DelayKt.delay(1000, this);                    label++;                    if (isSuspended(result)) return;                }                case 2: {                    LogKt.log(3);                    result = SuspendFunctionsKt.returnImmediately( this);                    label++;                    if (isSuspended(result)) return;                }                case 3:{                    LogKt.log(result);                    LogKt.log(4);                }            }            completion.resumeWith(Unit.INSTANCE);        } catch (Exception e) {            completion.resumeWith(e);        }    }     private boolean isSuspended(Object result) {        return result == IntrinsicsKt.getCOROUTINE_SUSPENDED();    }}

public class RunSuspend implements Continuation<Unit> {     private Object result;     @Override    public CoroutineContext getContext() {        return EmptyCoroutineContext.INSTANCE;    }     @Override    public void resumeWith(@NotNull Object result) {        synchronized (this){            this.result = result;            notifyAll(); // 协程已经结束，通知下面的 wait() 方法停止阻塞        }    }     public void await() throws Throwable {        synchronized (this){            while (true){                Object result = this.result;                if(result == null) wait(); // 调用了 Object.wait()，阻塞当前线程，在 notify 或者 notifyAll 调用时返回                else if(result instanceof Throwable){                    throw (Throwable) result;                } else return;            }        }    }}

public static void main(String... args) throws Throwable {    RunSuspend runSuspend = new RunSuspend();    ContinuationImpl table = new ContinuationImpl(runSuspend);    table.resumeWith(Unit.INSTANCE);    runSuspend.await();}

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}

internal abstract class BaseContinuationImpl(...) {    // 实现 Continuation 的 resumeWith，并且是 final 的，不可被重写    public final override fun resumeWith(result: Result<Any?>) {        ...        val outcome = invokeSuspend(param)        ...    }    // 由编译生成的协程相关类来实现    protected abstract fun invokeSuspend(result: Result<Any?>): Any?}

public static final Object test(@NotNull Continuation $completion) {    Job var10000 = BuildersKt.launch$default(CoroutineScopeKt.CoroutineScope((CoroutineContext)Dispatchers.getIO()), (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);                    //设置挂起后恢复，进入的状态                    this.label = 1;                    if (DelayKt.delay(11L, 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);    return var10000 == IntrinsicsKt.getCOROUTINE_SUSPENDED() ? var10000 : Unit.INSTANCE;}

@InternalCoroutinesApipublic fun <T> (suspend () -> T).startCoroutineCancellable(completion: Continuation<T>): Unit = runSafely(completion) {    createCoroutineUnintercepted(completion).intercepted().resumeCancellableWith(Result.success(Unit))}

@SinceKotlin("1.3")public actual fun <T> Continuation<T>.intercepted(): Continuation<T> =    (this as? ContinuationImpl)?.intercepted() ?: thisinternal abstract class ContinuationImpl(    ......) : BaseContinuationImpl(completion) {    constructor(completion: Continuation<Any?>?) : this(completion, completion?.context)     public override val context: CoroutineContext        get() = _context!!     @Transient    private var intercepted: Continuation<Any?>? = null     public fun intercepted(): Continuation<Any?> =        intercepted            ?: (context[ContinuationInterceptor]?.interceptContinuation(this) ?: this)                .also { intercepted = it }    // context[ContinuationInterceptor] 就是协程的 CoroutineDispatcher    ......}public abstract class CoroutineDispatcher :AbstractCoroutineContextElement(ContinuationInterceptor), ContinuationInterceptor {    public final override fun <T> interceptContinuation(continuation: Continuation<T>): Continuation<T> =        DispatchedContinuation(this, continuation)    ......}

internal fun <R, T> (suspend (R) -> T).startCoroutineCancellable(    receiver: R, completion: Continuation<T>,    onCancellation: ((cause: Throwable) -> Unit)? = null) =runSafely(completion) {    createCoroutineUnintercepted(receiver, completion).intercepted().resumeCancellableWith(Result.success(Unit), onCancellation)}

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

internal abstract class BaseContinuationImpl(    public val completion: Continuation<Any?>?) : Continuation<Any?>, CoroutineStackFrame, Serializable {    // This implementation is final. This fact is used to unroll resumeWith recursion.    public final override fun resumeWith(result: Result<Any?>) {        // This loop unrolls recursion in current.resumeWith(param) to make saner and shorter stack traces on resume        var current = this        var param = result        while (true) {             probeCoroutineResumed(current)            with(current) {                val completion = completion!! // fail fast when trying to resume continuation without completion                val outcome: Result<Any?> =                try {                    //执行invokeSuspend内的代码块                    val outcome = invokeSuspend(param)                    //如果代码块内执行了挂起方法，协程挂起，resumeWith执行结束，再次调用resumeWith时协程挂起点之后的代码才能继续执行                    if (outcome === COROUTINE_SUSPENDED) return                    Result.success(outcome)                } catch (exception: Throwable) {                    Result.failure(exception)                }                releaseIntercepted() // this state machine instance is terminating                if (completion is BaseContinuationImpl) {                    // 如果完成的completion也是BaseContinuationImpl，就会进入循环                    current = completion                    param = outcome                } else {                    // 执行completion resumeWith方法                    completion.resumeWith(outcome)                    return                }            }        }    }     protected abstract fun invokeSuspend(result: Result<Any?>): Any?         .....}

fun main(args: Array<String>) {    val coroutineDispatcher = newSingleThreadContext("ctx")    // 启动协程 1    GlobalScope.launch(coroutineDispatcher) {        println("the first coroutine")        async (Dispatchers.IO) {            println("the second coroutine 11111")            delay(100)            println("the second coroutine 222222")        }.await()        println("the first coroutine end end end")    }    // 保证 main 线程存活，确保上面两个协程运行完成    Thread.sleep(500)}

public final Object invokeSuspend(@NotNull Object $result) {    //挂起函数返回标识SUSPEND_FLAG    Object var5 = IntrinsicsKt.getCOROUTINE_SUSPENDED();    String var3;    boolean var4;    //label默认初始值为0    switch(this.label) {        case 0:            ResultKt.throwOnFailure($result);            CoroutineScope $this$launch = (CoroutineScope)this.L$0;            var3 = "the first coroutine";            var4 = false;            System.out.println(var3);            //新建并启动 async 协程            Deferred var10000 = BuildersKt.async$default($this$launch, (CoroutineContext)Dispatchers.getIO(), (CoroutineStart)null, (Function2)(new Function2((Continuation)null) {                int label;                 @Nullable                public final Object invokeSuspend(@NotNull Object $result) {                    //挂起标识                    Object var4 = IntrinsicsKt.getCOROUTINE_SUSPENDED();                    String var2;                    boolean var3;                    switch(this.label) {                        case 0:                            ResultKt.throwOnFailure($result);                            var2 = "the second coroutine 11111";                            var3 = false;                            System.out.println(var2);                            this.label = 1;                            //判断是否执行delay挂起函数                            if (DelayKt.delay(100L, this) == var4) {                                //挂起，跳出该方法                                return var4;                            }                            break;                        case 1:                            ResultKt.throwOnFailure($result);                            // 恢复协程后再执行一次 resumeWith()，然后无异常的话执行最后的 println()                            break;                        default:                            throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");                    }                     var2 = "the second coroutine 222222";                    var3 = false;                    System.out.println(var2);                    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);                }            }), 2, (Object)null);            //设置挂起后恢复时，进入的状态            this.label = 1;            //调用await()挂起函数            if (var10000.await(this) == var5) {                return var5;            }            break;        case 1:            ResultKt.throwOnFailure($result);            break;        default:            throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");    }     var3 = "the first coroutine end end end";    var4 = false;    System.out.println(var3);    return Unit.INSTANCE;}