操作系统内功 · 第 65 篇|futex:从用户态自旋到内核等待队列

锁为什么贵:无竞争路径也在交「系统调用税」

futex 用户态快路径与内核等待队列协作机制图

在没有 futex 的年代,用户态互斥锁的每一次加锁都要陷入内核:不管这把锁当天有没有第二个人来抢,进程都得先付出一次系统调用的固定成本——特权级切换、寄存器保存恢复、以及随之而来的缓存与 TLB 扰动。而锁的真实使用分布是极度倾斜的:绝大多数加锁操作根本没有竞争,临界区短、持有者很快释放。为这种「大概率空手而过」的路径每次都跑一趟内核,等于让所有线程为少数几次冲突集体买单。futex(fast userspace mutex)在 Linux 2.6 时代进入主线,就是针对这个问题的专门设计:把锁的状态放进一个用户态可见的整数,无竞争时用一条原子指令解决,竞争真正发生时才进内核排队睡觉。

这套设计的精妙之处在于分界线的选取:用户态原子指令能解决的部分,一分钱内核成本都不付;原子指令解决不了的部分——「我要睡了,请在他解锁时叫醒我」——才交给内核。要理解 futex,就要同时理解这两侧:用户侧的那个整数怎么用,内核侧的等待队列怎么组织,以及两边如何配合才能不丢唤醒。这也决定了 futex 是所有上层同步原语的地基:glibc 的 mutex、条件变量、信号量,乃至实时版本的优先级继承锁,全部建在同一个系统调用上。

flowchart TD
    A["线程 A 尝试加锁"] --> B{"用户态 cmpxchg:<br/>锁字从 0 改成 1 成功吗"}
    B -- "成功" --> C["直接进临界区<br/>全程零系统调用"]
    B -- "失败,已有人持锁" --> D["syscall futex<br/>FUTEX_WAIT 传入期望值"]
    D --> E{"内核里锁字仍等于<br/>传入的期望值吗"}
    E -- "不等于,锁已释放" --> F["返回 EAGAIN<br/>回用户态重新抢"]
    E -- "相等" --> G["计算 futex_key<br/>桶锁内挂进等待队列<br/>schedule 睡眠"]
    H["线程 B 解锁<br/>cmpxchg 把锁字改回 0"] --> I{"这条 futex 上有人排队吗"}
    I -- "无人等待" --> J["结束<br/>解锁同样零系统调用"]
    I -- "有等待者" --> K["futex FUTEX_WAKE<br/>按 key 定位同一个桶"]
    K --> L["摘下队首等待者<br/>标记唤醒并触发调度"]

futex 的三层设计:一个整数、一次系统调用与一条等待队列

futex 的全部世界由三样东西构成。第一样是用户态的 futex 字:一个 4 字节对齐的 32 位整数,它就是锁状态本身,语义完全由使用者约定——glibc 的 mutex 用 0 表示空闲、1 表示持锁且无等待者、2 表示持锁且有人在排队。第二样是系统调用 futex(2),签名可以概括为 futex(uaddr, op, val, timeout, uaddr2, val3):uaddr 指向那个整数,op 决定做什么,val 与其余参数随 op 的不同而变化。第三样是内核里的等待队列:所有在同一个 futex 字上睡着的任务,按 key 归入全局哈希表的某个桶里。

glibc 并没有为 futex 提供封装函数,用户态要直接调 syscall(SYS_futex, ...)。这不是疏忽而是刻意:futex 是给库作者用的积木,不是给应用开发者直接拼装的轮子。应用层绕过 pthread 直接写 futex 同步逻辑,极容易在内存序与丢唤醒上翻车,正确的姿势是使用 pthread 库,把 futex 的细节留给 glibc 与 musl 去操心。

futex_key:把一个用户态地址变成内核里的身份

内核不能直接拿用户态指针当 key——两个进程的同一个虚拟地址可能指向不同的物理页,同一段共享内存又可能因为映射方式不同而算出不同的身份。所以 futex_wait 与 futex_wake 的第一步都是 get_futex_key:把 uaddr 归一化成一个内核态的 futex_key。对带 FUTEX_PRIVATE_FLAG(值 128)的私有 futex,key 由「当前进程的 mm 结构指针加页内偏移」构成,全程不需要碰页表,代价极低;不带该标志的共享 futex,key 由「所属映射背后的 inode 与页偏移」构成,需要查页表找出这段地址挂在哪里。这也解释了为什么私有模式更快:省掉了整个地址翻译与映射查找的环节。

算出的 key 经过哈希落进全局哈希表的某个桶(futex_hash_bucket),每个桶一把自旋锁、一条链表。桶的数量随系统内存规模伸缩,为的是让上百核机器上的海量 futex 不会全部挤在同一把桶锁上。等待者以链表节点形式挂在桶里,节点记录等待进程、期望值与等待类型;早期的实现按优先级排序(plist),后来的内核简化成普通链表并给实时锁单独开了通道。任何一次 WAIT 或 WAKE 都要先拿桶锁,这把锁保护的是「检查值与挂队、唤醒」的原子性,也是丢唤醒问题的最后一道防线。

FUTEX_WAIT 与 FUTEX_WAKE:语义藏在两个参数里

FUTEX_WAIT(op 值 0)的语义是:如果 *uaddr 仍然等于我传入的 val,就把自己挂进对应桶的队列并睡眠;否则立刻返回 EAGAIN(与 EWOULDBLOCK 同值)。这个「先比较再睡」看起来朴素,实则是整套机制正确性的基石:它把「检查条件」和「挂队睡眠」两步用同一把桶锁串成原子操作。用户态必须先读当前值、再把它作为期望值传给内核复查,任何在读取之后发生的解锁与唤醒,都会因为内核侧的值不一致而被拒绝睡眠——线程拿到 EAGAIN 回去重试,天然规避了丢唤醒。

FUTEX_WAKE(op 值 1)则相反:按 key 找到桶,从队列上摘起至多 val 个等待者唤醒,返回实际唤醒的个数。注意等待者醒来并不代表拿到了锁——它只是被从睡眠中拉起,需要回到用户态重新执行原子指令去抢,抢不到就再次 WAIT。futex 不传递锁的所有权,只传递「该醒了」这件事,这也是它足够通用的原因:mutex、条件变量、信号量、读写锁全部可以建在同样两个原语之上。

带超时的等待用 FUTEX_WAIT_BITSET(op 值 9),它支持绝对时间与按位掩码匹配唤醒,glibc 的 timed mutex 底层走的正是它。普通 FUTEX_WAIT 遇到信号打断会返回 EINTR,调用方需要处理重试。等待期间 futex 字被第三方改掉怎么办?唤醒逻辑只认等待者在等待时登记的期望值,改值方按约定「先写状态、后叫人」,就构成完整的发布协议;这也是所有上层库必须遵守的纪律。

requeue:pthread_cond 广播的后手

条件变量的广播(pthread_cond_broadcast)面临一个经典困境:几十个等待者同时醒来,全部去抢同一把 mutex,瞬间制造一次惊群——大部分人醒来、抢锁失败、再次睡眠,白折腾一轮。futex 给出的工具是 FUTEX_CMP_REQUEUE(op 值 4):唤醒至多 val 个等待者,把剩下的整体转移到 uaddr2 指向的另一条等待队列上(通常就是这把 mutex 的 futex 队列),并且要求 *uaddr 仍等于 val3 才执行。这样一来,广播只放行一个线程去抢锁,其余人原地转投 mutex 的队列,等持锁者逐次解锁时按顺序放行。glibc 的条件变量正是这么实现的;FUTEX_WAIT_REQUEUE_PI 与 FUTEX_CMP_REQUEUE_PI 则是这套机制的实时优先级版本,留给下一篇细说。

手写一个 futex 原语:最小可运行示例

下面用 C 写一个最朴素的单向同步:等待线程盯着一个整数,直到它变成 1;置位线程改值并唤醒。注意 wait 循环里「先读后等」的写法——这就是前文说的丢唤醒防线,值得逐行体会。

#define _GNU_SOURCE
#include <errno.h>
#include <linux/futex.h>
#include <pthread.h>
#include <stdatomic.h>
#include <stdint.h>
#include <stdio.h>
#include <sys/syscall.h>
#include <unistd.h>

static _Atomic uint32_t word = 0;   /* futex 字:必须 4 字节对齐 */

static long futex(uint32_t *uaddr, int op, uint32_t val,
                  const struct timespec *ts) {
    return syscall(SYS_futex, uaddr, op, val, ts, NULL, 0);
}

static void *waiter(void *arg) {
    for (;;) {
        uint32_t cur = atomic_load(&word);
        if (cur == 1)
            break;                                   /* 快路径:条件已成立 */
        long r = futex((uint32_t *)&word, FUTEX_WAIT, cur, NULL);
        if (r == -1 && errno != EAGAIN && errno != EINTR) {
            perror("futex");
            break;
        }
        /* EAGAIN:值变了,重读重查;EINTR:被打断,继续等 */
    }
    printf("waiter: observed word = 1\n");
    return NULL;
}

int main(void) {
    pthread_t t;
    pthread_create(&t, NULL, waiter, NULL);
    usleep(100000);
    atomic_store(&word, 1);
    long woken = futex((uint32_t *)&word, FUTEX_WAKE, INT32_MAX, NULL);
    printf("main: woke %ld waiters\n", woken);
    pthread_join(t, NULL);
    return 0;
}

这段代码如果去掉「先读 cur 再作为期望值传入」的步骤、直接 FUTEX_WAIT 一个写死的旧值,那么在读取与等待之间的窗口里发生置位的话,线程会永远睡死——内核忠实地等着一个永远不会来的 WAKE。补上重查之后,窗口内的任何变化都会让内核以值不匹配为由退回 EAGAIN,循环自然重查。生产代码请勿从这段出发自己造锁:用它理解语义,然后回到 pthread。

glibc mutex 的落地:从一条 CAS 到慢路径

有了 futex,再看 glibc 的 pthread_mutex_lock 就豁然开朗。默认类型的锁字是 mutex 结构里的一个 32 位整数:0 表示空闲,1 表示持锁且无等待者,2 表示持锁且有人在排队。加锁快速路径就是一条 CAS:把 0 换成 1,成功即拿到锁,全程零系统调用。失败时先把状态升级为 2——向潜在解锁方宣告「有人在等」——再进入慢路径调用 futex 睡眠;解锁侧同样先原子地把 1 或 2 换回 0,只有当旧值是 2,也就是确实有等待者时,才调用 FUTEX_WAKE。这个 0/1/2 编码让「无人等待的解锁」也完全不需要进内核,加解锁两条快路径对称成立。

换句话说,一把普通的 pthread mutex 在无竞争时就是一条 CAS 指令,有竞争时才是 futex。这解释了为什么微基准里「mutex 很便宜」与线上压测里「锁很贵」并不矛盾:差别全在竞争度。当几十个线程在一把锁上排队时,每次唤醒都是一次真实的调度与上下文切换,再加上缓存与 TLB 被新邻居踩过,单次持锁成本会从纳秒级膨胀到微秒级——竞争本身成了开销的主体。

观测手段:把 futex 抓出来

判断一个服务的并发瓶颈是不是锁,最直接的证据链是系统调用统计。strace -c -f -e trace=futex -p <pid> 挂十秒钟,就能看出 futex 是每秒几千还是几十万次;bpftrace 一行可以按 op 拆分:bpftrace -e 'tracepoint:syscalls:sys_enter_futex /comm == "myserver"/ { @[args->op & 0x7f] = count(); }'(掩码 0x7f 是为了剥掉 PRIVATE 标志位,让 WAIT 与 WAKE 各归各位)。如果 WAIT 远多于 WAKE,说明大量时间耗在睡眠排队上;如果成对出现且频率极高,多半是锁竞争下的无效轮转。perf lock record 加 perf lock report 则能进一步把热点锁按调用栈聚合出来。

还有一类观测是反着来的:/proc/<pid>/status 里的 voluntary_ctxt_switches 持续上涨而 CPU 利用率并不高,通常就是一群线程在 futex 上反复睡着醒来。配合火焰图看用户态调用栈,塔尖落在 pthread_mutex_lock 附近的宽扁结构,基本可以定案。

两个真实工程场景

场景一:高并发日志的锁风暴

某网关服务 128 个工作线程共享一把日志锁,压测 QPS 上不去,火焰图塔尖在写日志函数。strace 显示 futex 每秒数十万次,其中大量是 WAIT 后立刻 EAGAIN 的短睡眠——这是典型的「临界区短但竞争烈」形态:锁保护的动作只有几百纳秒,但排队人数太多,排队本身成了开销主体。修复路径是分层削弱竞争:每线程先写各自的无锁缓冲,异步线程批量落盘;热点路径按线程哈希把单把锁分片成多把。改造后 futex 调用量降了两个数量级,P99 延迟随之回落。这类问题的教训是:futex 风暴往往不是 futex 的问题,而是「太多人排队」这个设计问题在内核侧的投影。

场景二:条件变量广播的惊群

一个任务分发器用单个条件变量承载全部 worker:每次批量投递任务调用 broadcast,几十个 worker 同时醒来抢一把 mutex。虽然 glibc 底层的 CMP_REQUEUE 已经把惊群收窄成「放行一个、其余转队」,但每次广播后那个「幸运儿」与后续解锁节奏仍然造成可观的调度抖动。改造方案是把单一条件变量按任务类型拆成多个,每个 worker 只在自己的条件上等待,投递方按类型定向唤醒(对应 FUTEX_WAKE 的 val 传 1 或 2,只叫需要的人)。广播从一次性唤醒全队变成定点唤醒,唤醒次数与上下文切换同时下降。

踩坑清单与收束

最后把散落在前文的约束收拢成一张清单,每一条都对应真实的翻车现场:

  • futex 字必须是 4 字节对齐的 32 位整数,未对齐内核直接返回 EINVAL。结构体里塞一个 uint32_t 并不天然保证对齐,压缩打包的结构要格外小心。
  • PRIVATE 与共享两种模式不能对同一个地址混用。PRIVATE 用 mm 加偏移算 key,共享模式用 inode 算 key,同一地址会落进不同哈希桶,唤醒方与等待方互不相认,症状是莫名其妙的永久睡死。
  • 永远不要绕过「先读值、再传给内核」的协议。内核复查期望值不是可选项,而是正确性的一部分,省掉这一步就是在赌调度时序。
  • FUTEX_WAKE 的 val 是唤醒个数上限:传 0 一个都不叫,传 INT32_MAX 才是全唤醒;条件变量的 notify_one 对应传 1。
  • 信号会打断等待并返回 EINTR,长等待必须处理重试;带超时的等待返回 ETIMEDOUT,同样要走重查循环。
  • futex 只负责「睡与醒」,不解决临界区长短问题。持锁做 IO、持锁调下游 RPC,无论内核的唤醒机制多么精巧都无法拯救——把临界区做小永远是第一优化。

下一篇顺着这条路往下走:当线程携带实时优先级时,简单的「谁先醒谁先抢」会制造优先级反转,futex 家族为此专门长出了 PI 分支——rt_mutex 与优先级继承,那是另一个同样精彩的故事。

← 返回资讯列表

读者留言

COMMENTS 暂无
仅本站原创文章开放留言 · 请勿留下手机号、邮箱等个人信息

还没有留言,来说第一句?