Detailed explanation of the thread scheduling example of Kotlin coroutine

 {
    //Coecho Body 1    (TAG, "before suspend job.")
    withContext() {
        //Coecho Body 2        (TAG, "print in Main thread.")
    }
    (TAG, "after suspend job.")
}

public fun (
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = ,
    block: suspend CoroutineScope.() -> Unit
): Job {
    //1. See 1.2.1    val newContext = newCoroutineContext(context)
    val coroutine = if ()
        LazyStandaloneCoroutine(newContext, block) else
        StandaloneCoroutine(newContext, active = true)
    //2. See 1.3 for details    (start, coroutine, block)
    return coroutine
}

public actual fun (context: CoroutineContext): CoroutineContext {
    val combined = foldCopies(coroutineContext, context, true)
    val debug = if (DEBUG) combined + CoroutineId(COROUTINE_ID.incrementAndGet()) else combined
    return 
    if (combined !==  && combined[ContinuationInterceptor] == null)
        debug + 
    else 
    	debug
}

internal fun <R, T> (suspend (R) -> T).startCoroutineCancellable(
    receiver: R, completion: Continuation<T>,
    onCancellation: ((cause: Throwable) -> Unit)? = null
) =
    runSafely(completion) {
    	//1. Create SuspendLambda coroutine        createCoroutineUnintercepted(receiver, completion)
            //2. Intercept: Take out the distributor and build the method Continuation.  See 1.3.1 for details            .intercepted()
            //3. Call the resume method of the method Continuation, see 1.4 for details.            .resumeCancellableWith((Unit), onCancellation)
    }

 public fun intercepted(): Continuation<Any?> =
        intercepted?: (
                //1. Remove the interceptor                context[ContinuationInterceptor]?
                    //2. Build the interceptor continuation                    .interceptContinuation(this)?: this)
                .also { intercepted = it }

//Base class to be extended by all coroutine dispatcher implementations.
public abstract class CoroutineDispatcher :
    AbstractCoroutineContextElement(ContinuationInterceptor), ContinuationInterceptor {
public final override fun <T> interceptContinuation(continuation: Continuation<T>):
        //See 1.4 for details        Continuation<T> = DispatchedContinuation(this, continuation)
}

internal class DispatchedContinuation<in T>(
    //1. Distributor    @JvmField val dispatcher: CoroutineDispatcher,
	//2. Note that here the implementation of Continuation is delegated to the continuation member variable.    @JvmField val continuation: Continuation<T>
) : DispatchedTask<T>(MODE_UNINITIALIZED)
, CoroutineStackFrame,
Continuation<T> by continuation {
    	//3. Rewrite the attribute delegate for yourself	    override val delegate: Continuation<T>
        get() = this
    ...
    // We inline it to save an entry on the stack in cases where it shows (unconfined dispatcher)
    // It is used only in Continuation<T>.resumeCancellableWith
    @Suppress("NOTHING_TO_INLINE")
    inline fun resumeCancellableWith(
        result: Result<T>,
        noinline onCancellation: ((cause: Throwable) -> Unit)?
    ) {
        val state = (onCancellation)
        //Default is true        if ((context)) {
            _state = state
            resumeMode = MODE_CANCELLABLE
            //4. See for details            (context, this)
        } else {
            executeUnconfined(state, MODE_CANCELLABLE) {
                if (!resumeCancelled(state)) {
                    resumeUndispatchedWith(result)
                }
            }
        }
    }
}

//
@JvmStatic
public actual val Default: CoroutineDispatcher = DefaultScheduler
//
// Instance of 
internal object DefaultScheduler : SchedulerCoroutineDispatcher(
    CORE_POOL_SIZE, MAX_POOL_SIZE,
    IDLE_WORKER_KEEP_ALIVE_NS, DEFAULT_SCHEDULER_NAME
) {
    ...
}

internal open class SchedulerCoroutineDispatcher(
    private val corePoolSize: Int = CORE_POOL_SIZE,
    private val maxPoolSize: Int = MAX_POOL_SIZE,
    private val idleWorkerKeepAliveNs: Long = IDLE_WORKER_KEEP_ALIVE_NS,
    private val schedulerName: String = "CoroutineScheduler",
) : ExecutorCoroutineDispatcher() {
    override val executor: Executor
        get() = coroutineScheduler
    // This is variable for test purposes, so that we can reinitialize from clean state
    private var coroutineScheduler = createScheduler()
    private fun createScheduler() =
        //1. See 1.5.2 for details        CoroutineScheduler(corePoolSize, maxPoolSize, idleWorkerKeepAliveNs, schedulerName)
    //2. See 1.5.2 for details    override fun dispatch(context: CoroutineContext, block: Runnable): Unit 
    = (block)
    ...
}
//
//2. In fact, it inherits ExecutorCoroutineDispatcherpublic abstract class ExecutorCoroutineDispatcher: CoroutineDispatcher(), Closeable {
    ...
}

internal class CoroutineScheduler(
    @JvmField val corePoolSize: Int,
    @JvmField val maxPoolSize: Int,
    @JvmField val idleWorkerKeepAliveNs: Long = IDLE_WORKER_KEEP_ALIVE_NS,
    @JvmField val schedulerName: String = DEFAULT_SCHEDULER_NAME
) : Executor, Closeable {
	... 
    override fun execute(command: Runnable) = dispatch(command)
    fun dispatch(block: Runnable, taskContext: TaskContext = NonBlockingContext, tailDispatch: Boolean = false) {
        trackTask() // this is needed for virtual time support
        val task = createTask(block, taskContext)
        // try to submit the task to the local queue and act depending on the result
        val currentWorker = currentWorker()
        val notAdded = (task, tailDispatch)
        if (notAdded != null) {
            if (!addToGlobalQueue(notAdded)) {
                // Global queue is closed in the last step of close/shutdown -- no more tasks should be accepted
                throw RejectedExecutionException("$schedulerName was terminated")
            }
        }
        val skipUnpark = tailDispatch && currentWorker != null
        // Checking 'task' instead of 'notAdded' is completely okay
        if ( == TASK_NON_BLOCKING) {
            if (skipUnpark) return
            signalCpuWork()
        } else {
            // Increment blocking tasks anyway
            signalBlockingWork(skipUnpark = skipUnpark)
        }
    }
}

internal abstract class DispatchedTask<in T>(
    @JvmField public var resumeMode: Int
) : SchedulerTask() {
	...
    internal abstract val delegate: Continuation<T>
    @Suppress("UNCHECKED_CAST")
    internal open fun <T> getSuccessfulResult(state: Any?): T =
        state as T
    internal open fun getExceptionalResult(state: Any?): Throwable? =
        (state as? CompletedExceptionally)?.cause
    public final override fun run() {
        assert { resumeMode != MODE_UNINITIALIZED } // should have been set before dispatching
        val taskContext = 
        var fatalException: Throwable? = null
        try {
            val delegate = delegate as DispatchedContinuation<T>
            //1. Remove the agent's continuation            val continuation = 
            withContinuationContext(continuation, ) {
                val context = 
                val state = takeState() // NOTE: Must take state in any case, even if cancelled
                val exception = getExceptionalResult(state)
                val job = if (exception == null && ) context[Job] else null
                if (job != null && !) {
                    val cause = ()
                    cancelCompletedResult(state, cause)
                    (cause)
                } else {
                    if (exception != null) {
                        (exception)
                    } else {
                        //1. The resume method of the wrapped continuum, and it really starts to start its coroutine state machine code.                        (getSuccessfulResult(state))
                    }
                }
            }
        } catch (e: Throwable) {
            // This instead of runCatching to have nicer stacktrace and debug experience
            fatalException = e
        } finally {
            val result = runCatching { () }
            handleFatalException(fatalException, ())
        }
    }
}

final class MainActivity$onCreate$1 extends SuspendLambda implements Function2<CoroutineScope, Continuation<? super Unit>, Object> {
    ...
    @Override // 
    public final Object invokeSuspend(Object $result) {
        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
        switch () {
            case 0:
                ($result);
                (, LiveLiterals$.m4147xf96cab04());
                 = 1;
                //1. Create a type that is automatically generated by the new compiler that inherits from SuspendLambda.                AnonymousClass1 anonymousClass1 = new AnonymousClass1(null);
                //2. Call withContext            	Object res = ((), anonymousClass1, this);
                if (res != coroutine_suspended) {
                    break;
                } else {
                    //Hang                    return coroutine_suspended;
                }
            case 1:
                ($result);
                break;
            default:
                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
        }
        (, LiveLiterals$.m4148xe0c1b328());
        return ;
    }
}

/* compiled from:  */
public static final class AnonymousClass1 extends SuspendLambda implements Function2<CoroutineScope, Continuation<? super Integer>, Object> {
    int label
    ...
    @Override // 
    public final Object invokeSuspend(Object obj) {
        IntrinsicsKt.getCOROUTINE_SUSPENDED();
        switch () {
            case 0:
                (obj);
                return ((, LiveLiterals$.m4146x7c0f011f()));
            default:
                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
        }
    }
}

public suspend fun <T> withContext(
    context: CoroutineContext,
    block: suspend CoroutineScope.() -> T
): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    //1. Get the current coroutine, note that the uCont here is the current continuum, that is, MainActivity$onCreate$1    return suspendCoroutineUninterceptedOrReturn sc@ { uCont ->
        //2. Calculate the obtained new coroutine context        val oldContext = 
        val newContext = oldContext + context
        //3. Quick judgment: Quickly deal with the situation where the new context and the old context are consistent.        // always check for cancellation of new context
        ()
        // FAST PATH #1 -- new context is the same as the old one
        if (newContext === oldContext) {
            val coroutine = ScopeCoroutine(newContext, uCont)
            return@sc (coroutine, block)
        }
        // FAST PATH #2 -- the new dispatcher is the same as the old one (something else changed)
        // `equals` is used by design (see equals implementation is wrapper context like ExecutorCoroutineDispatcher)
        if (newContext[ContinuationInterceptor] == oldContext[ContinuationInterceptor]) {
            val coroutine = UndispatchedCoroutine(newContext, uCont)
            // There are changes in the context, so this thread needs to be updated
            withCoroutineContext(newContext, null) {
                return@sc (coroutine, block)
            }
        }
        // SLOW PATH -- use new dispatcher
        //4. Create a new DispatchedCoroutine        val coroutine = DispatchedCoroutine(newContext, uCont)
        //5. Start coroutine        (coroutine, coroutine)
        ()
    }
}

internal fun <R, T> (suspend (R) -> T).startCoroutineCancellable(
    receiver: R, completion: Continuation<T>,
    onCancellation: ((cause: Throwable) -> Unit)? = null
) =
    runSafely(completion) {
    	//1. Create SuspendLambda coroutine        createCoroutineUnintercepted(receiver, completion)
            //2. Intercept: Take out the distributor and build the method Continuation.  See 1.3.1 for details            .intercepted()
            //3. Call the resume method of the method Continuation, see 1.4 for details.            .resumeCancellableWith((Unit), onCancellation)
    }

public final override fun resumeWith(result: Result<Any?>) {
        // This loop unrolls recursion in (param) to make saner and shorter stack traces on resume
        var current = this
        var param = result
        while (true) {
            // Invoke "resume" debug probe on every resumed continuation, so that a debugging library infrastructure
            // can precisely track what part of suspended callstack was already resumed
            probeCoroutineResumed(current)
            with(current) {
                val completion = completion!! // fail fast when trying to resume continuation without completion
                val outcome: Result<Any?> =
                    try {
                        val outcome = invokeSuspend(param)
                        if (outcome === COROUTINE_SUSPENDED) return
                        (outcome)
                    } catch (exception: Throwable) {
                        (exception)
                    }
                releaseIntercepted() // this state machine instance is terminating
                if (completion is BaseContinuationImpl) {
                    // unrolling recursion via loop
                    current = completion
                    param = outcome
                } else {
                    //1. Enter this judgment                    // top-level completion reached -- invoke and return
                    (outcome)
                    return
                }
            }
        }
    }

internal class DispatchedCoroutine<in T>(
    context: CoroutineContext,
    uCont: Continuation<T>
) : ScopeCoroutine<T>(context, uCont) {
}

internal open class ScopeCoroutine<in T>(
    context: CoroutineContext,
    @JvmField val uCont: Continuation<T> // unintercepted continuation
) : AbstractCoroutine<T>(context, true, true), CoroutineStackFrame {
}

public abstract class AbstractCoroutine<in T>(
    parentContext: CoroutineContext,
    initParentJob: Boolean,
    active: Boolean
) : JobSupport(active), Job, Continuation<T>, CoroutineScope {
}

    public final override fun resumeWith(result: Result<T>) {
        val state = makeCompletingOnce(())
        if (state === COMPLETING_WAITING_CHILDREN) return
        afterResume(state)
    }

//DispatchedCoroutine
override fun afterResume(state: Any?) {
        if (tryResume()) return // completed before getResult invocation -- bail out
        // Resume in a cancellable way because we have to switch back to the original dispatcher
        ().resumeCancellableWith(recoverResult(state, uCont))
}

    @JvmStatic
    public actual val Main: MainCoroutineDispatcher get() 
= 

internal object MainDispatcherLoader {
    private val FAST_SERVICE_LOADER_ENABLED = systemProp(FAST_SERVICE_LOADER_PROPERTY_NAME, true)
    @JvmField
    val dispatcher: MainCoroutineDispatcher = loadMainDispatcher()
    private fun loadMainDispatcher(): MainCoroutineDispatcher {
        return try {
            val factories = if (FAST_SERVICE_LOADER_ENABLED) {
                ()
            } else {
                // We are explicitly using the
                // `(MyClass::, MyClass::).iterator()`
                // form of the ServiceLoader call to enable R8 optimization when compiled on Android.
                // 1. Obtain the implementation class of MainDispatcherFactory                (
                        MainDispatcherFactory::,
                        MainDispatcherFactory::
                ).iterator().asSequence().toList()
            }
            @Suppress("ConstantConditionIf")
             {  }?.tryCreateDispatcher(factories)
                ?: createMissingDispatcher()
        } catch (e: Throwable) {
            // Service loader can throw an exception as well
            createMissingDispatcher(e)
        }
    }
}

internal class AndroidDispatcherFactory : MainDispatcherFactory {
    override fun createDispatcher(allFactories: List<MainDispatcherFactory>) =
        HandlerContext(().asHandler(async = true))
    override fun hintOnError(): String = "For tests  from kotlinx-coroutines-test module can be used"
    override val loadPriority: Int
        get() = Int.MAX_VALUE / 2
}

internal class HandlerContext private constructor(
    private val handler: Handler,
    private val name: String?,
    private val invokeImmediately: Boolean
) : HandlerDispatcher(), Delay {
    /**
     * Creates [CoroutineDispatcher] for the given Android [handler].
     *
     * @param handler a handler.
     * @param name an optional name for debugging.
     */
    constructor(
        handler: Handler,
        name: String? = null
    ) : this(handler, name, false)
    @Volatile
    private var _immediate: HandlerContext? = if (invokeImmediately) this else null
    override val immediate: HandlerContext = _immediate ?:
        HandlerContext(handler, name, true).also { _immediate = it }
    override fun isDispatchNeeded(context: CoroutineContext): Boolean {
        return !invokeImmediately || () != 
    }
    override fun dispatch(context: CoroutineContext, block: Runnable) {
        if (!(block)) {
            cancelOnRejection(context, block)
        }
    }
    override fun scheduleResumeAfterDelay(timeMillis: Long, continuation: CancellableContinuation<Unit>) {
        val block = Runnable {
            with(continuation) { resumeUndispatched(Unit) }
        }
        if ((block, (MAX_DELAY))) {
             { (block) }
        } else {
            cancelOnRejection(, block)
        }
    }
   ...
}