C++ std::atomic的load/store操作与memory_order选择

多线程编程中，数据竞争是导致程序崩溃或产生不可预测结果的元凶。C++11 引入的 std::atomic 是解决这一问题的核心工具，它能保证对变量的操作是不可分割的。然而，仅仅使用原子变量并不一定能保证正确的线程同步，还需要理解 load（读取）与 store（写入）操作背后的内存序（memory_order）选择。

以下是指引。

1. 理解原子变量的基础操作

std::atomic 封装了一个值，确保所有线程在访问该值时不会发生冲突。最基本的两个操作是读取和写入。

包含 <atomic> 头文件以使用原子类型。

声明 一个原子整数变量：

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

执行 写入操作，使用 store：

atomic_data.store(10); // 将原子变量的值设为 10

执行 读取操作，使用 load：

int value = atomic_data.load(); // 读取原子变量的当前值

注意：上述代码默认使用了最严格的内存序 std::memory_order_seq_cst（顺序一致性）。虽然最安全，但性能开销最大。

2. 掌握核心的内存序选项

C++ 提供了多种内存序选项，用于控制编译器和 CPU 对读写指令的重排优化。对于 load 和 store，主要关注以下三种。

下表对比了这三种内存序的特性与适用场景。

记住：对于大多数应用层代码，直接使用默认的 seq_cst 已经足够。只有在经过性能分析确认原子操作是瓶颈后，再考虑优化。

3. 选择内存序的实战步骤

根据业务逻辑，按照以下步骤选择合适的参数。

步骤一：判断是否仅需要单纯的计数

如果原子变量仅用于统计，且不需要依赖它来控制其他变量的读写逻辑。

使用 memory_order_relaxed。

// 线程 A：增加计数
atomic_counter.fetch_add(1, std::memory_order_relaxed);

// 线程 B：读取计数
int count = atomic_counter.load(std::memory_order_relaxed);

场景：记录服务器请求总数、循环次数统计。

步骤二：判断是否用于“发布-订阅”模式

如果一个线程负责写入数据并修改标志位，另一个线程负责检测标志位并读取数据。这需要保证“数据写入”发生在“标志位变为 true”之前，且“检测到标志位为 true”发生在“数据读取”之后。

在写入线程中，使用 memory_order_release 进行 store：

data = 100; // 普通变量写入
ready_flag.store(true, std::memory_order_release); // 原子变量写入

在读取线程中，使用 memory_order_acquire 进行 load：

if (ready_flag.load(std::memory_order_acquire)) { // 原子变量读取
    // 此时保证 data = 100 已经生效
    std::cout << data << std::endl;
}

场景：生产者-消费者模型、单例模式的双重检查锁。

步骤三：处理复杂的全局顺序依赖

如果涉及多个原子变量，且所有线程必须对它们的变化顺序达成一致，或者你不想处理复杂的重排问题。

保持默认，即省略参数或显式使用 memory_order_seq_cst。

atomic_x.store(1, std::memory_order_seq_cst);
atomic_y.store(2, std::memory_order_seq_cst);

4. 常见错误与修正

在使用 load 和 store 时，必须严格配对内存序，否则会导致同步失效。

错误示例：写入端使用了 release，但读取端使用了 relaxed。

// 线程 1
data_init = 1;
flag.store(true, std::memory_order_release); // 释放

// 线程 2
if (flag.load(std::memory_order_relaxed)) { // 错误：使用了松散序，无法获取同步语义
    use(data_init); // 可能读取到未初始化的数据
}

修正方法：将读取端的 load 改为 memory_order_acquire。

if (flag.load(std::memory_order_acquire)) { // 正确：配对使用
    use(data_init); 
}

5. 综合代码示例

以下代码展示了如何使用 acquire/release 机制安全地传递数据。

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

std::atomic<int> flag{0};
int payload = 0;

void writer() {
    // 1. 准备数据
    payload = 42;

    // 2. 发布数据（Release：保证 payload 的写入在 flag 修改之前完成）
    flag.store(1, std::memory_order_release);
}

void reader() {
    // 3. 等待数据（Acquire：保证 payload 的读取在 flag 检测之后）
    int expected = 1;
    while (flag.load(std::memory_order_acquire) != 1) {
        // 等待...
    }

    // 4. 安全使用数据
    std::cout << "Received: " << payload << std::endl;
}

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

    t1.join();
    t2.join();
    return 0;
}

运行 该程序，reader 线程必定能正确读取到 payload 的值 42。