协程基础

import kotlinx.coroutines.*
 
fun main() = runBlocking {
    // 同时启动 100,000 个协程
    val jobs = List(100_000) {
        launch {
            delay(1000L) // 每个协程挂起 1 秒
            print(".") // 恢复后打印一个点
        }
    }
    jobs.forEach { it.join() } // 等待所有协程完成
}

import kotlin.concurrent.thread
 
fun main() {
    // 尝试启动 100,000 个线程 —— 极大概率抛出 OutOfMemoryError
    val threads = List(100_000) {
        thread {
            Thread.sleep(1000L)
            print(".")
        }
    }
    threads.forEach { it.join() }
}

import kotlinx.coroutines.*
 
// suspend 关键字标记这是一个挂起函数
suspend fun fetchUserData(): String {
    println("开始获取用户数据... [${Thread.currentThread().name}]")
    delay(2000L) // 挂起点：模拟网络请求，协程在此挂起，线程被释放
    println("用户数据获取完成 [${Thread.currentThread().name}]")
    return "User(name=Kiro, age=1)" // 恢复后继续执行，返回结果
}
 
suspend fun fetchOrderData(): String {
    println("开始获取订单数据... [${Thread.currentThread().name}]")
    delay(1500L) // 另一个挂起点
    println("订单数据获取完成 [${Thread.currentThread().name}]")
    return "Order(id=1024, item=Keyboard)"
}
 
fun main() = runBlocking {
    // 虽然看起来是顺序执行，但每次 delay 时线程都被释放了
    val user = fetchUserData()   // 第一次挂起并恢复
    val order = fetchOrderData() // 第二次挂起并恢复
    println("结果: $user, $order")
}

// 编译器生成的伪代码（简化版）
// 原始的 suspend fun fetchUserData() 被转换为带 Continuation 参数的函数
fun fetchUserData(continuation: Continuation<String>): Any? {
    // 状态机：用 label 标记当前执行到哪一步
    val sm = continuation as? FetchUserDataSM ?: FetchUserDataSM(continuation)
 
    when (sm.label) {
        0 -> {
            // 第一次进入：执行到第一个挂起点之前的代码
            println("开始获取用户数据...")
            sm.label = 1 // 标记下一次恢复时应该跳到 label=1
            // 调用 delay，如果它挂起了，返回 COROUTINE_SUSPENDED
            if (delay(2000L, sm) == COROUTINE_SUSPENDED) {
                return COROUTINE_SUSPENDED // 告诉调用者：我挂起了
            }
        }
        1 -> {
            // 从挂起点恢复：执行 delay 之后的代码
            println("用户数据获取完成")
            return "User(name=Kiro, age=1)" // 返回最终结果
        }
    }
    // 不可达
    throw IllegalStateException()
}

// Continuation 接口的核心定义
public interface Continuation<in T> {
    // 协程上下文，包含调度器、Job 等信息
    public val context: CoroutineContext
    // 恢复协程执行，传入结果（成功值或异常）
    public fun resumeWith(result: Result<T>)
}

// Java 中的非结构化并发 —— 容易泄漏
ExecutorService executor = Executors.newFixedThreadPool(4);
 
void processRequest() {
    // 启动异步任务，但谁来管理它的生命周期？
    executor.submit(() -> fetchUserData());  // 如果 processRequest 出错，这个任务还在跑
    executor.submit(() -> fetchOrderData()); // 如果 Activity 销毁了，这个任务还在跑
    // 没有自动取消机制，没有父子关系，没有异常传播
}

import kotlinx.coroutines.*
 
fun main() = runBlocking { // 这是根作用域（父）
    println("父协程开始")
 
    // launch 在当前作用域中启动子协程
    val job1 = launch { // 子协程 1
        println("  子协程1 开始")
        delay(2000L)
        println("  子协程1 完成") // 父协程会等待这里执行完
    }
 
    val job2 = launch { // 子协程 2
        println("  子协程2 开始")
        delay(1000L)
        println("  子协程2 完成")
    }
 
    // 不需要手动 join！父协程（runBlocking）会自动等待所有子协程完成
    println("父协程：等待子协程完成...")
    // runBlocking 会在 job1 和 job2 都完成后才结束
}
// 输出顺序：
// 父协程开始
// 父协程：等待子协程完成...
// 子协程1 开始
// 子协程2 开始
// 子协程2 完成（1秒后）
// 子协程1 完成（2秒后）

import kotlinx.coroutines.*
 
fun main() = runBlocking {
    // 创建一个子作用域，模拟页面的生命周期
    val pageScope = CoroutineScope(Dispatchers.Default + Job())
 
    // 在页面作用域中启动多个网络请求
    pageScope.launch {
        println("请求1: 获取用户资料...")
        delay(5000L) // 模拟耗时请求
        println("请求1: 完成") // 如果被取消，这行不会执行
    }
 
    pageScope.launch {
        println("请求2: 获取推荐列表...")
        delay(5000L)
        println("请求2: 完成")
    }
 
    pageScope.launch {
        println("请求3: 获取消息通知...")
        delay(5000L)
        println("请求3: 完成")
    }
 
    // 模拟用户 1 秒后离开页面
    delay(1000L)
    println("用户离开页面 → 取消所有请求")
    pageScope.cancel() // 一行代码取消所有子协程！
 
    delay(2000L) // 等待一会儿，验证子协程确实被取消了
    println("验证：没有任何请求完成输出")
}

import kotlinx.coroutines.*
 
fun main() = runBlocking {
    try {
        coroutineScope { // 创建一个结构化的子作用域
            launch { // 子协程 A
                delay(1000L)
                println("子协程A完成") // 不会执行，因为 B 先失败了
            }
 
            launch { // 子协程 B
                delay(500L)
                throw RuntimeException("子协程B出错了！") // 500ms 后抛出异常
                // 异常传播：B 失败 → 父作用域取消 A → 父作用域自己也失败
            }
        }
    } catch (e: RuntimeException) {
        println("捕获到异常: ${e.message}") // 异常被传播到这里
    }
}
// 输出：捕获到异常: 子协程B出错了！

// ❌ 不推荐：GlobalScope 启动的协程没有父子关系，无法自动取消
GlobalScope.launch {
    // 这个协程的生命周期与整个应用一样长
    // 即使启动它的组件已经销毁，它仍然在运行
}
 
// ✅ 推荐：在明确的作用域中启动协程
class MyViewModel : ViewModel() {
    fun loadData() {
        viewModelScope.launch { // viewModelScope 在 ViewModel 销毁时自动取消
            val data = repository.fetchData()
            _uiState.value = data
        }
    }
}

fun main() = runBlocking {
    val job = launch {
        launch {
            delay(300L)
            println("A")
        }
        launch {
            delay(100L)
            println("B")
        }
        println("C")
    }
    delay(200L)
    job.cancel()
    delay(500L)
    println("D")
}

// 普通函数：调用后必须立即返回结果
fun fetchDataSync(): String {
    // 阻塞当前线程直到拿到数据
    return blockingHttpCall("https://api.example.com/data")
}
 
// 挂起函数：调用后可以挂起，让出线程，等数据就绪后再恢复
suspend fun fetchData(): String {
    // 在挂起点让出线程，数据就绪后恢复执行
    return httpClient.get("https://api.example.com/data")
}

// 这个函数虽然标记了 suspend，但内部没有任何挂起点
// 它实际上和普通函数行为完全一致，不会真正挂起
suspend fun add(a: Int, b: Int): Int {
    return a + b // 纯计算，没有挂起操作
}
 
// 这个函数才会真正挂起——因为内部调用了 delay()
suspend fun delayedAdd(a: Int, b: Int): Int {
    delay(1000L) // delay 是一个挂起函数，这里是真正的挂起点
    return a + b
}

// ✅ 在协程构建器内部调用
fun main() = runBlocking {
    val data = fetchData() // OK：runBlocking 的 lambda 就是协程体
    println(data)
}
 
// ✅ 在另一个挂起函数内部调用
suspend fun loadAndProcess(): String {
    val raw = fetchData()  // OK：当前函数本身就是 suspend
    return process(raw)
}
 
// ❌ 在普通函数中直接调用——编译错误
fun normalFunction() {
    // val data = fetchData() 
    // 编译器报错：Suspend function 'fetchData' should be called 
    // only from a coroutine or another suspend function
}

// 你写的 Kotlin 代码
suspend fun fetchData(): String { ... }
 
// 编译器实际生成的 JVM 字节码签名（伪代码表示）
fun fetchData(continuation: Continuation<String>): Any? { ... }

suspend fun example() {
    println("A")           // 普通语句，不是挂起点
    delay(1000)            // ← 挂起点 #1：delay 是挂起函数
    println("B")           // delay 恢复后执行
    val data = fetchData() // ← 挂起点 #2：fetchData 是挂起函数
    println("C: $data")    // fetchData 恢复后执行
    val x = add(1, 2)      // 虽然 add 是 suspend，但不会真正挂起
    println("D: $x")       // 紧接着执行
}

// 阻塞：线程被占用，什么都干不了，干等着
fun blockingWait() {
    Thread.sleep(1000) // 当前线程被阻塞 1 秒，无法执行其他任务
}
 
// 挂起：协程暂停，但线程被释放，可以去执行其他协程
suspend fun suspendingWait() {
    delay(1000) // 协程挂起 1 秒，线程被释放去做其他事情
}

fun main() = runBlocking {
    // 启动 100,000 个协程，每个都挂起 1 秒
    // 如果是线程，你需要 100,000 个线程（系统会崩溃）
    // 但协程可以轻松做到，因为挂起不占用线程
    val jobs = List(100_000) {
        launch {
            delay(1000L) // 挂起，不阻塞线程
            print(".")
        }
    }
    jobs.forEach { it.join() } // 等待所有协程完成
}

// kotlin.coroutines.Continuation 接口定义
public interface Continuation<in T> {
    // 协程上下文，携带调度器、Job 等信息
    public val context: CoroutineContext
 
    // 恢复协程执行，传入结果（成功值或异常）
    public fun resumeWith(result: Result<T>)
}

// 以成功值恢复
public inline fun <T> Continuation<T>.resume(value: T) {
    resumeWith(Result.success(value))
}
 
// 以异常恢复
public inline fun <T> Continuation<T>.resumeWithException(exception: Throwable) {
    resumeWith(Result.failure(exception))
}

// 你写的源码
suspend fun loadUserProfile(userId: String): Profile {
    val token = authenticate(userId)   // 挂起点 #1
    val userData = fetchUser(token)     // 挂起点 #2
    val profile = parseProfile(userData)
    return profile
}

// 编译器生成的状态机（伪代码，展示核心逻辑）
fun loadUserProfile(userId: String, cont: Continuation<Profile>): Any? {
    
    // 首次调用时创建状态机对象，后续恢复时复用同一个对象
    val sm = cont as? LoadUserProfileSM ?: LoadUserProfileSM(cont)
    
    when (sm.label) {
        
        0 -> {
            // ===== 状态 0：初始状态 =====
            sm.userId = userId          // 保存局部变量到状态机
            sm.label = 1                // 设置下一个状态
            // 调用第一个挂起函数，传入状态机自身作为 Continuation
            val result = authenticate(userId, sm)
            if (result == COROUTINE_SUSPENDED) return COROUTINE_SUSPENDED
            // 如果没有真正挂起（快速路径），直接进入下一个状态
            sm.result = result
            // fall through to state 1
        }
        
        1 -> {
            // ===== 状态 1：authenticate 完成后恢复 =====
            // 检查是否有异常
            sm.result.throwOnFailure()
            val token = sm.result as String  // 获取 authenticate 的返回值
            sm.token = token                 // 保存到状态机
            sm.label = 2                     // 设置下一个状态
            val result = fetchUser(token, sm)
            if (result == COROUTINE_SUSPENDED) return COROUTINE_SUSPENDED
            sm.result = result
            // fall through to state 2
        }
        
        2 -> {
            // ===== 状态 2：fetchUser 完成后恢复 =====
            sm.result.throwOnFailure()
            val userData = sm.result as UserData
            val profile = parseProfile(userData) // 普通函数，不是挂起点
            return profile                       // 最终返回结果
        }
        
        else -> throw IllegalStateException("Unexpected state")
    }
}

// 假设有一个传统的回调风格 API
interface Callback {
    fun onSuccess(data: String)
    fun onError(error: Exception)
}
 
fun loadDataAsync(callback: Callback) {
    // 模拟异步操作...
}
 
// 将回调 API 桥接为挂起函数
suspend fun loadData(): String {
    // suspendCancellableCoroutine 挂起当前协程，
    // 并将 Continuation 对象暴露给 lambda
    return suspendCancellableCoroutine { continuation ->
        loadDataAsync(object : Callback {
            override fun onSuccess(data: String) {
                // 异步操作成功，以成功值恢复协程
                continuation.resume(data)
            }
            override fun onError(error: Exception) {
                // 异步操作失败，以异常恢复协程
                continuation.resumeWithException(error)
            }
        })
 
        // 注册取消回调，支持协作式取消
        continuation.invokeOnCancellation {
            // 协程被取消时的清理逻辑
            // 例如取消网络请求
        }
    }
}

// 简化的调度流程示意
// 1. 异步操作完成，在 IO 线程调用 continuation.resume(data)
// 2. ContinuationInterceptor（即 Dispatcher）拦截这次恢复
// 3. 将恢复操作 dispatch 到目标线程（如 Main 线程）
// 4. 协程在目标线程上从挂起点恢复执行
 
suspend fun updateUI() {
    // 在 IO 线程执行网络请求
    val data = withContext(Dispatchers.IO) {
        fetchFromNetwork() // 挂起点：在 IO 线程执行
    }
    // withContext 返回后，自动恢复到原来的调度器（如 Main）
    textView.text = data // 在 Main 线程更新 UI
}

// Continuation 的包装层次（由内到外）
// 1. 原始 Continuation（状态机本身）
// 2. DispatchedContinuation（调度器包装，负责线程切换）
// 3. 可能还有其他拦截器的包装
 
// 恢复时的调用链：
// resume(value)
//   → DispatchedContinuation.resumeWith()
//     → dispatcher.dispatch(context, runnable)  // 切换线程
//       → 原始 Continuation.resumeWith()        // 在目标线程执行状态机

// 一个协程的内存开销大约包括：
// 1. 一个状态机对象（Continuation 实例）：几十到几百字节
// 2. 局部变量被提升为字段：与原始变量大小相同
// 3. 没有额外的线程栈（线程栈通常 512KB ~ 1MB）
 
// 对比：
// - 一个线程：约 1MB 栈内存 + OS 线程资源
// - 一个协程：约 几百字节 ~ 几KB
// - 10万个线程：约 100GB 内存（不可能）
// - 10万个协程：约 几十MB 内存（轻松）

suspend fun step1(): Int {
    println("Step 1 start")
    delay(100)
    println("Step 1 end")
    return 1
}
 
suspend fun step2(x: Int): Int {
    println("Step 2 start: $x")
    delay(100)
    println("Step 2 end")
    return x + 1
}
 
fun main() = runBlocking {
    println("Begin")
    val a = step1()
    val b = step2(a)
    println("Result: $b")
    println("End")
}

suspend fun compute(x: Int): String

// CoroutineScope 的扩展函数
// context: 可选的上下文覆盖，默认为 EmptyCoroutineContext
// start: 启动模式，默认 CoroutineStart.DEFAULT（立即调度）
// block: 协程体，一个挂起 lambda
public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit  // 返回 Unit，不产出值
): Job

import kotlinx.coroutines.*
 
fun main() = runBlocking {
    // 使用 launch 启动一个子协程
    // 返回的 job 是协程的句柄，不是计算结果
    val job: Job = launch {
        // 这里是协程体，运行在协程环境中
        println("协程开始执行，线程: ${Thread.currentThread().name}")
        delay(1000L) // 挂起 1 秒，不阻塞线程
        println("协程执行完毕")
    }
 
    println("launch 调用后立即执行到这里，不会等待协程完成")
 
    // 如果需要等待协程完成，可以调用 join()
    job.join() // 挂起当前协程，直到 job 完成
 
    println("所有工作完成")
}

launch 调用后立即执行到这里，不会等待协程完成
协程开始执行，线程: main
协程执行完毕
所有工作完成

// DEFAULT: 立即调度，协程体在调度器空闲时执行
launch(start = CoroutineStart.DEFAULT) { /* ... */ }
 
// LAZY: 惰性启动，直到调用 job.start() 或 job.join() 才调度
val lazyJob = launch(start = CoroutineStart.LAZY) {
    println("我是懒加载的协程")
}
// 此时协程还没有开始
lazyJob.start() // 手动触发启动
 
// ATOMIC: 立即调度，且在第一个挂起点之前不可取消
launch(start = CoroutineStart.ATOMIC) { /* ... */ }
 
// UNDISPATCHED: 立即在当前线程执行到第一个挂起点，不经过调度器
launch(start = CoroutineStart.UNDISPATCHED) {
    // 这行代码一定在调用 launch 的线程上立即执行
    println("立即执行，线程: ${Thread.currentThread().name}")
    delay(100) // 挂起后，恢复时才回到调度器指定的线程
    println("恢复后执行")
}

// 方式一：协程体内 try-catch
launch {
    try {
        riskyOperation() // 可能抛异常的挂起函数
    } catch (e: Exception) {
        println("捕获异常: ${e.message}")
    }
}
 
// 方式二：使用 CoroutineExceptionHandler（仅对 launch 有效）
val handler = CoroutineExceptionHandler { _, exception ->
    println("全局捕获: ${exception.message}")
}
// handler 作为上下文元素传入
launch(handler) {
    throw RuntimeException("出错了")
}

// async 的函数签名
// 注意协程体返回 T，而非 Unit
public fun <T> CoroutineScope.async(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> T  // 返回泛型 T
): Deferred<T>  // 返回 Deferred<T>，可通过 await() 获取 T

import kotlinx.coroutines.*
 
fun main() = runBlocking {
    // async 启动协程，返回 Deferred<Int>
    val deferred: Deferred<Int> = async {
        println("开始计算...")
        delay(1000L) // 模拟耗时计算
        42 // 协程体的最后一个表达式就是返回值
    }
 
    println("async 已启动，可以做其他事情")
 
    // await() 是挂起函数，会挂起当前协程直到结果就绪
    val result: Int = deferred.await()
    println("计算结果: $result") // 输出: 计算结果: 42
}

import kotlinx.coroutines.*
import kotlin.system.measureTimeMillis
 
// 模拟两个独立的网络请求
suspend fun fetchUserProfile(): String {
    delay(1000L) // 模拟 1 秒网络延迟
    return "用户资料"
}
 
suspend fun fetchUserOrders(): String {
    delay(1200L) // 模拟 1.2 秒网络延迟
    return "订单列表"
}
 
fun main() = runBlocking {
    val time = measureTimeMillis {
        // 同时启动两个异步任务
        val profileDeferred = async { fetchUserProfile() }
        val ordersDeferred = async { fetchUserOrders() }
 
        // 分别等待结果
        val profile = profileDeferred.await()
        val orders = ordersDeferred.await()
 
        println("$profile + $orders")
    }
    // 总耗时约 1200ms，而非 2200ms
    println("总耗时: ${time}ms")
}

// ❌ 错误写法：这不是并发，两个请求仍然是顺序的
val result = async {
    val profile = fetchUserProfile()   // 先等 1000ms
    val orders = fetchUserOrders()     // 再等 1200ms
    "$profile + $orders"               // 总共 2200ms
}
 
// ✅ 正确写法：启动两个独立的 async
val profileDeferred = async { fetchUserProfile() }  // 立即启动
val ordersDeferred = async { fetchUserOrders() }     // 立即启动
val profile = profileDeferred.await()  // 等待第一个
val orders = ordersDeferred.await()    // 等待第二个（可能已经完成了）

val deferred = async {
    throw RuntimeException("计算出错")
    // 异常被"存储"在 Deferred 中
}
 
// 直到调用 await() 时，异常才会被重新抛出
try {
    deferred.await()
} catch (e: RuntimeException) {
    println("在 await 处捕获: ${e.message}")
}

// 惰性 async：定义但不立即执行
val lazyDeferred = async(start = CoroutineStart.LAZY) {
    heavyComputation()
}
 
// 某个条件满足后才启动
if (needResult) {
    val value = lazyDeferred.await() // 此时才开始计算
}

// runBlocking 是顶层函数，不是 CoroutineScope 的扩展
// 它会阻塞调用它的线程
public fun <T> runBlocking(
    context: CoroutineContext = EmptyCoroutineContext,
    block: suspend CoroutineScope.() -> T
): T  // 直接返回结果 T，不是 Deferred

import kotlinx.coroutines.*
 
// main 函数是普通函数，不是挂起函数
// runBlocking 在这里充当桥梁
fun main() = runBlocking {
    // 这个 lambda 内部就是协程世界
    // 可以调用挂起函数
    println("协程开始，线程: ${Thread.currentThread().name}")
    delay(500L) // 挂起协程，但 main 线程被 runBlocking 阻塞
    println("协程结束")
}
// runBlocking 返回后，main 线程才继续（程序结束）

@Test
fun testFetchUser() = runBlocking {
    // 在测试中调用挂起函数
    val user = userRepository.fetchUser(1)
    assertEquals("Alice", user.name)
}

// ❌ 危险！在协程内部使用 runBlocking 可能导致死锁
launch(Dispatchers.Main) {
    // 当前在 Main 线程的协程中
    val result = runBlocking {
        // runBlocking 阻塞 Main 线程
        // 如果内部协程也需要 Main 线程，就死锁了
        withContext(Dispatchers.Main) {
            "永远到不了这里"
        }
    }
}

import kotlinx.coroutines.*
 
fun main() = runBlocking {  // runBlocking: 阻塞 main 线程，创建协程作用域
    println("1. runBlocking 开始，线程: ${Thread.currentThread().name}")
 
    // launch: 启动协程，返回 Job，不返回值
    val job = launch {
        delay(200L)
        println("3. launch 协程完成")
    }
 
    // async: 启动协程，返回 Deferred<String>
    val deferred = async {
        delay(300L)
        "async 的结果" // 返回值
    }
 
    println("2. 构建器调用完毕，等待结果...")
 
    job.join()                        // 等待 launch 完成
    val result = deferred.await()     // 等待 async 完成并获取结果
    println("4. async 返回: $result")
 
    println("5. runBlocking 结束")
}
// 输出顺序:
// 1. runBlocking 开始，线程: main
// 2. 构建器调用完毕，等待结果...
// 3. launch 协程完成
// 4. async 返回: async 的结果
// 5. runBlocking 结束

fun main() = runBlocking {
    val a = async {
        delay(200L)
        println("A")
        1
    }
    val b = async {
        delay(100L)
        println("B")
        2
    }
    println("C: ${a.await() + b.await()}")
}

// CoroutineScope 接口只有一个属性：coroutineContext
public interface CoroutineScope {
    // 该作用域关联的协程上下文，包含 Job、Dispatcher 等元素
    public val coroutineContext: CoroutineContext
}

// launch 是 CoroutineScope 的扩展函数
// 这意味着你必须在某个 scope 内才能调用 launch
public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext, // 可选的额外上下文
    start: CoroutineStart = CoroutineStart.DEFAULT,    // 启动模式
    block: suspend CoroutineScope.() -> Unit            // 协程体，本身也是一个新的 scope
): Job { ... }

// Android 中的 ViewModel 就实现了自己的协程作用域
// viewModelScope 是 ViewModel 的扩展属性
class MyViewModel : ViewModel() {
    fun loadData() {
        // viewModelScope 在 ViewModel 被清除时自动取消
        viewModelScope.launch {
            val data = repository.fetchData() // 挂起函数
            _uiState.value = data             // 更新 UI 状态
        }
    }
}
 
// 自定义类也可以实现 CoroutineScope
class NetworkService : CoroutineScope {
    // 创建一个 Job 用于管理所有子协程
    private val job = SupervisorJob()
 
    // 实现接口唯一的属性：组合 Job 和调度器
    override val coroutineContext: CoroutineContext
        get() = Dispatchers.IO + job
 
    fun fetchData() {
        // 现在可以直接在 this 上调用 launch
        launch {
            // 网络请求...
        }
    }
 
    // 提供清理方法，取消所有子协程
    fun destroy() {
        job.cancel() // 取消 job 会级联取消所有子协程
    }
}

fun main() = runBlocking {
    // 方式 1：CoroutineScope() 工厂函数
    // 注意：这是一个函数，不是构造函数（首字母大写是 Kotlin 的命名约定）
    val scope1 = CoroutineScope(Dispatchers.Default + Job())
 
    // 方式 2：使用 runBlocking 自带的 scope（当前 this）
    // runBlocking 的 lambda 接收者就是 CoroutineScope
    launch { // this: CoroutineScope -> 继承 runBlocking 的 scope
        println("在 runBlocking 的作用域中运行")
    }
 
    // 方式 3：coroutineScope 挂起函数（小写 c）—— 创建子作用域
    coroutineScope {
        launch {
            println("在子作用域中运行")
        }
    }
 
    // 方式 4：MainScope() 工厂函数（常用于 Android UI 层）
    // 内部使用 SupervisorJob + Dispatchers.Main
    val uiScope = MainScope()
 
    // 用完记得取消，防止泄漏
    scope1.cancel()
    uiScope.cancel()
}

fun main() = runBlocking {
    // runBlocking 创建了根 Job（root job）
    val rootJob = coroutineContext[Job]
    println("Root job: $rootJob")
 
    // launch 创建的协程自动成为 runBlocking 的子协程
    val childJob = launch {
        // 这个 launch 内部再启动的协程，是"孙子"协程
        val grandchildJob = launch {
            delay(1000)
            println("孙子协程完成")
        }
        println("子协程的 Job: ${coroutineContext[Job]}")
        println("孙子协程的 Job: $grandchildJob")
 
        // 验证父子关系
        println("孙子的父亲是子协程: ${grandchildJob.parent == coroutineContext[Job]}")
    }
 
    // 验证父子关系
    println("子协程的父亲是根协程: ${childJob.parent == rootJob}")
 
    // rootJob 的 children 包含 childJob
    println("根协程的子协程: ${rootJob?.children?.toList()}")
}

suspend fun demonstrateScopes() {
    // ---- coroutineScope：一个失败，全部取消 ----
    try {
        coroutineScope {
            launch {
                delay(500)
                println("任务 A 完成") // 不会打印！因为任务 B 先失败了
            }
            launch {
                delay(200)
                throw RuntimeException("任务 B 失败了") // 这会取消兄弟协程 A
            }
        }
    } catch (e: Exception) {
        println("coroutineScope 捕获异常: ${e.message}")
    }
 
    println("---分隔线---")
 
    // ---- supervisorScope：各自独立，互不影响 ----
    try {
        supervisorScope {
            launch {
                delay(500)
                println("任务 C 完成") // 会打印！任务 D 的失败不影响它
            }
            launch {
                delay(200)
                throw RuntimeException("任务 D 失败了") // 只影响自己
            }
            delay(1000) // 等待子协程完成
        }
    } catch (e: Exception) {
        println("supervisorScope 捕获异常: ${e.message}")
    }
}

fun main() = runBlocking {
    // CoroutineScope()：工厂函数，创建一个独立的、全新的作用域
    // 它不会与当前协程建立父子关系！
    val independentScope = CoroutineScope(Dispatchers.Default)
    independentScope.launch {
        delay(2000)
        println("独立作用域中的协程") // 可能不会打印，因为 main 可能先结束
    }
    // 必须手动管理生命周期
    // independentScope.cancel()
 
    // coroutineScope{}：挂起函数，创建一个子作用域
    // 它会挂起当前协程，直到内部所有子协程完成
    coroutineScope {
        launch {
            delay(500)
            println("子作用域中的协程") // 一定会打印
        }
        // coroutineScope 会等待这个 launch 完成后才返回
    }
    println("coroutineScope 之后的代码") // 在上面的子作用域全部完成后才执行
}

// 一个典型的并行分解示例：同时获取用户信息和订单列表
suspend fun loadUserDashboard(userId: String): Dashboard {
    // coroutineScope 确保两个请求都完成后才返回
    // 如果任何一个失败，另一个也会被取消（fail-fast 策略）
    return coroutineScope {
        // 并行发起两个网络请求
        val userDeferred = async { userService.getUser(userId) }       // 异步获取用户
        val ordersDeferred = async { orderService.getOrders(userId) }  // 异步获取订单
 
        // 等待两个结果，组装 Dashboard
        Dashboard(
            user = userDeferred.await(),     // 等待用户数据
            orders = ordersDeferred.await()  // 等待订单数据
        )
    }
    // 执行到这里时，两个请求一定都已完成（或者已经抛出异常）
}

// 非结构化并发（传统线程方式）—— 危险！
fun loadData() {
    thread {
        // 这个线程和 loadData() 没有任何生命周期绑定
        // loadData() 返回后，这个线程还在跑
        // 如果 Activity 已经销毁，这里更新 UI 就会崩溃
        val data = fetchFromNetwork()
        updateUI(data) // 💥 可能崩溃
    }
    // loadData() 立即返回，线程在后台野蛮生长
}

// 结构化并发（协程方式）—— 安全！
fun ViewModel.loadData() {
    viewModelScope.launch {
        // 这个协程绑定到 viewModelScope
        // 当 ViewModel 被清除时，viewModelScope 取消，这个协程也自动取消
        val data = fetchFromNetwork() // 挂起函数，可以安全取消
        updateUI(data) // ViewModel 还活着，安全更新
    }
}

fun main() = runBlocking {
    // 保证 1：作用域等待所有子协程
    coroutineScope {
        launch {
            delay(1000)
            println("1. 子协程完成") // 一定会在 "作用域结束" 之前打印
        }
        launch {
            delay(500)
            println("2. 另一个子协程完成")
        }
    }
    println("3. 作用域结束") // 一定在 1 和 2 之后打印
 
    println("===")
 
    // 保证 2：取消向下传播
    val parentJob = launch {
        launch {
            try {
                delay(Long.MAX_VALUE) // 永远挂起
            } catch (e: CancellationException) {
                println("4. 子协程被取消了: ${e.message}") // 父取消时触发
            }
        }
        launch {
            try {
                delay(Long.MAX_VALUE)
            } catch (e: CancellationException) {
                println("5. 另一个子协程也被取消了")
            }
        }
    }
    delay(100)           // 给子协程一点启动时间
    parentJob.cancel()   // 取消父协程 → 所有子协程级联取消
    parentJob.join()     // 等待取消完成
 
    println("===")
 
    // 保证 3：异常向上传播（使用 coroutineScope）
    try {
        coroutineScope {
            launch {
                delay(500)
                println("6. 这行不会打印") // 兄弟协程先失败，自己被取消
            }
            launch {
                delay(100)
                throw IllegalStateException("子协程出错了") // 异常向上传播
            }
        }
    } catch (e: Exception) {
        println("7. 父作用域捕获异常: ${e.message}")
    }
}

fun riskyOperation() {
    // ⚠️ GlobalScope 启动的协程没有父作用域
    // 它的生命周期等同于整个应用进程
    GlobalScope.launch {
        delay(5000)
        println("我可能在不该运行的时候还在运行")
    }
    // 没有人负责取消这个协程
    // 没有人等待它完成
    // 如果它持有 Activity 引用 → 内存泄漏
}

// Application 级别：最长生命周期
class MyApp : Application() {
    // 使用 SupervisorJob 防止单个任务失败影响全局
    val applicationScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
}
 
// ViewModel 级别：绑定到 ViewModel 生命周期
class UserViewModel : ViewModel() {
    fun loadDashboard() {
        viewModelScope.launch { // 自动在 onCleared() 时取消
            val dashboard = loadUserDashboard("123") // 内部使用 coroutineScope 并行分解
            _state.value = dashboard
        }
    }
}
 
// Activity/Fragment 级别：绑定到 UI 生命周期
class UserActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycleScope.launch { // 自动在 onDestroy() 时取消
            viewModel.state.collect { state ->
                // 安全地更新 UI，因为 scope 与生命周期绑定
                renderUI(state)
            }
        }
    }
}

class DataSyncService {
    // ✅ 最佳实践：SupervisorJob + 明确的调度器
    private val scope = CoroutineScope(
        SupervisorJob() +                    // 子任务失败不影响其他任务
        Dispatchers.IO +                     // IO 密集型操作
        CoroutineName("DataSyncService")     // 便于调试
    )
 
    fun syncAll() {
        // 每个 sync 任务独立，一个失败不影响其他
        scope.launch { syncUsers() }
        scope.launch { syncOrders() }
        scope.launch { syncProducts() }
    }
 
    // ✅ 必须提供清理方法
    fun shutdown() {
        scope.cancel() // 取消所有正在进行的同步任务
    }
}
 
// ❌ 反模式：不要这样做
class BadService {
    fun doWork() {
        // 每次调用都创建新的 scope，没有统一管理
        CoroutineScope(Dispatchers.IO).launch {
            // 这个协程没有人负责取消它
            // 如果 BadService 被销毁，协程还在跑 → 泄漏
        }
    }
}

fun main() = runBlocking {
    val scope = CoroutineScope(Job())
    scope.launch {
        delay(100)
        println("A")
    }
    coroutineScope {
        launch {
            delay(100)
            println("B")
        }
    }
    println("C")
}

// CoroutineContext 接口的核心定义（简化版）
public interface CoroutineContext {
    // 通过 Key 获取对应的元素，类似 map[key]
    public operator fun <E : Element> get(key: Key<E>): E?
 
    // 从初始值开始，对所有元素进行折叠（遍历）操作
    public fun <R> fold(initial: R, operation: (R, Element) -> R): R
 
    // 用 + 运算符组合两个上下文，右侧覆盖左侧的同 Key 元素
    public operator fun plus(context: CoroutineContext): CoroutineContext
 
    // 移除指定 Key 的元素，返回新的上下文
    public fun minusKey(key: Key<*>): CoroutineContext
 
    // Key 接口：每种 Element 都有一个伴生对象实现此接口
    public interface Key<E : Element>
 
    // Element 接口：上下文中的单个元素，本身也是一个 CoroutineContext
    public interface Element : CoroutineContext {
        public val key: Key<*>
    }
}

import kotlinx.coroutines.*
 
fun main() = runBlocking {
    // coroutineContext 是当前协程的上下文
    val ctx = coroutineContext
 
    // 通过 Key 取出具体元素
    val job: Job? = ctx[Job]                         // 取出 Job 元素
    val dispatcher = ctx[ContinuationInterceptor]    // 取出调度器元素
 
    println("当前 Job: $job")           // 输出当前协程的 Job 实例
    println("当前调度器: $dispatcher")   // 输出当前协程使用的调度器
}

import kotlinx.coroutines.*
 
fun main() = runBlocking {
    // 创建各种上下文元素
    val name = CoroutineName("数据加载协程")       // 命名元素
    val dispatcher = Dispatchers.IO                  // 调度器元素
    val handler = CoroutineExceptionHandler { ctx, throwable ->
        // 异常处理器：打印协程名和异常信息
        println("${ctx[CoroutineName]?.name} 发生异常: ${throwable.message}")
    }
 
    // 每个元素都可以独立使用，也可以组合
    println(name.key)        // 输出: CoroutineName
    println(dispatcher.key)  // 输出: ContinuationInterceptor
    println(handler.key)     // 输出: CoroutineExceptionHandler
}

import kotlinx.coroutines.*
 
fun main() = runBlocking {
    // 单个元素本身就是一个合法的 CoroutineContext
    val ctx1: CoroutineContext = CoroutineName("Worker")
    val ctx2: CoroutineContext = Dispatchers.IO
 
    // 用 + 组合多个元素，形成复合上下文
    val combined = ctx1 + ctx2
    println(combined[CoroutineName])           // 输出: CoroutineName(Worker)
    println(combined[ContinuationInterceptor]) // 输出: Dispatchers.IO
 
    // 继续追加元素
    val handler = CoroutineExceptionHandler { _, e -> println("Error: $e") }
    val fullCtx = combined + handler
    // fullCtx 现在包含三个元素: CoroutineName + Dispatchers.IO + Handler
 
    // 同 Key 元素：右侧覆盖左侧
    val ctx3 = CoroutineName("Alpha") + CoroutineName("Beta")
    println(ctx3[CoroutineName]) // 输出: CoroutineName(Beta)  ← 右侧覆盖
}

// 组合上下文的内部结构示意（链表形式）
// CombinedContext(
//     left = CombinedContext(
//         left = CoroutineName("Worker"),
//         element = Dispatchers.IO
//     ),
//     element = CoroutineExceptionHandler
// )

import kotlinx.coroutines.*
 
fun main() = runBlocking {
    // 演示 + 运算符的覆盖行为
    val base = Dispatchers.Default + CoroutineName("Base")
 
    // 覆盖调度器，保留名称
    val modified = base + Dispatchers.IO
    println(modified[ContinuationInterceptor]) // Dispatchers.IO（被覆盖）
    println(modified[CoroutineName])           // CoroutineName(Base)（保留）
 
    // 用 minusKey 移除某个元素
    val withoutName = base.minusKey(CoroutineName)
    println(withoutName[CoroutineName])           // null（已移除）
    println(withoutName[ContinuationInterceptor]) // Dispatchers.Default（保留）
}

import kotlinx.coroutines.*
 
fun main() = runBlocking {
    // 构建一个包含多个元素的上下文
    val ctx = Dispatchers.Default + CoroutineName("Demo") + Job()
 
    // 用 fold 遍历所有元素，收集到列表中
    val elements = ctx.fold(mutableListOf<CoroutineContext.Element>()) { list, element ->
        list.add(element)  // 将每个元素加入列表
        list               // 返回累积值
    }
 
    // 打印所有元素
    elements.forEach { element ->
        println("元素: $element, Key: ${element.key}")
    }
    // 输出类似:
    // 元素: CoroutineName(Demo), Key: CoroutineName
    // 元素: JobImpl{Active}@xxx, Key: Job
    // 元素: Dispatchers.Default, Key: ContinuationInterceptor
}

import kotlinx.coroutines.*
 
fun main() = runBlocking(CoroutineName("Parent") + Dispatchers.Default) {
    // 父上下文: Job(runBlocking) + Dispatchers.Default + CoroutineName("Parent")
 
    println("父协程名称: ${coroutineContext[CoroutineName]}")
    // 输出: CoroutineName(Parent)
 
    println("父协程调度器: ${coroutineContext[ContinuationInterceptor]}")
    // 输出: Dispatchers.Default
 
    // 启动子协程，通过参数覆盖调度器和名称
    val childJob = launch(Dispatchers.IO + CoroutineName("Child")) {
        // 子协程的上下文 = 继承父上下文 + 参数覆盖 + 新 Job
        println("子协程名称: ${coroutineContext[CoroutineName]}")
        // 输出: CoroutineName(Child)  ← 被参数覆盖
 
        println("子协程调度器: ${coroutineContext[ContinuationInterceptor]}")
        // 输出: Dispatchers.IO  ← 被参数覆盖
 
        println("子协程 Job: ${coroutineContext[Job]}")
        // 输出: 一个新的 StandaloneCoroutine 实例
 
        println("子 Job 的 parent: ${coroutineContext[Job]?.parent}")
        // 输出: 父协程的 BlockingCoroutine 实例（非 null）
    }
 
    childJob.join()
}

import kotlinx.coroutines.*
 
fun main() = runBlocking {
    val parentJob = coroutineContext[Job]!!
    println("父 Job: $parentJob")
 
    launch {
        val childJob = coroutineContext[Job]!!
        println("子 Job: $childJob")
        println("子 Job 是父 Job 吗? ${childJob === parentJob}")
        // 输出: false  ← 子协程有自己的 Job
 
        println("子 Job 的 parent 是父 Job 吗? ${childJob.parent === parentJob}")
        // 输出: true  ← 但 parent 指向父 Job
    }
}

import kotlinx.coroutines.*
 
fun main() = runBlocking {
    val externalJob = Job() // 创建一个独立的 Job
 
    // 危险！传入外部 Job 会打破父子关系
    launch(externalJob) {
        println("这个协程的 parent 不再是 runBlocking 的 Job")
        println("parent: ${coroutineContext[Job]?.parent}")
        // parent 是 externalJob，而不是 runBlocking 的 Job
        // 这意味着 runBlocking 无法等待这个协程完成
        // 也无法通过取消 runBlocking 来取消这个协程
    }
 
    // 正确做法：如果需要自定义 Job，使用 SupervisorJob(parent)
    launch(SupervisorJob(coroutineContext[Job])) {
        println("这个协程保持了结构化并发")
        // parent 仍然关联到 runBlocking 的 Job 层级中
    }
 
    delay(100)
    externalJob.cancel() // 需要手动管理外部 Job 的生命周期
}

import kotlinx.coroutines.*
 
// 自定义上下文元素：用于演示自定义 Key
class RequestId(val id: String) : AbstractCoroutineContextElement(RequestId) {
    // 伴生对象作为 Key
    companion object Key : CoroutineContext.Key<RequestId>
    override fun toString(): String = "RequestId($id)"
}
 
fun main() = runBlocking(CoroutineName("Root") + RequestId("REQ-001")) {
    // 第一层：Root 协程
    // 上下文 = Job(BlockingCoroutine) + CoroutineName("Root") + RequestId("REQ-001")
    printContext("Root")
 
    launch(CoroutineName("Layer1")) {
        // 第二层：继承 RequestId，覆盖 CoroutineName
        // 上下文 = 新Job(parent=Root的Job) + CoroutineName("Layer1") + RequestId("REQ-001")
        printContext("Layer1")
 
        launch(Dispatchers.IO) {
            // 第三层：继承 CoroutineName("Layer1") 和 RequestId，新增 Dispatchers.IO
            // 上下文 = 新Job(parent=Layer1的Job) + Dispatchers.IO + CoroutineName("Layer1") + RequestId("REQ-001")
            printContext("Layer2-IO")
        }
 
        launch(CoroutineName("Layer2-Custom") + RequestId("REQ-002")) {
            // 第三层：覆盖 CoroutineName 和 RequestId
            // 上下文 = 新Job + CoroutineName("Layer2-Custom") + RequestId("REQ-002")
            printContext("Layer2-Custom")
        }
    }
 
    delay(200) // 等待所有子协程完成
}
 
// 辅助函数：打印当前协程的上下文信息
suspend fun printContext(label: String) {
    val ctx = currentCoroutineContext() // 获取当前挂起函数所在的协程上下文
    println("=== $label ===")
    println("  Name: ${ctx[CoroutineName]}")
    println("  RequestId: ${ctx[RequestId]}")
    println("  Dispatcher: ${ctx[ContinuationInterceptor]}")
    println("  Job: ${ctx[Job]}")
    println("  Job.parent: ${ctx[Job]?.parent}")
    println()
}

import kotlinx.coroutines.*
import kotlin.coroutines.AbstractCoroutineContextElement
import kotlin.coroutines.CoroutineContext
 
// 自定义元素：携带用户身份信息
class UserContext(val userId: String, val role: String)
    : AbstractCoroutineContextElement(UserContext) {
    // 伴生对象实现 Key 接口，保证全局唯一
    companion object Key : CoroutineContext.Key<UserContext>
    override fun toString(): String = "UserContext(userId=$userId, role=$role)"
}
 
// 自定义元素：携带链路追踪 ID
class TraceContext(val traceId: String)
    : AbstractCoroutineContextElement(TraceContext) {
    companion object Key : CoroutineContext.Key<TraceContext>
    override fun toString(): String = "TraceContext($traceId)"
}
 
// 模拟业务函数：从上下文中读取用户信息
suspend fun fetchUserData(): String {
    // 在任意挂起函数中都可以访问上下文元素
    val user = currentCoroutineContext()[UserContext]
        ?: throw IllegalStateException("缺少 UserContext")
    val trace = currentCoroutineContext()[TraceContext]
 
    println("[${trace?.traceId}] 正在为用户 ${user.userId}(${user.role}) 加载数据...")
    delay(100) // 模拟网络请求
    return "用户 ${user.userId} 的数据"
}
 
fun main() = runBlocking {
    // 将自定义上下文注入协程
    launch(UserContext("U-1024", "admin") + TraceContext("TRACE-abc-123")) {
        val data = fetchUserData()
        println("获取结果: $data")
    }
 
    // 不同用户的协程，上下文完全隔离
    launch(UserContext("U-2048", "viewer") + TraceContext("TRACE-def-456")) {
        val data = fetchUserData()
        println("获取结果: $data")
    }
}

// CoroutineScope 的完整定义，就这么简单
public interface CoroutineScope {
    public val coroutineContext: CoroutineContext
}

import kotlinx.coroutines.*
 
fun main() = runBlocking {
    // 手动创建一个自定义 Scope
    val myScope = CoroutineScope(
        SupervisorJob() +                    // 独立的根 Job
        Dispatchers.IO +                     // 默认在 IO 线程池
        CoroutineName("MyScope") +           // 命名
        CoroutineExceptionHandler { _, e ->  // 异常处理
            println("MyScope 捕获异常: ${e.message}")
        }
    )
 
    // 在自定义 Scope 中启动协程
    myScope.launch {
        // 继承了 Dispatchers.IO、CoroutineName("MyScope")、ExceptionHandler
        println("运行在: ${coroutineContext[CoroutineName]}")
        println("调度器: ${coroutineContext[ContinuationInterceptor]}")
    }
 
    delay(100)
 
    // Scope 的生命周期管理：取消 Scope 会取消所有子协程
    myScope.cancel()
}

import kotlinx.coroutines.*
 
fun main() = runBlocking {
    launch(Dispatchers.Default + CoroutineName("Traveler")) {
        // 第一段：运行在 Default 线程池
        println("[${Thread.currentThread().name}] 挂起前")
 
        // 切换到 IO 调度器
        withContext(Dispatchers.IO) {
            // withContext 会临时替换调度器，但保留其他上下文元素
            println("[${Thread.currentThread().name}] IO 中")
            println("名称仍然是: ${coroutineContext[CoroutineName]}")
            // 输出: CoroutineName(Traveler)  ← 名称被保留
        }
 
        // 恢复到 Default 线程池
        println("[${Thread.currentThread().name}] 恢复后")
    }
}

import kotlinx.coroutines.*
 
// 模拟 Android ViewModel 中的协程使用
class MyViewModel {
    // viewModelScope 的上下文通常是:
    // SupervisorJob() + Dispatchers.Main.immediate
    private val viewModelScope = CoroutineScope(
        SupervisorJob() + Dispatchers.Main // 模拟 Android 的 viewModelScope
    )
 
    fun loadData() {
        // 在 Main 线程启动协程（继承 viewModelScope 的调度器）
        viewModelScope.launch {
            // 此处运行在 Main 线程，可以安全更新 UI
            showLoading()
 
            // 切换到 IO 线程执行网络请求
            val result = withContext(Dispatchers.IO) {
                // 此处运行在 IO 线程池
                fetchFromNetwork()
            }
 
            // 自动回到 Main 线程，更新 UI
            updateUI(result)
        }
    }
 
    fun onCleared() {
        // 取消 Scope 会取消所有子协程
        viewModelScope.cancel()
    }
 
    // 模拟函数
    private fun showLoading() = println("显示加载中...")
    private suspend fun fetchFromNetwork(): String {
        delay(500)
        return "网络数据"
    }
    private fun updateUI(data: String) = println("更新UI: $data")
}

import kotlinx.coroutines.*
 
fun main() = runBlocking(CoroutineName("Parent") + Dispatchers.Default) {
    // 不传参数 = 使用 EmptyCoroutineContext
    launch {
        // 完全继承父上下文的 CoroutineName 和 Dispatchers.Default
        println("名称: ${coroutineContext[CoroutineName]}")
        // 输出: CoroutineName(Parent)
 
        println("调度器: ${coroutineContext[ContinuationInterceptor]}")
        // 输出: Dispatchers.Default
    }
 
    // 显式传入 EmptyCoroutineContext，效果完全相同
    launch(EmptyCoroutineContext) {
        println("名称: ${coroutineContext[CoroutineName]}")
        // 输出: CoroutineName(Parent)
    }
}

fun main() = runBlocking(Dispatchers.Default + CoroutineName("Root")) {
    launch(CoroutineName("Outer")) {
        launch(Dispatchers.IO) { // ← inner
            println("Dispatcher: ${coroutineContext[ContinuationInterceptor]}")
            println("Name: ${coroutineContext[CoroutineName]}")
        }
    }
}

import kotlinx.coroutines.*
 
fun main() = runBlocking {
    // 打印当前可用处理器核心数，决定了 Default 调度器的线程数
    println("CPU 核心数: ${Runtime.getRuntime().availableProcessors()}")
 
    // 启动多个 CPU 密集型协程
    val jobs = List(10) { i ->
        // 使用 Dispatchers.Default 调度器
        launch(Dispatchers.Default) {
            // 模拟 CPU 密集型计算（如排序、加密、数学运算）
            var sum = 0L
            // 大量纯计算操作
            for (j in 1..10_000_000) {
                sum += j
            }
            // 打印执行线程，观察线程复用情况
            println("协程 #$i 完成, sum=$sum, 线程=${Thread.currentThread().name}")
        }
    }
    // 等待所有协程完成
    jobs.forEach { it.join() }
}

import kotlinx.coroutines.*
import java.io.File
 
fun main() = runBlocking {
    // 并发读取多个文件，使用 IO 调度器
    val fileNames = listOf("config.txt", "data.csv", "log.txt")
 
    val contents = fileNames.map { name ->
        // async + Dispatchers.IO：并发执行阻塞式文件读取
        async(Dispatchers.IO) {
            println("开始读取 $name, 线程=${Thread.currentThread().name}")
            // 模拟阻塞式 IO 操作
            Thread.sleep(1000) // 假装在读文件
            println("完成读取 $name, 线程=${Thread.currentThread().name}")
            "内容来自 $name" // 返回文件内容
        }
    }
 
    // 收集所有结果
    contents.forEach { deferred ->
        println(deferred.await())
    }
}