[知识点] 内存顺序属性的用途和行为

C++标准库中定义了以下几种内存顺序属性：

1. std::memory_order_relaxed
2. std::memory_order_consume
3. std::memory_order_acquire
4. std::memory_order_release
5. std::memory_order_acq_rel
6. std::memory_order_seq_cst

1. std::memory_order_relaxed

• 定义：不提供同步或顺序保证，只保证原子操作本身的原子性。
• 用途：适用于不需要同步的情况下，用于计数器等场景。
• 行为：操作之间可以自由重排序，其他线程可能看到不同的操作顺序。

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

// 计数器，用于多线程递增
std::atomic<int> counter(0);

void increment() {
    for (int i = 0; i < 1000; ++i) {
        // 使用 memory_order_relaxed 进行原子加操作
        // 不保证任何顺序，只保证原子性
        counter.fetch_add(1, std::memory_order_relaxed);
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

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

    // 输出最终的计数器值
    std::cout << "Counter: " << counter.load(std::memory_order_relaxed) << std::endl;
    return 0;
}

2. std::memory_order_consume

• 定义：专用于指针依赖的消费操作，确保后续依赖操作的顺序。
• 用途 ：用于消费操作，确保依赖指针的操作不会被重排序到消费操作之前。
• 行为 ：类似于 memory_order_acquire，但仅保证指针依赖的顺序。

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

// 原子指针，指向整数数据
std::atomic<int*> p;
int data;

void producer() {
    data = 42;
    // 使用 memory_order_release 存储指针
    // 确保 data 的写入在存储指针之前完成
    p.store(&data, std::memory_order_release);
}

void consumer() {
    int* ptr;
    // 使用 memory_order_consume 加载指针
    // 确保指针依赖的操作不会被重排序
    while (!(ptr = p.load(std::memory_order_consume)));
    // 输出指针指向的数据
    std::cout << "Data: " << *ptr << std::endl;
}

int main() {
    std::thread t1(producer);
    std::thread t2(consumer);

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

    return 0;
}

3. std::memory_order_acquire

• 定义 ：获取操作，确保后续读写操作 不会被重排序到获取操作之前。
• 用途 ：用于加载操作，以确保加载后的操作看到的是最新的数据。
• 行为 ：获取操作之前的读写操作可能被重排序，但之后的操作不会。

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

// 标志变量，用于同步
std::atomic<int> flag(0);
int data = 0;

void writer() {
    data = 42;
    // 使用 memory_order_release 存储标志
    // 确保 data 的写入在存储标志之前完成
    flag.store(1, std::memory_order_release);
}

void reader() {
    // 使用 memory_order_acquire 加载标志
    // 确保标志被加载后，读取 data 的操作不会被重排序
    while (flag.load(std::memory_order_acquire) != 1);
    // 输出 data 的值
    std::cout << "Data: " << data << std::endl;
}

int main() {
    std::thread t1(writer);
    std::thread t2(reader);

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

    return 0;
}

4. std::memory_order_release

• 定义：释放操作，确保之前的读写操作不会被重排序到释放操作之后。
• 用途：用于存储操作，以确保存储前的所有操作完成。
• 行为：释放操作之后的读写操作可能被重排序，但之前的操作不会。

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

// 标志变量，用于同步
std::atomic<int> flag(0);
int data = 0;

void writer() {
    data = 42;
    // 使用 memory_order_release 存储标志
    // 确保 data 的写入在存储标志之前完成
    flag.store(1, std::memory_order_release);
}

void reader() {
    // 使用 memory_order_acquire 加载标志
    // 确保标志被加载后，读取 data 的操作不会被重排序
    while (flag.load(std::memory_order_acquire) != 1);
    // 输出 data 的值
    std::cout << "Data: " << data << std::endl;
}

int main() {
    std::thread t1(writer);
    std::thread t2(reader);

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

    return 0;
}

5. std::memory_order_acq_rel

• 定义：获取和释放操作的组合，适用于读-修改-写操作。
• 用途 ：用于原子操作，如 compare_exchange，以确保操作的前后都不会被重排序。
• 行为：操作之前和之后的读写操作都不会被重排序。

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

// 原子计数器，用于多线程递增
std::atomic<int> counter(0);

void increment() {
    for (int i = 0; i < 1000; ++i) {
        int expected = counter.load(std::memory_order_relaxed);
        // 使用 memory_order_acq_rel 进行比较并交换操作
        // 确保操作之前和之后的读写顺序
        while (!counter.compare_exchange_weak(expected, expected + 1, std::memory_order_acq_rel));
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

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

    // 输出最终的计数器值
    std::cout << "Counter: " << counter.load(std::memory_order_relaxed) << std::endl;
    return 0;
}

6. std::memory_order_seq_cst

• 定义：获取和释放操作的组合，适用于读-修改-写操作。
• 用途 ：用于原子操作，如 compare_exchange，以确保操作的前后都不会被重排序。
• 行为：操作之前和之后的读写操作都不会被重排序。

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

// 原子变量
std::atomic<int> x(0), y(0);
int r1, r2;

void thread1() {
    // 使用 memory_order_seq_cst 存储 x
    // 确保全局顺序一致
    x.store(1, std::memory_order_seq_cst);
    // 使用 memory_order_seq_cst 加载 y
    // 确保全局顺序一致
    r1 = y.load(std::memory_order_seq_cst);
}

void thread2() {
    // 使用 memory_order_seq_cst 存储 y
    // 确保全局顺序一致
    y.store(1, std::memory_order_seq_cst);
    // 使用 memory_order_seq_cst 加载 x
    // 确保全局顺序一致
    r2 = x.load(std::memory_order_seq_cst);
}

int main() {
    std::thread t1(thread1);
    std::thread t2(thread2);

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

    // 输出结果
    std::cout << "r1: " << r1 << ", r2: " << r2 << std::endl;
    return 0;
}

总结

• std::memory_order_relaxed: 最弱的同步和顺序保证，仅保证原子操作本身的原子性。
• std::memory_order_consume: 专用于指针依赖，确保后续依赖操作的顺序。
• std::memory_order_acquire: 获取操作，确保后续读写操作不会被重排序到获取操作之前。
• std::memory_order_release: 释放操作，确保之前的读写操作不会被重排序到释放操作之后。
• std::memory_order_acq_rel: 获取和释放操作的组合，适用于读-修改-写操作。
• std::memory_order_seq_cst: 顺序一致性操作，提供最强的同步和顺序保证。