@Throws(InterruptedException::class)
public fun <T> runBlocking(context: CoroutineContext = EmptyCoroutineContext, block: suspend CoroutineScope.() -> T): T {
    // 通知編譯器，block只執(zhí)行一次
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    // 獲取當前線程
    val currentThread = Thread.currentThread()
    // 獲取上下文中的攔截器
    val contextInterceptor = context[ContinuationInterceptor]
    val eventLoop: EventLoop?
    val newContext: CoroutineContext
    // 如果攔截器為空，代表無法進行調度
    if (contextInterceptor == null) {
        // 從線程中獲取EventLoop，獲取失敗則創(chuàng)建一個新的
        eventLoop = ThreadLocalEventLoop.eventLoop
        // 添加到上下文中
        // newContext = EmptyCoroutineContext + context + eventLoop
        newContext = GlobalScope.newCoroutineContext(context + eventLoop)
    } else {// 如果有攔截器
        // 嘗試將當前攔截器轉換成EventLoop，
        // 如果轉換成功，則判斷是否允許可以在上下文中使用
        // 如果轉換失敗或不允許，則創(chuàng)建一個新的
        eventLoop = (contextInterceptor as? EventLoop)?.takeIf { it.shouldBeProcessedFromContext() }
            ?: ThreadLocalEventLoop.currentOrNull()
        // 計算新的上下文
        // 這里沒有把EventLoop加到上下文，因為加入后會覆蓋攔截器
        newContext = GlobalScope.newCoroutineContext(context)
    }
    // 創(chuàng)建一個協程
    val coroutine = BlockingCoroutine<T>(newContext, currentThread, eventLoop)
    // 啟動協程
    coroutine.start(CoroutineStart.DEFAULT, coroutine, block)
    // 分發(fā)任務
    return coroutine.joinBlocking()
}

// 繼承了AbstractCoroutine
private class BlockingCoroutine<T>(
    parentContext: CoroutineContext,
    private val blockedThread: Thread,
    private val eventLoop: EventLoop?
) : AbstractCoroutine<T>(parentContext, true) {
    // 該協程是一個作用域協程
    override val isScopedCoroutine: Boolean get() = true

    override fun afterCompletion(state: Any?) {
        // 如果當前線程不是阻塞線程
        if (Thread.currentThread() != blockedThread)
            // 喚醒阻塞線程
            LockSupport.unpark(blockedThread)
    }

    @Suppress("UNCHECKED_CAST")
    fun joinBlocking(): T {
        registerTimeLoopThread()
        try {
            // 注冊使用EventLoop
            eventLoop?.incrementUseCount()
            try {
                // 死循環(huán)
                while (true) {
                    @Suppress("DEPRECATION")
                    // 如果線程當前中斷，則拋出異常，同時取消當前協程
                    if (Thread.interrupted()) throw InterruptedException().also { cancelCoroutine(it) }
                    // 分發(fā)執(zhí)行任務，同時獲取等待時間
                    val parkNanos = eventLoop?.processNextEvent() ?: Long.MAX_VALUE
                    // 如果任務執(zhí)行結束，則退出循環(huán)
                    if (isCompleted) break
                    // 休眠指定的等待時間
                    parkNanos(this, parkNanos)
                }
            } finally { // paranoia
                // 注冊不使用EventLoop
                eventLoop?.decrementUseCount()
            }
        } finally { // paranoia
            unregisterTimeLoopThread()
        }
        // 獲取執(zhí)行的結果
        val state = this.state.unboxState()
        // 如果執(zhí)行過程中取消，則拋出異常
        (state as? CompletedExceptionally)?.let { throw it.cause }
        // 返回結果
        return state as T
    }
}

public suspend fun <T> withContext(
    context: CoroutineContext,
    block: suspend CoroutineScope.() -> T
): T {
    // 通知編譯器，block只執(zhí)行一次
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    // 直接掛起，獲取續(xù)體
    return suspendCoroutineUninterceptedOrReturn sc@ { uCont ->
        // 從續(xù)體中獲取上下文
        val oldContext = uCont.context
        // 計算新的上下文
        val newContext = oldContext + context
        // 檢查任務是否執(zhí)行完畢或取消
        newContext.checkCompletion()
        // 如果前后兩次的上下文完全相同，說明不需要切換，只需要執(zhí)行即可
        if (newContext === oldContext) {
            // 創(chuàng)建續(xù)體的協程
            val coroutine = ScopeCoroutine(newContext, uCont)
            // 執(zhí)行block
            return@sc coroutine.startUndispatchedOrReturn(coroutine, block)
        }
        // 攔截器相同，但是上下文中增加了其他的元素
        // 這里也是在同一個線程上執(zhí)行，但是其中增加的元素只在執(zhí)行當前的block中使用
        if (newContext[ContinuationInterceptor] == oldContext[ContinuationInterceptor]) {
            // 創(chuàng)建續(xù)體的協程
            val coroutine = UndispatchedCoroutine(newContext, uCont)
            // 將當前線程ThreadLocal中的對象更新成newContext上下文對應的對象
            withCoroutineContext(newContext, null) {
                // 執(zhí)行block
                return@sc coroutine.startUndispatchedOrReturn(coroutine, block)
            }
        }
        // 走到這里，說明要切換線程執(zhí)行block任務
        val coroutine = DispatchedCoroutine(newContext, uCont)
        // 啟動父協程
        coroutine.initParentJob()
        // 啟動協程
        block.startCoroutineCancellable(coroutine, coroutine)
        // 獲取結果
        coroutine.getResult()
    }
}

internal fun <T, R> ScopeCoroutine<T>.startUndispatchedOrReturn(receiver: R, block: suspend R.() -> T): Any? {
    // 初始化并綁定父協程
    initParentJob()
    // 獲取并處理執(zhí)行結果
    return undispatchedResult({ true }) {
        // 啟動協程
        block.startCoroutineUninterceptedOrReturn(receiver, this)
    }
}
private inline fun <T> ScopeCoroutine<T>.undispatchedResult(
    shouldThrow: (Throwable) -> Boolean,
    startBlock: () -> Any?
): Any? {
    // 啟動協程，獲取結果，
    val result = try {
        startBlock()
    } catch (e: Throwable) {
        // 產生異常，則按照取消處理
        CompletedExceptionally(e)
    }
    // 如果結果為掛起，則通知外部掛起    
    if (result === COROUTINE_SUSPENDED) return COROUTINE_SUSPENDED
    // 結束任務執(zhí)行，獲取最終狀態(tài)
    val state = makeCompletingOnce(result)
    // 如果需要等待子協程的結束，則通知外部掛起
    if (state === COMPLETING_WAITING_CHILDREN) return COROUTINE_SUSPENDED
    // 如果執(zhí)最終為異常狀態(tài)
    return if (state is CompletedExceptionally) {
        when {
            // 通過參數判斷是否拋出
            shouldThrow(state.cause) -> throw recoverStackTrace(state.cause, uCont)
            // 執(zhí)行結果為異常
            result is CompletedExceptionally -> throw recoverStackTrace(result.cause, uCont)
            // 結果不為異常，則返回
            else -> result
        }
    } else {
        // 對最終狀態(tài)進行拆箱，返回最終結果
        state.unboxState()
    }
}
// JobSupport中提供了下面的類和方法，當協程進入完成狀態(tài)時，會對狀態(tài)進行裝箱。
// 包裝類
private class IncompleteStateBox(@JvmField val state: Incomplete)
// 裝箱
internal fun Any?.boxIncomplete(): Any? = if (this is Incomplete) IncompleteStateBox(this) else this
// 拆箱
internal fun Any?.unboxState(): Any? = (this as? IncompleteStateBox)?.state ?: this

@SinceKotlin("1.3")
@InlineOnly
public actual inline fun <R, T> (suspend R.() -> T).startCoroutineUninterceptedOrReturn(
    receiver: R,
    completion: Continuation<T>
): Any? = (this as Function2<R, Continuation<T>, Any?>).invoke(receiver, completion)

internal open class ScopeCoroutine<in T>(
    context: CoroutineContext,
    @JvmField val uCont: Continuation<T>
) : AbstractCoroutine<T>(context, true), CoroutineStackFrame {
    final override val callerFrame: CoroutineStackFrame? get() = uCont as CoroutineStackFrame?
    final override fun getStackTraceElement(): StackTraceElement? = null
    // 作用域協程
    final override val isScopedCoroutine: Boolean get() = true
    internal val parent: Job? get() = parentContext[Job]
    // 該方法會在協程異常或取消時調用
    override fun afterCompletion(state: Any?) {
        // 進行攔截，切換線程，恢復執(zhí)行
        uCont.intercepted().resumeCancellableWith(recoverResult(state, uCont))
    }
    // 該方法會在將其掛起的方法執(zhí)行完畢后回調
    override fun afterResume(state: Any?) {
        // 直接恢復續(xù)體的執(zhí)行
        uCont.resumeWith(recoverResult(state, uCont))
    }
}

private class UndispatchedCoroutine<in T>(
    context: CoroutineContext,
    uCont: Continuation<T>
) : ScopeCoroutine<T>(context, uCont) {
    override fun afterResume(state: Any?) {
        val result = recoverResult(state, uCont)
        // 將當前線程ThreadLocal中的對象更新成uCont.context上下文對應的對象
        withCoroutineContext(uCont.context, null) {
            // 恢復執(zhí)行
            uCont.resumeWith(result)
        }
    }
}

internal actual inline fun <T> withCoroutineContext(context: CoroutineContext, countOrElement: Any?, block: () -> T): T {
    // 將線程上下文更新新的上下文，并返回老的上下文
    val oldValue = updateThreadContext(context, countOrElement)
    try {
        // 在新的上下文環(huán)境中執(zhí)行
        return block()
    } finally {
        // 執(zhí)行結束恢復老的上下文
        restoreThreadContext(context, oldValue)
    }
}

public interface ThreadContextElement<S> : CoroutineContext.Element {
    // 用于更新新的上下文，并且返回老的上下文
    public fun updateThreadContext(context: CoroutineContext): S
    // 重新恢復當前線程的上下文，
    // 其中oldStart來自updateThreadContext方法的返回值
    public fun restoreThreadContext(context: CoroutineContext, oldState: S)
}

// 狀態(tài)機狀態(tài)
private const val UNDECIDED = 0
private const val SUSPENDED = 1
private const val RESUMED = 2
private class DispatchedCoroutine<in T>(
    context: CoroutineContext,
    uCont: Continuation<T>
) : ScopeCoroutine<T>(context, uCont) {
    // 初始狀態(tài)
    private val _decision = atomic(UNDECIDED)
    // 嘗試掛起
    private fun trySuspend(): Boolean {
        _decision.loop { decision ->
            when (decision) {
                UNDECIDED -> if (this._decision.compareAndSet(UNDECIDED, SUSPENDED)) return true
                RESUMED -> return false
                else -> error("Already suspended")
            }
        }
    }
    // 嘗試恢復
    private fun tryResume(): Boolean {
        _decision.loop { decision ->
            when (decision) {
                UNDECIDED -> if (this._decision.compareAndSet(UNDECIDED, RESUMED)) return true
                SUSPENDED -> return false
                else -> error("Already resumed")
            }
        }
    }
    override fun afterCompletion(state: Any?) {
        // 通過afterResume方法實現
        afterResume(state)
    }
    override fun afterResume(state: Any?) {
        // 如果沒有掛起，則返回
        if (tryResume()) return
        // 進行攔截，切換線程，恢復執(zhí)行
        uCont.intercepted().resumeCancellableWith(recoverResult(state, uCont))
    }
    // 獲取最終結果
    fun getResult(): Any? {
        if (trySuspend()) return COROUTINE_SUSPENDED
        val state = this.state.unboxState()
        if (state is CompletedExceptionally) throw state.cause
        @Suppress("UNCHECKED_CAST")
        return state as T
    }
}