public actual object Dispatchers {
    ...
    @JvmStatic
    public val IO: CoroutineDispatcher = DefaultScheduler.IO
}

// 系統(tǒng)配置變量
public const val IO_PARALLELISM_PROPERTY_NAME: String = "kotlinx.coroutines.io.parallelism"
...
// 表示不會(huì)阻塞的任務(wù)，純CPU任務(wù)
internal const val TASK_NON_BLOCKING = 0
// 表示執(zhí)行過程中可能會(huì)阻塞的任務(wù)，非純CPU任務(wù)
internal const val TASK_PROBABLY_BLOCKING = 1
...
// 默認(rèn)線程池名稱
internal const val DEFAULT_DISPATCHER_NAME = "Dispatchers.Default"
...
internal object DefaultScheduler : ExperimentalCoroutineDispatcher() {
    // 創(chuàng)建名為Dispatchers.IO的線程池
    // 最大并發(fā)數(shù)量為kotlinx.coroutines.io.parallelism指定的值，默認(rèn)為64與CPU數(shù)量中的較大者
    // 默認(rèn)的執(zhí)行的任務(wù)類型為TASK_PROBABLY_BLOCKING
    val IO: CoroutineDispatcher = LimitingDispatcher(
        this,
        systemProp(IO_PARALLELISM_PROPERTY_NAME, 64.coerceAtLeast(AVAILABLE_PROCESSORS)),
        "Dispatchers.IO",
        TASK_PROBABLY_BLOCKING
    )
    override fun close() {
        throw UnsupportedOperationException("$DEFAULT_DISPATCHER_NAME cannot be closed")
    }
    // 可以看出IO和Default共用一個(gè)線程池
    override fun toString(): String = DEFAULT_DISPATCHER_NAME
    @InternalCoroutinesApi
    @Suppress("UNUSED")
    public fun toDebugString(): String = super.toString()
}

// dispatcher參數(shù)傳入了DefaultScheduler對(duì)象
// parallelism表示并發(fā)執(zhí)行的任務(wù)數(shù)量
// name表示線程池的名字
// taskMode表示任務(wù)模式，TaskContext接口中的常量
private class LimitingDispatcher(
    private val dispatcher: ExperimentalCoroutineDispatcher,
    private val parallelism: Int,
    private val name: String?,
    override val taskMode: Int
) : ExecutorCoroutineDispatcher(), TaskContext, Executor {
    // 用于保存任務(wù)的隊(duì)列
    private val queue = ConcurrentLinkedQueue<Runnable>()
    // 用于記錄當(dāng)前正在執(zhí)行的任務(wù)的數(shù)量
    private val inFlightTasks = atomic(0)
    // 獲取當(dāng)前線程池
    override val executor: Executor
        get() = this
    // Executor接口的實(shí)現(xiàn)，線程池的核心方法，通過dispatch實(shí)現(xiàn)
    override fun execute(command: Runnable) = dispatch(command, false)
    override fun close(): Unit = error("Close cannot be invoked on LimitingBlockingDispatcher")
    // CoroutineDispatcher接口的實(shí)現(xiàn)
    override fun dispatch(context: CoroutineContext, block: Runnable) = dispatch(block, false)
    // 任務(wù)分發(fā)的核心方法
    private fun dispatch(block: Runnable, tailDispatch: Boolean) {
        // 獲取當(dāng)前要執(zhí)行的任務(wù)
        var taskToSchedule = block
        // 死循環(huán)
        while (true) {
            // 當(dāng)前執(zhí)行的任務(wù)數(shù)加一，也可理解生成生成當(dāng)前要執(zhí)行的任務(wù)的編號(hào)
            val inFlight = inFlightTasks.incrementAndGet()
            // 如果當(dāng)前需要執(zhí)行的任務(wù)數(shù)小于允許的并發(fā)執(zhí)行任務(wù)數(shù)量，說明可以執(zhí)行，
            if (inFlight <= parallelism) {
                // 調(diào)用參數(shù)中的dispatcher對(duì)象，執(zhí)行任務(wù)
                dispatcher.dispatchWithContext(taskToSchedule, this, tailDispatch)
                // 返回，退出循環(huán)
                return
            }
            // 如果達(dá)到的最大并發(fā)數(shù)的限制，則將任務(wù)加入到隊(duì)列中
            queue.add(taskToSchedule)
            // 下面的代碼防止線程競(jìng)爭(zhēng)導(dǎo)致任務(wù)卡在隊(duì)列里不被執(zhí)行，case如下：
            // 線程1:inFlightTasks = 1 ，執(zhí)行任務(wù)
            // 線程2:inFlightTasks = 2，當(dāng)前達(dá)到了parallelism限制，
            // 線程1:執(zhí)行結(jié)束，inFlightTasks = 1
            // 線程2:將任務(wù)添加到隊(duì)列里，執(zhí)行結(jié)束，inFlightTasks = 0
            // 由于未執(zhí)行，因此這里當(dāng)前執(zhí)行的任務(wù)數(shù)先減一
            // 減一后如果仍然大于等于在大并發(fā)數(shù)，則直接返回，退出循環(huán)
            if (inFlightTasks.decrementAndGet() >= parallelism) {
                return
            }
            // 如果減一后，發(fā)現(xiàn)可以執(zhí)行任務(wù)，則從隊(duì)首獲取任務(wù)，進(jìn)行下一次循環(huán)
            // 如果隊(duì)列為空，說明沒有任務(wù)，則返回，退出循環(huán)
            taskToSchedule = queue.poll() ?: return
        }
    }
    // CoroutineDispatcher接口的實(shí)現(xiàn)，用于yield掛起協(xié)程時(shí)的調(diào)度處理
    override fun dispatchYield(context: CoroutineContext, block: Runnable) {
        // 也是通過dispatch方法實(shí)現(xiàn)，注意這里tailDispatch參數(shù)為true
        dispatch(block, tailDispatch = true)
    }
    override fun toString(): String {
        return name ?: "${super.toString()}[dispatcher = $dispatcher]"
    }
    // TaskContext接口的實(shí)現(xiàn)，用于在一個(gè)任務(wù)執(zhí)行完進(jìn)行回調(diào)
    override fun afterTask() {
        // 從隊(duì)首獲取一個(gè)任務(wù)
        var next = queue.poll()
        // 若可以獲取到
        if (next != null) {
            // 則執(zhí)行任務(wù)，注意這里tailDispatch參數(shù)為true
            dispatcher.dispatchWithContext(next, this, true)
            // 返回
            return
        }
        // 任務(wù)執(zhí)行完畢，當(dāng)前執(zhí)行的任務(wù)數(shù)量減一
        inFlightTasks.decrementAndGet()
        // 下面的代碼防止線程競(jìng)爭(zhēng)導(dǎo)致任務(wù)卡在隊(duì)列里不被執(zhí)行，case如下：
        // 線程1:inFlightTasks = 1 ，執(zhí)行任務(wù)
        // 線程2:inFlightTasks = 2
        // 線程1:執(zhí)行結(jié)束，執(zhí)行afterTask方法，發(fā)現(xiàn)隊(duì)列為空，此時(shí)inFlightTasks = 2
        // 線程2:inFlightTasks當(dāng)前達(dá)到了parallelism限制，
        //      將任務(wù)加入到隊(duì)列中，執(zhí)行結(jié)束，inFlightTasks = 1
        // 線程1:inFlightTasks=1，執(zhí)行結(jié)束
        // 從隊(duì)列中取出任務(wù)，隊(duì)列為空則返回
        next = queue.poll() ?: return
        // 執(zhí)行任務(wù)，注意這里tailDispatch參數(shù)為true
        dispatch(next, true)
    }
}

// corePoolSize線程池核心線程數(shù)
// maxPoolSize表示線程池最大線程數(shù)
// schedulerName表示內(nèi)部協(xié)程調(diào)度器的名字
// idleWorkerKeepAliveNs表示空閑的線程存活時(shí)間
@InternalCoroutinesApi
public open class ExperimentalCoroutineDispatcher(
    private val corePoolSize: Int,
    private val maxPoolSize: Int,
    private val idleWorkerKeepAliveNs: Long,
    private val schedulerName: String = "CoroutineScheduler"
) : ExecutorCoroutineDispatcher() {
    // 我們?cè)贒efaultScheduler類中就是通過默認(rèn)的構(gòu)造方法，
    // 創(chuàng)建的父類ExperimentalCoroutineDispatcher對(duì)象
    public constructor(
        corePoolSize: Int = CORE_POOL_SIZE,
        maxPoolSize: Int = MAX_POOL_SIZE,
        schedulerName: String = DEFAULT_SCHEDULER_NAME
    ) : this(corePoolSize, maxPoolSize, IDLE_WORKER_KEEP_ALIVE_NS, schedulerName)
    ...
    // 創(chuàng)建coroutineScheduler對(duì)象
    private var coroutineScheduler = createScheduler()
    // 核心的分發(fā)方法
    override fun dispatch(context: CoroutineContext, block: Runnable): Unit =
        try {
            // 調(diào)用coroutineScheduler對(duì)象的dispatch方法
            coroutineScheduler.dispatch(block)
        } catch (e: RejectedExecutionException) {
            // 只有當(dāng)coroutineScheduler正在關(guān)閉時(shí)，才會(huì)拒絕執(zhí)行，拋出異常
            DefaultExecutor.dispatch(context, block)
        }
    ...
    private fun createScheduler() = CoroutineScheduler(corePoolSize, maxPoolSize, idleWorkerKeepAliveNs, schedulerName)
    ...
}
// 核心線程數(shù)
@JvmField
internal val CORE_POOL_SIZE = systemProp(
    "kotlinx.coroutines.scheduler.core.pool.size",
    AVAILABLE_PROCESSORS.coerceAtLeast(2), // !!! at least two here
    minValue = CoroutineScheduler.MIN_SUPPORTED_POOL_SIZE
)
// 最大線程數(shù)
@JvmField
internal val MAX_POOL_SIZE = systemProp(
    "kotlinx.coroutines.scheduler.max.pool.size",
    (AVAILABLE_PROCESSORS * 128).coerceIn(
        CORE_POOL_SIZE,
        CoroutineScheduler.MAX_SUPPORTED_POOL_SIZE
    ),
    maxValue = CoroutineScheduler.MAX_SUPPORTED_POOL_SIZE
)
// 空閑線程的存活時(shí)間
@JvmField
internal val IDLE_WORKER_KEEP_ALIVE_NS = TimeUnit.SECONDS.toNanos(
    systemProp("kotlinx.coroutines.scheduler.keep.alive.sec", 60L)
)

// 實(shí)現(xiàn)了Executor和Closeable接口
// corePoolSize線程池核心線程數(shù)
// maxPoolSize表示線程池最大線程數(shù)
// schedulerName表示內(nèi)部協(xié)程調(diào)度器的名字
// idleWorkerKeepAliveNs表示空閑的線程存活時(shí)間
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 {
    init {
        // 核心線程數(shù)量必須大于等于MIN_SUPPORTED_POOL_SIZE
        require(corePoolSize >= MIN_SUPPORTED_POOL_SIZE) {
            "Core pool size $corePoolSize should be at least $MIN_SUPPORTED_POOL_SIZE"
        }
        // 最大線程數(shù)量必須大于等于核心線程數(shù)量
        require(maxPoolSize >= corePoolSize) {
            "Max pool size $maxPoolSize should be greater than or equals to core pool size $corePoolSize"
        }
        // 最大線程數(shù)量必須小于等于MAX_SUPPORTED_POOL_SIZE
        require(maxPoolSize <= MAX_SUPPORTED_POOL_SIZE) {
            "Max pool size $maxPoolSize should not exceed maximal supported number of threads $MAX_SUPPORTED_POOL_SIZE"
        }
        // 空閑的線程存活時(shí)間必須大于0
        require(idleWorkerKeepAliveNs > 0) {
            "Idle worker keep alive time $idleWorkerKeepAliveNs must be positive"
        }
    }
    ...
    // Executor接口中的實(shí)現(xiàn)，通過dispatch方法實(shí)現(xiàn)
    override fun execute(command: Runnable) = dispatch(command)
    // Closeable接口中的實(shí)現(xiàn)，通過shutdown方法實(shí)現(xiàn)
    override fun close() = shutdown(10_000L)
    ...
}

// 用于存儲(chǔ)全局的純CPU(不阻塞)任務(wù)
@JvmField
val globalCpuQueue = GlobalQueue()
// 用于存儲(chǔ)全局的執(zhí)行非純CPU(可能阻塞)任務(wù)
@JvmField
val globalBlockingQueue = GlobalQueue()
...
// 用于記錄當(dāng)前處于Parked狀態(tài)(一段時(shí)間后自動(dòng)終止)的線程的數(shù)量
private val parkedWorkersStack = atomic(0L)
...
// 用于保存當(dāng)前線程池中的線程
// workers[0]永遠(yuǎn)為null，作為哨兵位
// index從1到maxPoolSize為有效線程
@JvmField
val workers = AtomicReferenceArray<Worker?>(maxPoolSize + 1)
...
// 控制狀態(tài)
private val controlState = atomic(corePoolSize.toLong() shl CPU_PERMITS_SHIFT)
// 表示已經(jīng)創(chuàng)建的線程的數(shù)量
private val createdWorkers: Int inline get() = (controlState.value and CREATED_MASK).toInt()
// 表示可以獲取的CPU令牌數(shù)量，初始值為線程池核心線程數(shù)量
private val availableCpuPermits: Int inline get() = availableCpuPermits(controlState.value)
// 獲取指定的狀態(tài)的已經(jīng)創(chuàng)建的線程的數(shù)量
private inline fun createdWorkers(state: Long): Int = (state and CREATED_MASK).toInt()
// 獲取指定的狀態(tài)的執(zhí)行阻塞任務(wù)的數(shù)量
private inline fun blockingTasks(state: Long): Int = (state and BLOCKING_MASK shr BLOCKING_SHIFT).toInt()
// 獲取指定的狀態(tài)的CPU令牌數(shù)量
public inline fun availableCpuPermits(state: Long): Int = (state and CPU_PERMITS_MASK shr CPU_PERMITS_SHIFT).toInt()
// 當(dāng)前已經(jīng)創(chuàng)建的線程數(shù)量加1
private inline fun incrementCreatedWorkers(): Int = createdWorkers(controlState.incrementAndGet())
// 當(dāng)前已經(jīng)創(chuàng)建的線程數(shù)量減1
private inline fun decrementCreatedWorkers(): Int = createdWorkers(controlState.getAndDecrement())
// 當(dāng)前執(zhí)行阻塞任務(wù)的線程數(shù)量加1
private inline fun incrementBlockingTasks() = controlState.addAndGet(1L shl BLOCKING_SHIFT)
// 當(dāng)前執(zhí)行阻塞任務(wù)的線程數(shù)量減1
private inline fun decrementBlockingTasks() {
    controlState.addAndGet(-(1L shl BLOCKING_SHIFT))
}
// 嘗試獲取CPU令牌
private inline fun tryAcquireCpuPermit(): Boolean = controlState.loop { state ->
    val available = availableCpuPermits(state)
    if (available == 0) return false
    val update = state - (1L shl CPU_PERMITS_SHIFT)
    if (controlState.compareAndSet(state, update)) return true
}
// 釋放CPU令牌
private inline fun releaseCpuPermit() = controlState.addAndGet(1L shl CPU_PERMITS_SHIFT)
// 表示當(dāng)前線程池是否關(guān)閉
private val _isTerminated = atomic(false)
val isTerminated: Boolean get() = _isTerminated.value
companion object {
    // 用于標(biāo)記一個(gè)線程是否在parkedWorkersStack中(處于Parked狀態(tài))
    @JvmField
    val NOT_IN_STACK = Symbol("NOT_IN_STACK")
    // 線程的三個(gè)狀態(tài)
    // CLAIMED表示線程可以執(zhí)行任務(wù)
    // PARKED表示線程暫停執(zhí)行任務(wù)，一段時(shí)間后會(huì)自動(dòng)進(jìn)入終止?fàn)顟B(tài)
    // TERMINATED表示線程處于終止?fàn)顟B(tài)
    private const val PARKED = -1
    private const val CLAIMED = 0
    private const val TERMINATED = 1
    // 以下五個(gè)常量為掩碼
    private const val BLOCKING_SHIFT = 21 // 2x1024x1024
    // 1-21位
    private const val CREATED_MASK: Long = (1L shl BLOCKING_SHIFT) - 1
    // 22-42位
    private const val BLOCKING_MASK: Long = CREATED_MASK shl BLOCKING_SHIFT
    // 42
    private const val CPU_PERMITS_SHIFT = BLOCKING_SHIFT * 2
    // 43-63位
    private const val CPU_PERMITS_MASK = CREATED_MASK shl CPU_PERMITS_SHIFT
    // 以下兩個(gè)常量用于require中參數(shù)判斷
    internal const val MIN_SUPPORTED_POOL_SIZE = 1
    // 2x1024x1024-2
    internal const val MAX_SUPPORTED_POOL_SIZE = (1 shl BLOCKING_SHIFT) - 2
    // parkedWorkersStack的掩碼
    private const val PARKED_INDEX_MASK = CREATED_MASK
    // inv表示01反轉(zhuǎn)
    private const val PARKED_VERSION_MASK = CREATED_MASK.inv()
    private const val PARKED_VERSION_INC = 1L shl BLOCKING_SHIFT
}

// 一個(gè)枚舉類，表示W(wǎng)orker的狀態(tài)
enum class WorkerState {
    // 擁有了CPU令牌，可以執(zhí)行純CPU任務(wù)，也可以執(zhí)行非純CPU任務(wù)
    CPU_ACQUIRED,
    // 可以執(zhí)行非純CPU任務(wù)
    BLOCKING,
    // 當(dāng)前已經(jīng)暫停，一段時(shí)間后將終止，也有可能被再次使用
    PARKING,
    // 休眠狀態(tài)，用于初始狀態(tài)，只能執(zhí)行自己本地任務(wù)
    DORMANT,
    // 終止?fàn)顟B(tài)，將不再被使用
    TERMINATED
}

// 繼承自Thread類
// 私有化無參的構(gòu)造方法
internal inner class Worker private constructor() : Thread() {
    init {
        // 標(biāo)記為守護(hù)線程
        isDaemon = true
    }
    // 當(dāng)前線程在存儲(chǔ)線程池線程的數(shù)組workers中的索引位置
    @Volatile
    var indexInArray = 0
        set(index) {
            // 設(shè)置線程名
            name = "$schedulerName-worker-${if (index == 0) "TERMINATED" else index.toString()}"
            field = index
        }
    // 構(gòu)造方法
    constructor(index: Int) : this() {
        indexInArray = index
    }
    // 獲取當(dāng)前線程的調(diào)度器
    inline val scheduler get() = this@CoroutineScheduler
    // 線程存儲(chǔ)任務(wù)的本地隊(duì)列
    @JvmField
    val localQueue: WorkQueue = WorkQueue()
    // 線程的狀態(tài) （內(nèi)部轉(zhuǎn)換）
    @JvmField
    var state = WorkerState.DORMANT
    // 線程的控制狀態(tài)（外部賦予）
    val workerCtl = atomic(CLAIMED)
    // 終止截止時(shí)間，表示處于PARKING狀態(tài)的線程，在terminationDeadline毫秒后終止
    private var terminationDeadline = 0L
    // 表示當(dāng)線程處于PARKING狀態(tài)，進(jìn)入parkedWorkersStack后，
    // 下一個(gè)處于PARKING狀態(tài)并進(jìn)入parkedWorkersStack的線程的引用
    @Volatile
    var nextParkedWorker: Any? = NOT_IN_STACK
    // 偷取其他線程的本地隊(duì)列的任務(wù)的冷卻時(shí)間，后面會(huì)解釋
    private var minDelayUntilStealableTaskNs = 0L
    // 生成隨機(jī)數(shù)，配合算法，用于任務(wù)尋找
    private var rngState = Random.nextInt()
    ...
    // 表示當(dāng)前線程的本地隊(duì)列是否有任務(wù)
    @JvmField
    var mayHaveLocalTasks = false
    ...
}

override fun run() = runWorker()
private fun runWorker() {
    // 用于配合minDelayUntilStealableTaskNs自旋
    var rescanned = false
    // 線程池未關(guān)閉，線程沒有終止，則循環(huán)
    while (!isTerminated && state != WorkerState.TERMINATED) {
        // 尋找并獲取任務(wù)
        val task = findTask(mayHaveLocalTasks)
        // 如果找到了任務(wù)
        if (task != null) {
            // 重制兩個(gè)變量
            rescanned = false
            minDelayUntilStealableTaskNs = 0L
            // 執(zhí)行任務(wù)
            executeTask(task)
            // 繼續(xù)循環(huán)
            continue
        } else { // 如果沒有找到任務(wù)，說明本地隊(duì)列肯定沒有任務(wù)，因?yàn)楸镜仃?duì)列優(yōu)先查找
            // 設(shè)置標(biāo)志位
            mayHaveLocalTasks = false
        }
        // 走到這里，說明沒有找到任務(wù)
        // 如果偷取任務(wù)的冷卻時(shí)間不為0，說明之前偷到過任務(wù)
        if (minDelayUntilStealableTaskNs != 0L) {
            // 這里通過rescanned，首次minDelayUntilStealableTaskNs不為0，
            // 不會(huì)立刻進(jìn)入PARKING狀態(tài)，而是再次去尋找任務(wù)
            // 因?yàn)楫?dāng)過多的線程進(jìn)入PARKING狀態(tài)，再次喚起大量的線程很難控制
            if (!rescanned) {
                rescanned = true
            } else {// 再次掃描，仍然沒有找到任務(wù)
                // 置位
                rescanned = false
                // 嘗試釋放CPU令牌，并進(jìn)入WorkerState.PARKING狀態(tài)
                tryReleaseCpu(WorkerState.PARKING)
                // 清除中斷標(biāo)志位
                interrupted()
                // 阻塞minDelayUntilStealableTaskNs毫秒
                LockSupport.parkNanos(minDelayUntilStealableTaskNs)
                // 清零
                minDelayUntilStealableTaskNs = 0L
            }
            // 阻塞完成后繼續(xù)執(zhí)行
            continue
        }
        // 走到這里，說明線程可能很長(zhǎng)時(shí)間都沒有執(zhí)行任務(wù)了，則對(duì)其進(jìn)行暫停處理
        // tryPark比tryReleaseCpu要嚴(yán)格的多，會(huì)被線程會(huì)被計(jì)入到parkedWorkersStack，
        // 同時(shí)會(huì)修改workerCtl狀態(tài)
        tryPark()
    }
    // 退出循環(huán)
    // 嘗試釋放CPU令牌，并進(jìn)入終止?fàn)顟B(tài)
    tryReleaseCpu(WorkerState.TERMINATED)
}

// 尋找任務(wù)
fun findTask(scanLocalQueue: Boolean): Task? {
    // 嘗試獲取CPU令牌，如果獲取到了，則調(diào)用findAnyTask方法，尋找任務(wù)
    if (tryAcquireCpuPermit()) return findAnyTask(scanLocalQueue)
    // 如果沒有獲取到CPU令牌，只能去找非純CPU任務(wù)了
    // 如果允許掃描本地的任務(wù)隊(duì)列，則優(yōu)先在本地隊(duì)列中尋找，
    // 找不到則在全局隊(duì)列中尋找，從隊(duì)首中獲取
    val task = if (scanLocalQueue) {
        localQueue.poll() ?: globalBlockingQueue.removeFirstOrNull()
    } else {
        globalBlockingQueue.removeFirstOrNull()
    }
    // 如果在本地隊(duì)列和全局隊(duì)列中都找不到，則嘗試去其他線程的隊(duì)列里偷一個(gè)任務(wù)
    return task ?: trySteal(blockingOnly = true)
}
// 尋找CPU任務(wù)
private fun findAnyTask(scanLocalQueue: Boolean): Task? {
    // 如果允許掃描本地的任務(wù)隊(duì)列，則在本地隊(duì)列和全局隊(duì)列中隨機(jī)二選一，
    // 找不到則在全局隊(duì)列中尋找，從隊(duì)首中獲取
    if (scanLocalQueue) {
        // 隨機(jī)確定本地隊(duì)列和全局隊(duì)列的優(yōu)先順序
        val globalFirst = nextInt(2 * corePoolSize) == 0
        // 獲取任務(wù)
        if (globalFirst) pollGlobalQueues()?.let { return it }
        localQueue.poll()?.let { return it }
        if (!globalFirst) pollGlobalQueues()?.let { return it }
    } else {
        // 只能從全局獲取
        pollGlobalQueues()?.let { return it }
    }
    // 走到這里，說明本地隊(duì)列和全局隊(duì)列中都找不到
    // 那么就嘗試去其他線程的隊(duì)列里偷一個(gè)任務(wù)
    return trySteal(blockingOnly = false)
}
// 從全局隊(duì)列獲取任務(wù)
private fun pollGlobalQueues(): Task? {
    // 隨機(jī)獲取CPU任務(wù)或者非CPU任務(wù)
    if (nextInt(2) == 0) {
        // 優(yōu)先獲取CPU任務(wù)
        globalCpuQueue.removeFirstOrNull()?.let { return it }
        return globalBlockingQueue.removeFirstOrNull()
    } else {
        // 優(yōu)先獲取非CPU任務(wù)
        globalBlockingQueue.removeFirstOrNull()?.let { return it }
        return globalCpuQueue.removeFirstOrNull()
    }
}
// 偷取其他線程的本地隊(duì)列的任務(wù)
// blockingOnly表示是否只偷取阻塞任務(wù)
private fun trySteal(blockingOnly: Boolean): Task? {
    // 只有當(dāng)前線程的本地隊(duì)列為空的時(shí)候，才能偷其他線程的本地隊(duì)列
    assert { localQueue.size == 0 }
    // 獲取已經(jīng)存在的線程的數(shù)量
    val created = createdWorkers
    // 如果線程總數(shù)為0或1，則不偷取，直接返回
    // 0:需要等待初始化
    // 1:避免在單線程機(jī)器上過度偷取
    if (created < 2) {
        return null
    }
    // 隨機(jī)生成一個(gè)存在的線程索引
    var currentIndex = nextInt(created)
    // 默認(rèn)的偷取冷卻時(shí)間
    var minDelay = Long.MAX_VALUE
    // 循環(huán)遍歷
    repeat(created) {
        // 每次循環(huán)索引自增，帶著下一行代碼表示，從位置currentIndex開始偷
        ++currentIndex
        // 如果超出了，則從頭繼續(xù)
        if (currentIndex > created) currentIndex = 1
        // 從數(shù)組中獲取線程
        val worker = workers[currentIndex]
        // 如果線程不為空，并且不是自己
        if (worker !== null && worker !== this) {   
            assert { localQueue.size == 0 }
            // 根據(jù)偷取的類型進(jìn)行偷取
            val stealResult = if (blockingOnly) {
                // 偷取非CPU任務(wù)到本地隊(duì)列中
                localQueue.tryStealBlockingFrom(victim = worker.localQueue)
            } else {
                // 偷取任務(wù)到本地隊(duì)列中
                localQueue.tryStealFrom(victim = worker.localQueue)
            }
            // 如果返回值為TASK_STOLEN，說明偷到了
            // 如果返回值為NOTHING_TO_STEAL，說明要偷的線程的本地隊(duì)列是空的
            if (stealResult == TASK_STOLEN) {
                // 從隊(duì)列的隊(duì)首拿出來返回
                return localQueue.poll()
            // 如果返回值大于零，表示偷取的冷卻時(shí)間，說明沒有偷到  
            } else if (stealResult > 0) { // 說明至少還要等待stealResult時(shí)間才能偷取這個(gè)任務(wù)
                // 計(jì)算偷取冷卻時(shí)間
                minDelay = min(minDelay, stealResult)
            }
        }
    }
    // 設(shè)置偷取等待時(shí)間
    minDelayUntilStealableTaskNs = if (minDelay != Long.MAX_VALUE) minDelay else 0
    // 返回空
    return null
}
// 基于Marsaglia xorshift RNG算法
// 用于在2^32-1范圍內(nèi)計(jì)算偷取目標(biāo)
internal fun nextInt(upperBound: Int): Int {
    var r = rngState
    r = r xor (r shl 13)
    r = r xor (r shr 17)
    r = r xor (r shl 5)
    rngState = r
    val mask = upperBound - 1
    // Fast path for power of two bound
    if (mask and upperBound == 0) {
        return r and mask
    }
    return (r and Int.MAX_VALUE) % upperBound
}

// 執(zhí)行任務(wù)
private fun executeTask(task: Task) {
    // 獲取任務(wù)類型，類型為純CPU或可能阻塞
    val taskMode = task.mode
    // 重置線程閑置狀態(tài)
    idleReset(taskMode)
    // 任務(wù)執(zhí)行前
    beforeTask(taskMode)
    // 執(zhí)行任務(wù)
    runSafely(task)
    // 任務(wù)執(zhí)行后
    afterTask(taskMode)
}
// 重置線程閑置狀態(tài)
private fun idleReset(mode: Int) {
    // 重置從PARKING狀態(tài)到TERMINATED狀態(tài)的時(shí)間
    terminationDeadline = 0L
    // 如果當(dāng)前狀態(tài)為PARKING，說明尋找任務(wù)時(shí)沒有獲取到CPU令牌
    if (state == WorkerState.PARKING) {
        assert { mode == TASK_PROBABLY_BLOCKING }
        // 設(shè)置狀態(tài)為BLOCKING
        state = WorkerState.BLOCKING
    }
}
// 任務(wù)執(zhí)行前
private fun beforeTask(taskMode: Int) {
    // 如果執(zhí)行的任務(wù)為純CPU任務(wù)，說明當(dāng)前線程獲取到了CPU令牌，是核心線程，直接返回
    if (taskMode == TASK_NON_BLOCKING) return
    // 走到這里，說明線程執(zhí)行的是非純CPU任務(wù)，
    // 沒有CPU令牌也可以執(zhí)行，因此嘗試釋放CPU令牌，進(jìn)入WorkerState.BLOCKING
    if (tryReleaseCpu(WorkerState.BLOCKING)) {
        // 如果釋放CPU令牌成功，則喚起一個(gè)線程去申請(qǐng)CPU令牌
        signalCpuWork()
    }
}
// 執(zhí)行任務(wù)
fun runSafely(task: Task) {
    try {
        task.run()
    } catch (e: Throwable) {
        // 異常發(fā)生時(shí)，通知當(dāng)前線程的異常處理Handler
        val thread = Thread.currentThread()
        thread.uncaughtExceptionHandler.uncaughtException(thread, e)
    } finally {
        unTrackTask()
    }
}
// 任務(wù)執(zhí)行后
private fun afterTask(taskMode: Int) {
    // 如果執(zhí)行的任務(wù)為純CPU任務(wù)，說明當(dāng)前線程獲取到了CPU令牌，是核心線程，直接返回
    if (taskMode == TASK_NON_BLOCKING) return
    // 如果執(zhí)行的是非CPU任務(wù)
    // 當(dāng)前執(zhí)行的非CPU任務(wù)數(shù)量減一
    decrementBlockingTasks()
    // 獲取當(dāng)前線程狀態(tài)
    val currentState = state
    // 如果線程當(dāng)前不是終止?fàn)顟B(tài)
    if (currentState !== WorkerState.TERMINATED) {
        assert { currentState == WorkerState.BLOCKING }
        // 設(shè)置為休眠狀態(tài)
        state = WorkerState.DORMANT
    }
}

// block表示要執(zhí)行的任務(wù)
// taskContext表示任務(wù)執(zhí)行的上下文，里面包含任務(wù)的類型，和執(zhí)行完成后的回調(diào)
// tailDispatch表示當(dāng)前任務(wù)是否進(jìn)行隊(duì)列尾部調(diào)度，
// 當(dāng)tailDispatch為true時(shí)，當(dāng)前block會(huì)在當(dāng)前線程的本地隊(duì)列里的任務(wù)全部執(zhí)行完后再執(zhí)行
fun dispatch(block: Runnable, taskContext: TaskContext = NonBlockingContext, tailDispatch: Boolean = false) {
    // 上報(bào)時(shí)間，TimeSource相關(guān)，無需關(guān)注
    trackTask()
    // 創(chuàng)建任務(wù)
    val task = createTask(block, taskContext)
    // 獲取當(dāng)前的Worker，可能獲取不到
    val currentWorker = currentWorker()
    // 將當(dāng)前的任務(wù)添加到當(dāng)前線程的本地隊(duì)列中
    val notAdded = currentWorker.submitToLocalQueue(task, tailDispatch)
    // 不為空，說明沒有添加進(jìn)去，說明當(dāng)前的線程不是Worker
    if (notAdded != null) {
         // 將任務(wù)添加到全局隊(duì)列中，如果添加失敗了
        if (!addToGlobalQueue(notAdded)) {
            // 說明線程池正在關(guān)閉，拋出異常
            throw RejectedExecutionException("$schedulerName was terminated")
        }
    }
    // skipUnpark表示是否跳過喚起狀態(tài)，取決于這下面兩個(gè)參數(shù)
    val skipUnpark = tailDispatch && currentWorker != null
    // 如果當(dāng)前類型為純CPU任務(wù)
    if (task.mode == TASK_NON_BLOCKING) {
        // 如果跳過喚醒，則直接返回
        if (skipUnpark) return
        // 喚醒一個(gè)執(zhí)行純CPU任務(wù)的線程
        signalCpuWork()
    } else {
        // 喚醒一個(gè)執(zhí)行非CPU任務(wù)的線程
        signalBlockingWork(skipUnpark = skipUnpark)
    }
}
// 創(chuàng)建任務(wù)
internal fun createTask(block: Runnable, taskContext: TaskContext): Task {
    // 獲取當(dāng)前時(shí)間
    val nanoTime = schedulerTimeSource.nanoTime()
    // 如果當(dāng)前的block是Task類型的
    if (block is Task) {
        // 重新設(shè)置提交時(shí)間和任務(wù)上下文
        block.submissionTime = nanoTime
        block.taskContext = taskContext
        // 返回
        return block
    }
    // 封裝成TaskImpl，返回
    return TaskImpl(block, nanoTime, taskContext)
}
// 任務(wù)模型
// block表示執(zhí)行的任務(wù)
// submissionTime表示任務(wù)提交時(shí)間
// taskContext表示任務(wù)執(zhí)行的上下文
internal class TaskImpl(
    @JvmField val block: Runnable,
    submissionTime: Long,
    taskContext: TaskContext
) : Task(submissionTime, taskContext) {
    override fun run() {
        try {
            block.run()
        } finally {
            // 任務(wù)執(zhí)行完畢后，會(huì)在同一個(gè)Worker線程中回調(diào)afterTask方法
            taskContext.afterTask()
        }
    }
    override fun toString(): String =
        "Task[${block.classSimpleName}@${block.hexAddress}, $submissionTime, $taskContext]"
}
// 將任務(wù)添加到本地隊(duì)列
private fun Worker?.submitToLocalQueue(task: Task, tailDispatch: Boolean): Task? {
    // 如果當(dāng)前線程為空，則返回任務(wù)
    if (this == null) return task
    // 如果線程處于終止?fàn)顟B(tài)，則返回任務(wù)
    if (state === WorkerState.TERMINATED) return task
    // 如果任務(wù)為純CPU任務(wù)，但是線程沒有CPU令牌
    if (task.mode == TASK_NON_BLOCKING && state === WorkerState.BLOCKING) {
        // 則返回任務(wù)
        return task
    }
    // 標(biāo)記本地隊(duì)列有任務(wù)
    mayHaveLocalTasks = true
    // 添加到隊(duì)列
    return localQueue.add(task, fair = tailDispatch)
}
// 添加到全局隊(duì)列
private fun addToGlobalQueue(task: Task): Boolean {
    // 根據(jù)任務(wù)的類型，添加到全局隊(duì)列的隊(duì)尾
    return if (task.isBlocking) {
        globalBlockingQueue.addLast(task)
    } else {
        globalCpuQueue.addLast(task)
    }
}
// 對(duì)當(dāng)前線程進(jìn)行強(qiáng)制轉(zhuǎn)換，如果調(diào)度器也是當(dāng)前的調(diào)度器則返回Worker對(duì)象
private fun currentWorker(): Worker? = (Thread.currentThread() as? Worker)?.takeIf { it.scheduler == this }
// 喚起一個(gè)執(zhí)行非純CPU任務(wù)的線程
private fun signalBlockingWork(skipUnpark: Boolean) {
    // 當(dāng)前執(zhí)行阻塞任務(wù)的線程數(shù)量加1，并獲取當(dāng)前的控制狀態(tài)
    val stateSnapshot = incrementBlockingTasks()
    // 如果跳過喚起，則返回
    if (skipUnpark) return
    // 嘗試喚起，喚起成功，則返回
    if (tryUnpark()) return
    // 喚起失敗，則根據(jù)當(dāng)前的控制狀態(tài)，嘗試創(chuàng)建新線程，成功則返回
    if (tryCreateWorker(stateSnapshot)) return
    // 再次嘗試喚起，防止多線程競(jìng)爭(zhēng)情況下，上面的tryUnpark方法正好卡在線程釋放CPU令牌與進(jìn)入PARKING狀態(tài)之間
    // 因?yàn)榫€程先釋放CPU令牌，后進(jìn)入PARKING狀態(tài)
    tryUnpark()
}
// 喚起一個(gè)執(zhí)行純CPU任務(wù)的線程
internal fun signalCpuWork() {
    // 嘗試喚起，喚起成功，則返回
    if (tryUnpark()) return
    // 喚起失敗，則嘗試創(chuàng)建新線程，成功則返回
    if (tryCreateWorker()) return
    // 再次嘗試喚起，防止多線程競(jìng)爭(zhēng)情況下，上面的tryUnpark方法正好卡在線程釋放CPU令牌與進(jìn)入PARKING狀態(tài)之間
    // 因?yàn)榫€程先釋放CPU令牌，后進(jìn)入PARKING狀態(tài)
    tryUnpark()
}

// 本地隊(duì)列中存儲(chǔ)最后一次尾調(diào)的任務(wù)
private val lastScheduledTask = atomic<Task?>(null)
// fair表示是否公平的執(zhí)行任務(wù)，F(xiàn)IFO，默認(rèn)為false
fun add(task: Task, fair: Boolean = false): Task? {
    // fair為true，則添加到隊(duì)尾
    if (fair) return addLast(task)
    // 如果fair為false，則從lastScheduledTask中取出上一個(gè)尾調(diào)的任務(wù)，
    // 并把這次的新尾調(diào)任務(wù)保存到lastScheduledTask
    val previous = lastScheduledTask.getAndSet(task) ?: return null
    // 如果獲取上一次的尾調(diào)任務(wù)不為空，則添加到隊(duì)尾
    return addLast(previous)
}

internal const val BUFFER_CAPACITY_BASE = 7
internal const val BUFFER_CAPACITY = 1 shl BUFFER_CAPACITY_BASE // 1000 0000
internal const val MASK = BUFFER_CAPACITY - 1 // 0111 1111
// 存儲(chǔ)任務(wù)的數(shù)組，最多存儲(chǔ)128
private val buffer: AtomicReferenceArray<Task?> = AtomicReferenceArray(BUFFER_CAPACITY)
// producerIndex表示上一次向任務(wù)數(shù)組中添加任務(wù)的索引
// consumerIndex表示上一次消費(fèi)的任務(wù)索引
// producerIndex永遠(yuǎn)大于等于consumerIndex
// 二者差值就是當(dāng)前任務(wù)數(shù)組中任務(wù)的數(shù)量
private val producerIndex = atomic(0)
private val consumerIndex = atomic(0)
// buffer中非純CPU任務(wù)的數(shù)量（避免遍歷掃描）
private val blockingTasksInBuffer = atomic(0)
// 偷所有類型任務(wù)
fun tryStealFrom(victim: WorkQueue): Long {
    assert { bufferSize == 0 }
    // 從要偷取線程的本地隊(duì)列中輪訓(xùn)獲取一個(gè)任務(wù)
    val task  = victim.pollBuffer()
    // 如果獲取到了任務(wù)
    if (task != null) {
        // 將它添加到自己的本地隊(duì)列中
        val notAdded = add(task)
        assert { notAdded == null }
        // 返回偷取成功的標(biāo)識(shí)
        return TASK_STOLEN
    }
    // 如果偷取失敗，嘗試偷取指定線程的尾調(diào)任務(wù)
    return tryStealLastScheduled(victim, blockingOnly = false)
}
// 輪訓(xùn)獲取任務(wù)
private fun pollBuffer(): Task? {
    // 死循環(huán)
    while (true) {
        // 獲取上一次消費(fèi)的任務(wù)索引
        val tailLocal = consumerIndex.value
        // 如果當(dāng)前任務(wù)數(shù)組中沒有多處的任務(wù)，則返回空
        if (tailLocal - producerIndex.value == 0) return null
        // 計(jì)算偷取位置，防止數(shù)組過界
        val index = tailLocal and MASK
        // 通過CAS方式，將consumerIndex加一，表示下一次要從tailLocal + 1處開始偷取
        if (consumerIndex.compareAndSet(tailLocal, tailLocal + 1)) {
            // 從偷取位置初取出任務(wù)，如果偷取的任務(wù)為空，則繼續(xù)循環(huán)
            val value = buffer.getAndSet(index, null) ?: continue
            // 偷取成功
            // 若任務(wù)為阻塞任務(wù)，blockingTasksInBuffer的值減一
            value.decrementIfBlocking()
            // 返回任務(wù)
            return value
        }
    }
}
// 偷取非純CPU任務(wù)
fun tryStealBlockingFrom(victim: WorkQueue): Long {
    assert { bufferSize == 0 }
    // 從consumerIndex位置開始偷
    var start = victim.consumerIndex.value
    // 偷到producerIndex處截止
    val end = victim.producerIndex.value
    // 獲取任務(wù)數(shù)組
    val buffer = victim.buffer
    // 循環(huán)偷取
    while (start != end) {
        // 計(jì)算偷取位置，防止數(shù)組過界
        val index = start and MASK
        // 如果非純CPU任務(wù)數(shù)為0，則直接退出循環(huán)
        if (victim.blockingTasksInBuffer.value == 0) break
        // 獲取index處的任務(wù)
        val value = buffer[index]
        // 如果任務(wù)存在，而且是非純CPU任務(wù)，同時(shí)成功的通過CAS設(shè)置為空
        if (value != null && value.isBlocking && buffer.compareAndSet(index, value, null)) {
            // blockingTasksInBuffer的值減一
            victim.blockingTasksInBuffer.decrementAndGet()
            // 將偷取的任務(wù)添加到當(dāng)前線程的本地隊(duì)列中
            add(value)
            // 返回偷取成功標(biāo)識(shí)
            return TASK_STOLEN
        } else {
            // 如果偷取失敗，自增再次循環(huán)，從下一個(gè)位置開始偷
            ++start
        }
    }
    // 如果從任務(wù)數(shù)組中偷取失敗，嘗試偷取指定線程的尾調(diào)任務(wù)
    return tryStealLastScheduled(victim, blockingOnly = true)
}
// 偷取指定線程的尾調(diào)任務(wù)
private fun tryStealLastScheduled(victim: WorkQueue, blockingOnly: Boolean): Long {
    // 死循環(huán)
    while (true) {
        // 獲取指定線程的尾調(diào)任務(wù)，如果任務(wù)不存在，則返回偷取失敗標(biāo)識(shí)符
        val lastScheduled = victim.lastScheduledTask.value ?: return NOTHING_TO_STEAL
        // 如果要偷取的是非純CPU任務(wù)，但是任務(wù)類型為純CPU任務(wù)，說明只有核心線程才能偷
        // 返回偷取失敗標(biāo)識(shí)符
        if (blockingOnly && !lastScheduled.isBlocking) return NOTHING_TO_STEAL
        // 獲取當(dāng)前時(shí)間
        val time = schedulerTimeSource.nanoTime()
        //計(jì)算任務(wù)從添加開始到現(xiàn)在經(jīng)過的時(shí)長(zhǎng)
        val staleness = time - lastScheduled.submissionTime
        // 如果時(shí)長(zhǎng)小于偷取冷卻時(shí)間
        if (staleness < WORK_STEALING_TIME_RESOLUTION_NS) {
            // 返回當(dāng)前線程需要等待的時(shí)間
            return WORK_STEALING_TIME_RESOLUTION_NS - staleness
        }
        // 通過CAS，將lastScheduledTask設(shè)置為空，防止被其他線程執(zhí)行
        if (victim.lastScheduledTask.compareAndSet(lastScheduled, null)) {
            // 偷取成功，加入到當(dāng)前線程的隊(duì)列中
            add(lastScheduled)
            // 返回偷取成功表示
            return TASK_STOLEN
        }
        // 繼續(xù)循環(huán)
        continue
    }
}
// 偷取冷卻時(shí)間，尾調(diào)任務(wù)從添加開始，
// 最少經(jīng)過WORK_STEALING_TIME_RESOLUTION_NS時(shí)間才可以被偷
@JvmField
internal val WORK_STEALING_TIME_RESOLUTION_NS = systemProp(
    "kotlinx.coroutines.scheduler.resolution.ns", 100000L
)