协程基础 ⭐⭐

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 个线程 —— 大概率崩溃
    val threads = List(100_000) {
        thread {
            Thread.sleep(1000L) // 每个线程睡眠 1 秒（真正占用线程）
            print(".")
        }
    }
    threads.forEach { it.join() }
}

// 传统回调写法 —— 嵌套层层递进，形成"回调地狱"
fun loadDashboard() {
    // 第一层：登录
    loginService.login("user", "pass", object : Callback<Token> {
        override fun onSuccess(token: Token) {
            // 第二层：获取用户信息
            userService.getUser(token, object : Callback<User> {
                override fun onSuccess(user: User) {
                    // 第三层：获取订单列表
                    orderService.getOrders(user.id, object : Callback<List<Order>> {
                        override fun onSuccess(orders: List<Order>) {
                            // 终于拿到数据了...
                            updateUI(user, orders) // 更新 UI
                        }
                        override fun onFailure(e: Exception) {
                            showError(e) // 第三层错误处理
                        }
                    })
                }
                override fun onFailure(e: Exception) {
                    showError(e) // 第二层错误处理
                }
            })
        }
        override fun onFailure(e: Exception) {
            showError(e) // 第一层错误处理
        }
    })
}

// 协程写法 —— 看起来完全是同步的顺序代码
suspend fun loadDashboard() {
    try {
        // 第一步：登录（挂起，等待网络响应）
        val token = loginService.login("user", "pass")
        // 第二步：获取用户信息（挂起，等待网络响应）
        val user = userService.getUser(token)
        // 第三步：获取订单列表（挂起，等待网络响应）
        val orders = orderService.getOrders(user.id)
        // 三步全部完成，更新 UI
        updateUI(user, orders)
    } catch (e: Exception) {
        // 统一错误处理 —— 任意一步失败都会走到这里
        showError(e)
    }
}

// 编译器生成的状态机伪代码（简化版）
fun loadDashboard(continuation: Continuation<Unit>) {
    // label 记录当前执行到了哪一步
    val sm = continuation as? LoadDashboardSM ?: LoadDashboardSM(continuation)
 
    when (sm.label) {
        0 -> {
            sm.label = 1  // 标记：下次恢复时跳到 case 1
            // 调用 login()，如果它挂起了，就直接 return（释放线程）
            val result = loginService.login("user", "pass", sm)
            if (result == COROUTINE_SUSPENDED) return
        }
        1 -> {
            val token = sm.result as Token  // 从上次挂起中恢复，拿到结果
            sm.label = 2  // 标记：下次恢复时跳到 case 2
            val result = userService.getUser(token, sm)
            if (result == COROUTINE_SUSPENDED) return
        }
        2 -> {
            val user = sm.result as User    // 拿到用户信息
            sm.label = 3
            val result = orderService.getOrders(user.id, sm)
            if (result == COROUTINE_SUSPENDED) return
        }
        3 -> {
            val orders = sm.result as List<Order> // 拿到订单
            updateUI(user, orders)                // 全部完成
        }
    }
}

import kotlinx.coroutines.*
 
fun main() = runBlocking {
 
    // ========== 阻塞示例 ==========
    println("[阻塞] 开始 - ${Thread.currentThread().name}")
    Thread.sleep(2000L)  // 线程被占用 2 秒，期间无法做任何其他事
    println("[阻塞] 结束 - ${Thread.currentThread().name}")
 
    // ========== 非阻塞挂起示例 ==========
    println("[挂起] 开始 - ${Thread.currentThread().name}")
    delay(2000L)         // 协程挂起 2 秒，线程被释放去执行其他协程
    println("[挂起] 结束 - ${Thread.currentThread().name}")
}

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

// 你写的代码
suspend fun fetchUser(): User { ... }
 
// 编译器实际生成的签名（简化）
fun fetchUser(continuation: Continuation<User>): Any? { ... }

import kotlinx.coroutines.*
 
fun main() = runBlocking {
    // 在同一个线程上启动两个协程
    launch {
        println("协程A: 开始工作 [${Thread.currentThread().name}]")
        delay(1000L)  // A 挂起，线程释放
        println("协程A: 恢复工作 [${Thread.currentThread().name}]")
    }
 
    launch {
        println("协程B: 开始工作 [${Thread.currentThread().name}]")
        delay(500L)   // B 挂起，线程释放
        println("协程B: 恢复工作 [${Thread.currentThread().name}]")
    }
 
    println("主协程: 两个子协程已启动 [${Thread.currentThread().name}]")
}

主协程: 两个子协程已启动 [main]
协程A: 开始工作 [main]
协程B: 开始工作 [main]
协程B: 恢复工作 [main]    ← 500ms 后 B 先恢复
协程A: 恢复工作 [main]    ← 1000ms 后 A 恢复

import kotlinx.coroutines.*
import kotlin.system.measureTimeMillis
 
fun main() {
    // ========== 协程版本：启动 10 万个协程 ==========
    val coroutineTime = measureTimeMillis {
        runBlocking {
            // 使用 List 创建 100,000 个协程
            val jobs = List(100_000) {
                launch {
                    delay(1000L)  // 挂起 1 秒，不阻塞线程
                }
            }
            jobs.forEach { it.join() }  // 等待所有协程完成
        }
    }
    println("协程版本耗时: ${coroutineTime}ms")  // 约 1 秒多一点
 
    // ========== 线程版本：启动 10 万个线程 ==========
    val threadTime = measureTimeMillis {
        val threads = List(100_000) {
            Thread {
                Thread.sleep(1000L)  // 阻塞线程 1 秒
            }
        }
        threads.forEach { it.start() }  // 启动所有线程
        threads.forEach { it.join() }   // 等待所有线程完成
    }
    println("线程版本耗时: ${threadTime}ms")  // 极慢，甚至可能 OOM
}

// 线程模型：阻塞等待
fun fetchDataBlocking(): String {
    // 当前线程被阻塞，在等待网络响应的整个过程中
    // 这个线程完全无法做其他任何事情
    val response = httpClient.execute(request)  // ⛔ 线程在此阻塞
    return response.body()
}

import kotlinx.coroutines.*
 
fun main() = runBlocking {
    // 获取当前线程名称的辅助打印
    println("主协程开始, 线程: ${Thread.currentThread().name}")
 
    // 启动协程 A
    val jobA = launch(Dispatchers.Default) {
        println("协程A 开始工作, 线程: ${Thread.currentThread().name}")
        delay(2000L)  // ✅ 挂起协程，释放线程！线程可去干别的事
        // 恢复后可能在不同的线程上
        println("协程A 恢复执行, 线程: ${Thread.currentThread().name}")
    }
 
    // 启动协程 B
    val jobB = launch(Dispatchers.Default) {
        println("协程B 开始工作, 线程: ${Thread.currentThread().name}")
        delay(1000L)  // ✅ 挂起协程，释放线程！
        println("协程B 恢复执行, 线程: ${Thread.currentThread().name}")
    }
 
    // 等待两个协程都完成
    jobA.join()
    jobB.join()
    println("全部完成")
}

// ===== 挂起前：协程状态在线程栈上 =====
//
//  线程 A 的栈                        堆内存 (Heap)
//  ┌──────────────┐               ┌───────────────────┐
//  │ localVar = 42│──── 挂起 ───→ │ Continuation 对象  │
//  │ progress = 7 │               │  ├ localVar = 42   │
//  │ label = 0    │               │  ├ progress = 7    │
//  └──────────────┘               │  └ label = 1       │
//  线程 A 被释放，                  └───────────────────┘
//  可以去执行其他协程                  状态安全保存
//
// ===== 恢复后：可能在不同线程上 =====
//
//  线程 B 的栈                        堆内存 (Heap)
//  ┌──────────────┐               ┌───────────────────┐
//  │ localVar = 42│←── 恢复 ────  │ Continuation 对象  │
//  │ progress = 7 │               │  (数据读回栈)       │
//  │ label = 1    │               └───────────────────┘
//  └──────────────┘
//  在线程 B 上继续执行

// ❌ 回调地狱示例：层层嵌套，可读性极差
 
// 第一层：登录请求
loginService.login(username, password, object : Callback<Token> {
    override fun onSuccess(token: Token) {
        // 第二层：用 Token 获取用户信息
        userService.getUserInfo(token, object : Callback<UserInfo> {
            override fun onSuccess(userInfo: UserInfo) {
                // 第三层：用用户 ID 获取订单列表
                orderService.getOrders(userInfo.id, object : Callback<List<Order>> {
                    override fun onSuccess(orders: List<Order>) {
                        // 第四层：终于拿到数据，更新 UI
                        runOnUiThread {
                            displayOrders(orders)  // 显示订单
                        }
                    }
                    override fun onFailure(e: Exception) {
                        showError("获取订单失败: ${e.message}")  // 错误处理 3
                    }
                })
            }
            override fun onFailure(e: Exception) {
                showError("获取用户信息失败: ${e.message}")  // 错误处理 2
            }
        })
    }
    override fun onFailure(e: Exception) {
        showError("登录失败: ${e.message}")  // 错误处理 1
    }
})

// ✅ 协程版本：清晰的顺序结构
 
// 在 ViewModel 或合适的协程作用域中启动
viewModelScope.launch {
    try {
        // 第一步：登录（suspend 函数，挂起等待结果）
        val token = loginService.login(username, password)
 
        // 第二步：获取用户信息（拿到 token 后继续）
        val userInfo = userService.getUserInfo(token)
 
        // 第三步：获取订单列表（拿到 userInfo 后继续）
        val orders = orderService.getOrders(userInfo.id)
 
        // 第四步：更新 UI（如果在 Dispatchers.Main 上就可以直接更新）
        displayOrders(orders)
 
    } catch (e: Exception) {
        // ✅ 统一的错误处理！任何一步失败都会被捕获
        showError("操作失败: ${e.message}")
    }
}

// ========================================
// 优势 1：并发请求同样简洁
// ========================================
 
viewModelScope.launch {
    try {
        val token = loginService.login(username, password)
 
        // 两个请求并发执行！使用 async 同时发起
        val userInfoDeferred = async { userService.getUserInfo(token) }   // 并发请求 1
        val settingsDeferred = async { userService.getSettings(token) }   // 并发请求 2
 
        // 同时等待两个结果（总耗时 = max(请求1时间, 请求2时间)）
        val userInfo = userInfoDeferred.await()     // 获取用户信息结果
        val settings = settingsDeferred.await()     // 获取设置结果
 
        // 两个结果都拿到后，更新 UI
        updateUI(userInfo, settings)
 
    } catch (e: Exception) {
        // 任何一个请求失败都能被统一捕获
        showError(e.message)
    }
}
 
// ========================================
// 优势 2：超时控制极其简单
// ========================================
 
viewModelScope.launch {
    try {
        // withTimeout 会在超时后自动取消协程并抛出 TimeoutCancellationException
        val result = withTimeout(5000L) {   // 5 秒超时
            apiService.fetchData()           // 挂起等待
        }
        displayData(result)
    } catch (e: TimeoutCancellationException) {
        showError("请求超时，请重试")  // 超时处理
    } catch (e: Exception) {
        showError("请求失败: ${e.message}")  // 其他异常处理
    }
}
 
// ========================================
// 优势 3：取消操作自动传播
// ========================================
 
// 当 ViewModel 被销毁时（如 Activity 销毁）
// viewModelScope 会自动取消所有子协程
// 不需要手动管理回调的注销——再也不会有内存泄漏！

// launch 的简化签名
public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext, // 协程上下文，可指定调度器等
    start: CoroutineStart = CoroutineStart.DEFAULT,    // 启动模式，默认立即调度
    block: suspend CoroutineScope.() -> Unit            // 协程体：一个挂起 Lambda
): Job                                                  // 返回 Job 对象，用于控制生命周期

import kotlinx.coroutines.*
 
fun main() = runBlocking {
    // 在 runBlocking 提供的 CoroutineScope 中启动一个新协程
    val job: Job = launch {
        // 这里是协程体，运行在协程环境中
        println("协程开始执行，当前线程: ${Thread.currentThread().name}")
        delay(1000L)  // 挂起 1 秒，不会阻塞线程
        println("协程恢复执行")
    }
 
    println("launch 调用后立即执行到这里，不会等待协程完成")
 
    job.join() // 显式等待协程执行完毕（挂起当前协程，而非阻塞线程）
    println("协程已完成")
}

launch 调用后立即执行到这里，不会等待协程完成
协程开始执行，当前线程: main
协程恢复执行
协程已完成

fun main() = runBlocking {
    val job = launch {
        repeat(1000) { i ->
            println("工作中: $i")
            delay(500L) // 每 500ms 打印一次
        }
    }
 
    delay(1300L)               // 主协程等待 1.3 秒
    println("准备取消协程...")
    job.cancel()               // 发出取消信号（协程进入 Cancelling 状态）
    job.join()                 // 等待取消流程走完（进入 Cancelled 状态）
    // cancel() + join() 可以合并为：job.cancelAndJoin()
    println("协程已被取消")
}

工作中: 0
工作中: 1
工作中: 2
准备取消协程...
协程已被取消

fun main() = runBlocking {
    // LAZY 模式：创建后不会自动启动
    val lazyJob = launch(start = CoroutineStart.LAZY) {
        println("我是懒启动的协程，现在才开始执行!")
    }
 
    println("协程已创建，但尚未启动")
    delay(1000L) // 等一秒，证明协程确实没有自动启动
 
    lazyJob.start() // 显式启动
    delay(100L)      // 给协程一点执行时间
    println("结束")
}

public fun <T> CoroutineScope.async(
    context: CoroutineContext = EmptyCoroutineContext, // 同 launch，可指定调度器
    start: CoroutineStart = CoroutineStart.DEFAULT,    // 同 launch，支持 LAZY 等模式
    block: suspend CoroutineScope.() -> T              // 协程体的最后一个表达式就是返回值
): Deferred<T>                                         // 返回 Deferred，可通过 await() 取值

import kotlinx.coroutines.*
 
fun main() = runBlocking {
    // async 启动协程，Lambda 最后一行表达式即为返回值
    val deferred: Deferred<String> = async {
        delay(1000L) // 模拟耗时操作
        "Hello from async!" // 这就是返回值（类型自动推断为 String）
    }
 
    println("async 已启动，等待结果...")
 
    // await() 是挂起函数——它挂起当前协程，直到 async 协程完成并返回结果
    val result: String = deferred.await()
    println("拿到结果: $result")
}

async 已启动，等待结果...
拿到结果: Hello from async!

// ❌ 串行写法：总耗时 = 1s + 1.5s + 0.5s = 3s
suspend fun loadPageSerially() {
    val user = fetchUser()          // 耗时 1s
    val orders = fetchOrders()      // 耗时 1.5s
    val recommend = fetchRecommend() // 耗时 0.5s
    render(user, orders, recommend)
}

// ✅ 并发写法：总耗时 = max(1s, 1.5s, 0.5s) = 1.5s
suspend fun loadPageConcurrently() = coroutineScope {
    // 三个 async 同时启动，并发执行
    val userDeferred = async { fetchUser() }           // 立即启动
    val ordersDeferred = async { fetchOrders() }       // 立即启动
    val recommendDeferred = async { fetchRecommend() } // 立即启动
 
    // 三个 await 收集结果，总耗时取决于最慢的那个
    val user = userDeferred.await()
    val orders = ordersDeferred.await()
    val recommend = recommendDeferred.await()
 
    render(user, orders, recommend)
}

fun main() = runBlocking {
    val deferred = async {
        delay(500L)
        throw RuntimeException("async 内部出错了!") // 异常发生在这里
        "永远不会返回"
    }
 
    // 这一行正常执行，异常还没有暴露
    println("async 已启动")
 
    try {
        // await() 调用时，异常被重新抛出（rethrown）
        deferred.await()
    } catch (e: RuntimeException) {
        println("捕获到异常: ${e.message}")
    }
}

public fun <T> runBlocking(
    context: CoroutineContext = EmptyCoroutineContext, // 可选的上下文
    block: suspend CoroutineScope.() -> T              // 协程体
): T                                                   // 直接返回结果（不是 Deferred）

import kotlinx.coroutines.*
 
// main 函数本身不是协程环境，但 runBlocking 创建了一个
fun main() = runBlocking {
    // runBlocking 的 Lambda 就是一个 CoroutineScope
    // 在这里可以自由调用挂起函数
    println("开始: ${Thread.currentThread().name}")
 
    delay(1000L) // 挂起协程 1 秒（但 main 线程被 runBlocking 阻塞住）
 
    println("结束: ${Thread.currentThread().name}")
}
// 整个 main 函数耗时约 1 秒

fun main() = runBlocking {
    // launch 子协程 1
    launch {
        delay(200L)
        println("子协程 A 完成")
    }
 
    // launch 子协程 2
    launch {
        delay(100L)
        println("子协程 B 完成")
    }
 
    // async 子协程 3
    val result = async {
        delay(300L)
        42 // 返回计算结果
    }
 
    println("等待所有子协程...")
    println("async 结果: ${result.await()}")
    // runBlocking 会自动等待 launch 的子协程
    // 不需要手动 join
}

等待所有子协程...
子协程 B 完成
子协程 A 完成
async 结果: 42

fun main() = runBlocking {
    launch {
        delay(200L)
        println("A")
    }
 
    val result = async {
        delay(100L)
        println("B")
        "Kotlin"
    }
 
    println("C")
    println(result.await())
    println("D")
}

// 一个最简单的挂起函数
suspend fun fetchUserName(): String {
    delay(1000L) // delay 本身也是挂起函数，模拟耗时操作
    return "Claude"
}

// 编译器在参数列表末尾"偷偷"加了一个 Continuation 参数
// 返回值类型也变成了 Object（因为可能返回 COROUTINE_SUSPENDED 标记）
public final Object fetchUserName(Continuation<? super String> $completion) {
    // ... 状态机代码 ...
}

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

// 源码：包含两个挂起点的函数
suspend fun loadData(): String {
    val token = fetchToken()   // 挂起点 1
    val data = fetchData(token) // 挂起点 2
    return data
}

// 编译器生成的状态机伪代码
fun loadData(continuation: Continuation<String>): Any? {
    // sm 是编译器生成的 Continuation 子类实例，持有状态和局部变量
    val sm = continuation as? LoadDataContinuation
        ?: LoadDataContinuation(continuation) // 首次调用时包装
 
    when (sm.label) {
        0 -> {
            sm.label = 1                         // 设置下一个恢复点为状态 1
            val result = fetchToken(sm)          // 将自身传入作为回调
            if (result == COROUTINE_SUSPENDED)   // 如果真的挂起了
                return COROUTINE_SUSPENDED       // 向上传播挂起信号
            // 如果没有挂起（直接返回了结果），继续往下执行
        }
        1 -> {
            val token = sm.result as String      // 从续体中恢复上一步的结果
            sm.label = 2                         // 设置下一个恢复点为状态 2
            val result = fetchData(token, sm)    // 再次传入自身
            if (result == COROUTINE_SUSPENDED)
                return COROUTINE_SUSPENDED
        }
        2 -> {
            return sm.result as String           // 最终结果，返回给调用者
        }
    }
}

// ❌ 编译错误！普通函数中不能调用挂起函数
fun main() {
    val name = fetchUserName() // Error: Suspend function 'fetchUserName'
                               // should be called only from a coroutine or
                               // another suspend function
}
 
// ✅ 正确：在协程构建器中调用
fun main() = runBlocking {
    val name = fetchUserName() // OK，runBlocking 的 lambda 就是挂起上下文
    println(name)
}
 
// ✅ 正确：在另一个挂起函数中调用
suspend fun greetUser() {
    val name = fetchUserName() // OK，当前函数本身就是 suspend
    println("Hello, $name")
}

编译前：suspend fun fetchUserName(): String
编译后：fun fetchUserName(cont: Continuation<String>): Any?

// ⚠️ 这个函数虽然是 suspend，但内部没有任何挂起操作
// 它会在调用者所在的线程上直接同步执行！
suspend fun computeHash(input: String): String {
    // 这里只有 CPU 密集计算，没有调用任何挂起函数
    return MessageDigest.getInstance("SHA-256")
        .digest(input.toByteArray())
        .joinToString("") { "%02x".format(it) }
}

// ✅ 正确做法：使用 withContext 明确指定调度器
suspend fun computeHash(input: String): String =
    withContext(Dispatchers.Default) {      // 切到 Default 线程池（适合 CPU 密集型）
        MessageDigest.getInstance("SHA-256")
            .digest(input.toByteArray())
            .joinToString("") { "%02x".format(it) }
    }

// ========== 阻塞方式 ==========
fun fetchDataBlocking(): String {
    Thread.sleep(2000) // 🔴 当前线程被冻结 2 秒，完全无法做其他事
    return "data"
}
 
// ========== 挂起方式（非阻塞） ==========
suspend fun fetchDataSuspending(): String {
    delay(2000) // 🟢 协程挂起 2 秒，但线程立即被释放去处理其他任务
    return "data"
}

import kotlinx.coroutines.*
 
fun main() = runBlocking {
    // 启动 10 万个协程，每个挂起 1 秒后打印一个点
    val jobs = List(100_000) {
        launch {
            delay(1000L) // 挂起，不阻塞线程
            print(".")
        }
    }
    jobs.forEach { it.join() } // 等待所有协程完成
    println("\n全部完成！")
}
// ✅ 轻松运行，内存占用极小（几十 MB），几秒内完成

fun main() {
    // 启动 10 万个线程，每个阻塞 1 秒
    val threads = List(100_000) {
        thread {
            Thread.sleep(1000L) // 阻塞线程
            print(".")
        }
    }
    threads.forEach { it.join() }
    println("\n全部完成！")
}
// ❌ 大概率抛出 OutOfMemoryError！
// 每个线程默认占约 1MB 栈空间 → 10万线程 ≈ 100GB 内存

// delay 的简化实现原理
suspend fun delay(timeMillis: Long) {
    // suspendCancellableCoroutine 是创建挂起点的标准方式
    suspendCancellableCoroutine<Unit> { continuation ->
        // 1. 向调度器注册一个定时回调（类似 Handler.postDelayed）
        //    不占用任何线程！只是在时间堆里插了一条记录
        scheduler.scheduleResumeAfterDelay(timeMillis, continuation)
 
        // 2. 这个 lambda 返回后，当前函数返回 COROUTINE_SUSPENDED
        //    线程从协程的状态机中退出，去执行事件循环中的下一个任务
    }
    // 3. 定时器到期后，调度器调用 continuation.resume(Unit)
    //    协程的状态机从断点处恢复执行
}

// 挂起时的内存引用关系 (简化)
//
// ┌──────────────────────────────┐
// │       CoroutineScheduler     │   ← 调度器（管理线程池）
// │  ┌────────────────────────┐  │
// │  │  TimerHeap (时间堆)     │  │
// │  │  ┌──────────────────┐  │  │
// │  │  │ ResumeTask:       │  │  │
// │  │  │  - resumeTime     │──┼──┼──→ 到期后触发恢复
// │  │  │  - continuation ──┼──┼──┼──→ ┌─────────────────────┐
// │  │  └──────────────────┘  │  │    │  Continuation (书签)  │
// │  └────────────────────────┘  │    │  - label = 1          │
// └──────────────────────────────┘    │  - result = ...       │
//                                     │  - context (调度器等) │
//   ┌──────────────────────┐          └─────────────────────────┘
//   │  Worker Thread        │                    ▲
//   │  （已释放，正在执行    │                    │
//   │   其他协程的任务）     │     到期后调用 resumeWith()
//   └──────────────────────┘

import kotlinx.coroutines.*
 
fun main() = runBlocking {
    println("1: ${Thread.currentThread().name}")
    
    launch {
        println("2: ${Thread.currentThread().name}")
        delay(100)
        println("3: ${Thread.currentThread().name}")
    }
    
    println("4: ${Thread.currentThread().name}")
}

// ========== 1. launch ==========
val job: Job = scope.launch(Dispatchers.Default) {
    // 协程体：不返回有意义的值
    // 异常会立即传播给父级
    heavyComputation()
}
job.cancel()  // 取消协程
 
// ========== 2. async ==========
val deferred: Deferred<String> = scope.async(Dispatchers.IO) {
    // 协程体：最后一行表达式作为返回值
    fetchFromNetwork()          // 返回 String
}
val result: String = deferred.await()  // 挂起等待结果
 
// ========== 3. runBlocking ==========
fun main() = runBlocking {
    // 阻塞 main 线程，内部可使用 suspend 函数
    val data = async { loadData() }
    println(data.await())
}
 
// ========== 4. suspend 函数 ==========
suspend fun fetchUser(): User {
    // delay 是 suspend 函数，此处为挂起点
    delay(1000L)                // 挂起 1 秒，不阻塞线程
    return User("Kotlin")      // 恢复后继续执行
}

fun main() = runBlocking {
    val job = launch {
        println("A")
        delay(200)
        println("B")
    }
    println("C")
    delay(100)
    println("D")
    job.join()
    println("E")
}