互斥锁抢不到时会把自己挂进等待队列,让出 CPU;自旋锁抢不到时只在原地循环。区别不在"谁更快",而在等待的那段时间 CPU 归谁:前者归别人,后者归自己,而且什么活都没干。

忙等和睡眠等待,成本记在不同账上

自旋锁的模型只有一个共享标志位:0 表示空,1 表示被占。获取时用一条原子操作把 0 抢成 1;抢到就进临界区,没抢到就回到循环开头继续看。释放时把标志位清 0。

一次争用失败的 pthread_mutex_lock 大致要走:用户态原子操作失败,进内核,把自己挂到等待队列并置为睡眠,调度器保存寄存器、栈指针、页表基址,换下一个线程;持锁者解锁后把等待者标成就绪;等待者被调度回来,再从内核态返回用户态。这一套通常是一两微秒到十几微秒。

一次原子比较交换在同一个核的热缓存行上通常是几十纳秒。两个数量级以上的差距,就是自旋锁存在的理由:它把"睡眠再唤醒"换成"原地重试"。

这笔交换有前提。等待期间 CPU 不还给别人,所以:

  • 多核:持锁线程在另一个核上推进,自旋的核烧掉一部分算力,但临界区很快结束,总账可能划算。
  • 单核:持锁线程和被阻塞的线程排在同一个核上,转得越久,持锁者越晚被调度到,墙钟反而更长。
  • 内核的不可睡眠上下文:中断处理里不能睡眠,spin_lock 是少数能用的锁。用户态的 pthread_spin_lock 不关抢占,也没有内核那套上下文标记,但持锁时同样不能睡眠。

课件里"先看标志再置位"不是一步

课件描述原理时写:标志位为 false 时,线程设置它为 true 并进入临界区;为 true 时循环等待。这句话把"检查"和"设置"拆成了两步,在并发下不成立:两个线程都能看到 false,都能往下走,都以为自己拿到了锁。必须用一条原子指令把读取旧值和写入新值合成一步。

C11 的 atomic_flag 就是为这件事准备的:

#include <stdatomic.h>
 
static atomic_flag g_lock = ATOMIC_FLAG_INIT;
 
static inline void CpuRelax(void)
{
#if defined(__x86_64__) || defined(__i386__)
    __asm__ __volatile__("pause" ::: "memory");
#elif defined(__aarch64__)
    __asm__ __volatile__("yield" ::: "memory");
#endif
}
 
static inline void SpinLock(void)
{
    while (atomic_flag_test_and_set_explicit(&g_lock, memory_order_acquire))
        CpuRelax();
}
 
static inline void SpinUnlock(void)
{
    atomic_flag_clear_explicit(&g_lock, memory_order_release);
}

atomic_flag_test_and_set 的语义是:把标志位置为 true,并返回它之前的值。返回 false 表示刚才空着、这次抢到了;返回 true 表示刚才被占、没抢到。它不会因为没抢到就跳出循环,所以外层必须套 while。

课件把它叫 CAS(Compare-And-Swap)。二者不是一回事:test-and-set 只表达"写 1,顺便告诉我原来是什么",CAS 表达"原来等于 A 才改成 B"。x86 上 TAS 通常编成 xchg 或带 lock 前缀的位操作,ARM 上用 LDREX/STREX 的读—改—条件写循环。用 CAS 做 trylock 时,失败会把当前值回填进 expected,重试时手里已经是最新值,不必再读一次。

atomic_flag 在 C11 里是唯一被标准要求必须无锁实现的原子类型,底层就是一个 _Bool 或 unsigned char,标准只规定了 test_and_set 和 clear 两个操作。拿它做锁的底座,比拿 atomic_bool 稳。

两处细节决定它能不能用。第一,pause(老名字 rep nop)告诉处理器"我在自旋",顺手清掉流水线里预测错的指令、少抢超线程上另一个逻辑核的执行端口;没有它,自旋循环会把执行端口占满。第二,内存序。默认的 memory_order_seq_cst 最安全也最贵;有人为快改成 relaxed,编译器就可能把临界区里的写挪到解锁之后,锁本身没坏,被它保护的数据坏了。acquire 配 release 才是临界区在内存模型上的落地。

pthread_spin_* 的五个接口

#include <pthread.h>
 
int pthread_spin_init(pthread_spinlock_t *lock, int pshared);
int pthread_spin_destroy(pthread_spinlock_t *lock);
int pthread_spin_lock(pthread_spinlock_t *lock);
int pthread_spin_trylock(pthread_spinlock_t *lock);
int pthread_spin_unlock(pthread_spinlock_t *lock);

pshared 只有两个值:PTHREAD_PROCESS_PRIVATE 表示锁只在本进程的线程间用,PTHREAD_PROCESS_SHARED 表示跨进程,而且锁本身必须放在 mmap(MAP_SHARED) 出来的共享内存里才有意义。

几个容易踩的返回值:

  • pthread_spin_lock 抢不到时一直自旋,成功返回 0;标准允许它在检测到同一线程重复加锁时返回 EDEADLK,但不是每个实现都做这个检测,正确做法是根本不递归。
  • pthread_spin_trylock 抢不到立刻返回 EBUSY,这是个正整数,不是 -1。写 if (ret == -1) 永远判不到失败。
  • pthread_spin_destroy 之前必须确认没有线程还持有或还在等这把锁,否则行为未定义。
  • 这组接口不是 async-signal-safe 的。主流程正持着同一把锁时,信号处理函数里再去 pthread_spin_lock,会在同一个线程上原地自旋,没人能放锁。

课件卖票代码:锁里睡眠、锁外判断、无锁解锁

课件样例把加锁三行注释掉了,留下的循环是:

while (1)
{
    // pthread_spin_lock(&lock);
    if (ticket > 0)
    {
        usleep(1000);
        printf("%s sells ticket:%d\n", id, ticket);
        ticket--;
        // pthread_spin_unlock(&lock);
    }
    else
    {
        // pthread_spin_unlock(&lock);
        break;
    }
}

放开注释后有三处错:

第一,if (ticket > 0) 的判断在锁外。两个线程可以同时看到 ticket == 1,一个减到 0,另一个也打印 1 再减到 -1。判断、读值、写值必须一起放进临界区。

第二,usleep(1000) 是一毫秒,printf 内部有锁、有缓冲区、可能触发系统调用。把持自旋锁的线程睡一毫秒,等于让其他核在这一毫秒里空转;printf 也不该在自旋锁里。

第三,else 分支里的 unlock 一旦放开,就是对一把从未持有的锁解锁,可能提前把标志位清掉,让两个线程同时进临界区。

锁的范围应该只包住"读 ticket、判断、写 ticket",慢操作放到锁外:

static pthread_spinlock_t g_spin;   /* main 里 pthread_spin_init(&g_spin, PTHREAD_PROCESS_PRIVATE) */
static int g_ticket = 1000;
 
static void *Sell(void *arg)
{
    const char *id = (const char *)arg;
 
    while (1)
    {
        int got = 0;
 
        pthread_spin_lock(&g_spin);
        if (g_ticket > 0)
        {
            got = g_ticket;
            --g_ticket;
        }
        pthread_spin_unlock(&g_spin);
 
        if (got == 0)
            break;
 
        printf("%s sells ticket:%d\n", id, got);
    }
 
    return NULL;
}

不加锁的版本常常卖出多于 1000 张,多几张取决于线程交错:ticket-- 是读—改—写三步,两个线程读到同一个值,各自写回同一个减一后的值,一次递减被吞掉了。数据竞争不总是出错,它只是有时候出错。

课件说"多 CPU 下自旋锁可能不如别的锁",这句反了

课件注意事项里写:多 CPU 环境下自旋锁可能不如其他锁高效,因为它可能导致线程在不同的 CPU 上自旋等待。自旋锁恰恰是为多核设计的。它省下的上下文切换,只有在另一个核能同时推进时才谈得上收益;单核上自旋的人占着唯一的核,持锁者根本没机会跑,那才是纯浪费。Linux 内核在单核未开 SMP 的配置里,spin_lock 会退化成只关抢占、不自旋。

课件还说"没有退避策略可能形成活锁"。原地自旋不改任何状态,属于忙等造成的 CPU 浪费和饥饿(starvation),不是活锁;活锁是各方都在改变状态、互相响应,但整体推进不了。两者都会表现为"程序不往前走",原因和修法不同。

和互斥锁怎么选

互斥锁自旋锁
抢不到时睡眠,让出 CPU原地循环
唤醒成本两次上下文切换无
等待期间 CPU别人用自己烧
临界区长度长、可能阻塞几十条指令、无系统调用
核数单核也合适多核才有收益
公平性取决于实现不保证,可能饿死某个线程
中断/原子上下文(不可睡眠)不可以内核的 spin_lock 可以

还有一层成本容易被忽略:没有争用时,pthread_mutex_lock 的第一条路径也是一次原子比较交换,成功就返回,整条路径在用户态,不进内核。所以把互斥锁换成自旋锁,在低争用场景下快不了多少,只是把偶发的等待从"睡一觉"改成"烧 CPU"。

判断入口不是"哪个更快",而是临界区的性质:里面有 printf、malloc、磁盘或网络 I/O,就不要用自旋锁;单核或容器只给一个 CPU,也不要用;临界区到了微秒级,自旋的成本已经超过睡眠。真要换,先量争用强度(/usr/bin/time -v 里的自愿上下文切换数)、临界区长度(clock_gettime 前后各一次)、核数与线程数的比例,三项都过再动手。