fun A() {                 fun A                   fun B
    println(1)      +--------------+        +--------------+
    B()             |              |        |              |
    println(2)      |      A()     |        |              |
}                   |       |      |        |              |
                    |       v      |        |              |
fun B() {           |      B()     |  --->  |      B()     |
    println(3)      |              |        |      |       |
}                   |              |        |      v       |
                    |      A()     |  <---  |    return    |
A()                 |      |       |        |              |
                    |      v       |        |              |
                    |     END      |        |              |
                    +--------------+        +--------------+
/* 結果
    1
    3
    2
*/

     fun A                   fun B
+--------------+        +--------------+
|              |        |              |
|      A()     |        |              |
|       |      |        |              |
|       v      |        |              |
|      B()     |  --->  |      B()     |
|              |        |      |       |
|              |        |      v       |
|   cont A()   |  <---  |  resume A()  | ........ yield 讓出控制權
|       |      |        |              |
|       v      |        |              |
|  resume B()  |  --->  |    cont B()  |
|              |        |      |       |
|              |        |      v       |
|   cont A()   |  <---  |  resume A()  |
|       |      |        |              |
|       v      |        |              |
|  resume B()  |  --->  |    cont B()  |
|              |        |      |       |
|              |        |      v       |
|     A()      |  <---  |    return    |
|      |       |        |              |
|      v       |        |              |
|     END      |        |              |
+--------------+        +--------------+

val random = Random(0)

val thread = Thread {
    sleep(random.nextInt(1000).toLong());
    println("Complete")
}
thread.start()

sleep(random.nextInt(1000).toLong());
println("Complete")

public static void main(String[] args) throws InterruptedException {
    ThreadPool threadPool = new ThreadPool(5);
    Random random = new Random();

    for (int i=0; i<10; i++) {
        int fi = i;
        threadPool.execute(() -> {
            try {
                Thread.sleep(random.nextInt(1000));
                System.out.printf("task %d complete\n", fi);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
    }

    Thread.sleep(3000);
    threadPool.shutdown();
}

public class ThreadPoolExecutor extends AbstractExecutorService

// 從 Executors 創建 ThreadPoolExecutor
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

public abstract class AbstractExecutorService implements ExecutorService

public interface ExecutorService extends Executor {
    void shutdown();
    List<Runnable> shutdownNow();

    boolean isShutdown();
    boolean isTerminated();
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;

    <T> Future<T> submit(Callable<T> task);
    <T> Future<T> submit(Runnable task, T result);
    Future<?> submit(Runnable task);

    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;
    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;
    <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

public interface Executor {
    void execute(Runnable command);
}

// 這會晚點談
public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();

    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

public actual object Dispatchers {

    /*
        當 builders，像是 launch, async ...，中沒有使用 ContinuationInterceptor 時，這就是預設的 Dispatcher
        他會使用 JVM shared pool of thread

        CPU 核心數量 >= 執行緒數量 >= 2
    */
    @JvmStatic
    public actual val Default: CoroutineDispatcher = DefaultScheduler

    /*
        這是主執行緒。

        - 在 JS 這與 Default 一樣
        - 在 JVM 就是 Main Thread 或 JavaFx / Swing EDT dispatcher，這是由 ServiceLoader 決定
    */
    @JvmStatic
    public actual val Main: MainCoroutineDispatcher get() = MainDispatcherLoader.dispatcher

    /*
        這並沒有指定任何的執行緒
    */
    @JvmStatic
    public actual val Unconfined: CoroutineDispatcher = kotlinx.coroutines.Unconfined

    /*
        這是一個擁有共享 Thread Pool 的 dispatcher。
        我們會使用這個 dispatcher 來進行耗時作業。

        若同時建立多個 Dispatchers.IO 時，他們會共用執行緒：

        val myMysqlDbDispatcher = Dispatchers.IO.limitedParallelism(100)
        val myMongoDbDispatcher = Dispatchers.IO.limitedParallelism(60)

        此時系統會有 {core number} + 100 + 60 執行緒
    */
    @JvmStatic
    public val IO: CoroutineDispatcher = DefaultIoScheduler

    @DelicateCoroutinesApi
    public fun shutdown() {
        DefaultExecutor.shutdown()
        // Also shuts down Dispatchers.IO
        DefaultScheduler.shutdown()
    }
}

public abstract class CoroutineDispatcher :
    AbstractCoroutineContextElement(ContinuationInterceptor), ContinuationInterceptor {

    /** @suppress */
    @ExperimentalStdlibApi
    public companion object Key : AbstractCoroutineContextKey<ContinuationInterceptor, CoroutineDispatcher>(
        ContinuationInterceptor,
        { it as? CoroutineDispatcher })

    public open fun isDispatchNeeded(context: CoroutineContext): Boolean = true

    @ExperimentalCoroutinesApi
    public open fun limitedParallelism(parallelism: Int): CoroutineDispatcher {
        parallelism.checkParallelism()
        return LimitedDispatcher(this, parallelism)
    }

    public abstract fun dispatch(context: CoroutineContext, block: Runnable)

    @InternalCoroutinesApi
    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)

    public final override fun releaseInterceptedContinuation(continuation: Continuation<*>) {
        val dispatched = continuation as DispatchedContinuation<*>
        dispatched.release()
    }

    @Suppress("DeprecatedCallableAddReplaceWith")
    @Deprecated(
        message = "Operator '+' on two CoroutineDispatcher objects is meaningless. " +
            "CoroutineDispatcher is a coroutine context element and `+` is a set-sum operator for coroutine contexts. " +
            "The dispatcher to the right of `+` just replaces the dispatcher to the left.",
        level = DeprecationLevel.ERROR
    )
    public operator fun plus(other: CoroutineDispatcher): CoroutineDispatcher = other

    /** @suppress for nicer debugging */
    override fun toString(): String = "$classSimpleName@$hexAddress"
}

public abstract class ExecutorCoroutineDispatcher: CoroutineDispatcher(), Closeable {
    /** @suppress */
    @ExperimentalStdlibApi
    public companion object Key : AbstractCoroutineContextKey<CoroutineDispatcher, ExecutorCoroutineDispatcher>(
        CoroutineDispatcher,
        { it as? ExecutorCoroutineDispatcher })

    public abstract val executor: Executor
    public abstract override fun close()
}

override val executor: Executor
    get() = this

override fun execute(command: java.lang.Runnable) = dispatch(EmptyCoroutineContext, command)

override fun dispatch(context: CoroutineContext, block: Runnable) {
    default.dispatch(context, block)
}

@InternalCoroutinesApi
override fun dispatchYield(context: CoroutineContext, block: Runnable) {
    default.dispatchYield(context, block)
}

// 這裡會限制執行緒至少有 64 條
private val default = UnlimitedIoScheduler.limitedParallelism(
    systemProp(
        IO_PARALLELISM_PROPERTY_NAME,
        64.coerceAtLeast(AVAILABLE_PROCESSORS)
    )
)

@ExperimentalCoroutinesApi
public open fun limitedParallelism(parallelism: Int): CoroutineDispatcher {
    // 確保 parallelism >= 2
    parallelism.checkParallelism()
    // 這裡的 this 是 UnlimitedIoScheduler 而 parallelism 則是用來控制 runningWorkers 的數量 (當下執行的數量)
    return LimitedDispatcher(this, parallelism)
}

internal class LimitedDispatcher(
    private val dispatcher: CoroutineDispatcher,
    private val parallelism: Int
) : CoroutineDispatcher(), Runnable, Delay by (dispatcher as? Delay ?: DefaultDelay) {
    private val queue = LockFreeTaskQueue<Runnable>(singleConsumer = false)
}

override fun run() {
    var fairnessCounter = 0
    while (true) {
        val task = queue.removeFirstOrNull()
        if (task != null) {
            try {
                task.run()
            } catch (e: Throwable) {
                handleCoroutineException(EmptyCoroutineContext, e)
            }
            // 16 is our out-of-thin-air constant to emulate fairness. Used in JS dispatchers as well
            if (++fairnessCounter >= 16 && dispatcher.isDispatchNeeded(this)) {
                // Do "yield" to let other views to execute their runnable as well
                // Note that we do not decrement 'runningWorkers' as we still committed to do our part of work
                dispatcher.dispatch(this, this)
                return
            }
            continue
        }

        synchronized(workerAllocationLock) {
            --runningWorkers
            if (queue.size == 0) return
            ++runningWorkers
            fairnessCounter = 0
        }
    }
}

private fun addAndTryDispatching(block: Runnable): Boolean {
    queue.addLast(block)
    return runningWorkers >= parallelism
}

private inline fun dispatchInternal(block: Runnable, dispatch: () -> Unit) {
    if (addAndTryDispatching(block)) return

    if (!tryAllocateWorker()) return
    dispatch() // 若 runningWorkers < parallelism，便調用 dispatcher.dispatch() 或 dispatcher.dispatchYield
}

override fun dispatch(context: CoroutineContext, block: Runnable) {
    // 1. 將 Runnable 放入 queue 中
    dispatchInternal(block) {
        // 2. 調用 dispatch 並將自己傳入
        dispatcher.dispatch(this, this)
    }
}

@InternalCoroutinesApi
override fun dispatchYield(context: CoroutineContext, block: Runnable) {
    // 1. 將 Runnable 放入 queue 中
    dispatchInternal(block) {
        // 2. 調用 dispatchYield 並將自己傳入
        dispatcher.dispatchYield(this, this)
    }
}

private object UnlimitedIoScheduler : CoroutineDispatcher() {

    @InternalCoroutinesApi
    override fun dispatchYield(context: CoroutineContext, block: Runnable) {
        DefaultScheduler.dispatchWithContext(block, BlockingContext, true)
    }

    override fun dispatch(context: CoroutineContext, block: Runnable) {
        DefaultScheduler.dispatchWithContext(block, BlockingContext, false)
    }
}

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

internal object DefaultScheduler : SchedulerCoroutineDispatcher(
    CORE_POOL_SIZE, MAX_POOL_SIZE,
    IDLE_WORKER_KEEP_ALIVE_NS, DEFAULT_SCHEDULER_NAME
) {
    // Shuts down the dispatcher, used only by Dispatchers.shutdown()
    internal fun shutdown() {
        super.close()
    }

    // Overridden in case anyone writes (Dispatchers.Default as ExecutorCoroutineDispatcher).close()
    override fun close() {
        throw UnsupportedOperationException("Dispatchers.Default cannot be closed")
    }

    override fun toString(): String = "Dispatchers.Default"
}

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() =
        CoroutineScheduler(corePoolSize, maxPoolSize, idleWorkerKeepAliveNs, schedulerName)

    override fun dispatch(context: CoroutineContext, block: Runnable): Unit = coroutineScheduler.dispatch(block)

    override fun dispatchYield(context: CoroutineContext, block: Runnable): Unit =
        coroutineScheduler.dispatch(block, tailDispatch = true)

    internal fun dispatchWithContext(block: Runnable, context: TaskContext, tailDispatch: Boolean) {
        coroutineScheduler.dispatch(block, context, tailDispatch)
    }

    override fun close() {
        coroutineScheduler.close()
    }

    // fot tests only
    @Synchronized
    internal fun usePrivateScheduler() {
        coroutineScheduler.shutdown(1_000L)
        coroutineScheduler = createScheduler()
    }

    // for tests only
    @Synchronized
    internal fun shutdown(timeout: Long) {
        coroutineScheduler.shutdown(timeout)
    }

    // for tests only
    internal fun restore() = usePrivateScheduler() // recreate scheduler
}

@Suppress("NOTHING_TO_INLINE")
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

    // 1. 若 block != Task， 便創建 TaskImpl
    //    TaskImpl 是一個 Runnable Wrapper，同時還通過 TaskContext 記錄 afterTask() 的實作
    //    它會通過 run() 調用 block() 並在 finally 調用 taskContext.afterTask()
    val task = createTask(block, taskContext)

    // try to submit the task to the local queue and act depending on the result
    // 2. 若 currentThread 是 Worker，那就會有 Worker 否則為 null
    //    private fun currentWorker(): Worker? = (Thread.currentThread() as? Worker)?.takeIf { it.scheduler == this }
    val currentWorker = currentWorker()

    // 3. 嘗試將 task 放入 worker 的 localQueue 中。 這方法會在以下狀況下失敗：
    //    - 若 currentWorker == null
    //    - 若 currentWorker.state == TERMINATED
    //    - 若 task.mode != BLOCKING 且 currentWorker.state == BLOCKING (無法立可處理此 Task)
    //    另外， 若 tailDispatch == true， task 會被放置在 localQueue 的最後面
    val notAdded = currentWorker.submitToLocalQueue(task, tailDispatch)

    // 4. 若失敗 notAdded == task
    if (notAdded != null) {
        // 5. 嘗試將 task 放入 GlobalQueue 中
        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")
        }
    }

    // 6. skipUnpark == task 可以被放在最後面 且 目前 Worker 沒空
    val skipUnpark = tailDispatch && currentWorker != null
    // Checking 'task' instead of 'notAdded' is completely okay

    // 7. 若 task 需要馬上完成，但沒有人有空，那就當沒有一回事吧 :p
    if (task.mode == TASK_NON_BLOCKING) {
        if (skipUnpark) return

        // 8. 若有人有空或 task 並非要放在最後面時，它會嘗試 Unpark Worker (回收) 並嘗試創建 Worker。
        signalCpuWork()
    } else {

        // 9. Increment blocking tasks anyway
        signalBlockingWork(skipUnpark = skipUnpark)
    }

    // 10. 由於 Task 已放入 globalCpuQueue / globalBlockingQueue 中，所以創建的 Worker 都可以從他們這取得 Task。
}

internal class TaskImpl(
    @JvmField val block: Runnable,
    submissionTime: Long,
    taskContext: TaskContext
) : Task(submissionTime, taskContext) {
    override fun run() {
        try {
            block.run()
        } finally {
            taskContext.afterTask()
        }
    }

    override fun toString(): String =
        "Task[${block.classSimpleName}@${block.hexAddress}, $submissionTime, $taskContext]"
}

internal abstract class Task(
    @JvmField var submissionTime: Long,
    @JvmField var taskContext: TaskContext
) : Runnable {
    constructor() : this(0, NonBlockingContext)
    inline val mode: Int get() = taskContext.taskMode // TASK_XXX
}

@JvmField
internal val NonBlockingContext: TaskContext = TaskContextImpl(TASK_NON_BLOCKING)

@JvmField
internal val BlockingContext: TaskContext = TaskContextImpl(TASK_PROBABLY_BLOCKING)

override fun run() = runWorker()

private fun runWorker() {
    var rescanned = false
    while (!isTerminated && state != WorkerState.TERMINATED) {
        val task = findTask(mayHaveLocalTasks)
        // Task found. Execute and repeat
        if (task != null) {
            rescanned = false
            minDelayUntilStealableTaskNs = 0L
            executeTask(task)
            continue
        } else {
            mayHaveLocalTasks = false
        }
        /*
         * No tasks were found:
         * 1) Either at least one of the workers has stealable task in its FIFO-buffer with a stealing deadline.
         *    Then its deadline is stored in [minDelayUntilStealableTask]
         * // '2)' can be found below
         *
         * Then just park for that duration (ditto re-scanning).
         * While it could potentially lead to short (up to WORK_STEALING_TIME_RESOLUTION_NS ns) starvations,
         * excess unparks and managing "one unpark per signalling" invariant become unfeasible, instead we are going to resolve
         * it with "spinning via scans" mechanism.
         * NB: this short potential parking does not interfere with `tryUnpark`
         */
        if (minDelayUntilStealableTaskNs != 0L) {
            if (!rescanned) {
                rescanned = true
            } else {
                rescanned = false
                tryReleaseCpu(WorkerState.PARKING)
                interrupted()
                LockSupport.parkNanos(minDelayUntilStealableTaskNs)
                minDelayUntilStealableTaskNs = 0L
            }
            continue
        }
        /*
         * 2) Or no tasks available, time to park and, potentially, shut down the thread.
         * Add itself to the stack of parked workers, re-scans all the queues
         * to avoid missing wake-up (requestCpuWorker) and either starts executing discovered tasks or parks itself awaiting for new tasks.
         */
        tryPark()
    }
    tryReleaseCpu(WorkerState.TERMINATED)
}

val defaultIOScheduler = Dispatchers.IO

val threadNumber = 4
val limitedDispatcher = Dispatchers.IO.limitedDispatcher(threadNumber)

@JvmStatic
public actual val Default: CoroutineDispatcher = DefaultScheduler

@JvmStatic
public actual val Unconfined: CoroutineDispatcher = kotlinx.coroutines.Unconfined

internal object Unconfined : CoroutineDispatcher() {

    @ExperimentalCoroutinesApi
    override fun limitedParallelism(parallelism: Int): CoroutineDispatcher {
        throw UnsupportedOperationException("limitedParallelism is not supported for Dispatchers.Unconfined")
    }

    override fun isDispatchNeeded(context: CoroutineContext): Boolean = false

    override fun dispatch(context: CoroutineContext, block: Runnable) {
        /** It can only be called by the [yield] function. See also code of [yield] function. */
        val yieldContext = context[YieldContext]
        if (yieldContext != null) {
            // report to "yield" that it is an unconfined dispatcher and don't call "block.run()"
            yieldContext.dispatcherWasUnconfined = true
            return
        }
        throw UnsupportedOperationException("Dispatchers.Unconfined.dispatch function can only be used by the yield function. " +
            "If you wrap Unconfined dispatcher in your code, make sure you properly delegate " +
            "isDispatchNeeded and dispatch calls.")
    }

    override fun toString(): String = "Dispatchers.Unconfined"
}

@PublishedApi
internal class YieldContext : AbstractCoroutineContextElement(Key) {
    companion object Key : CoroutineContext.Key<YieldContext>

    @JvmField
    var dispatcherWasUnconfined = false
}

public suspend fun yield(): Unit = suspendCoroutineUninterceptedOrReturn sc@ { uCont ->
    val context = uCont.context
    context.ensureActive()
    val cont = uCont.intercepted() as? DispatchedContinuation<Unit> ?: return@sc Unit
    if (cont.dispatcher.isDispatchNeeded(context)) {
        // this is a regular dispatcher -- do simple dispatchYield
        cont.dispatchYield(context, Unit)
    } else {
        // This is either an "immediate" dispatcher or the Unconfined dispatcher
        // This code detects the Unconfined dispatcher even if it was wrapped into another dispatcher
        val yieldContext = YieldContext()
        cont.dispatchYield(context + yieldContext, Unit)
        // Special case for the unconfined dispatcher that can yield only in existing unconfined loop
        if (yieldContext.dispatcherWasUnconfined) {
            // Means that the Unconfined dispatcher got the call, but did not do anything.
            // See also code of "Unconfined.dispatch" function.
            return@sc if (cont.yieldUndispatched()) COROUTINE_SUSPENDED else Unit
        }
        // Otherwise, it was some other dispatcher that successfully dispatched the coroutine
    }
    COROUTINE_SUSPENDED
}

// suspendCoroutineUninterceptedOrReturn 只是用來傳遞 Continuation<T> 的
fun <T> suspendCoroutineUninterceptedOrReturn(crossinline block: (Continuation<T>) -> Any?): T

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

// Lazy loader for the main dispatcher
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) {
                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.maxByOrNull { it.loadPriority }?.tryCreateDispatcher(factories)
                ?: createMissingDispatcher()
        } catch (e: Throwable) {
            // Service loader can throw an exception as well
            createMissingDispatcher(e)
        }
    }
}

@InternalCoroutinesApi // Emulating DI for Kotlin object's
public interface MainDispatcherFactory {
    public val loadPriority: Int
    public fun createDispatcher(allFactories: List<MainDispatcherFactory>): MainCoroutineDispatcher
    public fun hintOnError(): String? = null
}

internal class AndroidDispatcherFactory : MainDispatcherFactory {

    override fun createDispatcher(allFactories: List<MainDispatcherFactory>): MainCoroutineDispatcher {
        val mainLooper = Looper.getMainLooper() ?: throw IllegalStateException("The main looper is not available")
        return HandlerContext(mainLooper.asHandler(async = true))
    }

    override fun hintOnError(): String = "For tests Dispatchers.setMain from kotlinx-coroutines-test module can be used"

    override val loadPriority: Int
        get() = Int.MAX_VALUE / 2
}

public abstract class MainCoroutineDispatcher : CoroutineDispatcher() {

    public abstract val immediate: MainCoroutineDispatcher

    override fun toString(): String = toStringInternalImpl() ?: "$classSimpleName@$hexAddress"

    // 這裡確保只有一個執行緒
    override fun limitedParallelism(parallelism: Int): CoroutineDispatcher {
        parallelism.checkParallelism()
        return this
    }

    @InternalCoroutinesApi
    protected fun toStringInternalImpl(): String? {
        val main = Dispatchers.Main
        if (this === main) return "Dispatchers.Main"
        val immediate =
            try { main.immediate }
            catch (e: UnsupportedOperationException) { null }
        if (this === immediate) return "Dispatchers.Main.immediate"
        return null
    }
}

public sealed class HandlerDispatcher : MainCoroutineDispatcher(), Delay {
    public abstract override val immediate: HandlerDispatcher
}

internal class HandlerContext private constructor(
    private val handler: Handler,
    private val name: String?,
    private val invokeImmediately: Boolean
) : HandlerDispatcher(), Delay {

    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 || Looper.myLooper() != handler.looper
    }

    // ...
}

override fun dispatch(context: CoroutineContext, block: Runnable) {
    if (!handler.post(block)) {
        cancelOnRejection(context, block)
    }
}

override fun scheduleResumeAfterDelay(timeMillis: Long, continuation: CancellableContinuation<Unit>) {

    // 1. 將 CancellableContinuation 包在 Runnable 中。
    //    如此一來便可以在 run() 時調用 resumeUndispatched(Unit)
    //    這方法會通過 Continuation 的 delegate: DispatchedContinuation 來進行 resume
    val block = Runnable {
        with(continuation) { resumeUndispatched(Unit) }
    }

    // 2. 將 Runnable 傳入 MessageQueue
    if (handler.postDelayed(block, timeMillis.coerceAtMost(MAX_DELAY))) {

        // 3. 若成功，註冊 onCancellation callback
        continuation.invokeOnCancellation { handler.removeCallbacks(block) }
    } else {
        // 4. 若失敗，直接取消 continuation.context 並從 Dispatchers.IO 傳遞 context 與 block
        //    這最後就會傳入 CoroutineScheduler
        cancelOnRejection(continuation.context, block)
    }
}

// 行為如同 scheduleResumeAfterDelay 但不會創建額外的 Runnable
override fun invokeOnTimeout(timeMillis: Long, block: Runnable, context: CoroutineContext): DisposableHandle {
    if (handler.postDelayed(block, timeMillis.coerceAtMost(MAX_DELAY))) {
        return DisposableHandle { handler.removeCallbacks(block) }
    }
    cancelOnRejection(context, block)
    return NonDisposableHandle
}

private fun cancelOnRejection(context: CoroutineContext, block: Runnable) {
    context.cancel(CancellationException("The task was rejected, the handler underlying the dispatcher '${toString()}' was closed"))
    Dispatchers.IO.dispatch(context, block)
}

internal class AndroidDispatcherFactory : MainDispatcherFactory {

    override fun createDispatcher(allFactories: List<MainDispatcherFactory>): MainCoroutineDispatcher {
        val mainLooper = Looper.getMainLooper() ?: throw IllegalStateException("The main looper is not available")
        return HandlerContext(mainLooper.asHandler(async = true))
    }

    override fun hintOnError(): String = "For tests Dispatchers.setMain from kotlinx-coroutines-test module can be used"

    override val loadPriority: Int
        get() = Int.MAX_VALUE / 2
}

@VisibleForTesting
internal fun Looper.asHandler(async: Boolean): Handler {
    // Async support was added in API 16.
    if (!async || Build.VERSION.SDK_INT < 16) {
        return Handler(this)
    }

    if (Build.VERSION.SDK_INT >= 28) {
        // TODO compile against API 28 so this can be invoked without reflection.
        val factoryMethod = Handler::class.java.getDeclaredMethod("createAsync", Looper::class.java)
        return factoryMethod.invoke(null, this) as Handler
    }

    val constructor: Constructor<Handler>
    try {
        constructor = Handler::class.java.getDeclaredConstructor(Looper::class.java,
            Handler.Callback::class.java, Boolean::class.javaPrimitiveType)
    } catch (ignored: NoSuchMethodException) {
        // Hidden constructor absent. Fall back to non-async constructor.
        return Handler(this)
    }
    return constructor.newInstance(this, null, true)
}

public suspend fun <T> withContext(
    context: CoroutineContext,
    block: suspend CoroutineScope.() -> T
): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return suspendCoroutineUninterceptedOrReturn sc@ { uCont ->
        // compute new context
        // 1. 取得 uCont.context
        val oldContext = uCont.context

        // Copy CopyableThreadContextElement if necessary
        // 2. 進行 copyForChild
        //    replace this [oldContext] CopyableThreadContextElement in the child [context] coroutine's context that is under
        //    construction if the added context does not contain an element with the same key.
        val newContext = oldContext.newCoroutineContext(context)

        // always check for cancellation of new context
        newContext.ensureActive()
        // FAST PATH #1 -- new context is the same as the old one
        if (newContext === oldContext) {

            // 3. 若 context 沒變，就創建 ScopeCoroutine
            val coroutine = ScopeCoroutine(newContext, uCont)

            // 4. 進行 probe coroutine，並使用 ContinuationImpl 包起來：
            //    - 如果 coroutine 是 BaseContinuationImpl 時會將 ScopeCoroutine 與 coroutine [Receiver] 包裹在 ContinuationImpl [ 或 RestrictedContinuationImpl] 中
            //    - 但若 coroutine 是 Function 就直接 invoke 它
            //
            return@sc coroutine.startUndispatchedOrReturn(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)

        // 5. 如果不同 context，但 ContinuationInterceptor 共用，那就創建 UndispatchedCoroutine
        if (newContext[ContinuationInterceptor] == oldContext[ContinuationInterceptor]) {
            val coroutine = UndispatchedCoroutine(newContext, uCont)
            // There are changes in the context, so this thread needs to be updated

            // 6. 更新 ThreadContext，在這裡轉換 Thread
            withCoroutineContext(newContext, null) {
                return@sc coroutine.startUndispatchedOrReturn(coroutine, block)
            }
        }
        // SLOW PATH -- use new dispatcher

        // 7. 如果 context 與 ContinuationInterceptor 皆不同，那就創建 DispatchedCoroutine
        val coroutine = DispatchedCoroutine(newContext, uCont)

        // 8. 進行 probe coroutine [completion]
        //    並將 receiver [coroutine] 與 probe 包裹成 ContinuationImpl 或 RestrictedContinuationImpl
        //    最後再從 context 中取得 ContinuationInterceptor 進行 resumeCancellableWith 調用。
        block.startCoroutineCancellable(coroutine, coroutine)

        // 9. 監看 DispatchedCoroutine 中的 _decision 與 state 來看看是否有結果
        //    並回傳 Any? 可能是 state as? T 也可能是 COROUTINE_SUSPENDED
        coroutine.getResult()
    }
}

@SinceKotlin("1.3")
@InlineOnly
@Suppress("UNUSED_PARAMETER", "RedundantSuspendModifier")
public suspend inline fun <T> suspendCoroutineUninterceptedOrReturn(crossinline block: (Continuation<T>) -> Any?): T {
    contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
    throw NotImplementedError("Implementation of suspendCoroutineUninterceptedOrReturn is intrinsic")
}

withContext(Dispatcher.Main) {
    val username: String

    withContext(Dispatchers.IO) {
        // 執行 IO
        username = getUserNameFromApi()
    }

    _binding.textview.text = username
}

runBlocking {
    val username: String

    withContext(Dispatchers.IO) {
        // 執行 IO
        username = getUserNameFromApi()
    }

    _binding.textview.text = username
}

viewModelScope.launch {
    val username: String

    withContext(Dispatchers.IO) {
        // 執行 IO
        username = getUserNameFromApi()
    }

    _binding.textview.text = username
}

@Throws(InterruptedException::class)
// 這裡通過 expect 方法知道 context 預設為 EmptyCoroutineContext
// https://github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-core/concurrent/src/Builders.concurrent.kt
public actual fun <T> runBlocking(context: CoroutineContext, block: suspend CoroutineScope.() -> T): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    // 1. 取得當下 thread
    val currentThread = Thread.currentThread()

    // 2. 從 context 取得 ContinuationInterceptor
    //    由於 context 預設為 EmptyCoroutineContext，所以他會是 null
    val contextInterceptor = context[ContinuationInterceptor]

    val eventLoop: EventLoop?
    val newContext: CoroutineContext

    if (contextInterceptor == null) {
        // create or use private event loop if no dispatcher is specified
        // 3. 如果 contextInterceptor 為 null 就取得當下 thread eventLoop
        //    但其實會創建 BlockingEventLoop(Thread.currentThread())
        eventLoop = ThreadLocalEventLoop.eventLoop

        // 4. 建構一個新的 CoroutineContext 變成 CombinedContext[content + CombinedContext[eventLoop]]
        newContext = GlobalScope.newCoroutineContext(context + eventLoop)
    } else {
        // See if context's interceptor is an event loop that we shall use (to support TestContext)
        // or take an existing thread-local event loop if present to avoid blocking it (but don't create one)

        // 5. 若有 ContinuationInterceptor，那就將 shouldBeProcessedFromContext == true 的 EventLoop 設為 eventLoop
        eventLoop = (contextInterceptor as? EventLoop)?.takeIf { it.shouldBeProcessedFromContext() }
            ?: ThreadLocalEventLoop.currentOrNull()

        // 6. 取得 CombinedContext[context]
        newContext = GlobalScope.newCoroutineContext(context)
    }

    // 7. 使用 eventLoop, newContext, currentThread 來創建 BlockingCoroutine
    val coroutine = BlockingCoroutine<T>(newContext, currentThread, eventLoop)

    // 8. 調用 AbstractCoroutine.start，這其實會執行：
    //    CoroutineStart.DEFAULT(block, receiver = coroutine, completion = coroutine)
    coroutine.start(CoroutineStart.DEFAULT, coroutine, block)

    // 9. 最後通過 AbstractCoroutine.joinBlocking() 它會調用 eventLoop.processNextEvent()
    return coroutine.joinBlocking()
}

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)

    // 與 runBlocking 相比， coroutine 在這會是 StandaloneCoroutine
    // 而 runBlocking 中會是 BlockingCoroutine
    coroutine.start(start, coroutine, block)
    return coroutine
}

public fun <T> CoroutineScope.async(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> T
): Deferred<T> {
    val newContext = newCoroutineContext(context)
    val coroutine = if (start.isLazy)
        LazyDeferredCoroutine(newContext, block) else
        DeferredCoroutine<T>(newContext, active = true)
    coroutine.start(start, coroutine, block)
    return coroutine
}

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

// AbstractCoroutine
init {
    if (initParentJob) initParentJob(parentContext[Job])
}

// JobSupport
protected fun initParentJob(parent: Job?) {
    assert { parentHandle == null }
    if (parent == null) {
        parentHandle = NonDisposableHandle
        return
    }
    parent.start() // make sure the parent is started
    @Suppress("DEPRECATION")
    val handle = parent.attachChild(this)
    parentHandle = handle
    // now check our state _after_ registering (see tryFinalizeSimpleState order of actions)
    if (isCompleted) {
        handle.dispose()
        parentHandle = NonDisposableHandle // release it just in case, to aid GC
    }
}

@Suppress("OverridingDeprecatedMember")
public final override fun attachChild(child: ChildJob): ChildHandle {
    return invokeOnCompletion(onCancelling = true, handler = ChildHandleNode(child).asHandler) as ChildHandle
}

public final override fun invokeOnCompletion(
    onCancelling: Boolean,
    invokeImmediately: Boolean,
    handler: CompletionHandler
): DisposableHandle {
    // Create node upfront -- for common cases it just initializes JobNode.job field,
    // for user-defined handlers it allocates a JobNode object that we might not need, but this is Ok.
    val node: JobNode = makeNode(handler, onCancelling)
    loopOnState { state ->
        when (state) {
            is Empty -> { // EMPTY_X state -- no completion handlers
                if (state.isActive) {
                    // try move to SINGLE state
                    if (_state.compareAndSet(state, node)) return node
                } else
                    promoteEmptyToNodeList(state) // that way we can add listener for non-active coroutine
            }
            is Incomplete -> {
                val list = state.list
                if (list == null) { // SINGLE/SINGLE+
                    promoteSingleToNodeList(state as JobNode)
                } else {
                    var rootCause: Throwable? = null
                    var handle: DisposableHandle = NonDisposableHandle
                    if (onCancelling && state is Finishing) {
                        synchronized(state) {
                            // check if we are installing cancellation handler on job that is being cancelled
                            rootCause = state.rootCause // != null if cancelling job
                            // We add node to the list in two cases --- either the job is not being cancelled
                            // or we are adding a child to a coroutine that is not completing yet
                            if (rootCause == null || handler.isHandlerOf<ChildHandleNode>() && !state.isCompleting) {
                                // Note: add node the list while holding lock on state (make sure it cannot change)
                                if (!addLastAtomic(state, list, node)) return@loopOnState // retry
                                // just return node if we don't have to invoke handler (not cancelling yet)
                                if (rootCause == null) return node
                                // otherwise handler is invoked immediately out of the synchronized section & handle returned
                                handle = node
                            }
                        }
                    }
                    if (rootCause != null) {
                        // Note: attachChild uses invokeImmediately, so it gets invoked when adding to cancelled job
                        if (invokeImmediately) handler.invokeIt(rootCause)
                        return handle
                    } else {
                        if (addLastAtomic(state, list, node)) return node
                    }
                }
            }
            else -> { // is complete
                // :KLUDGE: We have to invoke a handler in platform-specific way via `invokeIt` extension,
                // because we play type tricks on Kotlin/JS and handler is not necessarily a function there
                if (invokeImmediately) handler.invokeIt((state as? CompletedExceptionally)?.cause)
                return NonDisposableHandle
            }
        }
    }
}

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

// `block` 指的是
//    builder { /* 這段是 block */ }

// this 與 receiver 都是指 coroutine

public enum class CoroutineStart {
    DEFAULT,
    LAZY,
    @ExperimentalCoroutinesApi // Since 1.0.0, no ETA on stability
    ATOMIC,
    UNDISPATCHED;

    @InternalCoroutinesApi
    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
        }


    @InternalCoroutinesApi
    public 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
        }

}

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

private inline fun runSafely(completion: Continuation<*>, block: () -> Unit) {
    try {
        block()
    } catch (e: Throwable) {
        dispatcherFailure(completion, e)
    }
}

private fun dispatcherFailure(completion: Continuation<*>, e: Throwable) {
    /*
     * This method is invoked when we failed to start a coroutine due to the throwing
     * dispatcher implementation or missing Dispatchers.Main.
     * This situation is not recoverable, so we are trying to deliver the exception by all means:
     * 1) Resume the coroutine with an exception, so it won't prevent its parent from completion
     * 2) Rethrow the exception immediately, so it will crash the caller (e.g. when the coroutine had
     *    no parent or it was async/produce over MainScope).
     */
    completion.resumeWith(Result.failure(e))
    throw e
}

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

createCoroutineUnintercepted(receiver, completion)
    .intercepted()
    .resumeCancellableWith(Result.success(Unit), onCancellation)