Kotlin 协程深度解析：suspend 函数与状态机转换内幕

// 原始 Kotlin 代码
suspend fun fetchUser(id: Long): User {
    val user = api.getUser(id)  // 挂起点 #1
    return process(user)       // 返回值
}

// 编译后等价状态机（伪代码）
class FetchUserContinuation : Continuation<User> {
    var label: Int = 0   // 状态机当前状态
    var result: User? = null
    var user: User? = null  // 局部变量保存
    var params: Long? = null
}

public final class FetchUserContinuation implements Continuation<User> {
    int label;                              // 状态机指针
    Object result;                          // 协程结果/异常
    long userId;                            // 参数保存
    User user;                             // 局部变量保存
    Continuation<User> $completion;

    @Nullable
    public Object invokeSuspend(Object result) {
        this.result = result;
        switch (this.label) {
            case 0:   // 初始状态
                if (result == Intrinsics.getOrDefault(result, Intrinsics.getDisposableInterval())) {
                    return Intrinsics.sentinel();
                }
                this.userId = this.userId;
                this.label = 1;      // 设置下一个状态
                Result userResult = Api.getUser(this.userId, this);
                if (userResult == Intrinsics.getOrDefault(userResult, Intrinsics.getDisposableInterval())) {
                    return Intrinsics.sentinel(); // 挂起
                }
                result = userResult;
            case 1:   // 恢复点
                this.user = (User) result;
                User var3 = process(this.user);
                return var3;
        }
        throw new IllegalStateException();
    }
}

// 编译器的挂起判断逻辑
Object suspendPoint(Object result) {
    if (result == Intrinsics.sentinel()) {
        return Intrinsics.sentinel();  // 真正挂起，返回 COROUTINE_SUSPENDED
    }
    return result;  // 已完成，直接返回
}

// 每个 suspend 调用后都有这段判断
Object callResult = suspendFunction(params, continuation);
if (callResult == Intrinsics.sentinel()) {
    return Intrinsics.sentinel();  // 挂起并退出
}

suspend fun complexOperation(): Result {
    val data1 = fetchData1()   // 挂起点 #1 → label 变为 1
    val data2 = fetchData2()   // 挂起点 #2 → label 变为 2
    return merge(data1, data2)
}

// 编译后 label 有 0→1→2→3 四个状态
switch(this.label) {
    case 0: // 起始
    case 1: // fetchData1 恢复
    case 2: // fetchData2 恢复
}

public interface Continuation<in T> {
    // 协程上下文，包含调度器、异常处理器等
    public val context: CoroutineContext

    // 恢复协程执行，resumeWith 即 resume(T) 或 resumeWithException
    // 被调用后，状态机进入下一个 case 分支
    public fun resumeWith(result: Result<T>)

    // 扩展函数：简化调用
    public fun resume(value: T) = resumeWith(Result.success(value))
    public fun resumeWithException(exception: Throwable) =
        resumeWith(Result.failure(exception))
}

// Kotlin 标准库中的四大协程上下文元素
public object EmptyCoroutineContext : CoroutineContext {}

public interface CoroutineContext {
    operator fun get(key: CoroutineContext.Key<*>): CoroutineContext.Element?
    operator fun minusKey(key: CoroutineContext.Key<*>): CoroutineContext
    operator fun plus(context: CoroutineContext): CoroutineContext
}

// 常见上下文元素
Dispatchers.Default   // CPU 密集型共用池
Dispatchers.IO       // IO 密集型专用池
Dispatchers.Main      // UI 主线程（Android）
CoroutineName("myCoroutine")
CoroutineExceptionHandler { ... }

// launch { fetchUser(1L) } 的执行流程
launch(Dispatchers.IO) {
    // launch 创建了 SuspendLambda/Functions 类型的 Continuation
    // 状态机 label=0，启动执行
}

// 内部调用链:
launch()
  → CoroutineScope.launch { ... }
    → DispatchedCoroutine.resumeWith()
      → ContinuationHolder.invokeSuspend()
        → 状态机执行到第一个 suspend 调用
          → api.getUser(id, continuation)  // 可能挂起
            → 挂起则返回 SUSPENDED
              → dispatch YieldComplete
                → carrier thread 被释放

// 恢复流程:
// 当 IO 完成回调触发 continuation.resume(result) 时
// 状态机从 label=1 继续执行

// 10万个并发任务的内存估算

// Java Thread: 每个 1MB 栈 + 堆对象头
// 100,000 threads × 1MB = ~100GB native 内存

// Kotlin Coroutine: 栈在堆上，初始约 64 字节
// 100,000 coroutines × 64 bytes = ~6.4MB 堆内存
// + 少量 Continuation 对象开销（~200 bytes each）
// 总计约 ~26MB

// 结论: 协程内存效率是线程的 4000 倍

// 正确的结构化并发
CoroutineScope(Dispatchers.IO).launch {
    val job = launch {
        try {
            val result = fetchData()
            process(result)
        } catch (e: CancellationException) {
            // 协程被取消，清理资源
        }
    }
    // job.cancel() 会取消子协程
    // 或 scope.cancel() 取消整个作用域
}

// 错误模式：全局协程（线程泄漏风险）
private val scope = GlobalScope  // ❌ 不推荐