＜atomic＞ 注释4：memory_order_consume 获取-释放序(已被弃用)，memory_order_seq_cst 最严格，枚举类内存序 memory_order

（11） memory_order_consume 获取-释放序(已被弃用) ：

++ 虽然已经被弃用，依然给出最标准的使用范例：

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

std::atomic<int*> ptr;
int value;

void Write() {
    int* p = new int(42);
    value = 30; // 非原子操作
    ptr.store(p, std::memory_order_release); // 原子操作，释放内存顺序
}

void Read() {
    int* p2;
    while (!(p2 = ptr.load(std::memory_order_consume))) {
        // 忙等待，直到 ptr 被赋值
    }
    assert(*p2 == 42); // 这个断言通常不会失败，因为 p2 是从 ptr 消费得到的
    // 注意：以下断言可能失败，因为 value 不是从 ptr 消费得到的依赖项
    // assert(value == 30); // 这个断言可能会失败
    delete p2;
}

int main() {
    ptr.store(nullptr, std::memory_order_relaxed);
    std::thread write_thread(Write);
    std::thread read_thread(Read);
    write_thread.join();
    read_thread.join();
    return 0;
}

（12）memory_order_seq_cst 最严格：

++ 举例：

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

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

void increment(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;  // 创建了一个存储线程的  vector 容器

    for (int i = 0; i < num_threads; ++i) 
        threads.emplace_back(increment, n);

    for (auto& t : threads) 
        t.join();

    std::cout << "Final counter: " << counter << std::endl;
    return 0;
}

（13）枚举类内存序 memory_order，这些内存同步类型定义于《xatomic.h》 ：

（14）

谢谢