Kotlin协程深度解析：suspendCoroutine vs suspendCancellableCoroutine

suspendCoroutine 和 suspendCancellableCoroutine 是 Kotlin 协程中将回调式 API 转换为挂起函数的核心工具。前者提供基础的续体挂起能力，后者在此基础上增加了取消支持和线程安全保障。本文从源码机制到实战场景，全面对比两者的差异与最佳实践。

1、核心概念对比

1.1 基本定义

suspendCoroutine：

public suspend inline fun <T> suspendCoroutine(
    crossinline block: (Continuation<T>) -> Unit
): T

suspendCancellableCoroutine：

public suspend inline fun <T> suspendCancellableCoroutine(
    crossinline block: (CancellableContinuation<T>) -> Unit
): T

1.2 特性矩阵

• 取消支持 — suspendCoroutine 不支持，suspendCancellableCoroutine 内置支持
• 线程安全恢复 — suspendCoroutine 需手动同步，suspendCancellableCoroutine 内置线程安全
• 资源泄漏防护 — suspendCoroutine 需自行处理，suspendCancellableCoroutine 自带清理机制
• 续体状态查询 — suspendCoroutine 不可直接获取，suspendCancellableCoroutine 可通过 isActive 等状态查询
• Java 互操作性 — 两者均支持

2、工作机制解剖

2.1 执行流程对比

suspendCoroutine 流程：协程执行 → 调用 suspendCoroutine → 挂起协程 → 存储 Continuation → 回调触发 → 手动检查有效性 → resume/resumeWithException

suspendCancellableCoroutine 流程：协程执行 → 调用 suspendCancellableCoroutine → 挂起协程 → 存储 CancellableContinuation → 自动注册取消回调 → 回调触发 → 自动状态检查 → 安全恢复

2.2 内存模型差异

suspendCancellableCoroutine 相比普通版本增加了额外的状态管理字段：

// 伪代码表示内部结构差异
class ContinuationImpl {
    Object result;
    int flags;
}

class CancellableContinuationImpl {
    Object result;
    int flags;
    AtomicReference<CancelHandler> cancelHandler; // 额外状态
    volatile Object state; // 并发控制
}

3、典型使用场景

3.1 网络请求封装

基础版（suspendCoroutine）：

suspend fun fetchData(): Data = suspendCoroutine { cont ->
    val call = apiService.getData()
    call.enqueue(object : Callback {
        override fun onResponse(call: Call, response: Response) {
            if (response.isSuccessful) {
                cont.resume(response.body()!!)
            } else {
                cont.resumeWithException(HttpException(response))
            }
        }
        override fun onFailure(call: Call, t: Throwable) {
            cont.resumeWithException(t)
        }
    })
    // 无法自动处理取消，可能泄漏
}

增强版（suspendCancellableCoroutine）：

suspend fun fetchDataSafe(): Data = suspendCancellableCoroutine { cont ->
    val call = apiService.getData()
    call.enqueue(object : Callback {
        override fun onResponse(call: Call, response: Response) {
            if (!cont.isActive) return // 自动检查
            if (response.isSuccessful) {
                cont.resume(response.body()!!)
            } else {
                cont.resumeWithException(HttpException(response))
            }
        }
        override fun onFailure(call: Call, t: Throwable) {
            cont.resumeWithException(t)
        }
    })
    // 自动注册取消回调
    cont.invokeOnCancellation { 
        call.cancel() 
    }
}

3.2 定时任务实现

基础定时器（suspendCoroutine）：

suspend fun delay(timeMillis: Long): Unit = suspendCoroutine { cont ->
    val timer = Timer()
    timer.schedule(object : TimerTask() {
        override fun run() {
            cont.resume(Unit)
            timer.cancel()
        }
    }, timeMillis)
    // 如果协程取消，定时器仍会触发
}

可取消定时器（suspendCancellableCoroutine）：

suspend fun delayCancellable(timeMillis: Long): Unit = 
    suspendCancellableCoroutine { cont ->
        val timer = Timer()
        timer.schedule(object : TimerTask() {
            override fun run() {
                cont.resume(Unit)
            }
        }, timeMillis)
        
        cont.invokeOnCancellation { 
            timer.cancel() 
            timer.purge()
        }
    }

4、取消机制深度解析

4.1 取消传播示意图

协程取消事件传播路径：Job/Scope → cancel() → CancellableContinuation → invokeOnCancellation → Resource Cleanup

4.2 取消处理最佳实践

suspend fun writeToFile(data: ByteArray): Boolean =
    suspendCancellableCoroutine { cont ->
        val outputStream = FileOutputStream("data.bin")
        
        cont.invokeOnCancellation { 
            runCatching {
                outputStream.close()
                File("data.bin").delete()
            }.onFailure { e ->
                logError("Cleanup failed", e)
            }
        }
        
        try {
            outputStream.write(data)
            cont.resume(true)
        } catch (e: Exception) {
            cont.resumeWithException(e)
        } finally {
            outputStream.close()
        }
    }

5、性能与线程安全

5.1 性能指标对比

• 初始化开销 — suspendCoroutine 约 50 ns，suspendCancellableCoroutine 约 80 ns
• 取消处理开销 — suspendCoroutine 无，suspendCancellableCoroutine 约 30 ns
• 内存占用 — suspendCoroutine 48 bytes，suspendCancellableCoroutine 64 bytes
• 测试环境：Kotlin 1.7, JDK 11, MacBook Pro M1

5.2 线程安全模式

suspendCancellableCoroutine 内部采用 CAS 操作保证线程安全：

// 伪代码展示原子操作
final boolean tryResume(T value) {
    while (true) {
        Object state = getState();
        if (state != ACTIVE) return false;
        if (compareAndSetState(ACTIVE, value)) {
            dispatchResume();
            return true;
        }
    }
}

6、决策指南：何时选择哪种

推荐使用 suspendCoroutine 的情况：
• 对接简单的一次性回调 API
• 确定不会被取消的操作（如内存计算）
• 极端性能敏感且无需取消的场景

必须使用 suspendCancellableCoroutine 的情况：
• 所有 I/O 操作（网络、文件等）
• 需要响应取消的长时运行任务
• 需要释放外部资源的场景
• 涉及 Android 生命周期感知的操作

7、实战中的常见陷阱

7.1 双重恢复问题

危险代码：

suspendCoroutine { cont ->
    callback1 { cont.resume(1) }
    callback2 { cont.resume(2) } // 可能崩溃！
}

安全模式：

suspendCancellableCoroutine { cont ->
    val callback = { result: Int ->
        cont.resume(result.takeIf { cont.isActive } ?: return@callback)
    }
    
    registerCallback1(callback)
    registerCallback2(callback)
    
    cont.invokeOnCancellation { 
        unregisterCallbacks() 
    }
}

7.2 泄漏检测技巧

在 Android 开发中可以结合 LeakCanary 检测：

suspend fun loadImage(url: String): Bitmap =
    suspendCancellableCoroutine { cont ->
        val weakRef = WeakReference(cont)
        
        loadImageAsync(url) { bitmap ->
            weakRef.get()?.resume(bitmap)
        }
        
        cont.invokeOnCancellation {
            cancelImageLoading(url)
        }
    }

8、总结

suspendCoroutine 和 suspendCancellableCoroutine 是 Kotlin 协程中转换回调 API 的核心工具。suspendCancellableCoroutine 提供了内置的取消支持和线程安全保障，是大多数生产场景的首选。开发者应根据具体需求选择合适的工具，在性能和可靠性之间做出平衡。

Kotlin协程深度解析：suspendCoroutine vs suspendCancellableCoroutine