C++ 6种内存序详解(看完本文你就明白)

在多线程编程中，内存序是一个非常重要的概念，它可以帮助我们更好地控制多线程程序中的数据访问顺序。

C++ 11引入了6种内存序，分别是 memory_order_relaxed、memory_order_consume、memory_order_acquire、memory_order_release、memory_order_acq_rel 和 memory_order_seq_cst。这些内存序提供了不同级别的同步保证，可以帮助我们在多线程程序中实现更精细的控制。

• memory_order_relaxed: 最宽松的内存序，不提供任何同步保证。它只保证原子操作本身是原子的，但不保证操作之间的顺序。
• memory_order_consume: 消费者内存序，用于同步依赖关系。它保证了依赖于原子操作结果的后续操作将按照正确的顺序执行。
• memory_order_acquire: 获取内存序，用于同步对共享数据的访问。它保证了在获取操作之后对共享数据的所有读取操作都将看到最新的数据。
• memory_order_release: 释放内存序，用于同步对共享数据的访问。它保证了在释放操作之前对共享数据的所有写入操作都已完成，并且对其他线程可见。
• memory_order_acq_rel: 获取-释放内存序，结合了获取和释放两种内存序的特点。它既保证了获取操作之后对共享数据的所有读取操作都将看到最新的数据，又保证了在释放操作之前对共享数据的所有写入操作都已完成，并且对其他线程可见。
• memory_order_seq_cst: 顺序一致性内存序，提供了最严格的同步保证。它保证了所有线程都将看到相同的操作顺序，并且所有原子操作都将按照程序顺序执行。

1. 生产者-消费者模型

下面是一个简单的例子，展示了如何使用 memory_order_acquire 和 memory_order_release 来实现一个简单的生产者-消费者模型：

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

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

void producer() {
    data.store(42, std::memory_order_relaxed);
    ready.store(true, std::memory_order_release);
}

void consumer() {
    while (!ready.load(std::memory_order_acquire))
        ;
    std::cout << data.load(std::memory_order_relaxed) << std::endl;
}

int main() {
    std::thread t1(producer);
    std::thread t2(consumer);
    t1.join();
    t2.join();
    return 0;
}

在这个例子中，生产者线程使用 memory_order_release 来确保数据被正确地初始化，并且在 ready 变量被设置为 true 之前对其他线程可见。消费者线程则使用 memory_order_acquire 来确保在读取 data 变量之前，ready 变量已经被设置为 true。

2. 计数器

好的，下面是另一个例子，展示了如何使用 memory_order_seq_cst 来实现一个简单的计数器：

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

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

void worker(int n) {
    for (int i = 0; i < n; ++i) {
        counter.fetch_add(1, std::memory_order_seq_cst);
    }
}

int main() {
    const int n = 100000;
    const int num_threads = 4;
    std::vector<std::thread> threads;
    for (int i = 0; i < num_threads; ++i) {
        threads.emplace_back(worker, n);
    }
    for (auto& t : threads) {
        t.join();
    }
    std::cout << counter << std::endl;
    return 0;
}

在这个例子中，我们创建了4个线程，每个线程都对一个原子计数器进行了 n 次增加操作。由于我们使用了 memory_order_seq_cst 来保证原子操作的顺序一致性，所以最终计数器的值将恰好等于 n * num_threads。
希望这些例子能够帮助你更好地理解 C++ 6种内存序的用法及代码实例。