外观
06 - 锁等待时线程在做什么:原子操作、自旋、阻塞与 futex
摘要
锁竞争时,有的服务 CPU 飙高,有的 CPU 很低却延迟很长。本文从共享计数和等待故障切入,讲清原子操作、内存顺序、互斥锁、自旋与阻塞,再拆开 futex 的比较等待和唤醒流程,用最小条件变量示例说明正确等待,帮助读者区分竞争、死锁和调度延迟。
阅读指引
- 前置阅读:资源共享与隔离、调度与上下文切换。先分清共享对象,以及就绪、执行与阻塞。
- 本文定位:解释锁和等待的底层职责。Java 内存模型(JMM)、Java 同步队列框架(AQS)和 POSIX 线程库(pthread)的具体实现属于延伸阅读。
- 适用边界:futex 部分讨论 Linux 经典 futex 接口及其常见用途;高级锁如何使用它取决于语言运行时、库版本和平台。Python 示例不证明其底层必然出现某次 futex 调用。
- 示例要求:Python 3.8+,示例可跨平台运行,不需要 root。只展示有限数据和有期限的等待,不制造随机竞态、长期死锁或满核自旋。
1. 场景:同样是“锁慢”,为什么 CPU 表现完全不同
一个服务在竞争高峰 CPU 很高,线程持续尝试获取状态;另一个服务 CPU 很低,但线程栈反复停在锁等待。两者都可能是同步设计的问题,却不能用同一个“减少上下文切换”结论解释。
还可能有第三种情况:锁持有者本来只需做很少工作,却被调度、配额或外部 I/O 拖住,其他线程的等待随之变长。等待者的栈告诉我们“堵在哪里”,不一定告诉我们“为什么持有者没有释放”。
先把协议拆开:共享状态怎样修改、竞争失败后怎样等待、条件变化后怎样通知、被通知后怎样重新检查。
2. 基础概念地图:原子性、可见性、互斥与活性
先看一个简化的共享计数模型:count 初始为 0,两个线程各加一次。如果加法分成读取、计算和写入,两者可能都读到 0,都算出 1,再各自写回 1。执行了两次加法,结果却只有 1,这就是丢失更新。
互斥锁的基本办法是让这些步骤不能被另一个遵守同一把锁的线程插入:先获取锁,再读取和修改计数,最后释放锁。获取失败的线程怎样等待,是下一层问题;首先要确定哪些状态必须一起保护。 需要按这种协议保护的代码区域称为临界区(Critical Section),互斥锁(Mutex)控制谁能进入它。
在这个模型中,加法有没有被拆开、修改能否被其他线程看到、线程能否最终完成,是不同的问题:
| 概念 | 解决的问题 | 不能单独保证什么 |
|---|---|---|
| Atomicity,原子性 | 某个操作按协议不可被观察为部分完成 | 多个独立操作组成的业务不变量 |
| Visibility,可见性 | 一个线程的修改在什么同步条件下能被另一个线程看到 | 仅靠普通变量访问就得到跨线程保证 |
| Ordering,顺序约束 | 哪些读写不能越过同步边界重排 | 源代码顺序天然等于跨线程观察顺序 |
| Mutual Exclusion,互斥 | 同一临界区同一时刻只允许一个参与者 | 所有访问都自动遵守同一把锁 |
| Progress / Liveness,推进与活性 | 系统或任务能否持续完成工作 | 每个等待者必然在固定时间拿到锁 |
count += 1 是否会在某个具体语言或版本上出现上述交错,受语言语义与实现影响;没有复现丢失更新,不等于已证明安全。
业务不变量是多个状态之间必须始终成立的约束。例如库存扣减与订单创建需要保持一致,即使库存字段使用原子变量,也不能自动把这两件事合成一个原子操作。应先确定统一的同步边界;涉及数据库、消息等不同资源时,还需要事务、幂等(重复处理不产生额外效果)或恢复协议。
2.1 同步工具不是同义词:保护状态、等待条件与限制数量
| 工具或机制 | 主要回答什么 | 常见用法 | 不能自动做到什么 |
|---|---|---|---|
| Mutex,互斥锁 | 谁能进入共享状态的临界区 | 修改队列、发布版本时保护不变量 | 不能自动限制外部请求数量或保证持有者很快完成 |
| Condition Variable,条件变量 | 条件不成立时怎样释放锁并等待 | 等队列非空、工作完成或取消 | 通知不是数据,不累计保存每一次业务事件 |
| Semaphore,信号量 | 当前还能允许多少参与者进入 | 限定同时进行的外部调用数量 | 许可不等于某个具体连接,也不自动保护关联字段 |
| Event,事件标记 | 某个状态是否已发生或允许继续 | 记录就绪、停止意图 | 重复 set 不等于记录多个工作项,复位需要协议 |
| Atomic operation,原子操作 | 单次共享状态变化怎样按接口完成 | 计数、状态比较更新 | 不自动形成多个字段或外部副作用的事务 |
| Futex,内核等待机制 | 怎样围绕用户态状态字比较并阻塞/唤醒 | 同步库实现中的等待路径 | 不替代高级锁的状态机、所有权与内存顺序 |
例如连接池可用互斥锁保护内部列表,用条件变量等待空闲连接,入口还可以用信号量限制正在处理、尚未结束的请求数量。保护列表、等待连接和限制数量是三种职责。没有成功获取许可就不应归还许可;获取成功后,异常和取消路径也必须释放。许可数正确,并不保证池中对象状态正确。
Python 接口区别见 threading 文档,Java 容量保护应用见 Semaphore 并发许可。后面的条件变量示例会展示状态保护与等待怎样配合。
3. 原子操作怎样支撑锁:CAS 不等于万能正确性
锁本身也有共享状态:多个线程可能同时看到“空闲”,所以普通的“先检查,再设为占用”仍会发生竞争。CAS(Compare-and-Swap,比较并交换)把比较和条件更新合成一个原子操作:只有当前值符合预期时才更新,并报告结果。
text
期望锁状态是“空闲”
→ 原子尝试将其改为“占用”
→ 成功:按锁协议进入临界区
→ 失败:根据策略重试或进入等待在这个简化模型里,一个线程成功把“空闲”改成“占用”后,其他线程再用“空闲”作为预期值就会失败。成功者由此取得进入临界区的资格;失败者需要重试或等待。完整的锁协议还必须处理释放、内存顺序和等待者管理。
硬件实现并不统一:某些架构使用比较交换指令,另一些可用加载保留/条件存储实现原子读改写,即先读取并记录访问位置,再有条件地提交写入。因此,不能把一种汇编指令当作所有硬件的共同实现。
3.1 三个必须保留的边界
- 内存顺序:只让一个线程取得占用标志还不够,后续持有者还需要按规则看到前一个持有者对共享数据的修改。Release(释放)与 Acquire(获取)语义用于建立这种同步关系:在满足语言与接口规定的配对条件时,释放前的相关写入可被后续获取者观察到。具体保证应遵守所用语言的内存模型。
- 重试成本:竞争者反复写同一缓存行,会产生缓存一致性流量;失败重试也占执行预算。不是“没进内核就没有成本”。
- ABA 与生命周期:值从 A 改成 B 再回到 A,比较值可能看不出中间变化;如果 A 是可回收对象的地址,还要解决对象生命周期,而不仅是改成 CAS。
Cache Line,即缓存行,是 CPU 缓存管理的一组数据单位。多核修改共享数据时,需要协调各自缓存中的副本,这类协调产生缓存一致性流量。不同字段落在同一缓存行上并被不同线程修改时,也可能互相干扰,称为 False Sharing,即伪共享。是否值得优化,应测量真实访问、布局和吞吐,而不是见到原子变量就加填充。
在 Java 中进一步看 CAS 与原子类、JMM 与 happens-before。OS 等待机制不能代替 Java 的合法读写与发布规则。
3.2 lock-free 不是每个线程都永远不等
Lock-free,即无锁推进保证,通常强调系统整体能持续完成操作,不保证某一个线程不会长期失败重试。Wait-free,即无等待推进保证,通常要求每个参与者在算法规定的有限步骤内完成,条件更强。
这两个术语是算法保证,不等于“源代码没有 mutex”或“CPU 永远不用等内存”。内存分配、对象回收和外部调用也可能改变整体边界。选无锁结构前先确认需要解决的瓶颈,而不是把无锁当通用升级。
4. 竞争失败后:自旋还是阻塞
获取锁失败后,线程可以继续尝试,也可以暂时让出执行机会。Spin,即自旋,是保持可运行并不断检查或重试;它获得 CPU 时仍会执行等待代码。Blocking,即阻塞,是登记等待并挂起,等待期间不参与普通的 CPU 执行竞争;被唤醒后还要先获得调度,再检查状态。
| 策略 | 主要成本 | 可能适合 | 易错前提 |
|---|---|---|---|
| 自旋 | CPU 执行、重试、一致性流量 | 持有时间确实很短且持有者有机会运行 | 持有者被抢占或配额限制时,自旋可能更拖慢释放 |
| 阻塞 | 等待登记、唤醒和再次调度等 | 等待较长或 CPU 紧张 | 唤醒不保证立即运行,仍需重检条件 |
| 有限自旋后阻塞 | 两种路径的组合成本 | 库可依据竞争情况优化 | 阈值与适用性依库、版本和机器,不存在通用最佳次数 |
自旋并不天然更低延迟,阻塞也不天然更慢。真正要比较的是临界区持有时间分布、持有者执行机会、竞争者数量和实际资源预算。
例如只有一个 CPU 可用、持有者暂时没运行时,很多等待者持续自旋会与持有者争抢执行机会,而释放锁恰恰需要持有者先运行。反过来,极短临界区如果每次都走完整挂起和唤醒路径,也可能增加管理成本。应优先用成熟的同步库,避免手写“循环检查 + sleep”模拟互斥锁。
普通用户态互斥锁与内核 spinlock 也有边界差异。内核自旋锁所在上下文可能不允许睡眠,规则与配置、锁类型相关;不能把“用户态可自旋后阻塞”套用成内核持锁期间可以任意做 I/O。
5. futex:把用户态状态与内核等待连接起来
Futex,即 Fast Userspace Mutex,是 Linux 为基于共享内存状态的同步提供的等待与唤醒机制。它不是自动完成全部语义的一把高级互斥锁,锁的状态机和内存顺序仍由用户态库设计。
经典 futex 使用一个对齐的 32 位 futex word(等待字) 作为等待依据,内核会比较这个内存位置中的值。即使在 64 位系统,也不能随意把任意 64 位对象当作同一接口的等待字。跨进程等待时,参与者还需要指向相应共享内存位置;进程内私有优化选项不能误用成跨进程协议。
5.1 无竞争路径不必每次请求内核
常见库可以先在用户态原子获取状态,成功便进入临界区。只有可能需要较长等待等情形,才调用内核等待接口。具体是否自旋、采用何种状态编码和唤醒优化,依实现。
图表将在阅读到此处时加载…
这里只表示职责,不给可直接实现的完整锁状态机。真实实现必须处理竞争、内存顺序、等待者记录、超时、信号与对象生命周期。
5.2 比较并阻塞,避免“刚准备睡,对方已经通知完”
朴素错误协议如下:
text
等待者看到状态仍被占用
释放者把状态改为空闲并发出通知
等待者随后才登记睡眠
没有后续通知,等待者长期睡着经典 futex 等待接口提供原子的“比较并阻塞”语义:内核读取等待字、比较调用者给出的预期值,并在相等时按条件阻塞。如果释放者已经改变了状态,值就不再符合预期,等待者不会按旧条件睡下去,例如返回 EAGAIN,表示此次不能按给定预期值等待。若等待者已经进入等待,释放者则按协议改变状态并唤醒它。
这消除了关键检查窗口,但不代表 futex 自动修复任何丢失通知协议。用户态必须使用正确原子访问、状态变化与唤醒规则;简单二值示意也不能替代处理多等待者的真实状态机。
5.3 wake 不是把锁交给某个等待者
FUTEX_WAKE 唤醒适用的等待者,让它们有机会继续执行,但不直接保证:
- 某个特定线程一定先获得 CPU;
- 被唤醒线程必定获得锁;
- 共享数据已建立正确的内存顺序与发布关系;
- 所有等待者都按先进先出公平完成。
Predicate,即谓词,是“现在是否可以继续”的条件,例如队列非空、任务已完成。等待可能因状态变化、信号、超时等返回,也可能在业务条件尚未成立时被唤醒。因此,返回后必须重新检查谓词:通知只是提醒检查,条件才决定能否继续。即使通知时队列非空,在当前线程重新获取锁之前,数据也可能已被另一个消费者取走。
对比两种先后顺序,更容易理解为什么通知不需要“恰好赶上”:
| 先后顺序 | 正确协议中发生什么 | 错误协议的风险 |
|---|---|---|
| 生产者先完成 | 在锁内更新队列或完成标记;消费者后来检查时已经可继续 | 无条件 wait,等待一个早已发过的通知 |
| 消费者先到 | 在关联锁下检查不成立,按接口释放锁并等待;生产者修改状态后通知 | 检查和登记等待分离,中间通知被错过 |
| 多个消费者被通知 | 重新获取锁并逐一重检;没有数据者继续等待或处理完成/取消 | 把一次通知当作每个人都有一个数据项 |
因此,队列内容、完成标记等状态应由同一协议保护,并一直可供后续检查;不能仅凭“通知发生过”判断业务已经可以继续。这些状态可以保存在内存中,不要求落盘。
6. 可运行实战:用条件变量等待数据,而不是靠 sleep
Condition Variable,即条件变量,是结合锁等待条件变化的同步工具。等待期间释放关联锁,返回前重新获取锁;通知本身通常不释放通知方持有的锁。
把下面保存为 condition_demo.py,运行 python3 condition_demo.py。例子只有一个生产者和一个消费者、五个数据项,所有等待有期限。它展示谓词和通知协议,不测量底层 futex 次数。
condition 关联的锁保护队列和状态标记。消费者用 wait_for 等待“有数据、已完成或已取消”中的任一条件;等待时释放锁,让生产者可以入队。生产者在同一把锁内修改状态并通知,消费者重新获取锁后再检查。time.monotonic() 是用于计算经过时间的单调时钟;这里用同一个截止时间控制消费者的等待预算,避免每次醒来都重新获得完整的 4 秒。
python
from collections import deque
import threading
import time
def main():
condition = threading.Condition()
queue = deque()
state = {"done": False, "cancelled": False}
received = []
errors = []
def consume():
try:
deadline = time.monotonic() + 4
with condition:
while True:
# wait_for 会重检谓词;通知先到也不影响已有状态的观察。
remaining = max(0, deadline - time.monotonic())
available = condition.wait_for(
lambda: bool(queue) or state["done"] or state["cancelled"],
timeout=remaining,
)
if not available:
raise TimeoutError("等待数据超时")
if state["cancelled"]:
return
while queue:
received.append(queue.popleft())
if state["done"]:
return
except Exception as error:
with condition:
errors.append(str(error))
consumer = threading.Thread(target=consume)
consumer.start()
try:
for item_value in range(5):
with condition:
queue.append(item_value) # 状态修改与检查使用同一关联锁。
condition.notify()
with condition:
state["done"] = True
condition.notify_all()
consumer.join(timeout=5)
if consumer.is_alive():
raise TimeoutError("消费者未结束")
if errors:
raise RuntimeError(errors)
assert received == [0, 1, 2, 3, 4]
print("received:", received)
finally:
with condition:
state["cancelled"] = True
condition.notify_all()
consumer.join(timeout=2) # 失败时发出取消并有界等待,不遗留后台工作。
if consumer.is_alive():
raise RuntimeError("取消后消费者仍未结束")
if __name__ == "__main__":
main()预期输出:在等待预算内正常完成时,打印 received: [0, 1, 2, 3, 4]。生产者先执行还是消费者先执行,都不应改变数据顺序;已经入队的数据和完成标记可供后续检查,不依赖“通知恰好发生在等待之后”。如果调度或执行拖延导致超时,程序会报告异常,不能把有期限的等待理解为必定按期成功。
反例:先 sleep(0.1) 猜生产者已经完成,再读取队列;或无条件等待一次通知后直接取数据。
正例:持有关联锁检查谓词,不成立才等待;醒来重新检查,区分数据、完成、取消和超时。多个消费者时,一个数据项不代表所有被唤醒者都有数据,循环重检更不能省。
本例的单消费者顺序来自队列协议,不是锁承诺公平。真实业务应把耗时处理移到锁外,但取出任务、确认所有权和提交结果必须按业务一致性要求设计,不能机械地删除锁。
7. 活性问题:竞争、死锁、活锁与饥饿怎样区分
| 问题 | 核心表现 | 排查对象 |
|---|---|---|
| Contention,竞争 | 多个参与者争同一资源,仍能推进但可能慢 | 持有时间、频率、等待者数量、持有者路径 |
| Deadlock,死锁 | 形成无法按现有协议解开的等待关系 | 谁持有什么、又在等谁;不局限于两把互斥锁 |
| Livelock,活锁 | 持续响应或重试,却没有有效完成工作 | 重试规则、退避、冲突条件与进展计数 |
| Starvation,饥饿 | 某个任务长期得不到推进机会 | 公平性、竞争者、优先级和调度机会 |
| Priority Inversion,优先级反转 | 高优先级任务被低优先级持有者间接阻挡 | 持有者是否被其他任务推迟;所用锁是否有适用 PI 支持 |
例如高优先级线程在等低优先级线程释放锁,而中优先级线程又不断推迟持有者运行,高优先级线程的等待就被间接拉长。Priority Inheritance(PI),即优先级继承,是部分同步机制临时提高相关持有者优先级、缓解特定优先级反转的能力。Linux 有 PI futex 等机制,但不是所有普通 mutex 或 Java 锁都自动继承优先级。
避免死锁的常见办法包括统一资源获取顺序、减少嵌套、明确关闭与取消协议。加超时能限制一次等待,不一定修复业务状态:超时发生后已获取的资源、外部副作用和重试需要一并处理。
8. 排障:从等待者追到真正的持有者
| 现象 | 候选原因 | 需要补的证据 |
|---|---|---|
| CPU 高,完成量低 | 自旋、CAS 失败重试、活锁,或真实计算 | 热点代码与进展计数,别只看锁名字 |
| CPU 低,大量相同等待栈 | 长持锁、外部等待、关闭协议卡住 | 持有者栈、锁持有时间与外部调用期限 |
| 解锁后仍有长尾 | 唤醒后调度推迟、再竞争或配额受限 | 同窗口调度等待与 cgroup 证据 |
| 通知很多,却有任务永远等待 | 谓词、登记窗口、遗漏完成或取消 | 状态机、关联锁、异常路径与等待者生命周期 |
| 检测不到锁环但线程池卡住 | 任务等待同池子任务、容量或资源环 | 任务依赖、队列、执行器与资源预算 |
排查时先确定慢请求所在的实例和时间窗口,找到等待点,再追踪持有者正在计算、等待 I/O,还是尚未获得 CPU。cgroup 是 Linux 按任务组管理和限制资源的机制,组配额也可能推迟持有者或被唤醒线程的执行。
只观察 futex 等待不能确定是哪把业务锁:条件变量、运行库管理、线程 join(等待线程结束)等都可能使用相关等待路径。Java 继续看 锁竞争与长尾排查,结合重复线程栈、持有者和 Java Flight Recorder(JFR,运行时事件记录工具)等证据;高级源码读 ReentrantLock 与 AQS,不要把 AQS 队列直接等同于内核 futex 队列。
带权限和性能影响的系统调用跟踪属于选读。先用应用层有边界的计数和栈建立问题范围,再决定是否需要跟踪;调用次数不等于业务等待总时长,也不证明库在所有版本上都有同一条路径。
9. 容易踩的坑与工程取舍
前面的机制落到工程中,需要同时约束持锁工作、等待预算和失败后的资源处理:
- 锁内工作要有边界。 不限时的网络调用会延长持锁时间;把耗时工作移到锁外时,仍要设计状态检查、任务所有权和结果提交协议。
- 重试要有预算。
try-lock是尝试获取锁、失败即返回的接口。失败后无限重试仍可能产生饥饿或活锁;可以按业务需求选择退避(失败后延迟再次尝试)、拒绝或排队,并记录实际完成量。 - 取消和超时要有收尾协议。 限制等待时间只是第一步,还要释放已获取的许可和资源,处理已发生的外部副作用,确保完成或取消状态能被等待者观察到。
10. 名词解释与延伸阅读
| 名词 | 回查解释 |
|---|---|
| Atomic / CAS | 按协议不可观察为部分完成 / 比较预期值并条件更新 |
| Acquire / Release | 同步获取与发布方向,具体保证依语言与接口 |
| Mutex / Critical Section | 互斥工具 / 需要按协议保护的访问区域 |
| Semaphore / Event | 有数量的准入许可 / 表达发生或允许继续的状态标记,两者不自动保护业务不变量 |
| Spin / Block | 保持可运行并检查重试 / 挂起等待条件 |
| Futex Word / Wake | 经典等待接口的共享状态字 / 提醒适用等待者恢复检查 |
| Predicate / Condition Variable | 能否继续的条件 / 结合锁等待条件变化的工具 |
| ABA / False Sharing | 状态回到同值掩盖中间变化 / 不同对象因缓存粒度互相干扰 |
| Deadlock / Livelock / Starvation | 等待无法解开 / 持续动作无进展 / 某参与者长期无法推进 |
- 同专题回查:调度与上下文切换,解释被唤醒后为什么仍要等待 CPU。
- 语言层解释:JMM、CAS、AQS,分别说明合法读写、原子类与 Java 排队协议。
- 关闭应用:进程创建、信号与退出,把取消谓词和等待期限用于关闭,不在信号处理函数中随意加锁。
- 专项排障:描述符与等待链追资源持有者,跨层长尾案例解释外部 I/O 如何延长锁持有期;不能只修改等待者。
- 依据:Linux man-pages 的
futex(2)、futex(7)、pthread_cond_wait(3);Pythonthreading.Condition文档。真实原子语义应以对应语言规范和同步库接口为准,不照抄示意图实现锁。
11. 一句话总结与三个要点
锁的正确性来自状态与同步协议,等待性能还取决于重试、持有者进展和唤醒后的调度。
- 原子性、可见性、互斥与活性分别解决不同问题;单个 CAS 不自动保护整个业务。
- 自旋消耗 CPU,阻塞需要等待与唤醒管理;futex 连接两层,但不替代用户态锁状态机。
- 等待围绕谓词、取消与期限设计;诊断从等待者追到持有者,再检查外部等待与调度预算。