我们接触协程，往往会有如下疑问，本文一一解答
- 异步是怎么实现的，即执行权是怎么转移的？
- 挂起函数执行完毕后是怎么恢复现场，继续执行后续代码的？
- 协程里面各部分代码都在哪个线程上执行？
一、协程的简单使用示例
注意看注释，各部分代码在哪个线程上执行
// 使用调度器启动一个协程
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()方法恢复执行
