从一次凌晨告警说起:CPU 在烧,进度为零

凌晨两点,某采集服务的告警群炸了:负责落盘的实时线程本该每 20 毫秒醒一次,实际间隔却飙到了半秒,CPU 利用率倒是很高。登上机器一看,抢占最高频的是一个后台压缩任务(优先级不高但一直能跑),而真正该跑的实时线程在等一把锁,锁的持有者是个被压得抬不起头的低优先级线程。三个角色凑齐了,教科书式的优先级反转现场:高优先级被中优先级间接地、无限期地拖住了。
这个问题的诡异之处在于,它不违反任何单一组件的正确性。低优先级持锁没有错,中优先级抢占就绪任务没有错,高优先级等待锁也没有错——但三者组合起来,就构成了「中优先级的运行时间决定了高优先级等多久」的死局。普通调度器对此无能为力,因为调度器只看谁就绪、谁的优先级高,完全不知道「持锁」这件事改变了优先级的本来含义。解药必须是把锁与调度打通,这正是优先级继承的出发点。
优先级反转的三种面孔
第一种是最基本的无界反转:低优先级任务 L 持有锁,高优先级任务 H 阻塞在锁上,此时中优先级任务 M 变成就绪——它不需要锁,但它的存在让 L 无法运行,锁永远交不出去,H 的等待时间由 M 的运行时间决定,理论上无界。这是最常见也最容易被误诊的形态:现场看起来是「H 卡住了」,其实真凶是 M。
第二种是传递式反转,链式等待让问题向纵深发展:H 等 L1 上的锁,L1 的持有者又在等 L2 上的锁,L2 的持有者是最底层那个被压制的小角色。要救活 H,必须把「该跑的紧迫感」沿着锁链一路传下去,中间任何一环断了,链条顶端照样饿死。这种形态在多层锁嵌套的中间件里并不罕见,而且排查难度远高于第一种。
第三种是 convoy 型:一组等优先级的任务轮流持有同一把锁,任何一环的延迟都会累积成整队人马的长尾。它不必然无界,但在实时系统里同样致命,因为实时系统要的不是平均快,而是每次都快。
Mars Pathfinder 1997:一场远程救火的教科书
优先级反转的知名度,很大程度来自 1997 年 7 月的火星探路者事故。着陆器上的任务系统里,一个低优先级任务负责把气象数据写上信息总线,写之前持有一把互斥锁;一个中优先级的通信任务偶尔抢占它;而全系统优先级最高的总线管理任务要拿那把锁才能工作。总线管理任务迟迟不运行,看门狗判定系统失能,触发整机重启。工程组在地面实验室里用同样的硬件和任务集复现了故障,最终确认问题、并通过远程命令给那把锁打开优先级继承修复了它——据当时参与复盘的工程师回忆,故障期间着陆器前后共重启了 18 次。
这个案例留下了两个至今仍然成立的教训。其一,故障是概率性的:中优先级任务多久抢到一次 CPU、低优先级持锁窗口多长,都带随机性,导致问题在地面测试里藏了好几周,上了火星才爆发——带锁的实时系统必须显式处理反转,靠测试覆盖率兜不住这类时序问题。其二,修复手段就是今天 Linux 里那套机制的前身:把等待者的优先级临时「借」给持锁者,让锁尽快交出来。
Linux 的答案:rt_mutex 与等待链
内核里实现优先级继承的组件是 rt_mutex(实时互斥体,代码在 kernel/locking/ 下),它是内核自用实时锁与 PI futex 共同的底座。数据结构上有两棵树配合工作:每把 rt_mutex 挂一棵按优先级排序的等待者树,谁的优先级高谁排在前面;每个任务身上还挂着 pi_waiters——「所有等在我持有的锁上的等待者」聚合成的树。一个任务的有效优先级,取自身静态优先级与它身上所有等待者里的最高者优先级,哪个高用哪个。
当高优先级任务阻塞在某把 rt_mutex 上时,内核把等待者插入该锁的等待者树,然后沿着 owner 指针找到持锁任务,把它的有效优先级抬高到等待者的水平——这就是继承。继承是沿着锁链传递的:持锁者自己如果又阻塞在另一把锁上,它被抬高的优先级会作为「新的等待者优先级」继续向上传递,rt_mutex_adjust_prio_chain 一类的链式行走函数负责这段遍历,顺带做死锁检测——链条走回已经见过的任务就说明死锁,直接报错而不是原地转圈。
解锁时执行反向操作,通常称为去传递:锁交给等待者树里优先级最高的那个,原持有者重新计算自身有效优先级——如果身上还有其他等待者,就回落到剩余等待者的最高优先级;没有任何等待者则回到自己的静态优先级。一升一降两个方向合起来,保证「紧急的事总能借到跑动的权利」,又不留下永久性的虚高优先级。
flowchart TD
A["高优先级 H<br/>阻塞在锁 mutex_a 上"] --> B["内核把 H 插入 mutex_a<br/>的等待者树"]
B --> C["顺 owner 找到持锁者 L<br/>把 L 的有效优先级抬到 H 的档位"]
C --> D["中优先级 M 就绪<br/>但 L 已经和 H 一样高<br/>M 抢不过 L"]
D --> E["L 继续跑完临界区<br/>顺利解锁"]
E --> F["锁交给队首等待者 H<br/>L 去传递:回落到静态优先级"]
F --> G["H 接管执行<br/>M 从头到尾没能插队"]
FUTEX_LOCK_PI:把继承搬到用户态锁上
用户态要享受这套机制,靠的是 futex 家族里的 PI 分支:FUTEX_LOCK_PI(op 值 6)、FUTEX_UNLOCK_PI(op 值 7)、FUTEX_TRYLOCK_PI(op 值 8),以及与 requeue 配对的实时版本 FUTEX_WAIT_REQUEUE_PI(op 值 11)与 FUTEX_CMP_REQUEUE_PI(op 值 12)。与普通 futex 最大的差异在于:普通 WAIT 只管睡与醒,而 LOCK_PI 在睡眠的同时把调用者的实时优先级登记进内核等待链,持锁者因此被抬升。glibc 里通过 pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT) 初始化的 mutex,其加锁路径就会落到这些 op 上。
PI futex 的锁字协议也与普通 futex 不同,它不再用 0/1/2 编码,而是直接把持锁者的线程 ID 编进 futex 字:低位放 owner 的 TID,最高位作等待者标志位。这个设计很聪明——TID 是内核里全局唯一的,等于把「这把锁归谁」这件事写在了用户态可见的地方,用户态调试器读一眼锁字就知道是谁在持锁;内核在 LOCK_PI 时也靠它做无竞争快路径:如果锁字是 0,原子换上自己的 TID 就算拿锁成功。有竞争时则进入内核,把自己挂进 rt_mutex 的等待者树并触发继承。解锁侧持锁者把锁字换回 0,若有等待者标志则由内核挑最高优先级者转手——注意 PI 路径下锁的所有权是内核直接转交的,不像普通 futex 那样醒来后还得回用户态重新抢。
代价也要如实交代。PI 路径比普通 futex 多做了不少事:维护等待者树、行走继承链、必要时改任务优先级并重排实时队列。无竞争快路径仍然很轻(用户态原子交换即可),但一旦进入内核竞争路径,开销明显高于普通 WAIT。所以工程惯例是:只有确实存在实时线程共享的锁才用 PI mutex,普通线程池的锁用 PI 是白白付费。
用 PTHREAD_PRIO_INHERIT 修一次真实抖动
动手修之前,先确认诊断。优先级反转的现场证据可以这样收集:chrt -p <pid> 查看目标线程的调度类与实时优先级;grep prio /proc/<pid>/sched 看内核视角的有效优先级——如果某低优先级线程的 prio 长时间等于另一个高优先级线程的数值,说明继承正在生效(或曾经生效);strace 里看到 op 值为 6 的 futex 调用(LOCK_PI)即可确认走的 PI 路径。最后用 cyclictest 之类的延迟测量工具给出前后对比,把「抖动消失了」变成可复现的数字。
回到开头的采集服务:落盘线程与合成线程都是 SCHED_FIFO,它们共享帧队列上的一把锁;后台压缩任务是 SCHED_OTHER 的普通线程,偶尔会把某个刚拿到锁的 FIFO 低优先级线程挤下去。修复代码非常短:
#define _GNU_SOURCE
#include <errno.h>
#include <pthread.h>
#include <sched.h>
#include <stdio.h>
#include <string.h>
static pthread_mutex_t frame_lock;
int init_lock(void) {
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
int rc = pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);
if (rc) {
printf("PI not supported: %s\n", strerror(rc));
return rc;
}
rc = pthread_mutex_init(&frame_lock, &attr);
pthread_mutexattr_destroy(&attr);
return rc;
}
void producer_enter(void) {
pthread_mutex_lock(&frame_lock);
/* 持锁期间若有更高优先级的 FIFO 线程阻塞在此锁上,
本线程会被内核临时抬到对方档位,压缩任务插不了队 */
}
void producer_exit(void) {
pthread_mutex_unlock(&frame_lock);
/* 解锁触发去传递:优先级回落 */
}
改动前后用 cyclictest 一类的工具量最大延迟,效果一目了然:改前最大延迟数百毫秒,改后收窄到与临界区时长同量级。另一个同样典型的场景在自动驾驶或工业控制中间件里:感知、融合、控制三级流水线各自持有不同的锁并且互相嵌套,形成传递链,打开 PI 之后继承沿链传递,控制环路的 deadline miss 从偶发归零。两处的共同点是——锁的持有窗口本身并不长,坏就坏在「持锁者跑不动」,这正是继承机制擅长修的病。
边界与误区:继承不是万能药
- 优先级继承只对实时调度类有完整意义。SCHED_FIFO 与 SCHED_RR 的任务之间存在严格的优先级序,抬高才有明确语义;对 SCHED_OTHER 的普通任务,PI futex 也能工作,但「优先级」在 CFS 世界里只是权重,反转问题本身也弱得多,通常不值得为此上 PI 锁。
- 继承救不了「持锁者卡在内核里做无关的事」。持锁做磁盘 IO、持锁等网络回包,等待者把持锁者抬到天上去,它也得等 IO 回来才能解锁。PI 解决的是被调度压制,不是被 IO 阻塞。
- 解锁交给等待者树里最高优先级的那一个,但 PI 并不保证全局的锁获取顺序公平,嵌套多把 PI 锁时仍需自己保证加锁顺序,死锁该发生还是会发生——好在 rt_mutex 的链式行走附带死锁检测,能把它变成报错而不是挂死。
- 实时任务全速运行会饿死系统其余部分,内核用实时节流兜底:
/proc/sys/kernel/sched_rt_runtime_us默认给每秒留出 50 毫秒给普通任务(默认值 950000 微秒、周期 1000000 微秒)。某些「实时线程偶尔卡顿」的怪象,其实是节流在起作用,别急着怀疑优先级继承。 PTHREAD_PRIO_PROTECT(优先级天花板协议)在 glibc 上长期返回不支持,工程实践里基本只会用到 PTHREAD_PRIO_INHERIT,别照着教科书硬套天花板方案。
收个尾:优先级反转是「锁的状态污染了调度决策」的病,优先级继承是「让调度决策看见锁的状态」的药。Linux 把这套药方做进了 rt_mutex 与 futex 的 PI 分支,应用层一行 setprotocol 就能用上。判断该不该用它的标准很简单:只要有多于一个实时线程会碰同一把锁,就用 PI mutex;只要没有,就省下这份开销。下一篇我们把视线从锁的公平转向内存的公平——RCU,一种读侧零开销的同步艺术。
读者留言
COMMENTS 暂无还没有留言,来说第一句?