协程上下文与调度器 ⭐⭐⭐

// CoroutineContext 是所有上下文元素的容器接口
public interface CoroutineContext {
    // 通过 Key 获取对应的 Element，找不到则返回 null
    public operator fun <E : Element> get(key: Key<E>): E?
 
    // 函数式折叠操作，类似于集合的 reduce/fold
    public fun <R> fold(initial: R, operation: (R, Element) -> R): R
 
    // 组合两个上下文，返回新的上下文
    public operator fun plus(context: CoroutineContext): CoroutineContext
 
    // 从当前上下文中移除指定 Key 对应的元素
    public fun minusKey(key: Key<*>): CoroutineContext
 
    // Key 接口：每种 Element 类型都必须有一个伴生 Key
    public interface Key<E : Element>
 
    // Element 接口：上下文中的单个元素
    public interface Element : CoroutineContext
}

public interface Element : CoroutineContext {
    // 每个 Element 必须持有一个 Key，用于在上下文中唯一标识自己
    public val key: Key<*>
 
    // 默认实现：如果传入的 key 与自身的 key 匹配，则返回自身，否则返回 null
    @Suppress("UNCHECKED_CAST")
    public override operator fun <E : Element> get(key: Key<E>): E? =
        if (this.key == key) this as E else null  // 类型安全的向下转型
 
    // 默认实现：对自身执行一次 operation
    public override fun <R> fold(initial: R, operation: (R, Element) -> R): R =
        operation(initial, this)  // 单元素的 fold 就是直接应用一次 operation
 
    // 默认实现：如果要移除的 key 是自己，返回空上下文；否则返回自身
    public override fun minusKey(key: Key<*>): CoroutineContext =
        if (this.key == key) EmptyCoroutineContext else this
}

// CoroutineName 是一个简单的 Element 实现，用于给协程命名
public data class CoroutineName(
    val name: String  // 协程的名字，用于调试日志
) : AbstractCoroutineContextElement(CoroutineName) {
    // 伴生对象同时充当 Key
    public companion object Key : CoroutineContext.Key<CoroutineName>
 
    // 友好的 toString 输出
    override fun toString(): String = "CoroutineName($name)"
}

import kotlinx.coroutines.*
 
fun main() = runBlocking {
    // 创建几个独立的 Element
    val name = CoroutineName("worker")           // 协程名称元素
    val dispatcher = Dispatchers.IO               // 调度器元素（也是 Element）
    val job = Job()                               // Job 元素
 
    // 每个 Element 本身就是一个合法的 CoroutineContext
    val ctx: CoroutineContext = name              // 单个 Element 即可充当上下文
    println(ctx[CoroutineName])                   // 输出: CoroutineName(worker)
    println(ctx[Job])                             // 输出: null（当前上下文里没有 Job）
}

// Key 接口的定义极其简洁
public interface Key<E : Element>
// 泛型参数 E 表示：这个 Key 对应的 Element 类型是 E
// 通过 get(key: Key<E>): E? 返回值自动推断为 E，无需手动转型

// ===== 各种 Element 的 Key 定义模式 =====
 
// Job 的 Key
public interface Job : CoroutineContext.Element {
    public companion object Key : CoroutineContext.Key<Job>  // 伴生对象即 Key
}
 
// CoroutineDispatcher 的 Key（注意继承链上的 Key 复用）
public abstract class CoroutineDispatcher :
    AbstractCoroutineContextElement(ContinuationInterceptor),  // 使用父级的 Key
    ContinuationInterceptor {
    // ContinuationInterceptor 拥有自己的 Key
}
 
// ContinuationInterceptor 的 Key
public interface ContinuationInterceptor : CoroutineContext.Element {
    public companion object Key : CoroutineContext.Key<ContinuationInterceptor>
}

// CoroutineContext 接口中的 plus 默认实现
public operator fun plus(context: CoroutineContext): CoroutineContext =
    // 情况1：如果对方是空上下文，直接返回自身（短路优化）
    if (context === EmptyCoroutineContext) this
    else
        // 情况2：通过 fold 遍历 context 中的每个元素，逐一合并
        context.fold(this) { acc, element ->
            // 先从累积上下文中移除与当前 element 同 Key 的旧元素
            val removed = acc.minusKey(element.key)
            // 如果移除后为空，说明旧上下文只有这一个同 Key 元素，直接用新 element
            if (removed === EmptyCoroutineContext) element
            else {
                // 检查是否需要特殊处理 ContinuationInterceptor
                val interceptor = removed[ContinuationInterceptor]
                if (interceptor == null)
                    // 没有拦截器，直接构造 CombinedContext
                    CombinedContext(removed, element)
                else {
                    // 有拦截器时，先移除它，再重新添加到最外层（确保拦截器始终在链尾）
                    val left = removed.minusKey(ContinuationInterceptor)
                    if (left === EmptyCoroutineContext)
                        CombinedContext(element, interceptor)
                    else
                        CombinedContext(CombinedContext(left, element), interceptor)
                }
            }
        }

import kotlinx.coroutines.*
 
fun main() = runBlocking {
    // 定义若干独立的 Element
    val name = CoroutineName("data-loader")       // 协程名
    val dispatcher = Dispatchers.IO               // IO 调度器
    val handler = CoroutineExceptionHandler { _, e ->
        println("捕获异常: ${e.message}")          // 异常处理器
    }
 
    // 使用 plus(+) 操作符组合成复合上下文
    val combined = name + dispatcher + handler
    // 等价于: name.plus(dispatcher).plus(handler)
 
    // 验证组合结果：每个元素都可以通过各自的 Key 取出
    println(combined[CoroutineName])              // CoroutineName(data-loader)
    println(combined[ContinuationInterceptor])    // Dispatchers.IO
    println(combined[CoroutineExceptionHandler])  // 非 null
 
    // 同 Key 覆盖演示
    val updated = combined + CoroutineName("image-loader")
    println(updated[CoroutineName])               // CoroutineName(image-loader) ← 被覆盖了！
    println(updated[ContinuationInterceptor])     // Dispatchers.IO ← 其它元素不受影响
}

// CombinedContext 内部结构：左子树 + 最右元素
internal class CombinedContext(
    private val left: CoroutineContext,   // 左子树（可能也是 CombinedContext）
    private val element: Element          // 最右边的单个元素
) : CoroutineContext

// name + dispatcher + handler 的内部链式结构：
//
//         CombinedContext
//        /              \
//   CombinedContext    handler (Element)
//   /            \
// name          dispatcher (Element)
// (Element)
//
// 查找时从右往左遍历：先检查 handler → 再检查 dispatcher → 最后检查 name

import kotlinx.coroutines.*
 
fun main() = runBlocking {
    // 构建一个包含多个元素的上下文
    val ctx = CoroutineName("analyzer") + Dispatchers.Default + Job()
 
    // 使用 [] 操作符进行索引访问
    val name: CoroutineName? = ctx[CoroutineName]            // 传入伴生对象作为 Key
    val dispatcher = ctx[ContinuationInterceptor]            // 获取调度器
    val job: Job? = ctx[Job]                                 // 获取 Job
 
    println("Name: $name")          // CoroutineName(analyzer)
    println("Dispatcher: $dispatcher") // Dispatchers.Default
    println("Job: $job")            // JobImpl{Active}
 
    // 访问不存在的元素返回 null
    val handler = ctx[CoroutineExceptionHandler]
    println("Handler: $handler")    // null
}

// CombinedContext 的 get 实现
internal class CombinedContext(
    private val left: CoroutineContext,
    private val element: Element
) : CoroutineContext {
 
    override fun <E : Element> get(key: Key<E>): E? {
        var cur = this               // 从当前节点开始
        while (true) {
            // 先检查最右侧元素
            cur.element[key]?.let { return it }
            // 没找到，继续向左递归
            val next = cur.left
            if (next is CombinedContext) {
                cur = next           // 左子树是 CombinedContext，继续循环
            } else {
                return next[key]     // 左子树是单个 Element 或 Empty，直接查
            }
        }
    }
}

import kotlinx.coroutines.*
 
fun main() = runBlocking(CoroutineName("main-routine")) {
    // 在协程内部，coroutineContext 是一个隐式可用的属性
    val myName = coroutineContext[CoroutineName]?.name ?: "unnamed"
    println("当前协程名: $myName")   // 输出: 当前协程名: main-routine
 
    // 子协程会继承父上下文（但可以覆盖部分元素）
    launch(CoroutineName("child-routine")) {
        val childName = coroutineContext[CoroutineName]?.name
        val childJob = coroutineContext[Job]
        println("子协程名: $childName")           // child-routine
        println("子协程 Job: $childJob")           // StandaloneCoroutine{Active}
        println("是否继承父 Dispatcher: ${
            coroutineContext[ContinuationInterceptor]
        }")                                        // BlockingEventLoop（runBlocking 的调度器）
    }
}

val ctx = CoroutineName("A") + Dispatchers.IO + CoroutineName("B") + Job()
println(ctx[CoroutineName]?.name)

// CoroutineDispatcher 的继承关系（简化）
// CoroutineDispatcher 是 ContinuationInterceptor 的子类
// ContinuationInterceptor 是 CoroutineContext.Element 的子类
// 因此 Dispatcher 可以直接作为 CoroutineContext 使用
public abstract class CoroutineDispatcher :
    AbstractCoroutineContextElement(ContinuationInterceptor),  // 以 ContinuationInterceptor 为 Key
    ContinuationInterceptor {
 
    // 核心方法：将一个 Runnable 调度到目标线程执行
    public abstract fun dispatch(context: CoroutineContext, block: Runnable)
}

// 演示：同一上下文只能有一个调度器
fun main() = runBlocking {
    // Default + IO，后者覆盖前者，最终使用 IO
    val ctx = Dispatchers.Default + Dispatchers.IO
    // 通过 ContinuationInterceptor Key 取出的就是 Dispatchers.IO
    println(ctx[ContinuationInterceptor]) // 输出: Dispatchers.IO
}

// Android 中典型的 Main 调度器用法
class MyViewModel : ViewModel() {
 
    fun loadUserProfile() {
        // viewModelScope 默认使用 Dispatchers.Main.immediate
        viewModelScope.launch {
            // ① 这里运行在主线程——可以显示 loading
            _uiState.value = UiState.Loading
 
            // ② 切到 IO 线程去做网络请求
            val user = withContext(Dispatchers.IO) {
                userRepository.fetchUser()  // 网络请求，IO 密集
            }
 
            // ③ 自动切回主线程——可以更新 UI 状态
            _uiState.value = UiState.Success(user)
        }
    }
}

// Android 项目中需要引入此依赖（通常已自动包含）
// implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:x.x.x")
 
// JavaFX 项目
// implementation("org.jetbrains.kotlinx:kotlinx-coroutines-javafx:x.x.x")
 
// Swing 项目
// implementation("org.jetbrains.kotlinx:kotlinx-coroutines-swing:x.x.x")

// 通过 JVM 系统属性调整 IO 线程池大小
// 需要在程序启动前设置
// -Dkotlinx.coroutines.io.parallelism=128
 
// 或者在代码中（注意必须尽早执行）
System.setProperty("kotlinx.coroutines.io.parallelism", "128")

fun main() = runBlocking {
    // 在 Default 调度器启动协程
    launch(Dispatchers.Default) {
        println("Default: ${Thread.currentThread().name}")
        // 输出类似: Default: DefaultDispatcher-worker-1
 
        withContext(Dispatchers.IO) {
            // 虽然调度器切换了，但物理线程可能不变！
            println("IO: ${Thread.currentThread().name}")
            // 输出可能: IO: DefaultDispatcher-worker-1  ← 同一个 worker！
        }
    }
    // 两个调度器共享 "DefaultDispatcher-worker-X" 线程池
}

// 内存模型示意（简化）
// ┌─────────────────────────────────────────────┐
// │         CoroutineScheduler (共享线程池)         │
// │   worker-1  worker-2  worker-3  ... worker-N  │
// ├─────────────────────────────────────────────┤
// │  Dispatchers.Default (逻辑视图)               │
// │  并发上限 = CPU 核心数 (如 8)                   │
// ├─────────────────────────────────────────────┤
// │  Dispatchers.IO (逻辑视图)                    │
// │  并发上限 = max(64, 核心数)                    │
// └─────────────────────────────────────────────┘

// 创建独立的子调度器，互不影响
// 数据库操作限制最多 4 个并发
val dbDispatcher = Dispatchers.IO.limitedParallelism(4)
// 网络操作限制最多 16 个并发
val networkDispatcher = Dispatchers.IO.limitedParallelism(16)
 
suspend fun readFromDb() = withContext(dbDispatcher) {
    // 最多只有 4 个协程能同时执行数据库操作
    // 不会被网络请求的大量并发影响
    database.query("SELECT * FROM users")
}
 
suspend fun fetchFromNetwork() = withContext(networkDispatcher) {
    // 最多 16 个并发网络请求
    httpClient.get("https://api.example.com/data")
}

fun main() = runBlocking {
    // 打印 Default 调度器的线程数量上限
    println("CPU 核心数: ${Runtime.getRuntime().availableProcessors()}")
    // 假设 8 核 CPU，输出: CPU 核心数: 8
 
    // 启动大量 CPU 密集任务
    val jobs = (1..20).map { i ->
        launch(Dispatchers.Default) {
            // 模拟 CPU 密集计算
            var sum = 0L
            for (j in 1..100_000_000L) sum += j  // 纯计算，不阻塞
            println("Task $i done on ${Thread.currentThread().name}")
        }
    }
    jobs.forEach { it.join() }
    // 虽然启动了 20 个协程，但同一时刻最多只有 8 个在并行执行
    // 其余的会排队等待线程资源
}

// IO 上的 limitedParallelism：创建独立的子调度器
// 其并行度不受 IO 的 64 限制，是额外分配的
val ioChild = Dispatchers.IO.limitedParallelism(100) // 可以超过 64！
 
// Default 上的 limitedParallelism：在 Default 的线程池内部限制
// 不会创建额外线程，只是限制同时执行的协程数
val defaultChild = Dispatchers.Default.limitedParallelism(2)
// 即使 CPU 有 8 核，这个子调度器最多同时用 2 个线程

fun main() = runBlocking {
    // 在 runBlocking 的线程（main）上启动 Unconfined 协程
    launch(Dispatchers.Unconfined) {
        // ① 启动时：在调用者线程执行
        println("Start: ${Thread.currentThread().name}")
        // 输出: Start: main
 
        // ② 挂起点：delay 内部由 DefaultExecutor 线程恢复
        delay(100)
 
        // ③ 恢复后：在恢复协程的那个线程继续执行
        println("After delay: ${Thread.currentThread().name}")
        // 输出: After delay: kotlinx.coroutines.DefaultExecutor
        // ⚠️ 线程变了！不再是 main
 
        // ④ 再遇到 withContext 切换
        withContext(Dispatchers.IO) {
            println("In IO: ${Thread.currentThread().name}")
        }
 
        // ⑤ withContext 结束后，仍然不切回——留在 IO 的线程上
        println("After IO: ${Thread.currentThread().name}")
        // 输出: After IO: DefaultDispatcher-worker-1
        // ⚠️ 还是 IO 的线程，Unconfined 不会切回任何固定线程
    }
}

// ✅ 场景一：单元测试中，不关心线程调度，只关心逻辑正确性
@Test
fun testCalculation() = runBlocking(Dispatchers.Unconfined) {
    // 所有协程都在当前测试线程执行，无需额外调度
    val result = calculateAsync()  // 立即执行，不切线程
    assertEquals(42, result)
}
 
// ✅ 场景二：纯内存计算的协程，不涉及线程安全问题
//    且对性能要求极高，要避免任何调度开销
fun processEvent(event: Event) {
    scope.launch(Dispatchers.Unconfined) {
        // 不需要切线程，在事件触发的线程上直接处理
        eventBus.emit(event)  // 假设 emit 是挂起但不切线程的
    }
}

fun main() = runBlocking {
    launch(Dispatchers.Unconfined) {
        println("Thread A: ${Thread.currentThread().name}")
        withContext(Dispatchers.Default) {
            println("Thread B: ${Thread.currentThread().name}")
        }
        println("Thread C: ${Thread.currentThread().name}")
    }
}

// CoroutineDispatcher 抽象类（简化版源码）
public abstract class CoroutineDispatcher : 
    AbstractCoroutineContextElement(ContinuationInterceptor), // 以 ContinuationInterceptor 为 Key 注册到上下文
    ContinuationInterceptor {                                  // 实现续体拦截接口
 
    // ========== 核心方法：dispatch ==========
    // context: 当前协程的上下文（包含 Job、调度器等所有 Element）
    // block:   被封装成 Runnable 的协程续体代码
    public abstract fun dispatch(
        context: CoroutineContext, 
        block: Runnable
    )
    // 子类（如 Dispatchers.Default）必须实现此方法，
    // 将 block 投递到自己管理的线程或线程池中
 
    // ========== 可选方法：isDispatchNeeded ==========
    // 返回 true 表示需要调度（默认值）
    // 返回 false 表示直接在当前线程恢复，无需切换
    public open fun isDispatchNeeded(
        context: CoroutineContext
    ): Boolean = true
    // Dispatchers.Unconfined 重写此方法返回 false
 
    // ========== 拦截续体 ==========
    // 这是 ContinuationInterceptor 接口的方法
    // 将原始 Continuation 包装为 DispatchedContinuation
    public final override fun <T> interceptContinuation(
        continuation: Continuation<T>
    ): Continuation<T> =
        DispatchedContinuation(this, continuation)
        // this = 当前调度器实例
        // continuation = 原始续体（编译器生成的状态机）
}

// DispatchedContinuation 核心结构（简化）
internal class DispatchedContinuation<T>(
    val dispatcher: CoroutineDispatcher,   // 持有调度器引用
    val continuation: Continuation<T>      // 持有原始续体引用
) : Continuation<T>, Runnable {            // 同时是 Continuation 又是 Runnable
 
    // ========== Continuation 接口实现 ==========
    override val context: CoroutineContext
        get() = continuation.context       // 上下文委托给原始续体
 
    // 当协程从挂起点恢复时，此方法被调用
    override fun resumeWith(result: Result<T>) {
        val ctx = continuation.context     // 获取上下文
        val needDispatch =
            dispatcher.isDispatchNeeded(ctx) // 询问调度器是否需要调度
        if (needDispatch) {
            // 需要调度 → 暂存 result，将自身作为 Runnable 投递
            _state = result                // 保存恢复结果到字段
            dispatcher.dispatch(ctx, this) // ★ 核心：调用 dispatch
        } else {
            // 不需要调度 → 直接在当前线程恢复
            continuation.resumeWith(result)
        }
    }
 
    // ========== Runnable 接口实现 ==========
    // 当 dispatch 将 this 提交到线程池后，线程池最终会调用 run()
    override fun run() {
        val result = _state as Result<T>   // 取出之前暂存的结果
        continuation.resumeWith(result)    // 在目标线程上恢复原始续体
    }
}

// DefaultScheduler 简化源码
internal object DefaultScheduler : CoroutineDispatcher() {
 
    // 核心线程池实例
    private val coroutineScheduler = CoroutineScheduler(
        corePoolSize = CORE_POOL_SIZE,         // 默认 = CPU 核心数
        maxPoolSize = MAX_POOL_SIZE,           // 默认 = CPU 核心数（Default 模式下）
        schedulerName = "DefaultDispatcher"    // 线程名前缀
    )
 
    // ★ dispatch 实现：将 Runnable 提交到 CoroutineScheduler
    override fun dispatch(
        context: CoroutineContext, 
        block: Runnable
    ) {
        coroutineScheduler.dispatch(block, taskContext = TaskContext.NON_BLOCKING)
        // taskContext = NON_BLOCKING 表示这是 CPU 密集型任务
        // CoroutineScheduler 会将其放入本地队列，
        // 其他空闲线程可通过 work-stealing 窃取执行
    }
}

// IO 调度器简化源码
internal object IOScheduler : CoroutineDispatcher() {
 
    // ★ dispatch 实现：同一个 scheduler，不同的 taskContext
    override fun dispatch(
        context: CoroutineContext, 
        block: Runnable
    ) {
        // 复用 DefaultScheduler 的 coroutineScheduler 实例
        DefaultScheduler.coroutineScheduler.dispatch(
            block, 
            taskContext = TaskContext.PROBABLY_BLOCKING  
            // PROBABLY_BLOCKING 标记：告诉调度器这是 IO/阻塞型任务
            // 调度器发现阻塞任务多时，会创建额外线程（最多 64 个或 CPU 核心数，取较大值）
        )
    }
}

// Android 平台上的 Main 调度器（简化）
internal class HandlerDispatcher(
    private val handler: Handler  // 持有主线程 Handler 引用
) : CoroutineDispatcher() {
 
    // ★ dispatch 实现：通过 Handler.post 投递到主线程消息队列
    override fun dispatch(
        context: CoroutineContext, 
        block: Runnable
    ) {
        handler.post(block)
        // 等价于：handler.sendMessage(Message.obtain(handler, block))
        // block 被封装为 Message，放入主线程 Looper 的 MessageQueue
        // 主线程的 Looper.loop() 会取出 Message 并执行 block.run()
    }
}

// Unconfined 调度器核心（简化）
internal object Unconfined : CoroutineDispatcher() {
 
    // ★ 关键：告诉框架"我不需要调度"
    override fun isDispatchNeeded(
        context: CoroutineContext
    ): Boolean = false
    // 返回 false → DispatchedContinuation.resumeWith 
    // 不会调用 dispatch，直接在当前线程执行 continuation.resumeWith
 
    // dispatch 方法仍需实现（用于 yield 等特殊场景）
    override fun dispatch(
        context: CoroutineContext, 
        block: Runnable
    ) {
        // yield() 时会调用到这里
        // 使用内部的事件循环来排队执行
        val eventLoop = ThreadLocalEventLoop.currentOrNull()
        eventLoop?.dispatch(block) ?: block.run()
    }
}

// 基于 Java Executor 创建自定义单线程调度器
val singleThreadDispatcher: CoroutineDispatcher = 
    Executors.newSingleThreadExecutor { runnable ->
        // 自定义线程工厂，设置线程名便于调试
        Thread(runnable, "MyCustomThread").apply {
            isDaemon = true  // 设为守护线程，不阻止 JVM 退出
        }
    }.asCoroutineDispatcher()    // ★ 将 ExecutorService 转为 CoroutineDispatcher
// asCoroutineDispatcher() 扩展函数内部实现了 dispatch 方法：
// override fun dispatch(context, block) = executor.execute(block)
 
fun main() = runBlocking {
    // 在自定义调度器上启动协程
    launch(singleThreadDispatcher) {
        // 打印当前线程名 → "MyCustomThread"
        println("Running on: ${Thread.currentThread().name}")
    }
 
    // 用完后记得关闭，释放线程资源
    singleThreadDispatcher.close()
}

// withContext 是一个顶层挂起函数
// 泛型 T 表示代码块的返回值类型
public suspend fun <T> withContext(
    context: CoroutineContext,        // 要切换到的新上下文
    block: suspend CoroutineScope.() -> T // 在新上下文中执行的挂起代码块
): T                                  // 返回代码块的执行结果

// 假设这段代码运行在 Dispatchers.Main（主线程）
fun ViewModel.loadUserProfile(userId: String) {
    viewModelScope.launch {                         // 默认在 Dispatchers.Main 启动协程
        showLoading()                                // ① 主线程：显示加载动画
 
        // ② 切换到 IO 线程池执行网络请求
        val user = withContext(Dispatchers.IO) {
            apiService.fetchUser(userId)             // 在 IO 线程池中执行（阻塞式 IO 安全）
        }
        // ③ withContext 执行完毕后，自动回到 Dispatchers.Main
        
        // ④ 主线程：更新 UI
        displayUser(user)                            // 拿到 user 对象，直接更新界面
        hideLoading()                                // 隐藏加载动画
    }
}

// 伪代码展示合并逻辑
val mergedContext = currentCoroutineContext + newContext

launch(Dispatchers.Main + CoroutineName("ProfileLoader")) {
    // 当前上下文：Dispatcher=Main, Name=ProfileLoader, Job=parent's child
 
    withContext(Dispatchers.IO) {
        // 合并后的上下文：
        //   Dispatcher = IO        ← 被新传入的 Dispatcher 覆盖
        //   Name = ProfileLoader   ← 保留（newContext 中没有 Name 元素）
        //   Job = 新的子 Job       ← withContext 内部创建的（稍后详解）
        println(coroutineContext[CoroutineName])  // 输出: CoroutineName(ProfileLoader)
    }
}

launch(Dispatchers.Default) {
    // 当前已在 Default 调度器上
 
    withContext(Dispatchers.Default) {
        // 框架检测到 Dispatcher 相同，不会触发线程切换
        // 直接在当前线程执行，避免不必要的调度开销
        heavyComputation()
    }
}

fun main() = runBlocking {
    // runBlocking 创建一个绑定到当前线程的协程
    println("A - 线程: ${Thread.currentThread().name}")   // 主线程
 
    val result = withContext(Dispatchers.IO) {
        println("B - 线程: ${Thread.currentThread().name}") // IO 线程
        delay(1000)                                         // 模拟耗时操作（非阻塞）
        println("C - 线程: ${Thread.currentThread().name}") // IO 线程
        42                                                  // 返回值
    }
    // withContext 结束后，协程自动恢复到原来的上下文
 
    println("D - 线程: ${Thread.currentThread().name}")     // 回到主线程
    println("结果: $result")                                 // 输出: 结果: 42
}

A - 线程: main
B - 线程: DefaultDispatcher-worker-1
C - 线程: DefaultDispatcher-worker-1
D - 线程: main
结果: 42

launch {
    try {
        val data = withContext(Dispatchers.IO) {
            // 如果这里抛出异常...
            throw IOException("网络异常")
        }
    } catch (e: IOException) {
        // ...异常会直接在这里被 catch 到！
        // 这与 launch 的异常传播行为完全不同
        println("捕获异常: ${e.message}")
    }
}

// ViewModel 中的典型用法
class UserViewModel(
    private val userRepo: UserRepository  // 仓库层
) : ViewModel() {
 
    fun loadAndProcess(userId: String) {
        viewModelScope.launch {  // ① 在 Main 启动
            
            // ② 切到 IO：执行网络/数据库操作
            val rawData = withContext(Dispatchers.IO) {
                userRepo.fetchFromNetwork(userId)      // 网络请求
            }
 
            // ③ 切到 Default：执行 CPU 密集型数据处理
            val processedData = withContext(Dispatchers.Default) {
                rawData.items
                    .filter { it.isValid }              // 过滤无效数据
                    .sortedByDescending { it.priority } // 按优先级排序
                    .map { it.toUiModel() }             // 转换为 UI 模型
            }
 
            // ④ 自动回到 Main：更新 UI
            _uiState.value = UiState.Success(processedData)
        }
    }
}

// 方式一：withContext（推荐用于顺序执行）
val user = withContext(Dispatchers.IO) {
    fetchUser(id)                // 切到 IO 执行，完成后返回结果
}
 
// 方式二：async + await（功能相同，但有额外开销）
val user = async(Dispatchers.IO) {
    fetchUser(id)                // 启动一个新协程
}.await()                        // 立即等待结果

// ✅ async 的正确用法：并发执行多个独立任务
coroutineScope {
    val userDeferred = async(Dispatchers.IO) { fetchUser(id) }       // 并发任务 1
    val ordersDeferred = async(Dispatchers.IO) { fetchOrders(id) }   // 并发任务 2
 
    // 两个请求并行执行，总耗时 = max(任务1, 任务2)
    val user = userDeferred.await()
    val orders = ordersDeferred.await()
    
    display(user, orders)
}

launch(Dispatchers.Main) {
    println("层 0: ${Thread.currentThread().name}")    // Main
 
    withContext(Dispatchers.IO) {
        println("层 1: ${Thread.currentThread().name}") // IO worker
 
        withContext(Dispatchers.Default) {
            println("层 2: ${Thread.currentThread().name}") // Default worker
        }
        // 回到 IO
        println("层 1 恢复: ${Thread.currentThread().name}") // IO worker
    }
    // 回到 Main
    println("层 0 恢复: ${Thread.currentThread().name}")  // Main
}

Main ──→ IO ──→ Default ──→ IO ──→ Main
         ↑                    ↑
      withContext          withContext
       进入 IO              退出 Default

// 假设我们有一个非线程安全的缓存
val cache = HashMap<String, User>()  // HashMap 不是线程安全的
 
// ✅ 安全：所有对 cache 的操作都在同一个单线程 Dispatcher 上
val singleThread = newSingleThreadContext("CacheThread")
 
suspend fun getUser(id: String): User = withContext(singleThread) {
    // 这里的代码保证运行在 "CacheThread" 这个单线程上
    // 因此对 cache 的读写是线程安全的
    cache.getOrPut(id) {
        fetchUserFromDb(id)       // 注意：这个函数也需要是线程安全的
    }
}

val job = launch(Dispatchers.Main) {
    withContext(Dispatchers.IO) {
        repeat(1000) { i ->
            ensureActive()                         // 检查取消状态（最佳实践）
            println("处理第 $i 项...")
            Thread.sleep(100)                       // 模拟耗时操作
        }
    }
}
 
delay(500)
job.cancel()   // 取消父协程 → withContext 内部的子 Job 也会被取消

class UserRepository(
    private val api: UserApi,             // Retrofit 网络接口
    private val dao: UserDao,             // Room 数据库 DAO
    private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO  // 可注入的调度器（便于测试）
) {
    /**
     * 获取用户信息（带缓存策略）
     * 该函数对调用者来说是 main-safe（主线程安全）的，
     * 因为内部的所有阻塞操作都通过 withContext 切换到了 IO。
     */
    suspend fun getUser(userId: String): User {
        return withContext(ioDispatcher) {         // 切到 IO 线程池
 
            // 1. 先查本地缓存
            val cached = dao.findById(userId)      // 数据库查询（IO 操作）
            if (cached != null && !cached.isStale()) {
                return@withContext cached.toUser()  // 缓存命中，直接返回
            }
 
            // 2. 缓存未命中或已过期，发起网络请求
            val response = api.fetchUser(userId)    // 网络请求（IO 操作）
 
            // 3. 将网络数据写入本地缓存
            dao.insertOrUpdate(response.toEntity()) // 数据库写入（IO 操作）
 
            // 4. 返回最终数据
            response.toUser()                       // 返回转换后的领域模型
        }
    }
}
 
// 调用方（ViewModel）完全不需要关心线程切换
class UserViewModel(private val repo: UserRepository) : ViewModel() {
    fun load(userId: String) {
        viewModelScope.launch {                     // 在 Main 线程启动
            val user = repo.getUser(userId)          // 直接调用，无需 withContext
            _uiState.value = UiState.Success(user)   // 安全地更新 UI
        }
    }
}

fun main() = runBlocking(Dispatchers.Main) {
    println("1")
    
    val result = withContext(Dispatchers.IO) {
        println("2")
        delay(100)
        println("3")
        "Hello"
    }
    
    println("4 - $result")
    
    withContext(Dispatchers.Default) {
        println("5")
    }
    
    println("6")
}

// 伪代码：协程恢复时的调度路径
continuation.resumeWith(result)
  → intercepted().resumeWith(result)           // 1. 拦截器包装
    → DispatchedContinuation.resumeWith(result) // 2. 判断是否需要 dispatch
      → dispatcher.dispatch(context, block)     // 3. 提交 Runnable
        → executor.execute(block)               // 4. 线程池执行

// ═══════════════════════════════════════════════════════
// 场景 1：ViewModel 中发起网络请求
// ═══════════════════════════════════════════════════════
viewModelScope.launch {                         // 默认 Dispatchers.Main
    val user = withContext(Dispatchers.IO) {     // 切到 IO 线程池做网络请求
        api.fetchUser(userId)                    // 挂起，不阻塞主线程
    }                                           // 自动切回 Main
    nameTextView.text = user.name               // 安全地更新 UI
}
 
// ═══════════════════════════════════════════════════════
// 场景 2：CPU 密集型计算
// ═══════════════════════════════════════════════════════
viewModelScope.launch {
    val sorted = withContext(Dispatchers.Default) {  // 切到 Default（CPU 线程池）
        hugeList.sortedByDescending { it.score }     // 大数据排序
    }
    adapter.submitList(sorted)                       // 切回 Main 更新列表
}
 
// ═══════════════════════════════════════════════════════
// 场景 3：组合自定义 Context
// ═══════════════════════════════════════════════════════
val myContext = Dispatchers.IO +                // 调度器
    CoroutineName("data-sync") +                // 协程名（调试用）
    SupervisorJob()                             // 独立的 Job（不受父协程取消影响）
 
CoroutineScope(myContext).launch {
    // 此协程运行在 IO 线程池，名称为 "data-sync"
    syncData()
}
 
// ═══════════════════════════════════════════════════════
// 场景 4：从 Context 中提取元素
// ═══════════════════════════════════════════════════════
suspend fun logCoroutineInfo() {
    val ctx = coroutineContext                          // 获取当前协程的 Context
    val dispatcher = ctx[ContinuationInterceptor]       // 取出调度器
    val name = ctx[CoroutineName]?.name ?: "unnamed"    // 取出名称，可能为 null
    val job = ctx[Job]                                  // 取出 Job
    println("[$name] dispatcher=$dispatcher, isActive=${job?.isActive}")
}

fun main() = runBlocking {
    println("A: ${Thread.currentThread().name}")
 
    withContext(Dispatchers.Default) {
        println("B: ${Thread.currentThread().name}")
 
        withContext(Dispatchers.IO) {
            println("C: ${Thread.currentThread().name}")
        }
 
        println("D: ${Thread.currentThread().name}")
    }
 
    println("E: ${Thread.currentThread().name}")
}

val ctx1 = CoroutineName("alpha") + Dispatchers.IO
val ctx2 = ctx1 + CoroutineName("beta") + Dispatchers.Default