1
// 源代码
2
data = 42;
3
flag = 1;
4

5
// 编译器可能重排为（如果 data 和 flag 没有依赖关系）
6
flag = 1;
7
data = 42;

1
#include <atomic>
2

3
int data = 0;
4
std::atomic<int> flag{0};
5

6
// 线程 A（生产者）
7
void producer() {
8
    data = 42;                        // 普通写入
9
    flag.store(1, std::memory_order_release);  // Release 写入
10
    // 保证 data=42 在 flag=1 之前对其他线程可见
11
}
12

13
// 线程 B（消费者）
14
void consumer() {
15
    while (flag.load(std::memory_order_acquire) != 1)  // Acquire 读取
16
        ;
17
    // flag=1 的 Acquire 保证之后读到 data 的最新值
18
    assert(data == 42);  // 一定成功！
19
}

1
class Singleton {
2
    static std::atomic<Singleton*> instance;
3
    static std::mutex mtx;
4

5
public:
6
    static Singleton* getInstance() {
7
        Singleton* tmp = instance.load(std::memory_order_acquire);
8
        if (tmp == nullptr) {
9
            std::lock_guard<std::mutex> lock(mtx);
10
            tmp = instance.load(std::memory_order_relaxed);
11
            if (tmp == nullptr) {
12
                tmp = new Singleton();
13
                instance.store(tmp, std::memory_order_release);
14
            }
15
        }
16
        return tmp;
17
    }
18
};

1
// 编译器屏障：阻止编译器重排，但不阻止 CPU 重排
2
barrier();  // Linux 内核
3
__asm__ __volatile__("" ::: "memory");  // GCC
4

5
// 硬件屏障：同时阻止编译器和 CPU 重排
6
smp_mb();  // Linux 内核

1
// Dekker 互斥算法（在 x86 上正确，在 ARM 上可能失败）
2
std::atomic<int> flag0{0}, flag1{0}, turn{0};
3

4
// 线程 0
5
flag0.store(1, std::memory_order_relaxed);
6
while (flag1.load(std::memory_order_relaxed)) {
7
    if (turn.load(std::memory_order_relaxed) != 0) {
8
        flag0.store(0, std::memory_order_relaxed);
9
        while (turn.load(std::memory_order_relaxed) != 0);
10
        flag0.store(1, std::memory_order_relaxed);
11
    }
12
}
13
// 临界区...

1
// 错误的自旋锁（在 ARM 上可能失败）
2
void lock(std::atomic<int> &mutex) {
3
    while (mutex.exchange(1, std::memory_order_relaxed)) {
4
        // relaxed 不保证临界区内的写入对其他线程可见
5
    }
6
}
7

8
// 正确的自旋锁
9
void lock(std::atomic<int> &mutex) {
10
    while (mutex.exchange(1, std::memory_order_acquire)) {
11
        // acquire 保证临界区内的读取看到最新的值
12
    }
13
}
14

15
void unlock(std::atomic<int> &mutex) {
16
    mutex.store(0, std::memory_order_release);
17
    // release 保证临界区内的写入对其他线程可见
18
}

1
#include <stdio.h>
2
#include <pthread.h>
3
#include <stdatomic.h>
4

5
int x = 0, y = 0;
6
int r1 = 0, r2 = 0;
7

8
void *thread_a(void *arg) {
9
    x = 1;        // Store
10
    r1 = y;       // Load
11
    return NULL;
12
}
13

14
void *thread_b(void *arg) {
15
    y = 1;        // Store
16
    r2 = x;       // Load
17
    return NULL;
18
}
19

20
int main() {
21
    int count = 0;
22
    for (int i = 0; i < 1000000; i++) {
23
        x = y = 0;
24
        pthread_t t1, t2;
25
        pthread_create(&t1, NULL, thread_a, NULL);
26
        pthread_create(&t2, NULL, thread_b, NULL);
27
        pthread_join(t1, NULL);
28
        pthread_join(t2, NULL);
29
        if (r1 == 0 && r2 == 0) {
30
            count++;  // Store-Load 重排！
31
        }
32
    }
33
    printf("Store-Load 重排次数: %d / 1000000\n", count);
34
    // x86: 可能出现少量重排（Store Buffer 导致）
35
    // ARM: 可能出现更多重排
36
}

1
#include <stdio.h>
2
#include <pthread.h>
3
#include <stdatomic.h>
4

5
int data = 0;
6
atomic_int flag = 0;
7

8
// 无屏障版本
9
void *producer_no_barrier(void *arg) {
10
    data = 42;
11
    atomic_store(&flag, 1, memory_order_relaxed);
12
    return NULL;
13
}
14

15
// Release-Acquire 版本
16
void *producer_release(void *arg) {
17
    data = 42;
18
    atomic_store(&flag, 1, memory_order_release);
19
    return NULL;
20
}
21

22
void *consumer_acquire(void *arg) {
23
    while (atomic_load(&flag, memory_order_acquire) != 1);
24
    printf("data = %d\n", data);  // Release-Acquire: 一定是 42
25
    return NULL;
26
}

1
// 经典的 Message Passing 测试
2
int data = 0;
3
int flag = 0;
4

5
// 线程 A
6
void writer() {
7
    data = 42;        // Store 1
8
    flag = 1;         // Store 2
9
}
10

11
// 线程 B
12
void reader() {
13
    if (flag == 1) {  // Load 1
14
        assert(data == 42);  // Load 2
15
    }
16
}

1
        ┌──────────────────────────────┐
2
Acquire │ 之后的读/写不能越过此线向上  │
3
        └──────────────────────────────┘
4
              ↑ 之前的操作可以自由重排

1
              ↓ 之后的操作可以自由重排
2
        ┌──────────────────────────────┐
3
Release │ 之前的读/写不能越过此线向下  │
4
        └──────────────────────────────┘

1
// 模式 1：自旋锁
2
void lock(std::atomic<int> &mutex) {
3
    while (mutex.exchange(1, std::memory_order_acquire)) {
4
        // acquire: 临界区内的读取不会提前到锁获取之前
5
    }
6
}
7
void unlock(std::atomic<int> &mutex) {
8
    mutex.store(0, std::memory_order_release);
9
    // release: 临界区内的写入不会延迟到锁释放之后
10
}
11

12
// 模式 2：一次性初始化
13
std::atomic<int> initialized{0};
14
int data;
15

16
void init() {
17
    data = compute();  // 普通写
18
    initialized.store(1, std::memory_order_release);  // Release
19
}
20

21
void use() {
22
    if (initialized.load(std::memory_order_acquire)) {  // Acquire
23
        use_data(data);  // 一定看到 compute() 的结果
24
    }
25
}
26

27
// 模式 3：生产者-消费者队列（单生产者单消费者）
28
std::atomic<int> tail{0}, head{0};
29
int buffer[SIZE];
30

31
void produce(int val) {
32
    int t = tail.load(std::memory_order_relaxed);
33
    buffer[t % SIZE] = val;
34
    tail.store(t + 1, std::memory_order_release);  // Release: buffer 写入在 tail 更新之前
35
}
36

37
int consume() {
38
    int h = head.load(std::memory_order_relaxed);
39
    while (tail.load(std::memory_order_acquire) <= h);  // Acquire: 读取 buffer 在 tail 读取之后
40
    int val = buffer[h % SIZE];
41
    head.store(h + 1, std::memory_order_release);
42
    return val;
43
}

1
// SeqLock：读端无需获取锁
2
std::atomic<int> seq{0};
3
int data_a, data_b;
4

5
// 写端（需要互斥）
6
void write(int a, int b) {
7
    seq.fetch_add(1, std::memory_order_release);  // 序号变为奇数 → 写入中
8
    data_a = a;
9
    data_b = b;
10
    seq.fetch_add(1, std::memory_order_release);  // 序号变为偶数 → 写入完成
11
}
12

13
// 读端（无锁）
14
bool read(int *a, int *b) {
15
    int s1, s2;
16
    do {
17
        s1 = seq.load(std::memory_order_acquire);
18
        *a = data_a;  // 读取数据（可能正在被写入）
19
        *b = data_b;
20
        s2 = seq.load(std::memory_order_acquire);
21
    } while (s1 != s2 || s1 & 1);  // 序号变化或写入中 → 重试
22
    return true;
23
}

1
// 简化的 RCU 模式
2
struct Data {
3
    int values[100];
4
};
5

6
std::atomic<Data*> current{nullptr};
7

8
// 读者：无锁
9
void reader() {
10
    Data* ptr = current.load(std::memory_order_acquire);
11
    use(ptr->values);  // 使用期间 ptr 不会被释放
12
    // 通过 grace period 保证 ptr 在所有读者退出后才释放
13
}
14

15
// 写者：创建副本
16
void writer() {
17
    Data* old = current.load(std::memory_order_acquire);
18
    Data* new_data = malloc(sizeof(Data));
19
    *new_data = *old;           // 复制
20
    new_data->values[0] = 42;  // 修改副本
21
    current.store(new_data, std::memory_order_release);  // 原子替换
22
    // 等待 grace period 后释放 old
23
    synchronize_rcu();
24
    free(old);
25
}