并发编程里,我们说得最多的词是“锁”,但锁并不是一种凭空存在的原语。把任意一把内核锁拆开,底下永远是同两块地基:原子操作保证一次“读-改-写”不可被打断,内存屏障约束多核之间的可见顺序。本章我们暂不讲任何一把具体的锁,而是聚焦这两块地基—因为从第 2 章的 spinlock 到后面的 mutex、rwsem、ww_mutex,每一把锁都只是“原子操作 + 内存屏障 + 等待策略”的不同组合。地基不牢,上层锁的正确性无从谈起。
1.1 锁到底在防什么:数据竞争的三种面孔
两个 CPU 并发执行 counter++,结果可能小于预期。原因是 counter++ 并非一条指令,而是三步:
load r, [counter]; 读
add r, 1 ; 改
store [counter], r; 写
若两个 CPU 几乎同时读到同一个旧值,各自加一后写回,两次自增只留下一次效果——这是丢失更新(lost update)。
sequenceDiagram
participant A as CPU A
participant M as counter(初值 0)
participant B as CPU B
A->>M: load 读到 0
B->>M: load 读到 0
A->>A: 0 + 1 = 1
B->>B: 0 + 1 = 1
A->>M: store 写回 1
B->>M: store 写回 1
Note over M: 两次自增只留下 1,丢失一次更新
它是最直观的一种数据竞争,但不是唯一一种。并发缺陷有三种面孔:
- 丢失更新:多个“读-改-写”交错,部分更新被覆盖。根因是 RMW 不是原子的。
- 撕裂访问(torn access):一次读或写被编译器/硬件拆成多次。一个 64 位变量在某些路径上可能被拆成两个 32 位写,另一个 CPU 就可能读到“写了一半”的值。
- 乱序可见(reordering):即使每个访问本身原子,不同 CPU 观察到的操作顺序也可能不同。重排来自两层——编译器在编译期调换无数据依赖的读写,CPU 在运行期通过 store buffer、乱序执行改变全局可见顺序。
针对前两种,我们需要原子操作;针对第三种,我们需要内存屏障。这两件武器贯穿全章。
1.2 先过编译器这一关:READ_ONCE/WRITE_ONCE 与编译器屏障
上一节的三种竞争,病根都在多核硬件。但在麻烦真正抵达硬件之前,还站着一个更早出场的角色——编译器。它为了让代码跑得更快,会对我们写下的每一次内存访问做大胆假设,这些假设在单线程里天经地义,搬到多线程就会闯祸。所以本章第一件武器既不是原子指令、也不是硬件屏障,而是这层最轻、也最容易被忽略的防线。
先看一个几乎人人踩过的坑。一个线程原地打转,等另一个线程把标志置起:
while (!flag)
; /* 等 flag 变成非零 */
在编译器看来,这个循环里没有任何代码去改 flag,于是它把 flag 从内存读进寄存器一次,之后每轮都只看寄存器、不再回内存核对。结果是:哪怕另一个线程早已把 flag 置起,这个循环也永远看不到,活活变成一个出不来的死循环。编译器并没有算错,错在我们没有告诉它“这个变量会被别人从背后改动”。
C 语言标准把这种“两个线程不加同步地读写同一个变量”直接定义为未定义行为(data race is undefined behavior)。一旦踩中,编译器就有权做任何优化:缓存进寄存器、把多次读合并成一次、甚至整段删掉。要堵住它,我们得有办法对编译器下一道硬命令——“这次访问必须老老实实地、不多不少地打到内存上一次”。内核给出的答案就是 READ_ONCE/WRITE_ONCE,定义于 include/asm-generic/rwonce.h:
#define __READ_ONCE(x) (*(const volatile __unqual_scalar_typeof(x) *)&(x))
#define READ_ONCE(x) \
({ \
compiletime_assert_rwonce_type(x); \
__READ_ONCE(x); \
})
#define __WRITE_ONCE(x, val) \
do { \
*(volatile typeof(x) *)&(x) = (val); \
} while (0)
拨开宏的外壳,核心只有一个 volatile 强制转换。volatile 是对编译器下的一道硬命令:“这个地址随时可能被你看不见的力量改写,不许缓存、不许合并、不许省略,每次都给我实打实地去内存走一趟。”于是前面那个死循环只要改成 while (!READ_ONCE(flag)),编译器每一轮都会重新从内存取 flag,标志一置起,循环立刻退出。顺带地,它也堵住了 1.1 说的撕裂——volatile 保证这次访问是机器字长内一次完整的读或写,不会被拆成两半。而 compiletime_assert_rwonce_type 在编译期站岗:一旦你拿它去访问超过机器字长、根本无法保证“单次原子”的类型,直接编译报错,把隐患挡在上线之前。
READ_ONCE/WRITE_ONCE 管得住“单个变量的单次访问”,却管不了“多条语句之间谁先谁后”。当我们要约束的是“先写完 A,再写 B,两者别被调换”时,就要请出另一件更粗的工具——编译器屏障:
#define barrier() asm volatile("" ::: "memory")
它是一条什么都不执行的空汇编,玄机全在末尾的 "memory":这相当于对编译器喊一声“走到这条线,内存里的一切都可能已经变了,别把我前面拿到的旧值跨过这里接着用”。编译器于是不敢把屏障两侧的内存访问对调顺序。但一定要记住它的边界——它只拦得住编译器,拦不住 CPU。CPU 在运行期照样能乱序,那是 1.5 节硬件屏障要收拾的另一层问题;也正因为 x86 是强序模型,它的 smp_rmb/smp_wmb 才退化成了这条 barrier()。
这里要特别钉死一层认知:本节两件工具都只作用于“源码 → 汇编”的编译期,不会生成任何真实的屏障指令。
READ_ONCE/WRITE_ONCE靠volatile强制转换,约束的是编译器生成访存指令的行为——必须真的发一条 load/store,不许缓存进寄存器,不许合并或删除。它不产生任何额外的 CPU 指令(如mfence、lock前缀),生成的仍是一条普通的mov。barrier()是空汇编asm volatile("" ::: "memory"),不生成任何机器指令,只是命令编译器不要跨过这一点重排它安排指令的顺序。
真正约束运行期 CPU 乱序、会实际生成 LOCK 前缀或 mfence/lfence/sfence 的手段,要到 1.3 节的原子指令与 1.5 节的内存屏障才登场。
把本节两件工具收成一句话:READ_ONCE/WRITE_ONCE 管“一个变量的这一次访问必须真实发生、且不被撕裂”,barrier() 管“编译器不许跨过这一点重排代码”。它俩联手挡下的,是编译器惹的麻烦;至于多核 CPU 之间的可见顺序,要留到 1.5 节硬件屏障登场才能解决。
本节机制小结:READ_ONCE/WRITE_ONCE 与 barrier() 是整套原子与锁机制最底层的两块砖,后续每一层都建立在它们之上,本章及后续章节不会再重复解释,但会反复用到——atomic_read/atomic_set(1.3 节)就是 READ_ONCE/WRITE_ONCE 的直接封装;acquire/release 屏障(1.6 节)的 smp_load_acquire/smp_store_release 内部正是 READ_ONCE/WRITE_ONCE 再叠一条 barrier();而 spinlock、qspinlock、rwsem 在自旋等待锁状态时,读的都是 READ_ONCE(lock->val) 这类访问,靠的正是本节保证的“每轮真实重读、绝不被优化成死循环”。记住这一点,后面看任何一把锁的源码,都能一眼认出这两块地基。
1.3 原子类型与原子操作
atomic_t 的本体朴素得出人意料,就是一个对齐的 int(include/linux/types.h):
typedef struct {
int __aligned(sizeof(int)) counter;
} atomic_t;
用结构体包一层,是为了类型安全:强制所有访问都走 atomic_* API,杜绝裸 v.counter++。但类型安全只是表壳,真正的原子性来自硬件。注意,本节是全章第一次跨过软硬件分界线:1.2 节的 READ_ONCE/barrier() 都只在编译期约束编译器、不生成任何额外指令;而从本节的原子 RMW 起,我们第一次真正落到 CPU 指令层——x86 上靠 LOCK 前缀锁定缓存行(现代实现基于缓存一致性协议而非锁总线),由硬件保证一次读-改-写不可被打断。见 arch/x86/include/asm/atomic.h:
static __always_inline int arch_atomic_read(const atomic_t *v)
{
return __READ_ONCE((v)->counter); /* 对齐读本身即原子,无需 LOCK */
}
static __always_inline void arch_atomic_add(int i, atomic_t *v)
{
asm_inline volatile(LOCK_PREFIX "addl %1, %0"
: "+m" (v->counter)
: "ir" (i) : "memory"); /* RMW,必须 LOCK */
}
static __always_inline int arch_atomic_add_return(int i, atomic_t *v)
{
return i + xadd(&v->counter, i); /* 带返回:xadd 原子取回旧值 */
}
注意 read/set 不需要 LOCK——在 x86 上,对齐的字长读写天生原子,只需 READ_ONCE/WRITE_ONCE(回到 1.2 的编译期控制)防编译器捣乱即可;真正需要 LOCK 的是“读-改-写”这类复合操作。
这里请专注代码里的 LOCK_PREFIX,它正是软硬件分界。它定义在 arch/x86/include/asm/alternative.h:在 SMP 内核下展开成真实的 lock 前缀(机器码 0xF0),拼在 addl/cmpxchgl 前面,由 CPU 保证这条指令的原子性;在单处理器(UP)内核下则展开成空串,连前缀都不生成。换句话说,LOCK_PREFIX 是货真价实的一条硬件指令前缀,这与 1.2 里“不生成任何指令”的 barrier()、volatile 形成鲜明对照——读到这一层,我们已经站在硬件上了。
据此把原子操作分为三类:
- 纯读写:
atomic_read/atomic_set。 - 无返回值 RMW:
atomic_add/sub/inc/dec——只改不问结果。 - 带返回值或带条件的 RMW:
atomic_add_return(走xadd)、atomic_dec_and_test/inc_and_test(走GEN_UNARY_RMWcc,直接读 CPU 标志位判断结果是否为零)。第三类是引用计数、无锁算法的主力。
1.4 cmpxchg:无锁与锁快速路径的共同基石
如果说前面的原子操作是零件,cmpxchg(compare-and-swap,CAS)就是把零件拼成任意无锁算法的万能接头。它的语义是:“若内存当前值等于期望的旧值,就写入新值,并返回原值。”x86 实现见 arch/x86/include/asm/cmpxchg.h:
#define __raw_cmpxchg(ptr, old, new, size, lock) \
({ \
... \
case __X86_CASE_L: \
{ \
volatile u32 *__ptr = (volatile u32 *)(ptr); \
asm_inline volatile(lock "cmpxchgl %2, %1" \
: "=a" (__ret), "+m" (*__ptr) \
: "r" (__new), "0" (__old) \
: "memory"); \
break; \
} \
... \
})
#define arch_cmpxchg(ptr, old, new) \
__cmpxchg(ptr, old, new, sizeof(*(ptr))) /* 带 LOCK_PREFIX */
这里的 lock 不是新东西,正是 1.3 那个 LOCK_PREFIX——只不过 __raw_cmpxchg 把它抽成了一个宏参数,好让同一份汇编模板服务两种变体:arch_cmpxchg 走 __cmpxchg 填入 LOCK_PREFIX(SMP 下即真实的 lock 前缀),保证跨 CPU 原子;而 arch_cmpxchg_local 走 __cmpxchg_local 填入空串,只防本 CPU 中断、省掉前缀以求更快。所以 cmpxchg 的原子性依旧落在 1.3 划定的那条硬件线上。
有了 CAS,任何“读出旧值 → 算出新值 → 原子换上”的更新都能写成一个重试循环:
old = READ_ONCE(v);
do {
new = f(old);
} while (!try_cmpxchg(&v, &old, new)); /* 失败时 old 被刷新为最新值,重来 */
这个范式的重要性怎么强调都不过分:后续每一把锁的“抢锁快速路径”本质都是一次 CAS——mutex 用 CAS 把 owner 从 NULL 换成 current,qspinlock 用 CAS 抢 pending 位,rwsem 用 CAS 改 count。理解了这个循环,就理解了所有锁快速路径的骨架。(CAS 有个经典陷阱叫 ABA 问题:值从 A 变 B 再变回 A,CAS 会误判“没变过”;它在 RCU 与无锁数据结构章节再展开。)
1.5 内存屏障:四种基本屏障与 CPU 侧实现
原子操作解决了“单个操作不可分割”,但解决不了“多个操作之间的可见顺序”。考虑经典的消息传递:
CPU 0: data = 42; CPU 1: while (!flag) ;
flag = 1; r = data;
即使 data 和 flag 各自的写都是原子的,CPU 1 也可能先看到 flag == 1 却仍读到 data 的旧值——因为两个写在 CPU 0 的 store buffer 里可能乱序刷出,或 CPU 1 的两个读被乱序执行。修好它需要屏障。内核的四种基本屏障与 x86 实现见 arch/x86/include/asm/barrier.h:
#define __mb() asm volatile("mfence":::"memory") /* 全屏障:读写都不跨越 */
#define __rmb() asm volatile("lfence":::"memory") /* 读屏障 */
#define __wmb() asm volatile("sfence" ::: "memory") /* 写屏障 */
#define __smp_mb() asm volatile("lock addl $0,-4(%%" _ASM_SP ")" ::: "memory", "cc")
#define __smp_rmb() dma_rmb()
#define __smp_wmb() barrier()
几个要点:
mb/rmb/wmb用于与设备(MMIO/DMA)交互,映射到mfence/lfence/sfence。smp_mb/smp_rmb/smp_wmb用于 CPU 之间。x86 是强序模型,普通读读、写写本就不会被 CPU 乱序,所以smp_rmb/smp_wmb直接退化成编译器屏障;只有“写后读”这一种重排 x86 允许,因此smp_mb必须是真屏障——这里用一条lock addl $0, -4(%rsp)(对栈顶做一次带锁的空加法)充当全屏障,比mfence更快。- 弱序架构(ARM64、PowerPC 等)上,
smp_rmb/smp_wmb都是实打实的屏障指令。正因如此,可移植代码必须显式写屏障,不能依赖 x86 的强序“运气”。
顺着 1.3 划下的那条软硬件分界线,这四种屏障也可以按“是否生成硬件指令”归位:
| 屏障 | x86 生成 | 是否硬件指令 |
|---|---|---|
mb / rmb / wmb | mfence / lfence / sfence | 是 |
smp_mb | lock addl $0, -4(%rsp) | 是(靠 lock 前缀) |
smp_rmb / smp_wmb | 退化为 barrier() | 否,纯编译期 |
要抓住的关键是:同一行屏障是否落到硬件指令,取决于目标架构的强弱序。smp_wmb() 在 x86 上是空的 barrier()(回到 1.2 的编译期控制),换到 ARM64 就变成真实的 dmb 指令。这也解释了上一条要点——你在 x86 上漏写 smp_wmb 往往“碰巧正确”,一移植到弱序架构立刻暴雷。
1.6 acquire / release:锁真正依赖的顺序模型
全屏障语义强但开销大。锁真正需要的是一种单向的、更廉价的顺序:临界区里的访问不许“泄漏”到临界区外。这正是 acquire/release 模型:
- acquire(用于加锁):其后的所有访问,不得被重排到 acquire 之前。
- release(用于解锁):其前的所有访问,不得被重排到 release 之后。
两者一夹,临界区内的读写就被牢牢关在里面。x86 实现见 arch/x86/include/asm/barrier.h:
#define __smp_store_release(p, v) \
do { \
compiletime_assert_atomic_type(*p); \
barrier(); \
WRITE_ONCE(*p, v); \
} while (0)
#define __smp_load_acquire(p) \
({ \
typeof(*p) ___p1 = READ_ONCE(*p); \
compiletime_assert_atomic_type(*p); \
barrier(); \
___p1; \
})
在强序的 x86 上,acquire/release 不需要任何真屏障指令,一个编译器屏障 barrier() 加 READ_ONCE/WRITE_ONCE 就够了——因为硬件已经保证了除“写后读”外的顺序。这解释了 x86 上锁的解锁路径为何可以如此廉价(一次带 release 语义的普通写)。但这仍是 x86 的红利:在 ARM64 这类弱序架构上,acquire/release 会落到专门的硬件指令(如 ldar/stlr),解锁不再是一次普通写——这与 1.5 表格里 smp_wmb 的“x86 退化、弱序变真指令”如出一辙。同理,x86 上原子操作前后的屏障是空的:
#define __smp_mb__before_atomic() do { } while (0)
#define __smp_mb__after_atomic() do { } while (0)
因为带 LOCK 前缀的原子操作本身就是一个全屏障,无需再补。把 lock 理解为 acquire、unlock 理解为 release,是贯穿后续所有锁章节的顺序模型基础。
1.7 内核原子 API 的三层结构
翻源码时会发现 atomic_add 有好几个名字:arch_atomic_add、raw_atomic_add、atomic_add。这不是重复,而是刻意的三层结构:
arch_atomic_*:架构相关实现,如上文 x86 的LOCK_PREFIX "addl"。架构只需实现一个最小集。- fallback 生成层(
include/linux/atomic/atomic-arch-fallback.h):脚本据最小集自动补全所有变体(如架构没实现add_return,就用cmpxchg循环合成)。 atomic_*插桩层(include/linux/atomic/atomic-instrumented.h):对外的公开 API,包一层 KASAN/KCSAN 插桩用于并发缺陷检测。
这三层几乎全部由 scripts/atomic/ 下的脚本生成。分层的意义:架构移植者只写最小汇编,通用变体与调试插桩一次性交给公共层,既减负又统一。日常写驱动只需用最上层的 atomic_*,无需关心底下两层。
1.8 把地基拼成一把锁
现在用本章的零件,手写一把最小自旋锁,验证“锁 = CAS 抢 + release 放 + 等待策略”这个公式:
struct minimal_lock { atomic_t locked; }; /* 0=空闲 1=占用 */
static void minimal_lock(struct minimal_lock *l)
{
int expected;
do {
expected = 0;
/* CAS 抢锁:把 0 换成 1,成功即获得锁(acquire 语义) */
} while (!atomic_try_cmpxchg_acquire(&l->locked, &expected, 1));
}
static void minimal_unlock(struct minimal_lock *l)
{
/* release 语义写回 0,保证临界区内的写都已对他人可见 */
atomic_set_release(&l->locked, 0);
}
逐项对照:atomic_try_cmpxchg_acquire 是 1.4 的 CAS + 1.6 的 acquire;atomic_set_release 是 1.6 的 release;do-while 里的空转就是“等待策略”。这把锁能用,但它的等待策略太原始——所有争抢者都在同一个 locked 上自旋写,制造大量缓存行颠簸(cache-line bouncing)。第 2 章的 qspinlock 会把这个“裸自旋”升级成 MCS 队列,让每个等待者自旋在自己的本地节点上。这正是从“能用的锁”到“可扩展的锁”的分水岭。
1.9 误用与调试
地基层最常见的坑:
- 把裸
v++当原子:多核下必丢更新,改用atomic_inc或cmpxchg循环。 - 漏
READ_ONCE/WRITE_ONCE:轮询共享标志时写while (!flag),编译器可能把flag提进寄存器变成死循环;应写while (!READ_ONCE(flag))。 - 屏障不配对:
smp_store_release的写方必须有smp_load_acquire的读方与之配对,单边屏障等于没有顺序保证。消息传递两端都要设屏障。 - 误信 x86 强序:在 x86 上漏写
smp_rmb/smp_wmb往往“碰巧正确”,一移植到 ARM64 立即暴雷。写可移植代码要按弱序模型思考。
调试手段:开 CONFIG_KCSAN 做运行时数据竞争检测,它能抓出绝大多数漏加 READ_ONCE/原子化的并发访问;涉及复杂顺序推理时,Documentation/memory-barriers.txt 是内核内部的权威参考,tools/memory-model/ 下还有可对拍的形式化模型(LKMM)。锁序层面的死锁检测(lockdep)留到工具章。
本章小结
一切锁都建立在两块地基上:原子操作用 LOCK 前缀 / cmpxchg 保证“读-改-写”不可分割,解决丢失更新与撕裂;内存屏障约束多核可见顺序,其中 acquire/release 这对单向屏障恰好构成“临界区不外泄”的最小充分模型——lock 即 acquire,unlock 即 release。READ_ONCE/WRITE_ONCE 守住单次访问的原子与不可优化,cmpxchg 则是所有锁快速路径与无锁算法的共同接头。x86 的强序模型让许多屏障退化为空,但正确的心智模型应按弱序建立。带着“锁 = 原子 + 屏障 + 等待策略”这个公式,下一章我们拆解第一把真正的锁——从最朴素的 spinlock 到用 MCS 队列消除争用的 qspinlock。