【C++并发系列】第十一章：ence 和 barrier 是什么

博主介绍：程序喵大人

• 35 - 资深C/C++/Rust/Android/iOS客户端开发
• 10年大厂工作经验
• 嵌入式/人工智能/自动驾驶/音视频/游戏开发入门级选手
• 《C++20高级编程》《C++23高级编程》等多本书籍著译者
• 更多原创精品文章，首发gzh，见文末
• 👇👇记得订阅专栏，以防走丢👇👇
  😉C++基础系列专栏
  😃C语言基础系列专栏
  🤣C++大佬养成攻略专栏
  🤓C++训练营
  👉🏻个人网站

我们先从一个真实的工程线上的事故说起。在我们团队过往的经验中，曾经有一段无锁队列代码在线上环境偶尔会读取到旧数据。初版代码使用的是 release/acquire 配对的标准发布模式，运行一直很稳定。后来在排查另一个性能问题时，一位工程师为了优化性能，将原来的 store 和 load 降级成了 relaxed 级别，并在其前后分别补充了 std::atomic_thread_fence。他当时认为这在理论上是等价的，并且在某些平台上能节省开销。代码通过了审查和 CI 测试，上线后初期也未见异常。然而一周之后，这个偶发的旧数据 Bug 在一批采用 ARM 架构的机器上频繁出现。

事后排查这段代码时发现，他确实加上了对应的 fence，而且从大概的逻辑上看位置似乎也放对了。但真正的问题在于，fence 在具体代码行之间的摆放位置出现了偏差：release fence 被错误地放置在了 atomic store 之后，而 acquire fence 又被过早地放在了关键的数据读取之前。单独看每一行代码似乎都没问题，但组合起来时，跨线程的同步链并没有真正连接上。在 x86 架构这种强内存模型下，硬件自身带有的顺序保证掩盖了这个问题；而一旦切换到属于弱内存模型的 ARM 架构上，硬件底层的保护屏障消失，同步缺失的 Bug 就暴露出来了。

这起事故揭示了 fence 在工程开发中容易被误用的一面：它不是一种简单的修饰符，而是一组针对前后内存操作生效的、具有方向性的约束屏障。这套约束如何与原子变量精确配合形成跨线程的同步，以及它的位置敏感性，是我们必须要弄清楚的重点。

本章的目的并不是将 fence 推荐为常规的开发工具。看完这一章后，我希望你能明白 fence 的作用机制、它与自带内存序的 atomic 操作之间的关系，以及为什么在多数情况下我们应该尽量避免直接使用它。此外，当阅读他人编写的 fence 代码时，你能有能力去判断其同步链是否正确。

先看清楚不带 fence 的标准版本

为了更好地理解 fence 的机制，我们需要先回顾一下第 08 章中介绍的安全发布代码。

#include <atomic>

int data = 0;
std::atomic<bool> ready{false};

void Producer() {
    data = 42;                                          // (1)
    ready.store(true, std::memory_order_release);       // (2)
}

void Consumer() {
    while (!ready.load(std::memory_order_acquire)) {    // (3)
    }
    Use(data);                                          // (4)
}

这段代码建立同步链的逻辑我们之前详细探讨过：ready.store(true, release) 在生产者端封住了前面的 data = 42，而 ready.load(acquire) 则在消费者端挡住了后面的 Use(data)。当执行到 (3) 并且读到了 (2) 写入的 true 时，这两个原子操作之间就建立了 synchronizes-with 关系，保证了 (1) 的写入对 (4) 可见。

在这里需要注意一个关键细节：ready.store(true, std::memory_order_release) 这行代码在底层同时完成了两件事。首先，它将 true 写入 ready 这个原子变量；其次，它给排在前面的 data = 42 施加了一个顺序约束，确保之前的内存操作不会被重排到这次写入之后。这两件事被绑定在同一行代码里，使得代码的发布动作和顺序约束都集中在一处。

同样地，消费者端的 ready.load(std::memory_order_acquire) 也采用了这种绑定结构。它将"读取 ready 状态"和"给后续读取施加顺序约束"结合在了一起。

这种"原子操作 + 内存顺序约束"紧密捆绑的写法，是 C++ 内存模型在工程实践中最推荐的做法。它的优势在于同步意图清晰------审查者看到 release 就知道这是数据发布点，看到 acquire 就明白这是接收点，顺序约束作用在何处一目了然。

在硬件层面，编译器遇到 ready.store(true, release) 也会执行两个动作：生成对 ready 地址的写指令（在 x86 上通常是普通的 mov，在 ARM 上则是带有 release 语义的 stlr 指令），并在代码生成时确保前面的写入指令不会被挪到该指令之后。这样，编译器的行为与开发者的理解保持了同步。

fence 把排序约束单独拎出来

std::atomic_thread_fence 提供了另一种方式：它将"原子访问"和"顺序约束"拆分开来。

我们可以尝试用 fence 来改写同样的发布逻辑：

#include <atomic>

int data = 0;
std::atomic<bool> ready{false};

void Producer() {
    data = 42;                                              // (1)
    std::atomic_thread_fence(std::memory_order_release);    // (2) release fence
    ready.store(true, std::memory_order_relaxed);           // (3)
}

void Consumer() {
    while (!ready.load(std::memory_order_relaxed)) {        // (4)
    }
    std::atomic_thread_fence(std::memory_order_acquire);    // (5) acquire fence
    Use(data);                                              // (6)
}

观察这段重构后的代码，可以看到几个显著的变化。

首先，ready.store 和 ready.load 的内存序级别都被降为了 relaxed。这意味着它们现在仅承担读写原子变量的责任，不再附带任何方向上的顺序约束。

其次，发布动作的顺序约束被提取到了 (2) 这一行：std::atomic_thread_fence(std::memory_order_release)。这行代码不读写任何变量，而是作为一道屏障，确保它之前的写操作不会被重排到它之后。

同样，接收动作的顺序约束也被提取到了 (5) 这一行：std::atomic_thread_fence(std::memory_order_acquire)。它也是一道屏障，确保它之后的读操作不会被重排到它之前。

从逻辑推演上看，这种分离式写法和之前的组合式写法是等价的，跨线程的同步链依然成立。C++ 标准对此有明确说明：如果生产者执行了 release fence，随后在程序顺序上执行了对某变量 X 的 atomic store；而消费者从同一个变量 X 上执行了 atomic load 读到了该值，随后在程序顺序上执行了 acquire fence------那么，位于 release fence 之前的内存写入，将对 acquire fence 之后的内存读取可见。

按照执行流梳理一遍：

生产者侧                                     消费者侧
  data = 42                  ┐
        ↓ sequenced-before   │
  release fence  ┐           │
        ↓        │ 这道屏障  │
  ready.store    ┘ 封住前面  │
        |                    │
        |          synchronizes-with（通过 ready 配对）
        ↓                    │
                             ready.load  ┐
                                  ↓      │ 这道屏障
                             acquire fence┘ 挡住后面
                                  ↓ sequenced-before
                             Use(data)

这四个部分拼出了一条完整的 happens-before 链条。生产者将 data = 42 置于 release fence 之前；中间通过 ready 变量上的 relaxed 操作完成线程间同步；消费者通过 acquire fence 将 Use(data) 置于屏障之后。链条上游的写入对下游的读取可见。

需要指出的是，同步关系依然需要通过 ready 这个原子变量来建立。fence 自身不包含关于它在发布哪个变量的信息，它仅负责对前后的内存操作施加约束。两个线程之间传递状态信号的媒介仍然是 ready 的读写。fence 仅仅改变了顺序约束在代码中的物理位置，并没有改变线程间配对的变量。

关于 fence 的配对，有一个对称性问题需要澄清。release fence 搭配 relaxed store 的组合，能与什么组合配对？它必须配对 relaxed load 加上 acquire fence，但不仅限于此。如果消费者直接使用的是 acquire load，它同样能够与生产者的 release fence 加上 relaxed store 形成同步。标准定义了 fence-to-fence 以及 fence-to-atomic 两种配对规则。因此，以下四种组合实际上是互相兼容的：

生产者使用的组合	消费者使用的组合
release store	acquire load
release store	relaxed load + acquire fence
release fence + relaxed store	acquire load
release fence + relaxed store	relaxed load + acquire fence

这说明在实际开发中，生产者和消费者可以各自独立决定是否使用 fence。但在工程实践中，除非有明确的性能优化依据（例如需要批量发布多个 relaxed 状态），否则我们依然建议两侧统一使用标准的 release/acquire 操作。这种写法上的一致性有助于降低代码的维护成本。

此外，拆分了 fence 的写法在阅读上更加耗费心智。标准写法的同步意图集中在 release 或 acquire 的参数上；而 fence 的写法将同步意图分摊到两个位置，审查代码时必须将这两者拼凑起来理解。

更微妙的是，fence 屏障在代码里是"无名"的。它并未指明自己正在为哪个原子变量提供保障。审查者需要联系相邻的 atomic 操作，在上下文中寻找与之配套的读写。如果代码经过重构，原有的相邻关系被打破，最初的配对意图可能就会变得模糊不清。

fence 的位置如果放错了，约束就拦不到关键的操作

由于 fence 是上下文相关的方向性约束，它对在源码中的位置极其敏感。一旦位置放错，约束的作用范围就会偏离，同步链就会断裂。

来看一个错位的示例：

void BadProducer() {
    std::atomic_thread_fence(std::memory_order_release);    // 屏障跑到了前面
    data = 42;
    ready.store(true, std::memory_order_relaxed);
}

void BadConsumer() {
    while (!ready.load(std::memory_order_relaxed)) {
    }
    Use(data);
    std::atomic_thread_fence(std::memory_order_acquire);    // 屏障跑到了后面
}

在生产者端，release fence 被错误地放置在 data = 42 之前。release fence 的作用是约束排在它之前的内存操作，但现在它前面没有相关的写入操作，而它本该约束的 data = 42 则处于其管辖范围之外。这样一来，data = 42 可以被编译器自由重排到 ready.store 之后，导致数据的发布不完整。

在消费者端，Use(data) 这个读取操作跑到了 acquire fence 之前。acquire fence 的作用是约束排在它之后的内存读取，而现在的 Use(data) 脱离了这层保护，可能会被提前到 ready.load 之前执行，从而读到一个过期的初始值。

结合这两个错误，消费者在执行 Use(data) 时读到的极有可能不是 42，而是 0。

这种错误的危险在于，代码从语法上看完全合法，编译器不会报错，单元测试在 x86 机器上也可能顺利通过。只有在部署到弱内存模型架构时，才会暴露问题。这正是 fence 难以审查的原因之一------它将约束和原子访问拆分，要求开发者自己确保 fence 置于正确的相对位置。

不少开发者写错 fence 的原因在于，他们将 fence 理解为双向的屏障。但 C++ 标准里的 fence 不是双向隔离的，release fence 的约束范围是其前面的操作，acquire fence 则是其后面的操作。fence 是单向的限制，而非阻断所有重排的闸门。

为了避免用错，可以记住以下位置规则：

第一，release fence 必须位于普通数据的写入操作之后，且在原子变量的发布操作之前。 也就是放置在数据准备完毕和对外声明状态这两步之间。 第二，acquire fence 必须位于成功读取到发布标记之后，且在开始读取普通数据内容之前。 也就是放置在收到状态信号和实际使用数据这两步之间。

除此之外，还有一种不易察觉的错位，即 fence 被放置在仅于特定条件下执行的分支中：

void TrickyProducer() {
    data = 42;
    if (some_condition) {
        std::atomic_thread_fence(std::memory_order_release);
    }
    ready.store(true, std::memory_order_relaxed);
}

当 some_condition 为 false 时，release fence 被跳过，导致 data = 42 和 ready.store 之间失去顺序约束。消费者可能会读到未准备好的数据。

同样的情况也可能发生在 fence 被放入循环体或复杂的闭包中时。原生的 release/acquire 模式则没有这种问题，因为 release 约束是与 atomic store 绑定的，只要发生了写入，约束自然生效；如果不执行写入，状态也就不会被发布。

在普通变量上加 fence 依然属于 data race

有一种误用场景是，开发者将原有的原子变量改为普通变量，然后试图通过在外围添加 fence 来解决同步问题。

int data = 0;
bool ready = false;    // 普通 bool 变量，并非 atomic

void Producer() {
    data = 42;
    std::atomic_thread_fence(std::memory_order_release);
    ready = true;
}

void Consumer() {
    while (!ready) {
    }
    std::atomic_thread_fence(std::memory_order_acquire);
    Use(data);
}

这段代码看似使用了 release 和 acquire 形成同步，但它存在一个根本性问题：ready 只是一个普通的布尔变量。当两个线程在没有锁保护的情况下并发读写同一个普通变量时，这在 C++ 内存模型中构成了数据竞争（data race），导致程序行为未定义。

fence 无法改变这一点。fence 可以给前后的合法内存操作提供顺序约束，但不能将对普通变量的并发访问转化为合法的原子访问。线程间通过某个变量传递状态信号的前提是，该变量必须是原子的。

在具体执行中，这种做法会遇到几个典型的问题。首先，编译器可能会对消费者的 while (!ready) 进行循环不变式外提优化，将其缓存到寄存器中，导致线程陷入死循环。其次，在缓存层面，即使编译器不优化循环，CPU 仍可能一直读取本地缓存中的旧值。最后，并发检测工具（如 ThreadSanitizer）会立刻报告该普通变量上的数据竞争。

如果为了消除 TSan 警告而将 ready 改为 atomic<bool>，那么原本的 fence 往往就失去了意义，因为直接使用 atomic 自带的 release/acquire 已经足以解决问题。

这说明了 fence 在并发控制中的真实定位：fence 专门负责提供"顺序约束"，而原子变量专门负责承担"跨线程通信"。两者缺一不可。

辨析 thread fence、signal fence、编译器屏障与硬件屏障

在阅读并发代码时，容易混淆几个相关的术语。厘清它们的边界有助于理解代码的底层行为。

std::atomic_thread_fence 是 C++ 提供的线程间同步原语接口。它的主要功能是配合原子变量完成跨线程的可见性同步，至于在底层翻译成什么机器指令，取决于目标硬件平台。在强内存模型的 x86 架构下，针对 release fence 和 acquire fence，编译器通常只需插入编译器屏障，因为 x86 已经提供了足够的顺序保证；只有使用 seq_cst fence 时，才会生成诸如 mfence 的硬件屏障指令。而在弱内存模型的 ARM 架构上，release fence 通常对应 dmb ishst，acquire fence 对应 dmb ishld，seq_cst fence 则对应完整的 dmb ish。

以下是主流微架构平台上几种 fence 的生成情况概览：

C++ 源码写法	x86-64 生成情况	ARMv8 生成情况
atomic_thread_fence(relaxed)	无指令	无指令
atomic_thread_fence(acquire)	仅编译器屏障	dmb ishld
atomic_thread_fence(release)	仅编译器屏障	dmb ish（部分实现不同）
atomic_thread_fence(acq_rel)	仅编译器屏障	dmb ish
atomic_thread_fence(seq_cst)	mfence	dmb ish

由此可见，同一行 fence 源码在不同平台上生成的底层指令和代价可能相差甚远。这也解释了为何错误摆放 fence 的代码在 x86 环境下可能正常运行，而在 ARM 下会暴露问题。

std::atomic_signal_fence 则是一个应用范围非常狭窄的版本。它仅用于约束编译器在当前执行线程内部的指令重排，不会生成任何硬件同步指令。它的目标场景是解决信号处理函数与主流程代码之间的状态同步问题。在日常的多线程编程中，几乎不会用到它。

编译器屏障（compiler barrier）通常指用来阻止编译器对内存访问指令进行重排的标记指令，例如 GCC 中的 asm volatile("" ::: "memory")。C++ 标准库没有专门的 compiler barrier 接口，但 atomic_signal_fence 在效果上类似；而在 x86 下，普通的 release/acquire 级别的 atomic_thread_fence 实际也主要充当编译器屏障的作用。

硬件屏障（hardware barrier）特指 CPU 指令集层面的内存屏障机器指令，如 x86 的 mfence 和 ARM 的 dmb。这些指令直接干预 CPU 的内存子系统，强制规定屏障前后的内存读写顺序，通常伴随较高的性能开销，因为它们可能要求清空写缓冲区或等待缓存一致性协议同步。

总结来说，在 C++ 源码中写下 atomic_thread_fence 并不等同于在底层一定生成一条内存屏障指令。编译器会结合内存序参数和目标微架构平台，最终决定插入哪些物理约束指令。

在工程实践中怎么决定到底用不用 fence

在了解了 fence 的原理后，我们需要考虑在日常工程中何时使用它。

通用的决策原则是：在非特定优化的常规场景中，优先考虑使用标准的 store(release) 加上 load(acquire) 原子操作。因为这种写法逻辑清晰，易于代码审查，并且在大多数情况下编译器生成的机器码质量也足够好。只有在一些特定且理由充分的情况下，才考虑用 fence 进行改写优化。

这些特定的场景主要包括：

第一，一批并行的原子操作需要共享同一道屏障。 如果在某个临界点上，你需要将多个带有 relaxed 标记的原子操作统一拉升可见性，那么使用一道 fence 会比给每个操作单独加上 release 标记更节省开销。这种情况多见于并发基础设施的核心模块（如某些无锁队列的节点批量发布动作）。

第二，性能分析工具指出了明确的瓶颈。 在弱内存模型的平台上，反复执行带有 release/acquire 语义的原子操作可能会比执行 relaxed 加上统一的 fence 稍显昂贵。但在做出优化决定前，必须有具体的 profiler 数据作为支撑，否则很可能是过早优化，节省的时间有限，却带来了额外的审查和维护成本。

第三，复用既有的经典 fence 设计模式。 某些经典的无锁算法最初就是以 fence 的视角构建的。如果是移植或维护这类代码库，顺应原有的设计思路保留 fence 是合理的，但同时应保留详细的注释说明。

来看一个工程中合理使用 fence 的例子：在某个高频更新场景下，生产线程需要累加一批 relaxed 计数器，并在最后将结果统一发布给消费者：

std::atomic<int> counter_a{0};
std::atomic<int> counter_b{0};
std::atomic<int> counter_c{0};
std::atomic<bool> snapshot_ready{false};

void Producer() {
    counter_a.fetch_add(1, std::memory_order_relaxed);
    counter_b.fetch_add(1, std::memory_order_relaxed);
    counter_c.fetch_add(1, std::memory_order_relaxed);

    std::atomic_thread_fence(std::memory_order_release);
    snapshot_ready.store(true, std::memory_order_relaxed);
}

如果在这种场景下将每个 fetch_add 都升级为 release 级别，在 ARM 架构上将增加多条 dmb 指令的开销。业务需求只要求在发布点统一保证可见性，因此使用一道 release fence 将前面的 relaxed 操作笼罩住，再进行 relaxed store 是一次合理的优化。

然而，在这种合理的使用场景下，代码周边的注释依然必不可少。后续的维护者需要清楚地知道这道 fence 与哪个原子变量配对，它保护了哪些 relaxed 操作，以及为什么没有直接使用 release/acquire。

在决定引入 fence 之前，可以对照以下问题进行自查：

1. 配对的原子变量明确了吗？ fence 必须和某个原子变量上的 load/store 动作形成配合，请在注释中说明配对目标。
2. 位置是否准确无误？ release fence 需置于普通写入和原子发布操作之间；acquire fence 需置于原子读取操作和后续的普通读取之间。
3. 通信变量是 atomic 吗？ 用于跨线程传递信号的共享变量必须使用 std::atomic 声明。
4. 是否存在旁路分支绕开 fence 的可能？ 确认执行控制流中的特殊路径（如异常、提前返回）不会在绕开 fence 的情况下读写通信变量。
5. 是否包含了详尽的注释？ 注释需说明搭桥的原子变量、受保护的非原子操作区间以及采用 fence 的设计考量。

如果无法在设计中顺畅地回答这些问题，通常表明改回标准的 release/acquire 是更为稳妥的选择。

对于代码重构，如果你接手了包含现有 fence 逻辑的代码，可以考虑将其退回为 release/acquire 模式以提高可读性。最常规的改写是将生产者的 release fence 结合 relaxed store 合并为 release store；将消费者的 relaxed load 结合 acquire fence 合并为 acquire load。但在执行这一重构时，需要注意如果原来的 release fence 是为了统一保护多个 relaxed store，单纯合并并全部升级操作可能会引入多余的屏障，反而降低性能。在合并前，务必评估其在目标架构上的性能影响。

怎么读别人手写的 fence 代码

在代码评审时，遇到他人手写的 fence 代码，可以遵循以下步骤进行排查：

第一步，找出与 fence 配对的核心 atomic 变量。对于 release fence，向后查找相邻的负责发布的 atomic store 操作；对于 acquire fence，向前查找负责接收信号的 atomic load 操作。

第二步，确认通信的两端使用的是同一个原子变量。不同的 atomic 变量之间无法形成跨线程的 fence 同步。

第三步，明确受保护的操作集合。在生产者一侧，列出 release fence 之前的普通写入；在消费者一侧，列出 acquire fence 之后的读取操作。核实这些读取是否确有必要看到前序的写入，并检查是否有操作越出了保护范围。

第四步，检查代码的控制流。确认 fence 在所有的正常及异常执行路径上都能被正确执行，没有被条件跳转意外跳过。

第五步，留意版本修改历史。由于 fence 对物理位置敏感，早期的代码重构可能会意外改变操作与 fence 之间的相对位置。如果代码近期经过频繁修改，需要更加仔细地审查。

走完这五步，基本可以对一段基于 fence 的并发代码做出准确判断。这个审查流程要比直接评审 release/acquire 复杂，这也是我们在日常开发中优先推荐标准写法的根本原因，它更易于长期的团队协作与维护。

从顺序约束转向缓存开销

至此，关于"内存可见性顺序约束"的话题算是全面展开过了。无论是将约束与原子操作绑定的 release/acquire，还是将其分离的 fence，它们的底层技术目标是一致的。

但需要注意的是，在多线程系统里，使得代码运行缓慢的性能开销，不仅仅来源于为了保证可见性而插入的屏障指令。在现代多核 CPU 架构中，还有一笔非常普遍的成本：缓存一致性代价。

哪怕你的代码中全部采用了 relaxed 操作，没有任何 fence 屏障，只要两个独立的处理器核心在并发读写同一小块内存，承载着这些数据的缓存行（Cache Line）就会在不同核心的高速缓存间频繁转移。这个过程本身就会带来显著的延迟开销。

更为棘手的情况是，有时候代码中看似不相关的两个变量，因为内存布局紧凑而落在了同一条 64 字节的缓存行内。当两个核心分别独立高频访问各自的变量时，硬件的一致性协议会被迫将整条缓存行当成一个整体在核心间不断锁定和刷新。这种现象在学术界被称为"伪共享"（False Sharing）。伪共享能让在逻辑上高度并行的多线程代码在实际执行时暴露出严重的性能倒退。

在接下来的章节中，我们将深入探讨现代 CPU 内部的缓存子系统，以及 false sharing 的作用机制，并探讨如何通过内存对齐和空字节填充技术来缓解这一问题。

码字不易，欢迎大家点赞，关注，评论，谢谢！