在C++多线程开发中，std::atomic模板类提供了原子操作的能力，避免了传统互斥锁带来的性能开销。其中load方法用于原子地读取原子对象的值，store方法用于原子地写入值到原子对象，而这两个方法都可以接收一个memory_order参数，用来指定操作的内存顺序语义，这直接影响多线程下操作的可见性和执行顺序。
std::atomic的load和store基本用法
首先来看load和store的基础使用方式，以int类型的原子对象为例：
#include <atomic>
#include <iostream>
#include <thread>
// 定义原子int对象，初始值为0
std::atomic<int> atomic_num(0);
void write_thread() {
// 原子写入值10，使用默认的内存顺序
atomic_num.store(10);
}
void read_thread() {
// 原子读取值，使用默认的内存顺序
int val = atomic_num.load();
std::cout << "读取到的值: " << val << std::endl;
}
int main() {
std::thread t1(write_thread);
std::thread t2(read_thread);
t1.join();
t2.join();
return 0;
}
上面的代码中，store和load没有显式指定内存顺序，默认使用的是std::memory_order_seq_cst，也就是顺序一致的内存顺序，这是最严格也是最容易理解的内存顺序选项。
memory_order常见选项分类
C++中的memory_order枚举定义了6种内存顺序选项，按照限制强度从高到低可以分为三类：
- 顺序一致顺序：
std::memory_order_seq_cst - 获取-释放顺序：
std::memory_order_acquire、std::memory_order_release、std::memory_order_acq_rel - 宽松顺序：
std::memory_order_relaxed
1. 宽松顺序 memory_order_relaxed
宽松顺序只保证操作的原子性，不保证任何跨线程的可见性顺序，也不和其他操作形成同步关系，性能最高，但使用场景有限。比如只统计一个不需要严格同步的计数器时可以使用：
#include <atomic>
#include <thread>
#include <vector>
std::atomic<int> counter(0);
void increment() {
for (int i = 0; i < 1000; i++) {
// 宽松顺序的自增，只保证原子性
counter.fetch_add(1, std::memory_order_relaxed);
}
}
int main() {
std::vector<std::thread> threads;
for (int i = 0; i < 10; i++) {
threads.emplace_back(increment);
}
for (auto& t : threads) {
t.join();
}
// 最终counter的值一定是10000，因为fetch_add是原子的
std::cout << "最终计数: " << counter.load(std::memory_order_relaxed) << std::endl;
return 0;
}
这里即使使用宽松顺序，因为fetch_add本身是原子操作，所以最终计数结果是正确的，但其他线程无法保证看到中间过程的写入顺序。
2. 获取-释放顺序
获取-释放顺序是配对使用的，std::memory_order_release用于store操作，std::memory_order_acquire用于load操作。如果一个线程A用release顺序store了一个值，线程B用acquire顺序load到这个值，那么线程A在store之前的所有写操作，对线程B在load之后的所有读操作都是可见的，这形成了同步关系。
典型场景是线程间传递数据：
#include <atomic>
#include <iostream>
#include <thread>
#include <string>
std::atomic<bool> data_ready(false);
std::string data;
void producer() {
data = "生产的数据内容"; // 非原子写，在release store之前完成
// release顺序写入，保证之前的写操作对acquire的线程可见
data_ready.store(true, std::memory_order_release);
}
void consumer() {
// acquire顺序读取，直到读到true，保证之后的读能看到producer的写
while (!data_ready.load(std::memory_order_acquire)) {
// 等待数据就绪
}
std::cout << "消费到数据: " << data << std::endl;
}
int main() {
std::thread t1(producer);
std::thread t2(consumer);
t1.join();
t2.join();
return 0;
}
这个例子中，如果没有正确的获取-释放配对，consumer线程可能读到data_ready为true，但data还是空字符串，导致输出错误。使用release和acquire配对后，就能保证data的写入对consumer可见。
3. 顺序一致顺序 memory_order_seq_cst
顺序一致是最严格的内存顺序，所有使用seq_cst的操作会形成一个全局一致的执行顺序，所有线程看到的这些操作的顺序都是相同的，和程序的代码顺序一致（在单线程内）。它的行为最容易理解，但性能开销相对较大。
#include <atomic>
#include <iostream>
#include <thread>
std::atomic<int> x(0);
std::atomic<int> y(0);
int r1 = 0, r2 = 0;
void thread1() {
x.store(1, std::memory_order_seq_cst); // 操作1
r1 = y.load(std::memory_order_seq_cst); // 操作2
}
void thread2() {
y.store(1, std::memory_order_seq_cst); // 操作3
r2 = x.load(std::memory_order_seq_cst); // 操作4
}
int main() {
std::thread t1(thread1);
std::thread t2(thread2);
t1.join();
t2.join();
// 由于顺序一致，不可能出现r1和r2都为0的情况
std::cout << "r1: " << r1 << ", r2: " << r2 << std::endl;
return 0;
}
如果使用宽松顺序，就可能出现r1和r2都为0的情况，因为操作的顺序可能被重排，而顺序一致禁止了这种跨线程的重排，保证了全局顺序。
不同内存顺序的选择建议
在实际开发中，选择内存顺序可以遵循以下原则：
- 如果不确定该用哪种，优先使用
std::memory_order_seq_cst，保证正确性，再考虑性能优化 - 如果是简单的计数器、统计类场景，不需要跨操作同步，可以使用
std::memory_order_relaxed - 如果是线程间传递数据、通知状态变更的场景，使用获取-释放配对
std::memory_order_release和std::memory_order_acquire - 除非非常清楚内存模型，否则不要随意混用不同的内存顺序选项
注意事项
需要注意，load方法只能使用acquire、consume、relaxed、seq_cst这几种内存顺序，store方法只能使用release、relaxed、seq_cst这几种内存顺序，混用会导致编译错误。比如给load传入release顺序，或者给store传入acquire顺序都是不合法的。
另外，原子操作的内存顺序只影响原子操作本身的可见性，不保证非原子操作的原子性，所以不要在原子操作之间穿插非原子的共享数据读写，否则还是会出现数据竞争问题。
std::atomicloadstorememory_order修改时间：2026-07-11 06:00:32