在C++11之前，不同编译器对多线程内存行为的实现差异较大，开发者很难写出可移植的并发代码。C++11引入了统一的内存模型，其中std::memory_order就是用来指定原子操作的内存顺序约束，决定原子操作的读写如何与其他内存操作交互。
std::memory_order的枚举值分类
std::memory_order定义在<atomic>头文件中，主要包含以下6个常用枚举值，按照约束强度从弱到强可以分为三类：
- 宽松内存序：memory_order_relaxed
- 获取-释放内存序：memory_order_acquire、memory_order_release、memory_order_acq_rel
- 顺序一致内存序：memory_order_seq_cst
各内存序的具体含义与使用场景
1. memory_order_relaxed 宽松内存序
宽松内存序只保证原子操作本身的原子性，不保证任何内存操作的顺序，也不保证与其他线程的同步关系。它适用于只需要原子计数，不需要同步其他内存操作的场景。
#include <atomic>
#include <thread>
#include <iostream>
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::thread t1(increment);
std::thread t2(increment);
t1.join();
t2.join();
// 最终counter一定是2000，因为fetch_add本身是原子的
std::cout << "counter: " << counter << std::endl;
return 0;
}
2. 获取-释放内存序
这类内存序用于建立线程间的同步关系，release操作之前的所有内存写入，对对应acquire操作之后的内存读取可见。
memory_order_release
用于写操作，搭配store使用，表示当前原子变量的写入操作，会保证在该操作之前的所有内存修改，对后续执行对应acquire操作的线程可见。
memory_order_acquire
用于读操作，搭配load使用，表示当前原子变量的读取操作，会保证在该操作之后的所有内存读取，能看到其他线程release操作之前的所有修改。
#include <atomic>
#include <thread>
#include <iostream>
#include <string>
std::atomic<bool> ready(false);
std::string data;
// 写线程，准备数据后设置ready为true
void writer() {
data = "hello from writer";
// release语义，保证data的写入在ready赋值为true之前完成
ready.store(true, std::memory_order_release);
}
// 读线程，等待ready为true后读取数据
void reader() {
// acquire语义，保证ready为true之后，能读到writer中data的修改
while (!ready.load(std::memory_order_acquire)) {
// 等待ready变为true
}
std::cout << "read data: " << data << std::endl;
}
int main() {
std::thread t1(writer);
std::thread t2(reader);
t1.join();
t2.join();
return 0;
}
memory_order_acq_rel
同时具备acquire和release的语义，通常用于read-modify-write类的原子操作，比如fetch_add、exchange等。
#include <atomic>
#include <thread>
#include <iostream>
std::atomic<int> value(0);
void update() {
// acq_rel语义，既保证之前的写入对其他线程可见，也保证之后的读取能看到其他线程的修改
int old = value.fetch_add(1, std::memory_order_acq_rel);
std::cout << "old value: " << old << std::endl;
}
int main() {
std::thread t1(update);
std::thread t2(update);
t1.join();
t2.join();
std::cout << "final value: " << value << std::endl;
return 0;
}
3. memory_order_seq_cst 顺序一致内存序
这是std::memory_order的默认值，也是约束最强的一种内存序。它保证所有使用seq_cst的原子操作，在所有线程中看到的执行顺序是一致的，相当于全局有一个统一的操作顺序。但性能开销也是最大的。
#include <atomic>
#include <thread>
#include <iostream>
std::atomic<int> x(0);
std::atomic<int> y(0);
int result = 0;
void thread1() {
x.store(1, std::memory_order_seq_cst); // 操作1
y.store(1, std::memory_order_seq_cst); // 操作2
}
void thread2() {
while (y.load(std::memory_order_seq_cst) == 0) {} // 操作3
result = x.load(std::memory_order_seq_cst); // 操作4
}
int main() {
std::thread t1(thread1);
std::thread t2(thread2);
t1.join();
t2.join();
// 由于顺序一致，操作1一定在操作2之前，操作3看到操作2后，操作4一定能看到操作1的结果
// 所以result一定是1
std::cout << "result: " << result << std::endl;
return 0;
}
不同内存序的选择建议
选择内存序时，需要平衡正确性和性能：
- 如果只需要原子计数，不需要同步其他数据，优先选择memory_order_relaxed，性能最好
- 如果需要同步多个数据，比如生产者消费者场景中传递数据，选择获取-释放内存序，约束适中
- 如果不确定如何选择，或者需要最简单的正确性保证，选择默认的memory_order_seq_cst，虽然性能稍差但不容易出错
注意：错误的内存序选择会导致数据竞争和未定义行为，在不确定场景时，优先使用顺序一致内存序，再逐步根据性能需求优化。
常见误区说明
很多开发者会误以为原子操作本身就能保证所有内存操作的顺序，实际上只有搭配正确的std::memory_order，才能保证非原子内存操作的同步。另外，不同内存序的组合需要符合规则，比如release操作必须和acquire操作配对使用，才能建立有效的同步关系。
std::memory_order原子操作C++11内存模型内存序修改时间：2026-07-08 03:42:32