c++的内存模型(memory model)是什么_c++并发内存模型与顺序一致性讲解-C++-PHP中文网

c++内存模型是c++11引入的多线程内存行为规范，核心为原子操作与内存顺序。它通过memory_order_seq_cst实现顺序一致性，保证所有线程看到一致的操作顺序；还提供memory_order_relaxed、acquire/release等更灵活但需谨慎使用的选项，用于性能与安全性的权衡，支持跨线程同步与数据可见性控制。

c++的内存模型(memory model)是什么_c++并发内存模型与顺序一致性讲解

C++的内存模型是C++11标准引入的重要概念，主要用来定义多线程程序中变量的访问规则，特别是共享数据在不同线程之间的可见性和操作顺序。它为开发者提供了对并发编程中内存行为的精确控制，避免因编译器优化或CPU乱序执行导致的未定义行为。

什么是C++内存模型

C++内存模型的核心是原子操作（atomic）和内存顺序（memory order）。它不依赖于具体硬件架构，而是通过抽象的方式规定了多线程环境下读写操作的行为边界。

该模型允许程序员在性能与安全性之间做权衡。例如，在不需要严格同步的场景下可以使用宽松的内存顺序来提升效率；而在关键临界区则需保证强一致性。

顺序一致性（Sequential Consistency）

顺序一致性是最直观、最严格的内存顺序模型。当所有原子操作都使用 std::memory_order_seq_cst 时，整个程序表现为：所有线程看到的操作顺序是一致的，并且每个线程的操作按程序顺序出现。

这意味着：

所有线程对原子变量的修改有一个全局一致的顺序。
每个线程内的操作不会被重排。
结果符合程序员直觉——就像所有操作在一个线程上串行执行一样。

例如：

度加AI

度加AI官网入口，百度官方 AIGC 创作平台，支持 AI 成片、AI 生文、数字人、声音克隆、配音字幕与智能剪辑等在线创作能力。

下载

#include <atomic><br>
#include <thread><br>
std::atomic<bool> x{false}, y{false};<br>
std::atomic<int> z{0};<br><br>
void write_x() {<br>
    x.store(true, std::memory_order_seq_cst);<br>
}<br><br>
void write_y() {<br>
    y.store(true, std::memory_order_seq_cst);<br>
}<br><br>
void read_x_then_y() {<br>
    while (!x.load(std::memory_order_seq_cst))<br>
        ;<br>
    if (y.load(std::memory_order_seq_cst)) {<br>
        ++z;<br>
    }<br>
}<br><br>
void read_y_then_x() {<br>
    while (!y.load(std::memory_order_seq_cst))<br>
        ;<br>
    if (x.load(std::memory_order_seq_cst)) {<br>
        ++z;<br>
    }<br>
}<br><br>
int main() {<br>
    // 四个线程分别执行<br>
    std::thread a(write_x);<br>
    std::thread b(write_y);<br>
    std::thread c(read_x_then_y);<br>
    std::thread d(read_y_then_x);<br>
    a.join(); b.join(); c.join(); d.join();<br>
    // z 的值不可能为0<br>
}
</int></bool></thread></atomic>

在顺序一致性下，至少有一个判断会看到另一个变量已写入，因此 z 至少为1。这体现了全局一致的操作视图。

其他内存顺序选项

除了顺序一致性，C++还提供更灵活但需要谨慎使用的内存顺序：

memory_order_relaxed：仅保证原子性，不保证顺序。适用于计数器等无需同步上下文的场景。
memory_order_acquire / release：用于实现锁或同步结构。写操作用 release，读操作用 acquire，可建立“释放-获取”关系，确保某些写操作对后续获取操作可见。
memory_order_consume：比 acquire 更弱，只限制依赖的数据不被重排，实际支持有限，通常不推荐使用。

比如使用 acquire/release 实现简单的同步：

std::atomic<bool> flag{false};<br>
int data = 0;<br><br>

void writer() {<br>
    data = 42;                              // 非原子写<br>
    flag.store(true, std::memory_order_release); // 保证上面的写入不会被重排到 store 之后<br>
}<br><br>

void reader() {<br>
    while (!flag.load(std::memory_order_acquire)) // 等待 flag 变为 true<br>
        ;<br>
    // 此时 data 一定是 42<br>
    assert(data == 42);<br>
}
</bool>

这里通过 release-acquire 建立了同步关系，使得 writer 中对 data 的修改对 reader 可见。