C++如何在多线程中避免内存重排-C++-PHP中文网

使用std::atomic和内存序（如memory_order_release/acquire）可有效防止C++多线程中的内存重排，确保共享数据的可见性和顺序性。

c++如何在多线程中避免内存重排

在C++多线程编程中，避免内存重排的核心策略是使用原子操作（

std::atomic

登录后复制

）和内存屏障/栅栏（
std::atomic_thread_fence
登录后复制
）。这些机制能够强制编译器和CPU遵循特定的内存访问顺序，从而确保不同线程间共享数据的可见性和一致性，有效防止因重排导致的竞态条件和数据不一致问题。

解决方案

要有效避免C++多线程中的内存重排，我们主要依赖

std::atomic

登录后复制

类型和其提供的内存序（

memory_order

登录后复制

）语义。

std::atomic

登录后复制

封装了对基本数据类型的原子操作，这些操作本身就包含了必要的内存屏障指令，以确保在不同线程间的可见性和顺序性。

具体来说，当对一个共享变量进行读写时，如果这个变量不是

std::atomic

登录后复制

类型，那么编译器和CPU可能会为了优化性能，改变这些操作的执行顺序，或者将写操作的结果延迟到其他线程可见。这在单线程环境下通常无害，但在多线程中就可能导致一个线程看到的内存状态与另一个线程实际执行的顺序不符。

std::atomic

登录后复制

通过其内置的内存序参数，允许我们精细地控制原子操作的可见性保证。最常用的内存序包括：

立即学习“C++免费学习笔记（深入）”；

std::memory_order_relaxed
登录后复制
: 最弱的内存序，只保证操作本身的原子性，不提供任何跨线程的顺序保证。它就像是说：“我只管我自己，不关心别人怎么看。”
std::memory_order_acquire
登录后复制
: 读操作使用，确保该操作之后的所有内存访问不会被重排到该操作之前。它就像是说：“我拿到这个值之后，才能开始做其他事情。”
std::memory_order_release
登录后复制
: 写操作使用，确保该操作之前的所有内存访问不会被重排到该操作之后。它就像是说：“我把所有事情都做完之后，才把这个值放出去。”
std::memory_order_acq_rel
登录后复制
: 读-改-写操作使用，同时具备
```
acquire
```
登录后复制
和
```
release
```
登录后复制
的语义。
std::memory_order_seq_cst
登录后复制
: 最强的内存序，提供全局的顺序一致性。所有使用
```
seq_cst
```
登录后复制
的操作都会在一个单一的全局总序中被执行，且对所有线程可见。虽然最安全，但性能开销也最大。

通常，我们会将

release

登录后复制

操作与

acquire

登录后复制

操作配对使用，以建立一个“同步点”，确保

release

登录后复制

操作之前的所有内存写入对

acquire

登录后复制

操作之后的所有内存读取都是可见的。

对于那些不能直接使用

std::atomic

登录后复制

封装的复杂数据结构，或者需要在非原子操作之间建立顺序关系的场景，我们可以使用

std::atomic_thread_fence

登录后复制

来显式插入内存屏障。它不关联任何数据，只是在程序流中插入一个屏障，强制屏障两侧的内存操作不能跨越屏障重排。

#include <atomic>
#include <thread>
#include <vector>
#include <iostream>

std::atomic<bool> ready_flag(false);
int data = 0;

void producer() {
    data = 42; // 非原子操作
    // 确保data的写入在ready_flag设置为true之前完成
    ready_flag.store(true, std::memory_order_release); 
    std::cout << "Producer set data and flag." << std::endl;
}

void consumer() {
    // 等待ready_flag变为true
    while (!ready_flag.load(std::memory_order_acquire)) {
        std::this_thread::yield(); // 避免忙等
    }
    // 确保在读取data之前，ready_flag的写入已经可见
    std::cout << "Consumer read data: " << data << std::endl;
}

int main() {
    std::thread t1(producer);
    std::thread t2(consumer);

    t1.join();
    t2.join();

    return 0;
}

登录后复制

在这个例子中，

ready_flag.store(true, std::memory_order_release)

登录后复制

确保

data = 42

登录后复制

这个非原子操作的写入，在

ready_flag

登录后复制

被设置为

true

登录后复制

之前完成，并且对其他线程可见。而

ready_flag.load(std::memory_order_acquire)

登录后复制

则确保当它读取到

true

登录后复制

时，

data = 42

登录后复制

的写入也已经可见。如果没有这些内存序，

consumer

登录后复制

线程可能会在

data

登录后复制

还没被写入42之前就读取到它。

为什么CPU和编译器会进行内存重排？

内存重排并非一个“错误”，而是现代计算机系统为了追求极致性能而采取的一种优化手段。它发生在两个层面：

编译器重排（Compiler Reordering）：编译器在生成机器码时，可能会改变指令的执行顺序，只要这种改变不影响单线程程序的最终结果。比如，如果两个独立的内存操作之间没有数据依赖，编译器可能会交换它们的顺序，以便更好地利用CPU的流水线或减少缓存未命中。它就像一个高效的厨师，为了更快地准备好菜品，可能会先切菜再烧水，而不是严格按照食谱一步步来，只要最终的菜品味道不变。
处理器重排（Processor Reordering）：现代CPU拥有复杂的乱序执行（Out-of-Order Execution）引擎。它们不会严格按照程序指令的顺序执行，而是会动态地分析指令之间的依赖关系，并尽可能地并行执行独立的指令。此外，CPU的缓存系统也会引入写入缓冲（Write Buffer）和缓存一致性协议（Cache Coherence Protocol）等机制，这些都可能导致一个处理器核心的写入操作，不能立即被另一个核心观察到。举个例子，你给朋友发消息，消息先进入你的发送队列，而不是直接出现在朋友的手机上，这个过程就存在一个“延迟”和“重排”的可能。

这些优化在单线程环境中是完全透明且有益的，它们显著提升了程序的执行效率。但在多线程环境中，当多个线程共享数据时，如果没有适当的同步机制，这些重排就会打破我们对程序执行顺序的直观假设，导致数据不一致、竞态条件等难以调试的并发问题。因此，理解内存重排的本质，才能更好地选择合适的同步原语来“驯服”它。

std::atomic 如何保证内存可见性和顺序性？

std::atomic

登录后复制

通过在底层插入内存屏障（Memory Barriers）指令来保证内存的可见性和顺序性。这些屏障指令会强制CPU和编译器在特定点上停止重排操作，并确保之前的所有内存写入对其他处理器核心可见，同时刷新或失效相关缓存行。

让我们深入看看不同的

memory_order

登录后复制

是如何实现这一点的：

FashionLabs

AI服装模特、商品图，可商用，低价提升销量神器

查看详情

```
std::memory_order_relaxed
```
登录后复制
:
- 保证: 仅保证操作本身的原子性。
- 机制: 通常不插入任何内存屏障。它允许编译器和CPU对原子操作周围的内存访问进行任意重排，只要不破坏操作本身的原子性。这在某些计数器或统计场景中非常有用，比如一个线程只增加计数器，而不关心其他线程何时看到最新值。
- 示例:
```
counter.fetch_add(1, std::memory_order_relaxed);
```
  登录后复制
```
std::memory_order_acquire
```
登录后复制
:
- 保证: 一个
```
acquire
```
  登录后复制
  操作（通常是读操作）会“获取”内存，确保该操作之后的所有内存访问不会被重排到
```
acquire
```
  登录后复制
  操作之前。同时，它保证了在之前某个线程执行的
```
release
```
  登录后复制
  操作（或更强的内存序操作）所导致的所有内存写入，在当前线程的
```
acquire
```
  登录后复制
  操作之后都是可见的。
- 机制: 在某些架构上，这可能意味着在
```
acquire
```
  登录后复制
  操作之后插入一个读屏障（Load Barrier），阻止后续的读操作越过它被提前执行。
- 示例:
```
while (!flag.load(std::memory_order_acquire)) { /* spin */ }
```
  登录后复制
```
std::memory_order_release
```
登录后复制
:
- 保证: 一个
```
release
```
  登录后复制
  操作（通常是写操作）会“释放”内存，确保该操作之前的所有内存访问不会被重排到
```
release
```
  登录后复制
  操作之后。它保证了在当前线程
```
release
```
  登录后复制
  操作之前的所有内存写入，对其他线程的
```
acquire
```
  登录后复制
  操作（或更强的内存序操作）是可见的。
- 机制: 在某些架构上，这可能意味着在
```
release
```
  登录后复制
  操作之前插入一个写屏障（Store Barrier），阻止之前的写操作越过它被推迟执行。
- 示例:
```
data = 123; flag.store(true, std::memory_order_release);
```
  登录后复制
```
std::memory_order_acq_rel
```
登录后复制
:
- 保证: 用于读-改-写（RMW）操作，同时具备
```
acquire
```
  登录后复制
  和
```
release
```
  登录后复制
  的语义。它既能看到之前
```
release
```
  登录后复制
  操作的写入，又能让它之前的写入对后续的
```
acquire
```
  登录后复制
  操作可见。
- 机制: 结合了读屏障和写屏障的特性。
- 示例:
```
value.fetch_add(1, std::memory_order_acq_rel);
```
  登录后复制
```
std::memory_order_seq_cst
```
登录后复制
:
- 保证: 提供最强的内存序保证——顺序一致性。所有使用
```
seq_cst
```
  登录后复制
  的原子操作，在所有线程看来，都将以一个单一的、全局一致的顺序发生。
- 机制: 通常会插入全能屏障（Full Barrier），它既是读屏障也是写屏障，并且可能涉及额外的缓存同步操作。这会带来最高的性能开销，因为它限制了编译器和CPU的优化空间。
- 示例:
```
flag.store(true, std::memory_order_seq_cst);
```
  登录后复制

通过这些不同的内存序，

std::atomic

登录后复制

允许开发者在性能和正确性之间做出权衡。理解它们各自的保证和开销，是编写高效且正确的并发代码的关键。简单来说，

acquire

登录后复制

和

release

登录后复制

操作协同工作，就像在两个线程之间架起了一座“桥梁”，确保了数据流动的方向和可见性。

除了std::atomic，还有哪些低级机制可以避免内存重排？

虽然

std::atomic

登录后复制

是C++11及更高版本中推荐的、更高级别的内存重排解决方案，但在某些特殊场景或为了理解底层机制，我们仍然会接触到一些更低级的技术。

一个值得关注的是

std::atomic_thread_fence

登录后复制

。它不与任何特定的数据关联，而是直接在代码中插入一个内存屏障。它同样接受

std::memory_order

登录后复制

参数，用于指定屏障的强度。

#include <atomic>
#include <thread>
#include <iostream>

int shared_data = 0;
std::atomic<bool> data_ready(false);

void writer_thread() {
    shared_data = 100; // 非原子写
    // 在这里插入一个release fence，确保shared_data的写入在fence之前完成，
    // 并且对后续的acquire fence可见
    std::atomic_thread_fence(std::memory_order_release); 
    data_ready.store(true, std::memory_order_relaxed); // 这里relaxed是因为fence已经提供了顺序
    std::cout << "Writer finished." << std::endl;
}

void reader_thread() {
    while (!data_ready.load(std::memory_order_relaxed)) {
        std::this_thread::yield();
    }
    // 在这里插入一个acquire fence，确保在读取shared_data之前，
    // writer_thread的release fence之前的写入已经可见
    std::atomic_thread_fence(std::memory_order_acquire);
    std::cout << "Reader got data: " << shared_data << std::endl;
}

int main() {
    std::thread t1(writer_thread);
    std::thread t2(reader_thread);

    t1.join();
    t2.join();

    return 0;
}

登录后复制

在这个例子中，

std::atomic_thread_fence(std::memory_order_release)

登录后复制

确保了

shared_data = 100

登录后复制

的写入在

fence

登录后复制

之前完成并对其他线程可见。而

std::atomic_thread_fence(std::memory_order_acquire)

登录后复制

则保证了当它执行时，

writer_thread

登录后复制

中

release fence

登录后复制

之前的写入（即

shared_data = 100

登录后复制

）都已经对

reader_thread

登录后复制

可见。

data_ready

登录后复制

本身可以

relaxed

登录后复制

，因为它只是一个信号，真正的同步由

fence

登录后复制

来完成。

除了

std::atomic_thread_fence

登录后复制

，还有一些更底层的、平台相关的机制：

平台特定的内存屏障指令：例如，在x86/x64架构上，有
```
_mm_mfence
```
登录后复制
（全能屏障）、
```
_mm_lfence
```
登录后复制
（读屏障）、
```
_mm_sfence
```
登录后复制
（写屏障）等CPU指令。这些通常通过编译器内联函数（intrinsics）暴露出来。它们提供了最直接的CPU控制，但缺乏可移植性，且使用起来需要非常深入的硬件知识。通常，我们应该优先使用C++标准库提供的抽象，因为它们会根据目标平台选择最合适的底层指令。
互斥锁（Mutexes）和条件变量（Condition Variables）：虽然它们的主要作用是提供互斥访问和线程间的等待/通知机制，但它们在实现上通常也包含了隐式的内存屏障。例如，当一个线程释放一个互斥锁时，它通常会执行一个
```
release
```
登录后复制
语义的操作；当另一个线程获取同一个互斥锁时，它会执行一个
```
acquire
```
登录后复制
语义的操作。这意味着，在锁的保护下进行的所有内存操作，其可见性会得到保证。这也是为什么在多线程编程中，只要正确使用互斥锁，通常就不需要额外考虑内存重排的问题。它们为我们提供了一个更高级别的、更易于使用的同步抽象。