kotlin 协程（Coroutine）

cnflyhz

已于 2025-06-25 10:47:25 修改

阅读量1k

点赞数 12

CC 4.0 BY-SA版权

文章标签： kotlin 开发语言 android

于 2025-06-25 10:46:40 首次发布

本文链接：https://blog.youkuaiyun.com/pengyu1801/article/details/148893160

Coroutine（协程）的转换原理：

在 kotlin 中，Coroution 是一种轻量级的线程管理方式，其转换原理涉及 状态机生成、挂起函数转换和调度器机制。

一、协程的本质：状态机

kotlin 协程通过 编译器生成状态机 实现。（当你编写一个挂起函数（suspend））或协程体时，编译器会将其转换为一个状态机类。

示例代码

kotlin

suspend fun fetchData() {
    val data = loadFromNetwork() // 挂起点 1
    processData(data)          // 挂起点 2
}

编译后等价代码（简化版）

java

// 编译器生成的状态机类
final class FetchDataKt$fetchData$1 extends SuspendLambda implements Function2<Unit, Continuation<? super Unit>, Object> {
    int label;                // 当前状态
    Object result;            // 中间结果
    String data;              // 局部变量
    
    FetchDataKt$fetchData$1(Continuation<? super Unit> completion) {
        super(2, completion);
    }
    
    @Override
    public final Object invokeSuspend(Object $result) {
        this.result = $result;
        this.label |= Integer.MIN_VALUE;
        
        // 根据状态跳转到不同代码段
        switch (label) {
            case 0: // 初始状态
                // 执行 loadFromNetwork()
                return loadFromNetwork(this);
                
            case 1: // 恢复状态 1
                data = (String) result;
                processData(data);
                return Unit.INSTANCE;
                
            default:
                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
        }
    }
}

二、挂起函数的转换

挂起函数（suspend）的关键在于 保存和恢复执行状态：

挂起点（Suspension Point）：
当协程遇到挂起函数（如 delay()、withContext()）时，会：
- 保存当前状态（局部变量、执行位置）到状态机。
- 返回到调用者（不会阻塞线程）。
恢复执行：
当挂起条件满足（如网络请求完成）时，通过 Continuation.resume() 恢复状态机：
- 恢复局部变量和执行位置。
- 从挂起点继续执行。

三、协程调度器（CoroutineDispatcher）

协程通过 调度器 决定在哪个线程上执行：

常见调度器

Dispatchers.Main：Android 主线程，用于 UI 操作。
Dispatchers.IO：IO 优化的线程池，适合网络 / 文件操作。
Dispatchers.Default：CPU 密集型任务的默认线程池。
newSingleThreadContext()：创建专用单线程。

调度器工作原理

协程启动：

GlobalScope.launch(Dispatchers.IO) {
    val data = fetchData() // 在 IO 线程执行
    withContext(Dispatchers.Main) {
        updateUI(data)     // 切换到主线程
    }
}

线程切换实现：

withContext() 是一个挂起函数，会：

保存当前状态。
将任务提交到目标调度器的线程。
在新线程恢复执行。

四、协程与线程的关系

特性	协程	线程
创建成本	极低（约 2KB 内存）	高（约 1MB 栈空间）
调度方式	协作式（由协程自己决定何时挂起）	抢占式（由操作系统调度）
切换开销	极小（仅状态机跳转）	高（上下文切换涉及内核操作）
数量限制	可创建数百万个	通常限制在数千个
阻塞影响	仅阻塞当前协程	阻塞整个线程

五、关键组件与机制

1. Continuation

协程的核心接口，定义了恢复执行的方法：

interface Continuation<in T> {
    val context: CoroutineContext
    fun resumeWith(result: Result<T>)
}

编译器会为每个协程生成 Continuation 的实现。

2. Job

协程的生命周期控制器，可用于取消、检查状态：
```
val job = launch { ... }
job.cancel() // 取消协程
```

3. CoroutineContext

存储协程的上下文信息（如调度器、异常处理器）：
```
val scope = CoroutineScope(Dispatchers.IO + Job())
```

六、优化与调试建议

避免阻塞调度器线程：

// 错误：在 IO 调度器中执行 CPU 密集型任务
withContext(Dispatchers.IO) {
    heavyCalculation() // 应使用 Dispatchers.Default
}

使用协程作用域（CoroutineScope）：
避免内存泄漏，自动管理协程生命周期：
```
class MyViewModel : ViewModel() {
    fun fetchData() = viewModelScope.launch { ... }
}
```
调试工具：
- 使用 runBlocking { ... } 在测试中阻塞主线程。
- 通过 LoggingInterceptor 记录协程调度过程。