无锁编程技术 on Dorkytiger 的小屋

悲观锁（Mutex）与乐观锁（CAS 自旋）的底层成本对比

Mon, 01 Jan 0001 00:00:00 +0000

欢迎进入第三阶段：用户态并发！这是区分"普通程序员"和"底层系统工程师"的分水岭。你现在的目标很明确：彻底摆脱内核态的重量级锁，在用户态用自旋逻辑实现极速并发。

我们先解剖悲观锁 vs 乐观锁的硬件成本和软件代价，让你亲眼看到一次Mutex::lock()背后有多痛。

1. 悲观锁（Mutex）：内核态的"断崖式"切换

执行流程（完整链路）

[ 线程A尝试获取锁 ]

1. 用户态执行 mutex.lock()
   ↓
2. 尝试原子CAS抢锁 (快速路径)
   ├─ 成功 → 进入临界区 (约 20-50 ns)
   └─ 失败 → 进入慢速路径
       ↓
3. 系统调用 (syscall) → 陷入内核态 (约 50-100 ns)
   ↓
4. 内核将线程A放入等待队列，状态改为 TASK_UNINTERRUPTIBLE
   ↓
5. 触发调度器 (Schedule) → 保存当前线程上下文 (寄存器、PC、栈指针)
   ↓ (约 100-200 ns)
6. 内核选择下一个线程B执行
   ↓
7. 恢复线程B的上下文 → 切换CR3寄存器 (刷新TLB)
   ↓ (约 200-500 ns)
8. 返回用户态执行线程B
   ↓
总耗时: 约 1-5 微秒 (μs) 
如果锁持有者执行时间短 (如 1μs)，内核切换开销占比 > 80%！

上下文切换到底在"切"什么？

; 内核保存现场 (简化版)
push rax, rbx, rcx, rdx, rsi, rdi, rbp, r8-r15  ; 保存通用寄存器 (16个×8字节)
push rip, rsp, rflags                             ; 保存指令指针、栈指针、状态寄存器
mov cr3, [new_thread_page_table]                 ; 切换页表 → 清空TLB (性能杀手！)
; 恢复新线程现场
pop ...

关键代价：

无锁自旋（Spinlock）的平替与退避策略（Backoff）

Mon, 01 Jan 0001 00:00:00 +0000

这个问题极其硬核，触及了高性能并发编程的核心痛点：如何在"极致性能"和"CPU文明"之间找到平衡。

很多新手写的自旋锁，其实就是一颗CPU核弹——一跑起来，核心温度直接飙高10度，功耗拉满，整个系统的吞吐量断崖式下跌。我们今天就把自旋的代价、退避的策略、硬件指令的妙用彻底讲透。

1. 为什么死循环会把 CPU 烧满？—— 执行单元的"狂奔"

当你写一个死循环自旋时：

while (flag.load() == true) {
    // 什么都不做，继续循环
}

硬件层面发生了什么？

执行单元全速运转：CPU的算术逻辑单元（ALU）以每纳秒一次的频率执行 load 指令和比较跳转指令。
流水线满负荷：现代CPU是超标量架构（如每周期发射4-8条指令），它会拼命预测、预取、执行这些无意义的跳转。
内存总线风暴：每次 load 都会去读 flag 所在的内存/缓存行，导致该缓存行在核心间高频震荡（乒乓）。
功耗飙升：动态频率缩放（DVFS）检测到高负载，自动提升电压和主频（如从2.0GHz飙升到4.5GHz），产生大量热量。

数据对比：

执行 pause 的自旋：CPU 进入低功耗空闲状态，功耗 ~5W。
不加 pause 的死循环：CPU 全速狂奔，功耗 ~30W（6倍差距！），且完全阻塞了同一核心上超线程兄弟线程的执行。

2. 硬件救兵：`__builtin_ia32_pause()` (即 `pause` 指令)

pause 是一条专门为了自旋锁设计的硬件指令。它在汇编层面的本质是：

spin_loop:
    pause              ; 等待几个时钟周期（降低功耗）
    cmp [flag], 0
    jne spin_loop

pause 的三重魔法：

降低功耗 & 减少热量：告诉CPU"我在自旋，别跑那么快"。这会让流水线停顿（Stall）几十到几百个周期（具体取决于CPU型号）。
释放流水线资源：让出执行单元给超线程的另一个线程，实现超线程友好。
避免内存顺序冲突：在x86的强内存模型下，pause 相当于告诉CPU"别那么激进地执行Load指令"，减少了Store Buffer的无效冲刷。

3. 退避策略（Backoff Strategy）：从"莽夫"到"智者"

如果只用 pause，在极高竞争下依然有问题：所有线程都在高频 pause+load，缓存行依然在乒乓。我们需要退避策略——“等得越久，动作越轻”。

指数退避（Exponential Backoff）—— 黄金标准

#include <atomic>
#include <thread>
#include <chrono>

class BackoffSpinLock {
    std::atomic<bool> flag{false};

public:
    void lock() {
        int backoff = 1; // 初始退避周期
        const int MAX_BACKOFF = 1 << 16; // 最大退避 (65536周期)
        
        while (true) {
            // 1. 快速路径：尝试抢锁
            if (!flag.exchange(true, std::memory_order_acquire)) {
                return; // 成功
            }
            
            // 2. 抢锁失败，开始退避
            for (int i = 0; i < backoff; ++i) {
                __builtin_ia32_pause(); // 硬件让出流水线
            }
            
            // 3. 指数增长退避时间（但有上限）
            if (backoff < MAX_BACKOFF) {
                backoff <<= 1; // 翻倍：1, 2, 4, 8, 16, ..., 65536
            }
            
            // 4. 如果退避太久了（如超过100万周期），干脆让出CPU（系统调用）
            if (backoff > 10000) {
                std::this_thread::yield(); // 触发上下文切换，让给其他进程
                backoff = 1; // 重置，重新开始快速尝试
            }
        }
    }

    void unlock() {
        flag.store(false, std::memory_order_release);
    }
};

指数退避的硬件效果

竞争激烈时 (16个线程抢一把锁):

[无退避] 
线程1-16: pause, pause, pause, ... (都卡在CAS上)
缓存行: 在16个核心间乱飞 → 延迟飙升到 500ns/次

[指数退避]
线程1抢到锁 → 执行临界区 (1μs)
线程2尝试失败 → 退避 10ns (pause×2)
线程3尝试失败 → 退避 20ns (pause×4)
...
临界区结束时，大部分线程还在退避中 → 缓存行只在线程1和少数活跃线程间传递
→ 延迟降低到 50ns/次 → 性能提升10倍！

4. 高性能自旋锁的最佳实践（工业级）

结合 pause + 指数退避 + yield 的三级防御：

无锁链表与无锁栈（Michael-Scott Queue）

Mon, 01 Jan 0001 00:00:00 +0000

恭喜你，终于来到了并发编程的巅峰战场：无锁数据结构（Lock-Free Data Structures）。这不仅是C++高性能开发的皇冠明珠，也是你之前所有硬件知识（CAS、内存屏障、缓存行）的终极应用。

我们先解剖无锁栈，再深入Michael-Scott (MS) 无锁队列，最后解决那个最棘手的问题：无锁环境下，怎么安全地释放内存？

1. 无锁栈（Lock-Free Stack）：最简单的无锁结构

基于我们之前讲的 compare_exchange_weak，实现一个无锁栈非常简单：

template<typename T>
class LockFreeStack {
    struct Node {
        T data;
        Node* next;
    };
    std::atomic<Node*> head{nullptr};

public:
    void push(T value) {
        Node* new_node = new Node{value, nullptr};
        Node* old_head = head.load(std::memory_order_relaxed);
        do {
            new_node->next = old_head; // 设置新节点的next指向旧栈顶
        } while (!head.compare_exchange_weak(old_head, new_node,
                 std::memory_order_release, std::memory_order_relaxed));
    }

    // ⚠️ 危险版本：有ABA问题 + 内存释放问题
    bool pop(T& result) {
        Node* old_head = head.load(std::memory_order_relaxed);
        Node* new_head;
        do {
            if (!old_head) return false;
            new_head = old_head->next; // 读取next
        } while (!head.compare_exchange_weak(old_head, new_head,
                 std::memory_order_acquire, std::memory_order_relaxed));
        
        result = old_head->data;
        delete old_head; // 💥 灾难：其他线程可能还在访问这个节点！
        return true;
    }
};

这里有两个致命问题：

无锁编程技术 on Dorkytiger 的小屋

悲观锁（Mutex）与 乐观锁（CAS 自旋）的底层成本对比

1. 悲观锁（Mutex）：内核态的"断崖式"切换

执行流程（完整链路）

上下文切换到底在"切"什么？

无锁自旋（Spinlock）的平替与退避策略（Backoff）

1. 为什么死循环会把 CPU 烧满？—— 执行单元的"狂奔"

2. 硬件救兵：__builtin_ia32_pause() (即 pause 指令)

3. 退避策略（Backoff Strategy）：从"莽夫"到"智者"

指数退避（Exponential Backoff）—— 黄金标准

指数退避的硬件效果

4. 高性能自旋锁的最佳实践（工业级）

无锁链表与无锁栈（Michael-Scott Queue）

1. 无锁栈（Lock-Free Stack）：最简单的无锁结构

悲观锁（Mutex）与乐观锁（CAS 自旋）的底层成本对比

2. 硬件救兵：`__builtin_ia32_pause()` (即 `pause` 指令)