重新认识 CoroutineContext
之前研究 Kotlin 协程的时候,我们经常会看到 CoroutineContext:
coroutineContext[Job]
coroutineContext[ContinuationInterceptor]
一开始我把它简单理解成“协程上下文”,但真正去看源码之后,我觉得把它理解成协程的运行环境更加贴切。
因为协程运行时需要知道很多信息,比如它属于哪个 Job、应该在哪个 Dispatcher 上执行、叫什么名字、异常应该如何处理。这些信息都可以放在 CoroutineContext 中。
CoroutineContext 到底是什么
CoroutineContext 本身只是一个接口:
public interface CoroutineContext {
...
}
它并不关心具体保存的是什么信息。
真正放进 Context 中的是一个个 Element:
public interface Element : CoroutineContext {
public val key: Key<*>
}
这里有个挺有意思的设计:Element 自己也是 CoroutineContext。
常见的 Context Element 包括:
Job
CoroutineDispatcher
CoroutineName
CoroutineExceptionHandler
所以我们可以把一个协程的 Context 粗略理解成:
CoroutineContext
├── Job
├── Dispatcher
├── CoroutineName
└── CoroutineExceptionHandler
每个 Element 都有一个 Key,Context 可以通过这个 Key 找到对应的 Element:
coroutineContext[Job]
可以理解成:
从当前协程的运行环境中,找到 Job。
至于 Context 内部究竟是如何保存和查找这些 Element 的,并不是使用 CoroutineContext 时最需要关注的事情。对我们来说,更重要的是它会随着协程的创建参与到子协程的运行环境中。
子协程会继承父协程的 Context
最直观的例子就是:
withContext(
Dispatchers.IO + CoroutineName("parent")
) {
coroutineScope {
launch {
// 子协程
}
}
}
父协程的 Context 中包含:
Dispatchers.IO
CoroutineName("parent")
Job
当 launch 创建子协程时,子协程会以父协程的 Context 为基础创建自己的 Context。
可以用代码验证一下:
suspend fun testContext() {
withContext(
Dispatchers.IO + CoroutineName("parent")
) {
coroutineScope {
println("parent dispatcher: ${coroutineContext[ContinuationInterceptor]}")
println("parent name: ${coroutineContext[CoroutineName]}")
println("parent job: ${coroutineContext[Job]}")
launch {
println("child dispatcher: ${coroutineContext[ContinuationInterceptor]}")
println("child name: ${coroutineContext[CoroutineName]}")
println("child job: ${coroutineContext[Job]}")
}
}
}
}
运行后可以看到类似这样的结果:
parent dispatcher: Dispatchers.IO
parent name: CoroutineName(parent)
parent job: ScopeCoroutine{Active}@...
child dispatcher: Dispatchers.IO
child name: CoroutineName(parent)
child job: StandaloneCoroutine{Active}@...
这里出现了一个很有意思的现象。
子协程的 Dispatcher 和 CoroutineName 都延续了父协程的 Context。
但是 Job 不一样。
父协程是:
ScopeCoroutine
子协程却是:
StandaloneCoroutine
它们是两个不同的 Job。
这说明:
子协程虽然会继承父协程的 Context,但 Job 并不是简单地继承父协程的 Job。
Job 是一个特殊的 Context Element
我们前面已经知道:
interface Job : CoroutineContext.Element
所以 Job 确实是 Context 中的一个 Element。
但是在创建子协程时,Job 的处理方式比较特殊。
我们重新看一下 launch 创建协程的大致过程:
val newContext = newCoroutineContext(context)
val coroutine =
StandaloneCoroutine(newContext, active = true)
进入 AbstractCoroutine 后,可以看到:
init {
if (initParentJob) {
initParentJob(parentContext[Job])
}
}
override val context: CoroutineContext =
parentContext + this
这里实际上做了两件事情。
首先:
parentContext[Job]
从父 Context 中找到父 Job。
然后:
initParentJob(parentJob)
把这个 Job 建立成当前 Job 的父 Job。
与此同时:
parentContext + this
又把当前这个新创建出来的协程对象加入自己的 Context。
而 StandaloneCoroutine 本身就是一个 Job。
所以最终关系实际上是:
父协程 Context
└── Parent Job
│
│ parent
↓
Child Job
│
↓
子协程 Context
因此,Job 的“继承”并不是:
父 Job
↓
子协程继续使用同一个 Job
而是:
父 Job
↓
作为 parent
↓
创建新的 Child Job
这也是协程能够形成父子层级的基础。
CoroutineContext 真正解决了什么问题
现在再回头看 CoroutineContext,我觉得它的作用就清楚很多了。
它不是一个简单的参数集合,而是:
协程的运行环境。
当我们创建子协程时,父协程的 Context 会参与构造子协程的 Context。这样一来,Dispatcher、名称等运行环境信息可以自然地延续到子协程,而 Job 则通过“新的 Job + 父 Job”的方式建立协程之间的层级关系。
所以我们之前看到的:
coroutineContext[Job]
并不只是从某个容器里拿一个对象。
它背后连接的是整个协程的运行环境,以及协程之间的父子关系。
至于这个新的 Job 是如何维护状态、如何完成、如何取消,以及取消如何沿着父子关系传播,就要进入下一个问题:
重新认识 Job。