C++ `std::atomic` 内存顺序：`seq_cst`, `acquire`, `release`, `relaxed` 的精确选择 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

哈喽，各位好！今天咱们来聊聊 C++ std::atomic 的内存顺序，这玩意儿听起来高大上，其实就是告诉编译器和 CPU，你别太浪，有些事情得按规矩来。咱们的目标是搞清楚 seq_cst、acquire、release 和 relaxed 这四个小家伙，看看在不同的场景下，该选哪个才能让程序既跑得快，又不会莫名其妙地出错。

一、为啥需要内存顺序？

首先，得明白为啥需要内存顺序。现在的 CPU 都很聪明，为了提高效率，它们会乱序执行指令，还会用各种缓存。编译器也不闲着，也会优化代码，把指令挪来挪去。这些优化在单线程环境下通常没问题，但在多线程环境下，就可能出幺蛾子了。

举个例子，假设有两个线程：

线程 A：设置一个标志位 flag = true
线程 B：检查 flag，如果为 true，就执行一些操作

如果没有内存顺序的约束，编译器或 CPU 可能把线程 A 里的 flag = true 挪到其他指令后面执行，或者线程 B 里的 flag 检查提前到其他指令前面执行。结果就是，线程 B 可能在 flag 还没被设置的时候就执行了操作，导致程序出错。

内存顺序就是用来告诉编译器和 CPU：有些指令必须按顺序执行，不能乱来。

二、四种内存顺序：seq_cst、acquire、release、relaxed

C++ std::atomic 提供了四种内存顺序，它们分别代表了不同程度的约束。咱们从最严格的开始，由强到弱地介绍。

std::memory_order_seq_cst (Sequential Consistency)

这是最严格的内存顺序，也是 std::atomic 的默认值（如果不指定，就是它）。它保证了所有线程对所有原子操作都看到一个全局统一的顺序。你可以理解为，所有线程都按照一个固定的时间轴观察原子操作，不会出现时间错乱。
- 作用： 提供最强的同步保证，确保所有线程看到一致的执行顺序。
- 代价： 性能最差，因为需要全局同步，会阻止很多优化。
代码示例：
```
#include <iostream>
#include <atomic>
#include <thread>

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

void writer() {
    data.store(42, std::memory_order_seq_cst); // 写入数据
    flag.store(true, std::memory_order_seq_cst); // 设置标志位
}

void reader() {
    while (!flag.load(std::memory_order_seq_cst)); // 等待标志位被设置
    std::cout << "Data: " << data.load(std::memory_order_seq_cst) << std::endl; // 读取数据
}

int main() {
    std::thread t1(writer);
    std::thread t2(reader);

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

    return 0;
}
```
在这个例子中，writer 线程先写入数据，然后设置标志位。reader 线程等待标志位被设置后，才读取数据。由于使用了 std::memory_order_seq_cst，可以保证 reader 线程一定能看到 writer 线程写入的数据。
std::memory_order_acquire (Acquire) 和 std::memory_order_release (Release)

这两个家伙通常一起使用，它们用于实现释放-获取（Release-Acquire）语义。这种语义比 seq_cst 宽松一些，但仍然能提供足够的同步保证，并且性能更好。
- release： 用于写入原子变量的操作。它保证所有之前的写入操作都对其他线程可见。你可以理解为，release 操作就像一个信号枪，告诉其他线程：“我之前的操作都完成了，你们可以开始了。”
- acquire： 用于读取原子变量的操作。它保证所有之后的读取操作都能看到 release 操作写入的值。你可以理解为，acquire 操作就像一个监听器，等待 release 信号，一旦收到信号，就保证能看到最新的数据。
代码示例：
```
#include <iostream>
#include <atomic>
#include <thread>

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

void writer() {
    data.store(42, std::memory_order_relaxed); // 写入数据，relaxed 顺序
    flag.store(true, std::memory_order_release); // 设置标志位，release 顺序
}

void reader() {
    while (!flag.load(std::memory_order_acquire)); // 等待标志位被设置，acquire 顺序
    std::cout << "Data: " << data.load(std::memory_order_relaxed) << std::endl; // 读取数据，relaxed 顺序
}

int main() {
    std::thread t1(writer);
    std::thread t2(reader);

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

    return 0;
}
```
在这个例子中，writer 线程使用 release 顺序设置 flag，reader 线程使用 acquire 顺序读取 flag。这意味着，在 reader 线程看到 flag 被设置为 true 之后，它一定能看到 writer 线程写入的 data 值。注意，data 的读写使用了relaxed 顺序，这没问题，因为flag 的 release-acquire 已经保证了同步。

关键点：
- release 操作之前的写入操作，对 acquire 操作之后的读取操作可见。
- acquire 操作之后的读取操作，能看到 release 操作之前的写入操作。
release-acquire 语义的用途：
- 互斥锁： lock 操作使用 acquire 顺序，unlock 操作使用 release 顺序。
- 条件变量： wait 操作使用 acquire 顺序，notify 操作使用 release 顺序。
- 线程安全的队列： enqueue 操作使用 release 顺序，dequeue 操作使用 acquire 顺序。
std::memory_order_relaxed (Relaxed)

这是最宽松的内存顺序，它只保证原子操作的原子性，不提供任何同步保证。也就是说，编译器和 CPU 可以随意地优化和重排指令，只要保证原子操作本身是不可分割的就行。
- 作用： 提供最低的同步保证，只保证原子操作的原子性。
- 代价： 性能最好，因为允许最大的优化。
代码示例：
```
#include <iostream>
#include <atomic>
#include <thread>

std::atomic<int> counter(0);

void increment() {
    for (int i = 0; i < 100000; ++i) {
        counter.fetch_add(1, std::memory_order_relaxed); // 增加计数器
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

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

    std::cout << "Counter: " << counter.load(std::memory_order_relaxed) << std::endl; // 读取计数器
    return 0;
}
```
在这个例子中，多个线程并发地增加计数器。由于使用了 std::memory_order_relaxed，每个线程都可以随意地增加计数器，不需要等待其他线程。最终的计数器值可能不是 200000，但它至少会是一个接近 200000 的值（因为原子操作保证了每次增加都是不可分割的）。

relaxed 顺序的用途：
- 计数器： 多个线程并发地增加计数器，不需要严格的同步保证。
- 统计信息： 收集一些统计信息，允许一定的误差。
- 性能敏感的代码： 在确定不会出现数据竞争的情况下，可以使用 relaxed 顺序来提高性能。

三、如何选择合适的内存顺序？

选择合适的内存顺序是一个需要权衡的过程。你需要考虑以下几个因素：

正确性： 首先要保证程序的正确性。如果选择的内存顺序太宽松，可能导致数据竞争和未定义的行为。
性能： 其次要考虑程序的性能。如果选择的内存顺序太严格，会阻止很多优化，降低程序的运行速度。
复杂性： 最后要考虑代码的复杂性。复杂的内存顺序可能难以理解和维护，容易出错。

一些建议：

优先使用 release-acquire 语义： 在大多数情况下，release-acquire 语义能提供足够的同步保证，并且性能比 seq_cst 更好。
只有在确定不会出现数据竞争的情况下，才使用 relaxed 顺序： relaxed 顺序虽然性能最好，但也最容易出错。
如果对内存顺序不太确定，就使用 seq_cst： seq_cst 虽然性能最差，但它能保证程序的正确性。
使用工具来检测数据竞争： 可以使用 Valgrind、ThreadSanitizer 等工具来检测程序中的数据竞争。

表格总结：

内存顺序	约束程度	性能	用途
`seq_cst`	最严格	最差	提供最强的同步保证，确保所有线程看到一致的执行顺序。
`release`	较严格	较好	用于写入原子变量的操作，保证之前的所有写入操作都对其他线程可见。
`acquire`	较严格	较好	用于读取原子变量的操作，保证之后的所有读取操作都能看到 `release` 操作写入的值。
`relaxed`	最宽松	最好	只保证原子操作的原子性，不提供任何同步保证。

四、高级话题：fence 和 atomic_thread_fence

除了 std::atomic 的内存顺序之外，C++ 还提供了 std::atomic_thread_fence 函数，它可以用来显式地插入内存屏障。内存屏障是一种特殊的指令，它可以阻止编译器和 CPU 对指令进行重排。

std::atomic_thread_fence 的用法与 std::atomic 的内存顺序类似，也支持 seq_cst、acquire、release 和 relaxed 四种内存顺序。

代码示例：

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

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

void producer() {
  data.store(42, std::memory_order_relaxed);
  std::atomic_thread_fence(std::memory_order_release); // 释放屏障
  ready = true;
}

void consumer() {
  while (!ready); // 自旋等待，注意这里不是原子操作
  std::atomic_thread_fence(std::memory_order_acquire); // 获取屏障
  std::cout << "Data: " << data.load(std::memory_order_relaxed) << std::endl;
}

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

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

  return 0;
}

在这个例子中，producer 线程先写入数据，然后插入一个 release 屏障，最后设置 ready 标志。consumer 线程等待 ready 标志被设置后，插入一个 acquire 屏障，然后读取数据。由于使用了内存屏障，可以保证 consumer 线程一定能看到 producer 线程写入的数据。

fence 的用途：

在非原子操作周围提供同步保证： 比如上面的例子，ready 变量不是原子变量，但仍然可以使用内存屏障来保证同步。
更精细地控制内存顺序： 可以使用 fence 来实现更复杂的同步模式。

五、总结

std::atomic 的内存顺序是一个复杂但重要的概念。理解内存顺序可以帮助你编写出正确、高效的多线程程序。记住，选择合适的内存顺序需要权衡正确性、性能和复杂性。希望今天的讲解能让你对 seq_cst、acquire、release 和 relaxed 有更深入的理解。以后写并发代码的时候，记得多留个心眼，选对内存顺序，才能让你的程序跑得又快又稳！

下次见！

发表回复 取消回复

发表回复取消回复