一个 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?