kotlin协程实现原理梳理

我们接触协程，往往会有如下疑问，本文一一解答

1. 异步是怎么实现的，即执行权是怎么转移的？
2. 挂起函数执行完毕后是怎么恢复现场，继续执行后续代码的？
3. 协程里面各部分代码都在哪个线程上执行？

一、协程的简单使用示例

注意看注释，各部分代码在哪个线程上执行

// 使用调度器启动一个协程
launch(Dispatchers.IO) {
    // 这个代码块会在 dispatcher 的线程池中的一个线程上执行，假定是A
    print("A")

    // 调用一个挂起函数，如果内部实现没有切换执行线程，将仍旧在A线程上执行
    suspendFunction()

    // 当 suspendFunction 完成后，这个代码块会尽量在原来的A线程上恢复执行，但是有可能会是别的IO线程
    print("B")
}

二、 协程的几个关键对象

1. CoroutineScope接口

定义了协程的作用域，是生命周期管理的关键类，包含CoroutineContext

public interface CoroutineScope {
    public val coroutineContext: CoroutineContext
}

2. CoroutineContext

协程执行的上下文，上面提供了很多工具方法，比如包含一个调度器

3. 协程Coroutine

理解为一个任务，是job接口的一种实现

private open class StandaloneCoroutine(
    parentContext: CoroutineContext,
    active: Boolean
) : AbstractCoroutine<Unit>(parentContext, initParentJob = true, active = active) {
    override fun handleJobException(exception: Throwable): Boolean {
        handleCoroutineException(context, exception)
        return true
    }
}

4. 调度器CoroutineDispatcher

决定了协程任务在哪个线程上运行, 简化代码如下：

public abstract class CoroutineDispatcher {
     //分发任务到特定线程
     public abstract fun dispatch(context: CoroutineContext, block: Runnable)
}

• Dispatchers.Main：这个调度器用于在主线程中执行协程。这通常用于更新 UI 或者执行其他需要在主线程中执行的任务。如果你尝试在没有主线程的环境中使用它，比如后端应用，它会抛出异常。
• Dispatchers.IO：这个调度器用于执行 I/O 密集型任务，比如网络请求或者读写文件。它内部使用了一个用于 I/O 任务的线程池。
• Dispatchers.Default：这个调度器用于执行 CPU 密集型任务，比如复杂的计算或者排序操作。它内部使用了一个用于计算的线程池。
• Dispatchers.Unconfined：这个调度器有一个特殊的行为，协程会在调用它的线程立即执行，直到第一个挂起点。当协程被唤醒时，它会在唤醒它的线程继续执行

5. 协程创建器：launch, async等

可以看到创建器被定义成CoroutineScope的扩展函数

public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job {
    val newContext = newCoroutineContext(context)
    val coroutine = if (start.isLazy)
    LazyStandaloneCoroutine(newContext, block) else
    StandaloneCoroutine(newContext, active = true)
    coroutine.start(start, coroutine, block)
    return coroutine    
}

6. 挂起函数

不用多说，异步任务可以定义成挂起函数

三、协程实现原理展示

kotlin的很多特性都是用过编译器动态修改代码来实现，协程的实现原理也是一样，他通过把协程转换为一种状态机来转让执行权和恢复原来执行代码。

我们用一个简化形式的代码来理解这一点，注意看注释。

我们假定写了如下代码：

launch(Dispatchers.IO) { 
   print("A") 
   //这是一个挂起函数
   doSomething() 
   print("B") 
 } 

上述代码会被kotlin转化为：

//状态机类，很多文档也翻译成连续体
interface Continuation<T> {
    val context: CoroutineDispatcher fun resumeWith(result: Result<T>)
 }


//创建状态机类
val coroutine = object : Continuation<Unit> { 
    var label = 0 
    val coroutineDispatcher = XXX
    override fun resumeWith(result: Result<Unit>) { 
        //使用调度器来把任务分发到特定线程！！！
        coroutineDispatcher.dispatch(Runnable { 
          when (label) {
             0 -> { 
                print("A") 
                label = 1 
                doSomething(this) //注意：挂起函数被传入了额外参数，就是Continuation实例！！！
                } 
             1 -> { 
                print("B")  
                    } 
            } 
        } 
    } 
} 


fun doSomething(Continuation c){
    //原来异步逻辑....省略
    
    //执行完毕后调用连续体，恢复原来的执行流程
    c.resumeWith(XXX)
}

//启动协程 
coroutine.resumeWith(Result.success(Unit))

上述流程概括起来为3步：

• 在协程在编译的时候会被转化为一个状态机，实现Continuation接口，
• 挂起函数后面的代码内容会被塞入状态机的下一个状态分支
• Continuation实现类会被当做额外参数，传递给原来的挂起函数，挂起函数执行完毕后会继续调用Continuation.resumeWith()方法恢复执行