发现无锁队列在某些机器上运行的时候并不能保证顺序，可能是什么问题？

x86/x64  → TSO（Total Store Order）
  允许的重排：只有 StoreLoad（写后读可以被重排）
  不允许：StoreStore、LoadLoad、LoadStore

ARM / ARM64 → 弱内存模型（Weakly Ordered）
  几乎所有重排都允许：
  StoreStore（写-写可以被重排）← 这是锁-free queue 最常踩的坑
  LoadLoad
  LoadStore
  StoreLoad

PowerPC → 比 ARM 还弱

// 错误版本：tail 用了 relaxed
bool push(const T& item) {
    size_t tail = tail_.load(std::memory_order_relaxed);
    size_t next = (tail + 1) & MASK;
    if (next == head_.load(std::memory_order_acquire))
        return false;

    buffer_[tail] = item;                          // ① 写数据

    tail_.store(next, std::memory_order_relaxed);  // ② 更新 tail（BUG：relaxed）
    return true;
}

bool pop(T& item) {
    size_t head = head_.load(std::memory_order_relaxed);
    if (head == tail_.load(std::memory_order_relaxed))  // ③ 读 tail（BUG：relaxed）
        return false;

    item = buffer_[head];                          // ④ 读数据

    head_.store((head + 1) & MASK, std::memory_order_release);
    return true;
}

Producer（核心0）         Consumer（核心1）

① buffer_[tail] = item   
② tail_.store(next)      
                          ③ 看到 tail 更新了（tail != head）
                          ④ 读 buffer_[head]
                             ← 读到的是旧数据或垃圾值！

原因：ARM 允许 StoreStore 重排
CPU 实际执行顺序可能是：
  ② tail_.store(next)    ← 先把 tail 写到其他核可见
  ① buffer_[tail] = item ← 数据写入还没传播过去

Producer（核心0）         Consumer（核心1）

① buffer_[tail] = item   
② tail_.store(next)      
                          ③ 看到 tail 更新了（tail != head）
                          ④ 读 buffer_[head]
                             ← 读到的是旧数据或垃圾值！

原因：ARM 允许 StoreStore 重排
CPU 实际执行顺序可能是：
  ② tail_.store(next)    ← 先把 tail 写到其他核可见
  ① buffer_[tail] = item ← 数据写入还没传播过去

// acquire 语义：保证此行之后的所有读取（包括 buffer_ 的读）
// 能看到配对 release 之前的所有写入
if (head == tail_.load(std::memory_order_acquire))  // ✅
    return false;

item = buffer_[head];  // 现在保证能读到正确数据

Producer:
  buffer_[tail] = item;              ─┐
  tail_.store(next, release);         ┘ release：这两行有先后顺序，且对外可见

                    ↕  synchronizes-with（跨线程的 happens-before）

Consumer:
  tail_.load(acquire);               ─┐
  item = buffer_[head];              ─┘ acquire：这两行有先后顺序，且能看到上面的写

// 错误：CAS 成功时用 relaxed
if (tail->next.compare_exchange_weak(
        next, node,
        std::memory_order_relaxed,   // ← 成功时应该是 release
        std::memory_order_relaxed)) {
    // ...
}

// 正确：
if (tail->next.compare_exchange_weak(
        next, node,
        std::memory_order_release,   // 成功时：发布新节点，需要 release
        std::memory_order_relaxed)) { // 失败时：只是重试，relaxed 够了
    // ...
}

// 出队时读取节点数据：
Node* next = head->next.load(std::memory_order_acquire); // 需要 acquire
val = next->data;  // 能看到入队时写入的 data

# 快速搜索代码里所有用了 relaxed 的地方
grep -n "memory_order_relaxed" your_queue.cpp

对每一对"写数据 → 通知 → 读数据"的模式，确认：

写数据            store(release)         load(acquire)       读数据
─────────── ≺ ──────────────── sync ──────────────── ≺ ──────────
必须在 release 之前        这里建立同步        必须在 acquire 之后

// 用 TSan（Thread Sanitizer）可以检测 data race
// 编译时加 -fsanitize=thread

// 或者在 ARM 机器上用 stress 工具加大并发压力：
for (int i = 0; i < 1000000; i++) {
    producer_thread();
    consumer_thread();
    assert(consumed_value == produced_value);  // 验证顺序
}

// 危险：依赖 x86 的强内存模型，换平台就出 Bug
std::atomic<int> flag{0};
flag.store(1, std::memory_order_relaxed);  // 在 x86 上恰好不会被重排

// 安全：用标准规定的 memory order，所有平台行为一致
flag.store(1, std::memory_order_release);

1. 这个 store 之前，有没有普通内存写入需要对其他线程可见？
   → 如果有，用 release

2. 这个 load 之后，有没有普通内存读取依赖于"看到最新值"？
   → 如果有，用 acquire

3. 这个操作是否需要全局顺序一致（比如实现 mutex）？
   → 用 seq_cst（代价最高，非必要不用）

4. 以上都不是（只是单纯的计数器、统计）？
   → 才能用 relaxed