重新认识 CoroutineContext

10 阅读3分钟

重新认识 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。