先说计数器。四个线程各把一个全局变量加一百万次,期望结果四百万。不加任何同步,本机 -O0 跑出来是 1543164,少了将近两百四十万次;同一份代码换成 -O2,又正好得到 4000000。后者不是正确,只是编译器把累加放进了寄存器、最后才写回一次,碰巧凑齐了总数。两次运行都不构成证据,因为这段代码在语言层面就是错的。
再说等待标志。一个线程循环检查 while (!ready) {},另一个线程把 ready 置为真。不开优化能退出,开了 -O2 可能永远转下去,因为编译器认为循环里没人改这个变量,把它提到寄存器里只读一次。有人加 volatile 解决了,就以为 volatile 是同步原语;它只阻止编译器缓存,不阻止 CPU 重排,也不保证原子性。
最后是无锁队列。压测时偶尔丢一条消息,偶尔读到越界的下标,换台机器、换个优化级别,现象又变了。这三类故障的共同点是:代码的正确性从来没有被语言保证过,只是在某些硬件和优化组合下碰巧能跑。
数据竞争是未定义行为,不是「偶尔算错」
标准里的定义很直接:两个线程访问同一个内存位置,至少有一个是写,且两者之间没有 Happens-Before 关系,这就是数据竞争(data race)。一旦存在数据竞争,整个程序的行为就是未定义行为(undefined behavior,简称 UB)。注意范围:不是「这一次读到了旧值」,而是编译器可以假设竞争不存在,据此做任何优化,包括删掉你的判断、把变量塞进寄存器、把两次读合并成一次。
所以「加个 sleep 就好了」「用 -O0 跑就正常」都不是修复,只是让未定义行为没有暴露。下面这张表是同一段计数代码在本机两种优化级别下的实测结果,第二行特别值得警惕。
| 编译选项 | 普通计数器 | 原子计数器 | 说明 |
|---|---|---|---|
-O0 | 1543164 | 4000000,55 ms | 每次都读写内存,丢更新非常明显 |
-O2 | 4000000 | 4000000,58 ms | 累加被放进寄存器,最后写回一次,总数碰巧对上 |
-O2 那一行的「正确」来自优化把一个循环的一百万次内存读写变成寄存器累加,四个线程各写回一次,合计刚好四百万。它依赖的是未定义行为的具体实现:换个编译器、改一下循环结构、在循环里加一行日志,数字立刻会变。判断代码对不对,不能靠某一次运行结果,只能看有没有建立同步关系。
要让访问合法,只有两条路:把访问变成原子操作,或者用锁、条件变量、future 等机制建立 Happens-Before。没有第三条。原子操作也不是万能药,它只解决「单次访问不撕裂」,多个操作之间的逻辑仍然要自己保证。
std::atomic 保证什么,不保证什么
std::atomic<T> 是 C++11 起提供的原子类型。它保证单个 load、store 和读改写(read-modify-write)操作不可分割:其他线程要么看到操作前的值,要么看到操作后的值,不会看到中间状态。但它不保证「由多个操作组成的逻辑」原子。最典型的是自增:count++ 实际是「读、加一、写回」三步,每一步都原子,整体仍可能交错。
std::atomic<int> n{0};
// 错误示范:两个线程都执行下面两行
int old = n.load(); // 都读到 5
n.store(old + 1); // 都写回 6,只增加了一次
// 正确写法:读改写合成一个原子操作
n.fetch_add(1);
类似的还有 fetch_sub、fetch_or、exchange、compare_exchange。凡是「基于当前值算新值」的逻辑,都必须用这类读改写接口,不能先 load 再 store。
本机实测三个类型:int、long long 和指针的 is_lock_free() 都返回 1,sizeof(std::atomic<long long>) 是 8,和普通 long long 一样。也就是说在这些类型上,原子操作编译成一条带 lock 前缀的指令或等价的 CPU 原子指令,不需要内部锁。换成 16 字节的结构体,可能就变成 lock_free=0,底层改用锁实现,性能完全不同;上生产前值得跑一次这个检查。
还有几个容易忽略的细节。原子类型不可拷贝、不可移动,不能放进需要复制的容器里按值传;它要求对齐,未对齐的原子访问在有些平台直接崩。C++20 起默认构造的 std::atomic 不保证初始化为 0,必须写成 std::atomic<int> n{0};。最重要的是:原子性只覆盖这一个变量,两个原子变量之间的可见顺序仍然可能被重排,这正是下一节要解决的。
六种内存序:一份重排许可清单
内存序(memory order)是给编译器和 CPU 的一份许可清单:允许它们把哪些读写提前或延后。C++ 定义了六种,日常真正用到的其实是四种。
| 内存序 | 语义 | 典型用途 | 代价 |
|---|---|---|---|
relaxed | 只保证本次操作原子,不建立任何跨线程顺序 | 计数、统计量 | 最低 |
acquire | 读操作;它之后的读写不能挪到它前面 | 读到标志后访问数据 | 读屏障 |
release | 写操作;它之前的读写不能挪到它后面 | 写好数据后置标志 | 写屏障 |
acq_rel | 读改写操作同时具备两者 | CAS、需要发布的 fetch_add | 中等 |
consume | 按数据依赖排序,实践中等同 acquire,标准不建议使用 | 极少 | 与 acquire 接近 |
seq_cst | 全局单一顺序,所有 seq_cst 操作像排进同一条队 | 默认值、需要全局一致 | 最高 |
默认参数就是 seq_cst,所以初学时什么都不写反而最安全,只是慢一点。真要压性能时才逐处降级,并且每降一处都要说清它依赖哪个关系、和谁配对。
为什么需要这些?因为「代码顺序」和「其他线程看到的效果」不是一回事。编译器和 CPU 都会重排:编译器为了流水线把读提前,CPU 的 store buffer 让写延迟可见。x86 相对强,只允许「store 之后的 load 提前」,也就是 StoreLoad 重排;ARM、Power 弱得多,load-load、load-store 都可能重排。这解释了为什么在 x86 开发机上写错内存序很难复现,一上 ARM 服务器就出问题。
relaxed:只适合不在乎顺序的地方
统计请求数、命中率这类只求最终总数、不需要别的线程看到「数据已准备好」的场景。拿它来发布数据是错的:读者可能先看到标志、后看到还没填完的内容。
seq_cst:不用想太多的默认
当两个变量必须互斥地只出现一种组合时,只有 seq_cst 能保证。经典的 Dekker 互斥尝试里,两个线程各写自己的标志再读对方的标志,acquire/release 不够,双方可能都读不到对方。
Dekker 那个例子值得记住:两个线程各自写自己的标志、再读对方的标志,结果都读不到对方写的值,于是双方都认为「对方没进临界区」,一起进去了。x86 的 StoreLoad 重排就能造成这种结果,把两个写都改成 seq_cst 才能避免。这也是为什么不能把「加锁」简化成两个 acquire/release 标志。
用 release 与 acquire 发布一份数据
最常见的模式是「发布」:生产者先填好一份数据,再置一个就绪标志;消费者看到标志后再读数据。标志必须用 release 写、acquire 读,否则消费者可能先看到标志为真、后看到还没填完的数据。
#include <atomic>
#include <thread>
struct Payload { int id; int values[16]; };
Payload payload; // 普通内存,不是原子类型
std::atomic<bool> ready{false};
// 生产者线程
payload.id = 7;
for (int i = 0; i < 16; ++i) payload.values[i] = i * i;
ready.store(true, std::memory_order_release);
// 消费者线程
while (!ready.load(std::memory_order_acquire)) {
std::this_thread::yield();
}
// 走到这里,payload 的 16 个值一定已经写完
std::printf("id=%d v0=%d\n", payload.id, payload.values[0]);
「跑什么、看到什么算通过」:编译运行后消费者打印 id=7 v0=0,说明数据完整;把两处内存序都换成 relaxed 再跑,在 x86 上很可能仍然打印正确——这不能证明代码对,只说明这台机器没有暴露重排;用 ThreadSanitizer 编译(g++ -fsanitize=thread)才会指出这里缺少同步关系。这个反例值得亲手做一次,它能纠正「跑对了就是对的」这个直觉。
release 的承诺是「我之前的所有写,对读到这次 release 写的线程可见」,acquire 的承诺是「我之后的读写,不会被挪到这次读之前」。两者必须成对出现在同一个变量的同一次发布与订阅上,只写一半没有意义。反过来,消费者在读完之后对 payload 的修改,生产者看不到,除非再加一次反向的发布。
如果数据会被反复更新,单靠一个布尔标志不够:消费者可能读到「新标志配旧字段的中间态」。这时要么加锁或用序列锁,要么用双缓冲加原子切换索引,把「发布整份快照」变成一次指针交换。思路和上一篇 IPC 里讲的双缓冲完全一样,只是把进程换成了线程。
CAS、ABA 与重试成本
比较并交换(compare-and-swap,CAS)对应 compare_exchange:如果当前值等于期望值,就换成新值并返回成功;否则把当前值写回期望值变量并返回失败。它是绝大多数无锁算法的积木。
std::atomic<int> v{0};
int expected = v.load(std::memory_order_relaxed);
while (!v.compare_exchange_weak(expected, expected + 1,
std::memory_order_acq_rel,
std::memory_order_relaxed)) {
// 失败时 expected 已被更新为最新值,直接重试即可
}
weak 版本允许「假失败」:值明明没变也返回失败,在 ARM 这类 LL/SC 架构上很常见,所以必须写在循环里重试。strong 版本不会假失败,但某些平台实现更贵。循环里不要重新 load,失败时 expected 已经被写成最新值,直接再 CAS 就行。
本机实测:四个线程各 CAS 一百万次,最终 value=4000000,累计失败重试 1963681 次,接近一半的操作白跑了一遍。这是「无锁不等于快」的直接证据:竞争越激烈,CAS 循环越像自旋,CPU 的时间花在失败重试和缓存行来回搬运上。
ABA 是 CAS 的经典陷阱:线程一读到值 A,被切走;线程二把 A 改成 B 又改回 A;线程一回来 CAS 成功,以为自己看到的状态没变。在无锁栈里,这会让一个已经被弹出的节点被重新压入,指针错乱。常见对策是给指针配一个版本号、打包进 128 位一起 CAS;或者用风险指针(hazard pointer)、引用计数,保证节点在被别人使用时不会被回收。
最后这一点才是无锁的真正难点:不只是「怎么改指针」,还有「什么时候可以 delete 一个别人可能正在读的节点」。没有安全的回收方案,写得再漂亮也会 use-after-free。很多看起来能跑的无锁结构,问题都出在这里,而不是出在 CAS 本身。
单生产者单消费者环形队列
SPSC(single producer, single consumer)是最简单也最实用的一种无锁结构:一个线程只写、一个线程只读,不需要 CAS,两个原子索引就够。
#include <atomic>
#include <cstddef>
template <typename T, std::size_t N>
class SpscQueue {
static_assert((N & (N - 1)) == 0, "N 必须是 2 的幂");
public:
bool push(const T& v) {
std::size_t head = head_.load(std::memory_order_relaxed);
std::size_t next = (head + 1) & (N - 1);
if (next == tail_.load(std::memory_order_acquire)) return false; // 满
buf_[head] = v;
head_.store(next, std::memory_order_release);
return true;
}
bool pop(T& out) {
std::size_t tail = tail_.load(std::memory_order_relaxed);
if (tail == head_.load(std::memory_order_acquire)) return false; // 空
out = buf_[tail];
tail_.store((tail + 1) & (N - 1), std::memory_order_release);
return true;
}
private:
T buf_[N];
alignas(64) std::atomic<std::size_t> head_{0};
alignas(64) std::atomic<std::size_t> tail_{0};
};
生产者只改 head_,消费者只改 tail_,各自读对方的索引用 acquire,写自己索引用 release。容量留一个空位,用「next 追上 tail」判满,这样不用额外计数,也不会出现 head 和 tail 相等时分不清空和满。容量取 2 的幂,取模退化成按位与,省掉一次除法。
实测:一个线程 push 一亿次、另一个线程 pop 并累加,输出 sum=500000500000 expected=500000500000 ms=28,值完全对上,耗时二十多到三十多毫秒(随运行波动)。换成一锁一条件变量的队列,同样数据量通常慢一个数量级,因为每次都要唤醒、抢锁、检查条件。
但这个写法只对 SPSC 成立。多生产者时两个线程会同时 CAS head_,需要改成 CAS 循环并处理失败重试;多消费者同理;两者都有就是 MPMC,通常要给每个槽位配一个序号,判断「这一格是不是轮到我」,实现复杂很多。自己写 MPMC 之前先用成熟库,别在业务里发明。
伪共享:两个无关变量为什么互相拖慢
两个线程分别写两个不同变量,逻辑上毫无关系,性能却像在抢同一把锁。原因是它们落在同一条缓存行:CPU 以缓存行为单位同步,一个核改了这行,另一个核手里的副本就失效,得重新拉取。这叫伪共享(false sharing)。
本机 std::hardware_destructive_interference_size 实测是 64,也就是一条缓存行 64 字节。把 head_ 和 tail_ 挨着放,生产者写 head 会让消费者手里的 tail 那行失效,队列吞吐直接掉下来;每个索引单独 alignas(64),各占一行,互不干扰。
注意 alignas 只保证起始对齐。如果变量本身小于 64 字节,它仍可能和后面的变量共享一行,所以通常再配一个填充数组把这一行占满。别把填充写成魔法数字 64:用 hardware_destructive_interference_size,或查目标平台手册,有些 CPU 的缓存行是 128 字节。
伪共享和解锁无关。有些团队把锁换成原子操作后发现更慢,就是因为它把原本「一把锁保护一大片」变成了「多个核频繁写相邻的原子变量」,缓存行来回搬。先测,再改,别把「用了原子」当成优化。
现象、真实原因、第一步查什么
| 你看到的现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 多线程计数结果比预期小 | 自增是读改写三步,整体不是原子;或存在数据竞争 | 改用 fetch_add 或加锁,别只加 volatile |
-O2 下等待标志的死循环不退出 | 编译器把非原子标志缓存进寄存器,认为循环内无人修改 | 改成 std::atomic 加 acquire 读 |
| 偶发读到只初始化了一半的对象 | 缺少 release 与 acquire 的发布关系 | 检查标志和数据的读写是否配对 |
| CAS 循环 CPU 打满、吞吐不涨 | 竞争激烈,失败重试形成风暴 | 减少共享点、分片计数,或换队列结构 |
| 无锁队列压测偶尔丢数据 | 满空判断错、索引未原子、把 SPSC 当 MPMC 用 | 确认生产者与消费者各只有几个线程 |
| 队列越界读写或崩溃 | 容量不是 2 的幂、掩码写错、head 与 tail 更新顺序颠倒 | 核对 N、位掩码和 store 的位置 |
| ThreadSanitizer 报 data race | 确实缺少同步,报告里的两个栈就是竞争点 | 按栈补锁或补原子操作,别忽略报告 |
| 换到 ARM 机器后行为变了 | 弱内存模型暴露了被 x86 掩盖的重排 | 把 relaxed 逐处改成 acquire 或 release |
边界与代价
- 无锁不是默认选项。 低竞争下
std::mutex的开销只有几十纳秒,可读性和可维护性远好于手写无锁;只有压测证明锁是瓶颈,才值得换。 - 原子操作也有成本。 带
lock前缀的指令会锁缓存行,seq_cst还要额外屏障;多个核抢同一个原子变量时,退化和抢锁差不多。 - 安全回收是最大难点。 无锁结构的正确性一半在指针操作,一半在「节点何时能释放」;风险指针、epoch、引用计数各有代价,别低估。
- 平台差异会掩盖错误。 x86 上跑通的代码到 ARM 可能立刻坏;内存序降级必须有测试矩阵,或者至少在 TSan 下跑一遍。
- 复杂度换算得来吗。 无锁代码难读、难改、难排查,交接成本高;除非是通用基础库,业务代码优先选有界队列加锁或线程池。
- 先测再优化。 用性能计数器看缓存未命中、上下文切换,用 TSan 看竞争点;没有数据支撑的「优化」通常是负优化。
当天能自己验证的练习
- 复现丢更新:四个线程各加一百万次,用
-O0和-O2各跑一遍,记录两个数字,并写出第二行为什么会「看起来正确」。 - 把计数器改成
std::atomic<long long> fetch_add,再分别用默认内存序和relaxed计时;顺便打印is_lock_free()和sizeof。 - 用 CAS 循环实现计数器并统计失败次数,把线程数从 2 加到 8,观察重试次数占总操作数的比例怎么变。
- 写一个 SPSC 环形队列,跑一亿条数据核对累加和;再把容量改成非 2 的幂,确认编译期断言会拦住你。
- 做伪共享对比实验:head 和 tail 相邻放与各自
alignas(64)放,各计时一次;再用-fsanitize=thread跑第一题的代码,读一遍竞争报告。
小结
三句话:数据竞争是未定义行为,别用「跑对了」证明代码正确;原子操作只保证单次访问不可分割,跨变量的顺序要靠 acquire 与 release 配对;无锁的难点不在队列本身,而在竞争下的重试成本和节点的安全回收。
到这里,C++ 这一组从语法、类型、指针、类、标准库、内存管理、构建、错误处理、线程、系统调用、文件系统、网络、异步、IPC 到并发底层,已经连成一条完整的线。回头看任何一篇,都应该能对上手里正在写的代码;如果对不上,问题通常不在语言,而在「这个场景该用哪种模型」,那正是这组文章想帮你建立的判断。