C++ 并发编程指南（11）原子操作 | 11.4、通过内存序实现顺序模型

前言

前文介绍了六种内存顺序，以及三种内存模型，本文通过代码示例讲解六种内存顺序使用方法，并实现相应的内存模型。

一、通过内存序实现顺序模型

1、Relaxed Ordering

memory_order_relaxed 表示“最宽松的内存序”，不提供任何同步保证。具体来说，memory_order_relaxed 仅保证原子操作本身是原子的，但不保证操作之间的顺序。

在 memory_order_relaxed 的语义下，编译器和处理器可能会对原子操作进行重排序，以提高性能。在多线程环境中，使用 memory_order_relaxed 的原子操作可能会产生不可预测的结果，因为线程之间的操作顺序可能会因为重排序而发生变化。例如：

std::atomic<bool> x, y;
std::atomic<int> z;

void write_x_then_y() {
    x.store(true, std::memory_order_relaxed);  // 1
    y.store(true, std::memory_order_relaxed);  // 2
}

void read_y_then_x() {
    while (!y.load(std::memory_order_relaxed)) { // 3
        std::cout << "y load false" << std::endl;
    }

    if (x.load(std::memory_order_relaxed)) { //4
        ++z;
    }
}

void TestOrderRelaxed() {
    std::thread t1(write_x_then_y);
    std::thread t2(read_y_then_x);
    t1.join();
    t2.join();
    assert(z.load() != 0); // 5
}

在上面的程序中断言有可能被触发，线程A执行write_x_then_y函数，线程B执行read_y_then_x函数。由于使用宽松内存序，操作1对应的指令可能重排到操作2对应的指令后面，此时，当线程A执行完操作2时，操作1还没有被执行，x对应的值还没有写入到内存（x=false、y=true）。线程2执行到操作3时，读到y为true退出循环，线程2看到的x的值为false时（可以从指令重排与缓存结构两个角度来理解），不会执行操作4，进而导致断言触发。

注意：虽然 memory_order_relaxed 不提供同步保证，但它仍然可以用于某些不需要严格同步的场景。例如，在某些计数器或统计场景中，可以使用宽松内存序来提高性能，因为这些场景通常不需要严格的同步语义。

2、Sequencial Consistent Ordering

memory_order_seq_cst 代表了顺序一致性（Sequentially Consistent）的内存模型。这种内存序提供了最严格的同步保证，它确保所有线程都将看到相同的操作顺序，并且所有原子操作都将按照程序顺序执行。

具体来说，当使用 memory_order_seq_cst 进行原子操作时，编译器和处理器不会对这些操作进行任何形式的重排序，以确保在所有线程中看到的操作顺序是一致的。这种内存序适用于那些需要强一致性的场景，但也可能带来一定的性能开销。

使用memory_order_seq_cst内存序，解决前面遇到的问题，如下：

void write_x_then_y() {
    x.store(true, std::memory_order_seq_cst);  // 1
    y.store(true, std::memory_order_seq_cst);  // 2
}

void read_y_then_x() {
    while (!y.load(std::memory_order_seq_cst)) { // 3
        std::cout << "y load false" << std::endl;
    }

    if (x.load(std::memory_order_seq_cst)) { //4
        ++z;
    }
}

void TestOrderSeqCst() {
    std::thread t1(write_x_then_y);
    std::thread t2(read_y_then_x);
    t1.join();
    t2.join();
    assert(z.load() != 0); // 5
}

上面的代码x和y采用的是memory_order_seq_cst，当线程2执行到操作3，读出来y的值为true时会退出循环。因为使用的是全局一致性模型，不会对指令顺序进行优化，操作1一定会在操作2前面执行，所以当y的值被修改成成true时（执行操作2），操作1一定被执行了，此时，在线程2看到的x的值为true，会执行操作4，进而断言不会被触发。

注意：实现 sequencial consistent 模型有一定的开销，现代 CPU 通常有多核，每个核心还有自己的缓存，为了做到全局顺序一致，每次写入操作都必须同步给其他核心。为了减少性能开销，如果不需要全局顺序一致，应该考虑使用更加宽松的顺序模型。

3、Acquire Release Ordering

Acquire Release Ordering 模型中，会使用 memory_order_acquire、memory_order_release 和 memory_order_acq_rel 这三种内存顺序，具体用法如下:

• memory_order_acquire：原子变量的 load 操作可以使用，称为 acquire 操作
• memory_order_release：原子变量的 store 操作可以使用，称为 release 操作
• memory_order_acq_rel：read-modify-write 操作即读 (load) 又写 (store)，可以使用 memory_order_acquire、memory_order_release 和 memory_order_acq_rel。如果使用 memory_order_acquire则作为 acquire 操作；如果使用 memory_order_release，则作为 release 操作；如果使用 memory_order_acq_rel，则同时为两者

Acquire-release 可以实现 synchronizes-with 关系（该关系的解释可以参考11.5章节），可以通过Acquire-release 修正 TestOrderRelaxed函数以达到同步的效果，如下：

void TestReleaseAcquire() {
    std::atomic<bool> rx, ry;

    std::thread t1([&]() {
        rx.store(true, std::memory_order_relaxed); // 1
        ry.store(true, std::memory_order_release); // 2
    });


    std::thread t2([&]() {
        while (!ry.load(std::memory_order_acquire)); //3
        assert(rx.load(std::memory_order_relaxed)); //4
    });

    t1.join();
    t2.join();
}

采用Acquire-release 模型，操作3与操作2构成 synchronizes-with 关系，操作2的结果对操作3可见。当操作3读取到y的值为true时，说明操作2一定被执行了，操作2使用的是memory_order_release内存序，操作1指令不会被优化到操作2后面（参考11.3对memory_order_release内存序的介绍），操作2执行了，那么操作1也一定会被执行，线程2此时读到y=true、x=true，操作4一定会被执行，断言不会被触发。