Foreword

This article analyzes the implementation principle of coroutines in Kotlin/JVM.

First look at the suspend keyword

The following example simulates a network request:

class Temp {
    suspend fun fetchData(argument: String): Boolean {
        val result = netRequest(argument)
        return result == 0
    }

    // Simulate a network request
    suspend fun netRequest(argument: String): Int {
        delay(1000)
        return argument. length
    }
}

These two methods are decorated with the suspend keyword. We will decompile the bytecode of this file into Java code with the same effect:

public final class Temp {
   @Nullable
   public final Object fetchData(@NotNullString argument, @NotNull Continuation var2) {
      Object $continuation;
      label25: {
         if (var2 instanceof ) {
            $continuation = ()var2;
            if (((()$continuation).label & Integer.MIN_VALUE) != 0) {
               (()$continuation).label -= Integer.MIN_VALUE;
               break label25;
            }
         }

         $continuation = new ContinuationImpl(var2) {
            // $FF: synthetic field
            Object result;
            int label;

            @Nullable
            public final Object invokeSuspend(@NotNull Object $result) {
               this.result = $result;
               this.label |= Integer.MIN_VALUE;
               return Temp.this.fetchData((String)null, this);
            }
         };
      }

      Object $result = (()$continuation).result;
      Object var6 = IntrinsicsKt. getCOROUTINE_SUSPENDED();
      Object var10000;
      switch((()$continuation).label) {
      case 0:
         ResultKt.throwOnFailure($result);
         (()$continuation).label = 1;
         var10000 = this.netRequest(argument, (Continuation)$continuation);
         if (var10000 == var6) {
            return var6;
         }
         break;
      case 1:
         ResultKt.throwOnFailure($result);
         var10000 = $result;
         break;
      default:
         throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
      }

      int result = ((Number)var10000).intValue();
      return Boxing. boxBoolean(result == 0);
   }

   @Nullable
   public final Object netRequest(@NotNull String argument, @NotNull Continuation var2) {
      Object $continuation;
      label20: {
         if (var2 instanceof ) {
            $continuation = ()var2;
            if (((()$continuation).label & Integer.MIN_VALUE) != 0) {
               (()$continuation).label -= Integer.MIN_VALUE;
               break label20;
            }
         }

         $continuation = new ContinuationImpl(var2) {
            // $FF: synthetic field
            Object result;
            int label;
            Object L$0;

            @Nullable
            public final Object invokeSuspend(@NotNull Object $result) {
               this.result = $result;
               this.label |= Integer.MIN_VALUE;
               return Temp.this.netRequest((String)null, this);
            }
         };
      }

      Object $result = (()$continuation).result;
      Object var5 = IntrinsicsKt. getCOROUTINE_SUSPENDED();switch((()$continuation).label) {
      case 0:
         ResultKt.throwOnFailure($result);
         (()$continuation).L$0 = argument;
         (()$continuation).label = 1;
         if (DelayKt.delay(1000L, (Continuation)$continuation) == var5) {
            return var5;
         }
         break;
      case 1:
         argument = (String)(()$continuation).L$0;
         ResultKt.throwOnFailure($result);
         break;
      default:
         throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
      }

      return Boxing. boxInt(argument. length());
   }
}

A few lines of coroutine-related codes correspond to so many Java codes. It can be seen that the kotlin compiler has done a lot for us.

The readability of the above code is not high. For example, there are undefined types such as . I use jd-gui to Temp.class The file was decompiled again， After getting more information, I integrated the above decompiled code with the information obtained from jd-gui decompilation, and appropriately renamed some classes and variables, Get the more complete and readable “Java code corresponding to Temp.class decompiled”, first of all about fetchData of:

public final Object fetchData(@NotNull String argument,@NotNull Continuation completion) {
    Object $continuation;
    label25:
    {
        if (completion instanceof FetchDataStateMachine) {
            $continuation = (FetchDataStateMachine) completion;
            if (($continuation.label & Integer.MIN_VALUE) != 0) {
                $continuation.label -= Integer.MIN_VALUE;
                break label25;
            }
        }
        $continuation = new FetchDataStateMachine(completion);
    }

    Object $result = $continuation. result;
    Object resultTemp;
    switch ($continuation.label) {
        case 0:
            ResultKt.throwOnFailure($result);$continuation.label = 1;
            resultTemp = this.netRequest(argument, (Continuation) $continuation);
            if (resultTemp == COROUTINE_SUSPENDED) {
                return COROUTINE_SUSPENDED;
            }
            break;
        case 1:
            ResultKt.throwOnFailure($result);
            resultTemp = $result;
            break;
        default:
            throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
    }

    int result = ((Number) resultTemp).intValue();
    return Boxing. boxBoolean(result == 0);
}

static final class FetchDataStateMachine extends ContinuationImpl {
    Object result;
    int label;

    FetchDataStateMachine(Continuation $completion) {
        super($completion);
    }

    @Nullable
    public final Object invokeSuspend(@NotNull Object $result) {
        this.result = $result;
        this.label|= Integer.MIN_VALUE;
        return Temp. this. fetchData(null, (Continuation) this);
    }
}

netRequest related codes and fetchData related codes are similar in structure and form:

public final Object netRequest(@NotNull String argument,@NotNull Continuation completion) {
    Object $continuation;
    label20:
    {
        if (completion instanceof NetRequestStateMachine) {
            $continuation = (NetRequestStateMachine) completion;
            if (($continuation.label & Integer.MIN_VALUE) != 0) {
                $continuation.label -= Integer.MIN_VALUE;
                break label20;
            }
        }
        $continuation = new NetRequestStateMachine(completion);
    }

    Object $result = $continuation. result;
    switch ($continuation.label) {
        case 0:
            ResultKt.throwOnFailure($result);$continuation. functionParameter = argument;
            $continuation.label = 1;
            if (DelayKt.delay(1000L, (Continuation) $continuation) == COROUTINE_SUSPENDED) {
                return COROUTINE_SUSPENDED;
            }
            break;
        case 1:
            argument = (String) ($continuation. functionParameter);
            ResultKt.throwOnFailure($result);
            break;
        default:
            throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
    }

    return Boxing. boxInt(argument. length());
}

static final class NetRequestStateMachine extends ContinuationImpl {
    Object result;
    int label;
    Object functionParameter;

    NetRequestStateMachine(Continuation $completion) {
        super($completion);
    }

    @Nullable
    public final Object invokeSuspend(@NotNull Object $result) {
        this.result = $result;this.label |= Integer.MIN_VALUE;
        return Temp.this.netRequest(null, (Continuation) this);
    }
}

It can be found that in the decompiled Java code, the fetchData and netRequest methods both have a Continuation completion code> parameter, which is done by Kotlin Compiler for us. For functions modified by suspend, Kotlin Compiler will help you when compiling We pass in a Continuation parameter in this function, and use the Continuation parameter instead of the suspend modifier. What is the meaning of this parameter? Woolen cloth?

First knowledge continuation

Continuations are a key to understanding how coroutines work.

Look at traditional network requests first:

data class User(val id: Long, val name: String)

interface Callback {
    fun success(user: User)
    fun failure(t: Throwable)
}

class Model {
    fun getUserInfo(callback: Callback) {
        Thread.sleep(1000) // simulate network request
        callback.success(User(1, "giagor"))
    }
}

class Business {
    val model = Model()

    fun getUserInfo() {
        model.getUserInfo(object : Callback {
            override fun success(user: User) {
                showMsg(user. toString())
            }

            override fun failure(t: Throwable) {
                showMsg(t. message ?: "")
            }
        })
    }

    fun showMsg(msg: String) {
        //...
    }
}

When using Model to make a network request, use Callback to receive the result of the network request, we At this time, we can use Callback Think of it as a continuation, that is, the continuation of the network request, used to receive the result of the network request.

Use the Continuation interface in the coroutine to represent a continuation, which represents a continuation after a suspension point, that is, the rest of the code that should be executed after the suspension point:

public interface Continuation {
    // The context of the coroutine corresponding to the continuation
    public val context: CoroutineContext
    // Resume the execution of the corresponding coroutine, and pass a result indicating success or failure as the return value of the last suspension point
    public fun resumeWith(result: Result<T>)
}

In Kotlin 1.3, there is also an extension function that can easily call resumeWith:

public inline fun  Continuation.resume(value: T): Unit =
    resumeWith(Result. success(value))

public inline fun  Continuation.resumeWithException(exception: Throwable): Unit =
    resumeWith(Result. failure(exception))

As mentioned earlier, for functions modified by suspend, Kotlin Compiler will help us pass in a Continuation parameter in the function, Use the Continuation parameter instead of the suspend modifier, Through the Continuation parameter, Kotlin Compiler can convert our The coroutine code is converted into an equivalent callback code, that is to say, the Kt compiler has written the callback code for us. As for how to write it for us, we will analyze it later. code>Continuation to control the asynchronous call process is called CPS transformation (Continuation-Passing-Style Transformation).

State machine

fetchData function will generate the following static internal class when compiled （continuation):

static final class FetchDataStateMachine extends ContinuationImpl {
    Object result;
    int label;

    FetchDataStateMachine(Continuation $completion) {
        super($completion);
    }

    @Nullable
    public final Object invokeSuspend(@NotNull Object $result) {
        this.result = $result;
        this.label |= Integer.MIN_VALUE;
        return Temp. this. fetchData(null, (Continuation) this);
    }
}

FetchDataStateMachineThe inheritance relationship is as follows:

FetchDataStateMachine -> ContinuationImpl -> BaseContinuationImpl -> Continuation

FetchDataStateMachine receives a Continuation parameter named $completion, $completion is saved in the parent classBaseContinuationImpl:

internal abstract class BaseContinuationImpl(
    public val completion: Continuation?
) : Continuation, CoroutineStackFrame, Serializable {...}

Through $completion, the execution result of the fetchData function can be passed back to the function calling fetchData, with $completion has the ability to implement callback.

The state machine FetchDataStateMachine declares two variables result and label

• result: Indicates the result of the previous Continuation, for example, there are functions A and B, ContinuationA and ContinuationB are declared inside the function, A calls B and ContinuationA is passed to B for saving. In the subsequent callback process, ContinuationA can get the execution result of ContinuationB::invokeSuspend from the result variable .
• label: Kotlin Compiler can identify where inside the function will be suspended, each suspension point (suspension point code>) is represented as a state of the state machine (state), these states are represented by the switch case statement. label indicates which state of the state machine should be executed currently, specifically which case to enter, and is recorded by the label variable The current state of the state machine.

Look at the first half of the code of fetchData:

public final Object fetchData(@NotNull String argument,@NotNull Continuation completion) {
    Object $continuation;
    label25:
    {
        if (completion instanceof FetchDataStateMachine) {
            $continuation = (FetchDataStateMachine) completion;
            if (($continuation.label & Integer.MIN_VALUE) != 0) {
                $continuation.label -= Integer.MIN_VALUE;
                break label25;
            }
        }
        $continuation = new FetchDataStateMachine(completion);
    }
    ...
}

It will judge whether the incoming completion is of FetchDataStateMachine type, if so, do some operations on its label variable, if notThen directly create a FetchDataStateMachine and pass in completion (completion will be saved).

Look at the second half of the code of fetchData:

public final Object fetchData(@NotNull String argument,@NotNull Continuation completion) {
    Object $continuation;
    ...
    Object $result = $continuation. result;
    Object resultTemp;
    switch ($continuation.label) {
        case 0:
            ResultKt.throwOnFailure($result);
            $continuation.label = 1;
            resultTemp = this.netRequest(argument, (Continuation) $continuation);
            if (resultTemp == COROUTINE_SUSPENDED) {
                return COROUTINE_SUSPENDED;
            }
            break;
        case 1:
            ResultKt.throwOnFailure($result);
            resultTemp = $result;
            break;
        default:
            throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
    }

    int result = ((Number) resultTemp).intValue();
    return Boxing. boxBoolean(result == 0);
}

fetchDataThe original code statement of the method will be divided into multiple case statements under switch, here is

The label variable in

FetchDataStateMachine is to control which case branch to execute currently.

It can be seen that the function and the continuation form a finite state machine (FSM, namely Finite-State Machine) to control the execution of the coroutine code.

What is “non-blocking suspend”?

In the netRequest method, delay(1000) is called to suspend the current coroutine, simply look at the decompilation of the delay method Code after:

public static final Object delay(long timeMillis, @NotNull Continuation $completion) {
    if (timeMillis <= 0L) {
        return Unit. INSTANCE;
    } else {// implementation class
        CancellableContinuationImpl cancelableContinuationImpl = new CancellableContinuationImpl(IntrinsicsKt. intercepted($completion), 1);
        cancelableContinuationImpl.initCancellability();
        // upcast
        CancellableContinuation cont = (CancellableContinuation)cancellableContinuationImpl;
        if (timeMillis < Long.MAX_VALUE) {
            // delay operation
            getDelay(cont. getContext()).scheduleResumeAfterDelay(timeMillis, cont);
        }
// get execution result
        Object result = cancelableContinuationImpl. getResult();
        if (result == COROUTINE_SUSPENDED) {
            DebugProbesKt.probeCoroutineSuspended($completion);
        }
// return result
        return result;
    }
}

In this method, the delay operation will be performed. If it needs to be suspended, the COROUTINE_SUSPENDED value will be returned to the caller.

Combining the decompiled code of fetchData, netRequest and delay, we can get the following call graph:

The red line in the figure indicates that the function returns COROUTINE_SUSPENDED and needs to be suspended. When the delay method needs to be suspended, it returns COROUTINE_SUSPENDED, then the netRequest method returns COROUTINE_SUSPENDED, then fetchData method returns COROUTINE_SUSPENDED, repeating this process until the top of the call stack.

Through this “end method call” method, the coroutine is temporarily not executed on this thread, so that the thread can handle other tasks (including executing other coroutines), which is why the coroutine The suspension will not block the current thread, which is also the origin of “non-blocking suspension”.

How to restore?

Since the coroutine is suspended, there is a corresponding recovery of the coroutine. Let me talk about the conclusion first: the essence of coroutine recovery is to call back the continuation.

I haven’t studied the specific implementation of the delay function yet,but the delay function will perform a waiting operation in a certain sub-thread, and when the delay time arrives, it will The resumeWith method of $completion passed to the delay function will be called, that is, the resumeWith method of NetRequestStateMachine will be called method. The inheritance relationship and parent class of NetRequestStateMachine are as follows:

NetRequestStateMachine -> ContinuationImpl -> BaseContinuationImpl -> Continuation

BaseContinuationImpl is currently a focus of our analysis, it mainly does the following things:

1. Save completion: It saves the FetchDataStateMachine instance of the fetchData method, so that the continuation can be called back level by level .
2. Rewrite the resumeWith method: BaseContinuationImpl rewrites the resumeWith method of the Continuation interface, This method is used to restore the coroutine and is also the core logic of coroutine recovery.

We look at the definition of the BaseContinuationImpl class:

internal abstract class BaseContinuationImpl(
    public val completion: Continuation?
) : Continuation, CoroutineStackFrame, Serializable {
    // This implementation is final. This fact is used to unroll resumeWith recursion.
    public final override fun resumeWith(result: Result) {
        // 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) {
            // Perform debug probes on each resumed continuation, allowing the debug library to track exactly which parts of the suspended call stack
            // has been restored.
            probeCoroutineResumed(current)
            with(current) {
                val completion = completion!! // fail fast when trying to resume continuation without completion
                val outcome: Result =
                    try {
                        val outcome = invokeSuspend(param)
                        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) {// unrolling recursion via loop
                    current = completion
                    param = outcome
                } else {
                    // top-level completion reached -- invoke and return
                    completion. resumeWith(outcome)
                    return
                }
            }
        }
    }

    protected abstract fun invokeSuspend(result: Result): Any?

    protected open fun releaseIntercepted() {
        // does nothing here, overridden in ContinuationImpl
    }
    
    ...
}

The focus is on the implementation of the resumeWith method, which executes the callback logic under a while(true) loop. Let’s combine the decompiled code of fetchData and netRequest given above to see when the delay time of the delay function is called NetRequestStateMachine‘s resumeWith method, what is the follow-up execution process:

1. Execute the resumeWith method of NetRequestStateMachine parent class BaseContinuationImpl.
2. Execute the current continuation which is NetReThe invokeSuspend method of questStateMachine (NetRequestStateMachine has implemented this method, if you forget it, you can look back at the previous decompiled code).
3. The invokeSuspend method of NetRequestStateMachine calls the netRequest method, and passes in the continuation itself as a parameter.
4. In the netRequest method, since the type of completion is NetRequestStateMachine, you can use the continuation directly , there is no need to create a new continuation body like the first time entering the netRequest method. At this time, the label value of the continuation is 1, so enter the case 1 statement branch of netRequest.

Actually, in this process, there are some calculation and conversion operations on the label of the continuation body, but the final value of label is 1, The calculation and conversion operation done does not affect our analysis, so it is not the focus

5. From the continuation, take out the parameter that was first passed into the netRequest method, that is, argument, and return argument.length . For the convenience of later explanation, the return value argument.length is recorded as netRequest-Return here.
6. Then the netRequest method ends, NetRequestStateMachine::invokeSuspend method is also executed, and netRequest-Return is also used as the return value of the invokeSuspend method, which will be passed to the BaseContinuationImpl In the resumeWith method, in the resumeWith method, wrap netRequest-Return as Result and save to the outcome variable.
7. Determine whether completion held by NetRequestStateMachine is of BaseContinuationImpl type, we know that the instance it holds is actually FetchDataStateMachine, so it must be BaseContinuationImpl, so the variable is updated

 // Update current to FetchDataStateMachine instance
current = completion
// Update param to outcome (wraps the Result of netRequest-Return)
    param = outcome

In this way, the callback can actually be realized, let’s continue to look back.

8. Continue to the next round of while loop, FetchDataStateMachine::invokeSuspend will be executed in the with block , in invokeSuspend ， Save the incoming parameter param to the result variable (In fact, this is similar to the traditional callback, and the traditional callback also needs to save the execution result of the lower layer Call back to the upper layer), and then call the fetchData method.
9. In the fetchData method, since the incoming completion is already of type FetchDataStateMachine, so there is no need to go to Create a new continuation. Since the value of the continuation label is 1 at this time, it will enter the case 1 statement, and the netRequest method The execution result is stored in the resultTemp variable, and finally the fetchData method ends and the result result == 0 is returned. For the convenience of explanation, The execution result of the fetchData method is recorded as fetchData-Return.
10. FetchDataStateMachine::invokeSuspendThe method will also end and return fetchData-Return, and then in resumeWith of BaseContinuationImpl In the method, fetchData-Return is wrapped as Result. Then it will judge whether the completion held by FetchDataStateMachine is of type BaseContinuationImpl.
11. The follow-up direction of the code, we are not clear at present, we have to know to call fetchData method, what will be done in order to know the follow-up code trend.

From the above process analysis, we have a basic understanding of the recovery of the coroutine, and the flow chart is given below to summarize:

Looking at the calling process of the continuation above, it is actually calling the invokeSuspend method of the continuation layer by layer. From the process point of view, it is a bit like a recursive call, but BaseContinuationImpl:: The implementation of resumeWith is not the same as recursion. Its implementation is to call the invokeSuspend method on the continuation once in the while(true) loop, and then record Its return result is used as the method parameter of the next continuation invokeSuspend.

Simply speaking, it is calling the invokeSuspend method of a continuation, and after the execution of this method is completed, the invokeSuspend method of the next continuation is called. One reason for this is to avoid the call stack being too deep, and there are related comments in BaseContinuationImpl::resumeWith:

This loop unrolls recursion in current.resumeWith(param) to make saner and shorter stack traces on resume

Start a coroutine

We call the fetchData method in a coroutine:

class Temp2 {
    fun execute() {
        GlobalScope. launch(Dispatchers. Main) {
            Temp(). fetchData("argument")
        }
    }
}

A coroutine can be started by the launch method, and its source code is as follows:

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
}

The code in the coroutine will be packaged as a block. By default, a StandaloneCoroutine will be created and its start method will be called And return StandaloneCoroutine.

Standalone Coroutine indirectly implements the Job interface and Continuation interface, as follows:

private open class StandaloneCoroutine(
    parentContext: CoroutineContext,
    active: Boolean
) : AbstractCoroutine(parentContext, active) {
    override fun handleJobException(exception: Throwable): Boolean {
        handleCoroutineException(context, exception)
        return true
    }
}

public abstract class AbstractCoroutine(
    /**
     * The context of the parent coroutine.
     */
    @JvmField
    protected val parentContext: CoroutineContext,
    active: Boolean = true
) : JobSupport(active), Job, Continuation, CoroutineScope {...}

It can be seen that StandaloneCoroutine has multiple roles and implements the Job, Continuation, CoroutineScope interface. The following code tracing can draw a conclusion that the topmost continuation implementation is the coroutine itself, that is, when the coroutine resumes, the continuation body is called back layer by layer, and the topmost continuation is the coroutinecoroutine itself，That is StandaloneCoroutine (here we take StandaloneCoroutine as an example).

In addition, pay attention to the block block type passed in the launch method:

 block: suspend CoroutineScope.() -> Unit

It is equivalent to the following function type:

// CoroutineScope: converted from extension function
// Continuation: converted from the suspend keyword, the Continuation parameter is passed in by the compiler
block : (CoroutineScope,Continuation) -> Unit

// Or expressed in the form of Function2
block : Function2

Then trace the calling process of starting the coroutine. In the launch method, the AbstractCoroutine::start method is called:

 public fun  start(start: CoroutineStart, receiver: R, block: suspend R.() -> T) {
        initParentJob()
        // Syntactic sugar, actually calls the CoroutineStart.invoke method
        start(block, receiver, this)
    }

CoroutineStart::invoke method:

 public operator fun  invoke(block: suspend R.() -> T, receiver: R, completion: Continuation): Unit =
        when (this) {
            DEFAULT -> block. startCoroutineCancellable(receiver, completion)
            ATOMIC -> block. startCoroutine(receiver, completion)
            UNDISPATCHED -> block. startCoroutineUndispatched(receiver, completion)
            LAZY -> Unit // will start lazily
        }

From the launch method, we can know that the default value of CoroutineStart is CoroutineStart.DEFAULT, so it will call block The startCoroutineCancellable method:

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

When I followed the code call of createCoroutineUnintercepted in AS, I found that it would jump to the IntrinsicsKt.class file, which was not found in this file The source code of the method, finally found the IntrinsicsJvm.kt file, and found the source code of the createCoroutineUnintercepted method, as follows:

# R: CoroutineScope
# T: Unit
@SinceKotlin("1.3")
public actual fun  (suspend R.() -> T).createCoroutineUnintercepted(
    receiver: R,
    completion: Continuation
): Continuation {
    // The probeCoroutineCreated method directly returns completion
    val probeCompletion = probeCoroutineCreated(completion)
    return if (this is BaseContinuationImpl)
        create(receiver, probeCompletion)
    else {
        createCoroutineFromSuspendFunction(probeCompletion) {
            (this as Function2<R, Continuation, Any?>).invoke(receiver, it)
        }
    }
}

Here will determine whether the type of this is BaseContinuationImpl, this is what we passed in launch before lambda block, so what type is this lambda code block? To know the answer, we have to decompile the code given at the beginning of this section

kotlinCode:

class Temp2 {
    fun execute() {
        GlobalScope. launch(Dispatchers. Main) {
            Temp(). fetchData("argument")
        }
    }
}

Properly rename and adjust the decompiled java code to get:

public final class Temp2 {
    ...
    static final class LaunchLambda extends SuspendLambda implements Function2<CoroutineScope, Continuation, Object> {
        int label;

        LaunchLambda(Continuation $completion) {super(2, $completion);
        }

        @Nullable
        public final Object invokeSuspend(@NotNull Object $result) {
            switch (this.label) {
                case 0:
                    ResultKt.throwOnFailure(SYNTHETIC_LOCAL_VARIABLE_1);
                    this.label = 1;
                    if ((new Temp()). fetchData("argument", (Continuation) this) == COROUTINE_SUSPENDED)
                        return COROUTINE_SUSPENDED;
                    (new Temp()). fetchData("argument", (Continuation) this);
                    return Unit. INSTANCE;
                case 1:
                    ResultKt.throwOnFailure(SYNTHETIC_LOCAL_VARIABLE_1);
                    return Unit. INSTANCE;
            }
            throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
        }

        @NotNull
        public final Continuation create(@Nullable Object value, @NotNull Continuation $completion) {
            return (Continuation) new LaunchLambda($completion);
        }

        @Nullable
        public final Object invoke(@NotNull CoroutineScope p1, @Nullable Continuation p2) {
            return ((LaunchLambda) create(p1, p2)). invokeSuspend(Unit. INSTANCE);
        }
    }
}

It can be seen that a static internal class LaunchLambda is automatically generated in Temp2, which corresponds to the introduced in the launch method >lambda block. Inheritance relationship of LaunchLambda (from top to bottom, order from subclass to parent class):

LaunchLambda
-> SuspendLambda // Lambda blocks modified with suspend will inherit from this class
-> ContinuationImpl
-> BaseContinuationImpl // rewrite resumeWith function
-> Continuation

OK, back to the createCoroutineUnintercepted method, now you can answer the question just raised, lambda incoming lambda block of type BaseContinuationImpl? According to the inheritance relationship above, of course it is! Then it will call the create method of LaunchLambda, note that the second parameter is passed in completion (the code says probeCompletion), it will eventually be saved in the completion variable of the parent class BaseContinuationImpl, this completion parameter is < The StandaloneCoroutine created in the code>launch method is the coroutine itself, which is the topmost continuation when the coroutine resumes.

A LaunchLambda instance is obtained by calling the create method, and the createCoroutineUnintercepted method is executed and the LaunchLambda instance is returned. Then the code execution returns to startCoroutineCancellable, review the method:

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

There are two parts of the call here, first calling the intercepted method, and then calling the resumeCancellableWith method. The intercepted method is related to the continuation interception mechanism, which will be introduced later. Ignore it here. Here, it is directly considered that the resumeCancellableWith method of the LaunchLambda instance is called. , the method is as follows:

public fun  Continuation.resumeCancellableWith(
    result: Result,
    onCancellation: ((cause: Throwable) -> Unit)? = null
): Unit = when (this) {
    is DispatchedContinuation -> resumeCancellableWith(result, onCancellation)
    else -> resumeWith(result)
}

Then it will go to the resumeWith method. As mentioned earlier, this method is implemented in the parent class BaseContinuationImpl, and invokeSuspend will be called in this method method, the invokeSuspend method is implemented in LaunchLambda, as follows:

@Nullable
public final Object invokeSuspend(@NotNull Object $result) {
    switch (this.label) {
        case 0:
            ResultKt.throwOnFailure(SYNTHETIC_LOCAL_VARIABLE_1);
            this.label = 1;
            if ((new Temp()). fetchData("argument", (Continuation) this) == COROUTINE_SUSPENDED)
                return COROUTINE_SUSPENDED;
            (new Temp()). fetchData("argument", (Continuation) this);
            return Unit. INSTANCE;
        case 1:
            ResultKt.throwOnFailure(SYNTHETIC_LOCAL_VARIABLE_1);
            return Unit. INSTANCE;
    }
    throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
}

At the beginning, the value of label is 0, so it will enter the case 0 statement branch, in which the label will be set The value of >label is 1, then create a Temp object andAnd call its fetchData method, and pass in LaunchLambda itself as a parameter, that is, the LaunchLambda instance will be saved in fetchData< In the completion variable of the continuation created by the /code> method, it is convenient to call back when the coroutine resumes.

11. When FetchDataStateMachine::invokeSuspend is executed, it will be judged in resumeWith method of BaseContinuationImpl< Whether the completion (i.e. LaunchLambda) held by code>FetchDataStateMachine is of BaseContinuationImpl type depends on LaunchLambda Inheritance relationship, it is easy to get the answer “yes”, so it will enter the next round of while loop and call the invokeSuspend method of LaunchLambda.
12. Because label = 1 will enter case 1 statement, which directly return Unit. Then judge whether the completion (i.e. StandaloneCoroutine) held by LaunchLambda is of BaseContinuationImpl type, according to StandaloneCoroutine is easy to get the answer "no", so the resumeWith method of StandaloneCoroutine will be called.
13. StandaloneCoroutine's resumeWith method is implemented in the parent class AbstractCoroutine:

 public final override fun resumeWith(result: Result) {
        val state = makeCompletingOnce(result.toState())
        // If waiting for the child coroutine to complete, return
        if (state === COMPLETING_WAITING_CHILDREN) return
        // should do some follow-up processing
        afterResume(state)
    }

public interface CoroutineContext {...}

public interface Continuation {
    // The context of the coroutine corresponding to the continuation
    public val context: CoroutineContext
    // Resume the execution of the corresponding coroutine, and pass a result indicating success or failure as the return value of the last suspension point
    public fun resumeWith(result: Result)
}

 public interface Element : CoroutineContext {...}

scope.launch(CoroutineName("coroutine") + Dispatchers.Main) {...}

 public operator fun plus(context: CoroutineContext): CoroutineContext = ...

internal class CombinedContext(
    private val left: CoroutineContext,
    private val element: Element
) : CoroutineContext, Serializable {
    override fun  get(key: Key): E? {
        var cur = this
        while (true) {
            cur.element[key]?.let { return it }
            val next = cur. left
            if (next is CombinedContext) {cur = next
            } else {
                return next[key]
            }
        }
    }
    ...
}

public interface CoroutineContext {
...
    public interface Key

    public interface Element : CoroutineContext {
        // Key used to identify the element
    public val key: Key
        ...
    }
}

public abstract class AbstractCoroutineContextElement(public override val key: Key) : Element

public data class CoroutineName(
    val name: String
    /* CoroutineName.Key can be abbreviated as CoroutineName */
) : AbstractCoroutineContextElement(CoroutineName) {
    
    public companion object Key : CoroutineContext.Key
...}

The above is a common way to implement the coroutine context element, that is, define a companion object in the coroutine context element, and use the companion object as Key to identify the context element.

public interface CoroutineContext {
    // get element by key
    public operator fun  get(key: Key): E?

    // translated as "folding", it is related to the accumulation of context elements
    public fun  fold(initial: R, operation: (R, Element) -> R): R

    // Accumulation of coroutine context elements
    public operator fun plus(context: CoroutineContext): CoroutineContext = ...
        
// In the current CoroutineContext, after removing the element identified by the key, the remaining context elements (returned in the form of CoroutineContext)
    public fun minusKey(key: Key): CoroutineContext

    public interface Key

    public interface Element : CoroutineContext {
        // Key that identifies the context element
        public val key: Key

        // If the key is the same, return the element itself, otherwise return null
        public override operator fun  get(key: Key): E? =
            @Suppress("UNCHECKED_CAST")
            if (this.key == key) this as E else null

        // Execute the incoming operation function
        public override fun  fold(initial: R, operation: (R, Element) -> R): R =
            operation(initial, this)

        public override fun minusKey(key: Key): CoroutineContext =
            if (this.key == key) EmptyCoroutineContext else this
    }
}

public operator fun plus(context: CoroutineContext): CoroutineContext =
    if (context === EmptyCoroutineContext) this else // fast path -- avoid lambda creation
        context.fold(this) { acc, element ->
            val removed = acc.minusKey(element.key)
            if (removed === EmptyCoroutineContext) element else {
                // make sure interceptor is always last in the context (and thus is fast to get when present)
                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)}
            }
        }

public interface ContinuationInterceptor : CoroutineContext.Element {
    // Key corresponding to the continuation interceptor
companion object Key : CoroutineContext.Key
    
    // Return a continuation that wraps the original continuation (the original continuation is passed in as a method parameter).
    // If the method does not want to intercept the incoming continuation, it can also return the original continuation directly.
    // When the original continuation is completed, if the continuation was intercepted before, the coroutine framework will call releaseInterceptedContinuation
    // method, the parameter passed in is the "wrapper class of the continuation".
    public fun  interceptContinuation(continuation: Continuation): Continuation
    
    // This function will only be called if the interceptContinuation is successfully intercepted.
    // If the original continuation is successfully intercepted， When the original continuation is completed and is no longer used, this method will be called, and the parameter passed in is the "wrapper class of the continuation".
    public fun releaseInterceptedContinuation(continuation: Continuation) {
        /* do nothing by default */
    }
    ...
}

public abstract class CoroutineDispatcher :
    AbstractCoroutineContextElement(ContinuationInterceptor), ContinuationInterceptor {
    
    @ExperimentalStdlibApi
    public companion object Key : AbstractCoroutineContextKey(
        ContinuationInterceptor,
        { it as? CoroutineDispatcher })
    
    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  interceptContinuation(continuation: Continuation): Continuation =
        DispatchedContinuation(this, continuation)
        
    @InternalCoroutinesApi
    public override fun releaseInterceptedContinuation(continuation: Continuation) {
        (continuation as DispatchedContinuation).reusableCancellableContinuation?.detachChild()
    }
        
...
}

 public actual val Main: MainCoroutineDispatcher get() = MainDispatcherLoader.dispatcher

 @JvmField
    val dispatcher: MainCoroutineDispatcher = loadMainDispatcher()

    private fun loadMainDispatcher(): MainCoroutineDispatcher {
        return try {
            val factories = if (FAST_SERVICE_LOADER_ENABLED) {
                FastServiceLoader. loadMainDispatcherFactory()
            } else {// We are explicitly using the
                // `ServiceLoader.load(MyClass::class.java, MyClass::class.java.classLoader).iterator()`
                // form of the ServiceLoader call to enable R8 optimization when compiled on Android.
                ServiceLoader.load(
                        MainDispatcherFactory::class.java,
                        MainDispatcherFactory::class.java.classLoader
                ).iterator().asSequence().toList()
            }
            @Suppress("ConstantConditionIf")
            factories.maxBy { it.loadPriority }?.tryCreateDispatcher(factories)
                ?: createMissingDispatcher()
        } catch (e: Throwable) {
            // Service loader can throw an exception as well
            createMissingDispatcher(e)
        }
    }

public fun MainDispatcherFactory.tryCreateDispatcher(factories: List): MainCoroutineDispatcher =
    try {
        createDispatcher(factories)
    } catch (cause: Throwable) {
        createMissingDispatcher(cause, hintOnError())
    }

internal class AndroidDispatcherFactory : MainDispatcherFactory {

    override fun createDispatcher(allFactories: List) =
        HandlerContext(Looper. getMainLooper(). asHandler(async = true))
...
}

# handler: Handler of the main thread
internal class HandlerContext private constructor(
    private val handler: Handler,
    private val name: String?,
    private val invoke Immediately: Boolean
) : HandlerDispatcher(), Delay {
	
    public constructor(
        handler: Handler,
        name: String? = null
    ) : this(handler, name, false)
    ...
    override fun isDispatchNeeded(context: CoroutineContext): Boolean {
        return !invokeImmediately || Looper.myLooper() != handler.looper
    }
    
    override fun dispatch(context: CoroutineContext, block: Runnable) {
        handler. post(block)
    }
    ...
}

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

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

internal abstract class ContinuationImpl(
    completion: Continuation?,
    private val _context: CoroutineContext?
) : BaseContinuationImpl(completion) {
    constructor(completion: Continuation?) : this(completion, completion?.context)
...
    @Transient
    private var intercepted: Continuation? = null
    
    public fun intercepted(): Continuation =
        intercepted
            ?: (context[ContinuationInterceptor]?. interceptContinuation(this) ?: this)
                .also { intercepted = it }
    ...
}

 public final override fun  interceptContinuation(continuation: Continuation): Continuation =
        DispatchedContinuation(this, continuation)

internal class DispatchedContinuation(
    @JvmField val dispatcher: CoroutineDispatcher,
    @JvmField val continuation: Continuation
) : DispatchedTask(MODE_UNINITIALIZED), CoroutineStackFrame, Continuation by continuation {...}

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

public fun  Continuation.resumeCancellableWith(
    result: Result,
    onCancellation: ((cause: Throwable) -> Unit)? = null
): Unit = when (this) {
    is DispatchedContinuation -> resumeCancellableWith(result, onCancellation)
    else -> resumeWith(result)
}

 inline fun resumeCancellableWith(
        result: Result,
        noinline onCancellation: ((cause: Throwable) -> Unit)?
    ) {
        val state = result.toState(onCancellation)
        if (dispatcher.isDispatchNeeded(context)) { // need thread scheduling
            _state = state
            resumeMode = MODE_CANCELLABLE
            // Thread scheduling, passing itself in as a Runnable block
            dispatcher. dispatch(context, this)
        } else { // No need for thread scheduling
            executeUnconfined(state, MODE_CANCELLABLE) {
                if (!resumeCancelled(state)) {
                    // Finally, continuation.resumeWith will be called, namely LaunchLambda.resumeWith
                    resumeUndispatchedWith(result)
                }
            }
        }
    }

 public final override fun run() {
        ...
        try {
            // The obtained delegate is actually DispatchedContinuationval delegate = delegate as DispatchedContinuation
            // The obtained continuation is actually LaunchLambda
            val continuation = delegate. continuation
            val context = continuation.context
            val state = takeState() // NOTE: Must take state in any case, even if canceled
            withCoroutineContext(context, delegate.countOrElement) {
                val exception = getExceptionalResult(state)
                /*
                 * Check whether continuation was originally resumed with an exception.
                 * If so, it dominates cancellation, otherwise the original exception
                 * will be silently lost.
                 */
                val job = if (exception == null && resumeMode.isCancellableMode) context[Job] else null
                if (job != null && !job.isActive) {
                    val cause = job. getCancellationException()cancelCompletedResult(state, cause)
                    continuation. resumeWithStackTrace(cause)
                } else {
                    if (exception != null) {
                        continuation. resumeWithException(exception)
                    } else {
                        // Under normal circumstances, it will execute here and call the resume method of LaunchLambda
                        continuation. resume(getSuccessfulResult(state))
                    }
                }
            }
        } catch (e: Throwable) {
            ...
        } finally {
            ...
        }
    }

 protected override fun releaseIntercepted() {
        val intercepted = intercepted
        // intercepted is not null and not itself (that is, the continuation was successfully intercepted before), enter the If block
        if (intercepted != null && intercepted !== this) {
            // Call the releaseInterceptedContinuation method of the continuation interceptor and pass in the continuation wrapper class
 context[ContinuationInterceptor]!!.releaseInterceptedContinuation(
            intercepted)
        }
        // Set the intercepted variable to CompletedContinuation
        this. intercepted = CompletedContinuation // just in case
    }

scope.launch(Dispatchers.Main) {
    withContext(Dispatchers.IO) {}
}

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