一个 Worker 的一生 —— runWorker() 与 WorkerState 状态机

22 阅读5分钟

一个 Worker 的一生 —— runWorker() 与 WorkerState 状态机

阅读源码版本:kotlinx.coroutines 1.10.x

前言

上一篇文章,我们已经知道:

CoroutineScheduler 通过:

  • CPU Permit
  • createdWorkers
  • blockingTasks

控制整个线程池的并发度。

但是还有一个问题。

Scheduler 明明已经知道:

当前还有多少 CPU Worker

为什么还要维护:

enum class WorkerState {

    CPU_ACQUIRED,

    BLOCKING,

    PARKING,

    DORMANT,

    TERMINATED
}

这些状态?

直到真正读懂 runWorker() 我才发现:

整个 CoroutineScheduler,其实就是一个巨大的状态机。

WorkerState 不是为了描述 Worker。

而是为了告诉 Scheduler:

这个 Worker 下一步应该做什么。


runWorker() 是整个 Scheduler 的心脏

如果只能选择一个函数代表 CoroutineScheduler。

我会选择:

runWorker()

原因很简单。

Scheduler 所有设计。

最后都会汇聚到这里。

几乎整个 Worker 生命周期都发生在:

while (true) {

    task = findTask()

    executeTask(task)

}

看起来非常普通。

但是:

整个 CoroutineScheduler 最核心的思想。

全部藏在:

findTask()

executeTask()

里面。


一个 Worker 的生命周期

我更喜欢把 Worker 看成一个人。

每天上班。

它会不断重复下面几个动作。

寻找工作

↓

开始工作

↓

工作结束

↓

继续寻找工作

如果一直找不到工作。

那么:

休息

↓

继续寻找工作

如果 Scheduler 决定裁员。

那么:

退出

整个生命周期。

其实就是:

          +---------------+
          |               |
          |               ▼
      找 Task ------> 执行 Task
          ▲               |
          |               |
          |               ▼
      被唤醒 <------- Park
          |
          ▼
     Terminated

整个 Scheduler。

实际上一直围绕这个循环工作。


Worker 第一步:寻找 Task

Worker 最重要的工作。

其实不是执行 Task。

而是:

寻找 Task。

源码中:

对应:

findTask(...)

上一篇已经介绍过。

寻找顺序大致如下:

LocalQueue

↓

GlobalQueue

↓

Steal

↓

Park

为什么:

LocalQueue 放第一?

原因很简单。

它几乎没有竞争。

速度最快。

Cache 命中率最高。

如果 LocalQueue 没有。

才会访问 GlobalQueue。

如果 GlobalQueue 也没有。

最后:

尝试:

Work Stealing

只有所有地方都没有任务。

Worker 才会真正进入休眠。


为什么需要 PARKING?

很多人第一次看到:

PARKING

都会觉得:

不就是 Thread.sleep() 吗?

其实完全不是。

Scheduler 并不希望 Worker 真正退出。

因为:

创建线程是非常昂贵的。

假设,现在没有任务。如果Worker立即退出,几毫秒以后新的 Task 又来了。

Scheduler 又需要:

创建线程

↓

启动线程

↓

初始化

代价很高。

因此:

Scheduler 更希望:

Worker

↓

暂时休眠

↓

等待唤醒

于是:

就有了:

PARKING

状态。

可以理解为:

待命。


CPU_ACQUIRED 到底是什么?

上一篇。

我们介绍了 CPU Permit。

只有拿到 Permit。

Worker 才允许执行:

NonBlockingTask

因此。

Worker 获得 Permit 后。

状态变成:

CPU_ACQUIRED

很多人第一次看到这个状态。

会误以为:

Worker 正在执行 CPU Task。

其实不是。

准确来说。

应该理解成:

这个 Worker 拥有执行 CPU Task 的资格。

注意。

这里是:

资格

而不是:

正在执行

两者完全不同。


BLOCKING 状态

接下来。

Worker 执行:

BlockingTask

例如:

socket.read()

或者:

Thread.sleep()

那么Worker会进入:

BLOCKING

与此同时。

它会:

释放 CPU Permit

为什么?

因为:

Scheduler 已经认为:

这个 Worker 暂时不会参与 CPU 计算。

Permit 应该交给别人。

于是,其他 Worker就有机会继续执行CPU Task。

整个 Scheduler 的 CPU 并行度保持稳定。


executeTask() 中那个奇怪的 assert

阅读源码时。

很多人都会看到:

if (state == WorkerState.PARKING) {

    assert { task.isBlocking }

    state = WorkerState.BLOCKING

}

第一次看到这里我也很疑惑。

为什么这里一定要:

assert(task.isBlocking)

后来。

整个 Scheduler 串起来以后。

这个判断就变得非常自然。

因为一个 Worker 如果已经进入:

PARKING

再次被唤醒。

并且没有重新获得 CPU Permit。

那么它只能执行:

BlockingTask

否则,就违反了CPU Permit 的设计。

所以这里实际上是在验证 Scheduler 自己维护的状态是否正确。

它不是业务判断而是整个状态机的一次自检。


DORMANT 为什么存在?

还有一个容易被忽略的状态:

DORMANT

很多文章甚至不会介绍它。

其实它表示:

Worker目前没有 Task。

但是还没有真正进入:

PARKING

可以理解成一种:

准备休眠

的中间状态。

Scheduler会根据系统负载决定:

继续工作

还是

真正 Park

这样可以减少:

频繁:

Park

↓

Unpark

带来的系统调用开销。


TERMINATED

最后。

Worker 生命周期结束。

进入:

TERMINATED

之后Scheduler不会再把 Task 放进它的:

LocalQueue

如果其他线程继续 dispatch,Task 会进入:

GlobalQueue

等待新的 Worker。


WorkerState 本质是什么?

看到这里我终于理解了一件事情:

WorkerState并不是描述:

Worker 是谁。

而是描述:

Scheduler 接下来应该怎样对待这个 Worker。

例如:

CPU_ACQUIRED

↓

允许执行 CPU Task
BLOCKING

↓

释放 Permit
PARKING

↓

等待唤醒
TERMINATED

↓

彻底移除

整个 CoroutineScheduler实际上就是不断推动

WorkerState

发生转换。

这也是为什么我认为CoroutineScheduler本质上就是一个状态机。


总结

如果把整个 CoroutineScheduler 浓缩成一句话。

我会这样描述:

Scheduler 并不是在调度 Task,而是在不断推动一群 Worker 在不同状态之间转换。

Task:

只是触发状态变化的事件。真正被调度的其实一直都是:

WorkerState

理解这一点之后。

再回头阅读:

  • runWorker()
  • executeTask()
  • findTask()

几乎所有代码都会变得顺理成章。

因为它们真正维护的不是线程不是队列而是整个 Scheduler 的状态机。

下一篇,我们将进入 CoroutineScheduler 最后一部分源码:

dispatch() 为什么优先进入 LocalQueue?

为什么 submitToLocalQueue() 有那么多失败条件?

以及:

CoroutineScheduler 为什么不像 ForkJoinPool 那样完全依赖 Work Stealing?