互斥锁、自旋锁的原理、区别、使用场景
自旋锁原理
自旋锁(Spinlock)是一种基于忙等待(Busy-waiting)机制的互斥同步原语。与传统互斥锁(Mutex)在获取锁失败时将线程挂起(休眠)不同,自旋锁会让线程持续在循环中反复检查锁状态,直到成功获取。
核心工作原理
自旋锁的本质依赖于现代 CPU 提供的硬件级原子操作指令(如 x86 的 LOCK CMPXCHG、XCHG,ARM 的 LDREX/STREX 或 CAS)。
- 加锁(Lock)
- 线程尝试执行原子操作(如
compare_and_swap或test_and_set),将锁标志位从 0 改为 1。 - 如果修改成功,说明抢到锁,直接进入临界区。
- 如果修改失败(说明已被其他线程持有),线程不让出 CPU,而是在
while循环中反复执行原子操作或读取状态,即“原地自旋”,直到锁被释放。
- 线程尝试执行原子操作(如
- 解锁(Unlock)
- 持锁线程执行完毕后,通过原子写操作(或带 Release 内存序的写)将标志位重置为 0。
- 此时正在自旋的其他线程会检测到状态变化,竞争获取该锁。
为什么需要自旋锁?(对比互斥锁)
- 互斥锁(Mutex)的开销:当锁发生竞争时,互斥锁会将线程放入等待队列,触发内核态上下文切换(Context Switch)。上下文切换涉及保存寄存器、切换页表缓存(TLB flush)和调度开销,通常需要数微秒到数十微秒。
- 自旋锁的优势:完全在用户态/轻量指令级完成,避免了线程休眠与唤醒的上下文切换成本。只要临界区极小、持锁时间极短,自旋锁的响应延迟远低于互斥锁。
核心缺陷与注意事项
- CPU 空耗与发热:自旋过程相当于 CPU 在跑死循环,若临界区耗时较长或发生长时间等待,会白白浪费 CPU 时间片并导致功耗飙升。
- 死锁与单核问题:在单核 CPU 或禁用抢占的场景下,若自旋线程优先级高于持锁线程,自旋线程独占 CPU 将导致持锁线程永远无法运行并释放锁,引发死锁。
- 缓存一致性风暴(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:“我现在正在轮询等待,请帮我优化流水线并降低开销”。
核心作用与原理
- 避免流水线清空惩罚(Pipeline Flush) 自旋循环在退出时(即成功获取锁或条件满足时),CPU 的分支预测极易因为预测失败而清空整个指令流水线,导致几十到上百个时钟周期的严重延迟。
PAUSE指令向硬件提示当前处于循环等待,能大幅缓解甚至消除这种流水线回退惩罚。 - 降低 CPU 功耗与发热 空转的
while循环会让 CPU 核心满负荷狂转。插入PAUSE会让该核心轻微休眠几个到几十个周期(不同架构约为 10~140 个 cycle),显著降低发热和耗电。 - 缓解超线程(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 走的是纯用户态的“快路径”。
- 线程在用户态直接通过一条硬件级别的原子指令(如 CAS, Compare-And-Swap),尝试将内存中的锁状态变量从
0修改为1。 - 因为没有其他线程在抢,修改瞬间成功,加锁完成。
- 为什么快: 整个加锁过程完全发生在用户态,没有任何系统调用(System Call),没有陷入内核,更没有线程的上下文切换。它的开销仅仅是一条 CPU 原子指令的执行时间(纳秒级别),因此快如闪电。
为什么竞争激烈时会变慢?(慢路径 Slow Path)
当多个线程同时死磕同一把锁时,纯用户态的原子操作就搞不定了,必须退化到“慢路径”。
- 线程在用户态尝试执行 CAS 原子抢锁,但发现锁状态已经是
1或2(抢锁失败)。 - 为了避免像自旋锁(Spinlock)那样死循环空转浪费 CPU,抢锁失败的线程会主动通过 futex 系统调用 陷入内核态(
SYS_futex)。 - 进入内核后,内核会将这个抢不到锁的线程放入对应的 等待队列 中,并将其状态置为休眠(阻塞),然后调度器会把 CPU 时间片分配给其他线程。
- 当持有锁的线程在用户态执行解锁时,不仅要把状态变量改回
0,如果它发现之前状态是2(有等待者),它还需要触发一次 futex 系统调用进入内核,通知内核“我用完了,你可以唤醒等待队列里的兄弟了”。 - 为什么慢: 竞争激烈时,线程无法在用户态解决战斗,被迫频繁触发系统调用陷入内核。这不仅带来了极高的调用开销,还会引发重量级的 线程上下文切换 和 CPU 调度成本(需要保存和恢复寄存器状态、内核栈,且会导致 CPU 缓存失效)。
总结
现代操作系统的锁设计哲学就是:先在用户态以最低成本(原子指令)尝试抢锁,抢不到时再通过 futex 机制退行到内核态进行休眠等待和唤醒。无竞争时享受零系统调用带来的极致性能,高竞争时则必须承担上下文切换和调度的物理成本。
区别、使用场景
互斥锁和自旋锁都是互斥类型的锁,核心区别在于线程等待锁的策略和开销:
-
对于互斥锁,如果线程拿不到锁,它会阻塞休眠。
-
对于自旋锁,如果线程拿不到锁,它会在一个循环里不停的尝试获取(忙等待)。
-
互斥锁的主要开销来自于两次上下文切换以及隐含的 Cache 失效、跨进程线程切换时的 TLB 失效问题
-
自旋锁的开销是 CPU 空转时间
注意有些自旋锁的实现也会让出执行权,只不过这里自旋锁的让出执行权,是指线程从 运行态变为就绪态;而互斥锁的让出执行权,是指锁从运行态变为阻塞态。
使用场景:
- 如果临界区执行时间比较长,或者代码逻辑里可能有 IO 操作,一定要用互斥锁,否则空转会浪费大量 CPU
- 如果临界区执行时间非常短,或者就几条简单指令,那么自旋锁避免上下文切换带来的收益就会大于空转的损耗,性能更高
该如何选择?优先选择 std::mutex,如果明确知道(通过性能测试火焰图、bpf)互斥锁才是性能瓶颈,才考虑使用自旋锁优化。
另外,mutex 可以设置为 PTHREAD_MUTEX_ADAPTIVE_NP,mutex 现在用户态自旋大约 4us,再陷入内核等待,

浙公网安备 33010602011771号