互斥锁、自旋锁的原理、区别、使用场景

自旋锁原理

自旋锁(Spinlock)是一种基于忙等待(Busy-waiting)机制的互斥同步原语。与传统互斥锁(Mutex)在获取锁失败时将线程挂起(休眠)不同,自旋锁会让线程持续在循环中反复检查锁状态,直到成功获取。

核心工作原理

自旋锁的本质依赖于现代 CPU 提供的硬件级原子操作指令(如 x86 的 LOCK CMPXCHG、XCHG,ARM 的 LDREX/STREX 或 CAS)。

  1. 加锁(Lock)
    • 线程尝试执行原子操作(如 compare_and_swap 或 test_and_set),将锁标志位从 0 改为 1。
    • 如果修改成功,说明抢到锁,直接进入临界区。
    • 如果修改失败(说明已被其他线程持有),线程不让出 CPU,而是在 while 循环中反复执行原子操作或读取状态,即“原地自旋”,直到锁被释放。
  2. 解锁(Unlock)
    • 持锁线程执行完毕后,通过原子写操作(或带 Release 内存序的写)将标志位重置为 0。
    • 此时正在自旋的其他线程会检测到状态变化,竞争获取该锁。

为什么需要自旋锁?(对比互斥锁)

  • 互斥锁(Mutex)的开销:当锁发生竞争时,互斥锁会将线程放入等待队列,触发内核态上下文切换(Context Switch)。上下文切换涉及保存寄存器、切换页表缓存(TLB flush)和调度开销,通常需要数微秒到数十微秒。
  • 自旋锁的优势:完全在用户态/轻量指令级完成,避免了线程休眠与唤醒的上下文切换成本。只要临界区极小、持锁时间极短,自旋锁的响应延迟远低于互斥锁。

核心缺陷与注意事项

  1. CPU 空耗与发热:自旋过程相当于 CPU 在跑死循环,若临界区耗时较长或发生长时间等待,会白白浪费 CPU 时间片并导致功耗飙升。
  2. 死锁与单核问题:在单核 CPU 或禁用抢占的场景下,若自旋线程优先级高于持锁线程,自旋线程独占 CPU 将导致持锁线程永远无法运行并释放锁,引发死锁。
  3. 缓存一致性风暴(Cache Bouncing):若多个 CPU 核心同时执行原子的写指令(如不断 test_and_set),会频繁失效彼此的 CPU 缓存行(MESI 协议广播),严重拖垮内存总线性能。

现代工程优化:自旋锁的演进

为了缓解纯自旋的性能损耗,生产环境中的实现通常包含以下优化:

  • Test-and-Test-and-Set (TTAS): 自旋期间仅使用普通的只读操作(从本地 L1/L2 缓存读标志位),只有在发现锁被释放时才真正发起原子写操作,大幅减少缓存总线流量。
  • PAUSE 指令优化(如 x86 _mm_pause): 在自旋循环中插入 CPU 指令提示,避免流水线因内存乱序冲突而发生昂贵的清空惩罚,同时降低 CPU 功耗。
  • 分级退避与混合自旋(Hybrid Spinlock): 先短时间自旋若干次;若仍未抢到,则插入多次 pause 或指数退避延迟;若持续超时,最终退化为主动让出(sched_yield)或挂起休眠(如同大多数语言中 std::mutex 的底层实现)。

典型实现

#include <array>
#include <thread>
#include <atomic>
#include <emmintrin.h>

struct spinlock {
    void lock() noexcept {
        // approx. 5*5 ns (= 25 ns), 10*40 ns (= 400 ns), and 3000*...
        // (~ 1 ms), respectively, when measured on a 2.9 GHz Intel...
        constexpr std::array iterations = {5, 10, 3000};

        // 阶段 1:紧凑短轮询(直接 try_lock)
        for (int i = 0; i < iterations[0]; ++i) {
            if (try_lock())
                return;
        }

        // 阶段 2:轻度等待(单次 _mm_pause 降低 CPU 流水线惩罚)
        for (int i = 0; i < iterations[1]; ++i) {
            if (try_lock())
                return;

            _mm_pause();
        }

        // 阶段 3:深度重试与让出 CPU
        while (true) {
            for (int i = 0; i < iterations[2]; ++i) {
                if (try_lock())
                    return;

                _mm_pause();
                _mm_pause();
                _mm_pause();
                _mm_pause();
                _mm_pause();
                _mm_pause();
                _mm_pause();
                _mm_pause();
                _mm_pause();
                _mm_pause();
            }

            // 等待时间过长,让出 CPU 执行权给其他线程
            // waiting longer than we should, let's give other threads
            // a chance to recover
            std::this_thread::yield();
        }
    }

    bool try_lock() noexcept {
        return !flag.test_and_set(std::memory_order_acquire);
    }

    void unlock() noexcept {
        flag.clear(std::memory_order_release);
    }

private:
    std::atomic_flag flag = ATOMIC_FLAG_INIT;
};

_mm_pause() 是 x86 架构编译器提供的一个内置函数(intrinsic),它会被编译为一条汇编指令:PAUSE。

它的核心作用是在自旋等待(Spin-Wait / Spinlock)循环中通知 CPU:“我现在正在轮询等待,请帮我优化流水线并降低开销”。

核心作用与原理

  1. 避免流水线清空惩罚(Pipeline Flush) 自旋循环在退出时(即成功获取锁或条件满足时),CPU 的分支预测极易因为预测失败而清空整个指令流水线,导致几十到上百个时钟周期的严重延迟。PAUSE 指令向硬件提示当前处于循环等待,能大幅缓解甚至消除这种流水线回退惩罚。
  2. 降低 CPU 功耗与发热 空转的 while 循环会让 CPU 核心满负荷狂转。插入 PAUSE 会让该核心轻微休眠几个到几十个周期(不同架构约为 10~140 个 cycle),显著降低发热和耗电。
  3. 缓解超线程(SMT)资源争抢 在同一个物理核共享的两个逻辑线程中,一个线程陷入空转会抢占发射队列等执行资源。_mm_pause() 释放了流水线资源,让同核心的另一个线程跑得更快。

补充提示:

  • 跨平台标准: C++20 引入了硬件无关的替代品 std::this_thread::yield()(让出时间片)以及专门对应此类指令的实验性提案;在主流跨平台代码中,ARM 架构上对应的指令是 __yield() / YIELD。
  • 头文件: 包含 <immintrin.h> 或 <emmintrin.h> 即可使用。

互斥锁原理

在 Linux 环境下,C++ 的 std::mutex 底层本质上是封装了 POSIX 线程库的 pthread_mutex_t,而 pthread_mutex_t 的核心性能支撑点正是 Linux 内核提供的 futex(Fast Userspace Mutex,快速用户空间互斥体)机制。

这套架构的设计非常精妙,它将轻量级的操作留给程序自己,只在必要时才请操作系统出面,完美解答了你关于锁性能的疑问。

用户态与内核态的分工:futex 的运转机制

futex 的核心思想是将一把锁的生命周期拆分为“状态标记”和“阻塞排队”两部分,分别在不同的运行级别处理:

  • 用户态 (User Space): 负责维护一个共享的整型变量(代表锁的当前状态,例如 0 表示无锁,1 表示已锁定,2 表示已锁定且有其他线程在等待)。所有的 尝试加锁 和 尝试解锁 第一步都在用户态完成。
  • 内核态 (Kernel Space): 负责维护一个复杂的等待队列(Wait Queue)。内核不关心锁的业务逻辑,它只负责在收到请求时,把指定的线程挂起到队列中休眠,或者在收到通知时,把队列里的线程唤醒。

为什么锁竞争不激烈时 mutex 很快?(快路径 Fast Path)

在没有竞争或竞争极低的情况下,std::mutex 走的是纯用户态的“快路径”。

  1. 线程在用户态直接通过一条硬件级别的原子指令(如 CAS, Compare-And-Swap),尝试将内存中的锁状态变量从 0 修改为 1。
  2. 因为没有其他线程在抢,修改瞬间成功,加锁完成。
  3. 为什么快: 整个加锁过程完全发生在用户态,没有任何系统调用(System Call),没有陷入内核,更没有线程的上下文切换。它的开销仅仅是一条 CPU 原子指令的执行时间(纳秒级别),因此快如闪电。

为什么竞争激烈时会变慢?(慢路径 Slow Path)

当多个线程同时死磕同一把锁时,纯用户态的原子操作就搞不定了,必须退化到“慢路径”。

  1. 线程在用户态尝试执行 CAS 原子抢锁,但发现锁状态已经是 1 或 2(抢锁失败)。
  2. 为了避免像自旋锁(Spinlock)那样死循环空转浪费 CPU,抢锁失败的线程会主动通过 futex 系统调用 陷入内核态(SYS_futex)。
  3. 进入内核后,内核会将这个抢不到锁的线程放入对应的 等待队列 中,并将其状态置为休眠(阻塞),然后调度器会把 CPU 时间片分配给其他线程。
  4. 当持有锁的线程在用户态执行解锁时,不仅要把状态变量改回 0,如果它发现之前状态是 2(有等待者),它还需要触发一次 futex 系统调用进入内核,通知内核“我用完了,你可以唤醒等待队列里的兄弟了”。
  5. 为什么慢: 竞争激烈时,线程无法在用户态解决战斗,被迫频繁触发系统调用陷入内核。这不仅带来了极高的调用开销,还会引发重量级的 线程上下文切换 和 CPU 调度成本(需要保存和恢复寄存器状态、内核栈,且会导致 CPU 缓存失效)。

总结

现代操作系统的锁设计哲学就是:先在用户态以最低成本(原子指令)尝试抢锁,抢不到时再通过 futex 机制退行到内核态进行休眠等待和唤醒。无竞争时享受零系统调用带来的极致性能,高竞争时则必须承担上下文切换和调度的物理成本。

区别、使用场景

互斥锁和自旋锁都是互斥类型的锁,核心区别在于线程等待锁的策略和开销:

  • 对于互斥锁,如果线程拿不到锁,它会阻塞休眠。

  • 对于自旋锁,如果线程拿不到锁,它会在一个循环里不停的尝试获取(忙等待)。

  • 互斥锁的主要开销来自于两次上下文切换以及隐含的 Cache 失效、跨进程线程切换时的 TLB 失效问题

  • 自旋锁的开销是 CPU 空转时间

注意有些自旋锁的实现也会让出执行权,只不过这里自旋锁的让出执行权,是指线程从 运行态变为就绪态;而互斥锁的让出执行权,是指锁从运行态变为阻塞态。

使用场景:

  • 如果临界区执行时间比较长,或者代码逻辑里可能有 IO 操作,一定要用互斥锁,否则空转会浪费大量 CPU
  • 如果临界区执行时间非常短,或者就几条简单指令,那么自旋锁避免上下文切换带来的收益就会大于空转的损耗,性能更高

该如何选择?优先选择 std::mutex,如果明确知道(通过性能测试火焰图、bpf)互斥锁才是性能瓶颈,才考虑使用自旋锁优化。

另外,mutex 可以设置为 PTHREAD_MUTEX_ADAPTIVE_NP,mutex 现在用户态自旋大约 4us,再陷入内核等待,

posted @ 2026-10-11 22:51  光風霽月  阅读(27)  评论(0)    收藏  举报