重温并发任务:Linux 多线程同步利器自旋锁

typedef volatile int pthread_spinlock_t;

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);

#include <stdio.h>#include <stdlib.h>#include <pthread.h>#include <unistd.h>#include <time.h>#define THREAD_NUM 10    // 线程数#define ADD_NUM 1000000  // 每个线程累加次数// 全局共享计数器long long g_count = 0;// 自旋锁pthread_spinlock_t spinlock;// 线程函数：自旋锁保护计数器累加void* add_count(void* arg){    (void)arg; // 屏蔽未使用参数警告    for(int i=0; i<ADD_NUM; i++)    {        // 加锁：仅保护count++        pthread_spin_lock(&spinlock);        g_count++; // 原子操作，耗时<1μs        // 解锁：必须成对        pthread_spin_unlock(&spinlock);    }    return NULL;}int main(){    pthread_t tid[THREAD_NUM];    struct timespec start, end;    double cost_time;    // 检查CPU核心数（仅多核运行）    int cpu_num = sysconf(_SC_NPROCESSORS_ONLN);    if (cpu_num <= 1) {        printf("警告：当前CPU核心数为%d，自旋锁性能差，建议改用互斥锁！\n", cpu_num);    }    // 初始化自旋锁（进程内私有）    pthread_spin_init(&spinlock, PTHREAD_PROCESS_PRIVATE);    // 记录开始时间    clock_gettime(CLOCK_MONOTONIC, &start);    // 创建10个线程    for(int i=0; i<THREAD_NUM; i++)    {        pthread_create(&tid[i], NULL, add_count, NULL);    }    // 等待所有线程完成    for(int i=0; i<THREAD_NUM; i++)    {        pthread_join(tid[i], NULL);    }    // 记录结束时间    clock_gettime(CLOCK_MONOTONIC, &end);    // 销毁自旋锁    pthread_spin_destroy(&spinlock);    // 计算耗时（秒）    cost_time = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9;    printf("=====================================\n");    printf("最终计数器值：%lld（预期：%d）\n", g_count, THREAD_NUM*ADD_NUM);    printf("总耗时：%.3f秒\n", cost_time);    printf("每秒累加次数：%.0f次\n", (double)(THREAD_NUM*ADD_NUM)/cost_time);    printf("=====================================\n");    return 0;}

运行结果（4 核 CPU）

✅ 示例二：进阶版 — 非阻塞自旋锁 + 轮询操作（防死自旋核心模板）

实现非阻塞自旋锁的轮询操作，避免线程永久自旋：

1. 1. 线程 1 用pthread_spin_lock持有锁，模拟短时间操作；
2. 2. 线程 2 用pthread_spin_trylock非阻塞加锁，失败则轮询重试，超过最大次数则退出；
3. 3. 严格遵守「短持有、低竞争」规则，无 CPU 满载风险。

#include <stdio.h>#include <stdlib.h>#include <pthread.h>#include <unistd.h>#include <errno.h>#define MAX_RETRY 10000 // 最大轮询次数// 共享状态标志int g_flag = 0;// 自旋锁pthread_spinlock_t spinlock;// 线程1：持有锁修改标志void* thread1(void* arg){    (void)arg;    // 加锁    pthread_spin_lock(&spinlock);    printf("线程1：获取自旋锁，修改flag为1\n");    g_flag = 1;    // 模拟短时间持有锁（1ms）    usleep(1000);    // 解锁    pthread_spin_unlock(&spinlock);    printf("线程1：释放自旋锁\n");    return NULL;}// 线程2：非阻塞轮询加锁void* thread2(void* arg){    (void)arg;    int retry = 0;    while(retry < MAX_RETRY)    {        // 非阻塞加锁        int ret = pthread_spin_trylock(&spinlock);        if(ret == 0)        {            // 加锁成功            printf("线程2：第%d次尝试，获取自旋锁，flag=%d\n", retry+1, g_flag);            g_flag = 2;            printf("线程2：修改flag为2，释放自旋锁\n");            pthread_spin_unlock(&spinlock);            break;        }        else if(ret == EBUSY)        {            // 锁被占用，继续轮询            retry++;            // 轮询间隔（可选，降低CPU占用）            // usleep(1);        }        else        {            printf("线程2：加锁失败，错误码=%d\n", ret);            break;        }    }    if(retry >= MAX_RETRY)    {        printf("线程2：超过最大重试次数（%d），退出\n", MAX_RETRY);    }    return NULL;}int main(){    pthread_t tid1, tid2;    // 初始化自旋锁    pthread_spin_init(&spinlock, PTHREAD_PROCESS_PRIVATE);    // 创建线程1（先持有锁）    pthread_create(&tid1, NULL, thread1, NULL);    usleep(100); // 确保线程1先执行    // 创建线程2（轮询加锁）    pthread_create(&tid2, NULL, thread2, NULL);    // 等待线程完成    pthread_join(tid1, NULL);    pthread_join(tid2, NULL);    // 销毁自旋锁    pthread_spin_destroy(&spinlock);    printf("主线程：最终flag=%d\n", g_flag);    return 0;}

运行结果

✅ 示例三：生产级版 — 自旋锁 vs 互斥锁性能对比（选型核心模板）

实现自旋锁和互斥锁的性能对比测试，帮助快速选型：

1. 1. 分别用自旋锁和互斥锁保护同一计数器；
2. 2. 输出两种锁的执行耗时和每秒操作数；
3. 3. 验证「短持有、低竞争」场景下自旋锁的性能优势。

#include <stdio.h>#include <stdlib.h>#include <pthread.h>#include <unistd.h>#include <time.h>#define THREAD_NUM 8     // 线程数#define ADD_NUM 500000   // 每个线程累加次数// 共享计数器long long g_spin_count = 0;long long g_mutex_count = 0;// 自旋锁&互斥锁pthread_spinlock_t spinlock;pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;// 自旋锁累加函数void* spin_add(void* arg){    (void)arg;    for(int i=0; i<ADD_NUM; i++)    {        pthread_spin_lock(&spinlock);        g_spin_count++;        pthread_spin_unlock(&spinlock);    }    return NULL;}// 互斥锁累加函数void* mutex_add(void* arg){    (void)arg;    for(int i=0; i<ADD_NUM; i++)    {        pthread_mutex_lock(&mutex);        g_mutex_count++;        pthread_mutex_unlock(&mutex);    }    return NULL;}// 耗时计算函数double calc_cost(struct timespec start, struct timespec end){    return (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9;}int main(){    pthread_t tid[THREAD_NUM];    struct timespec start, end;    double spin_cost, mutex_cost;    // 检查CPU核心数    int cpu_num = sysconf(_SC_NPROCESSORS_ONLN);    printf("当前CPU核心数：%d\n", cpu_num);    // ========== 测试自旋锁性能 ==========    pthread_spin_init(&spinlock, PTHREAD_PROCESS_PRIVATE);    clock_gettime(CLOCK_MONOTONIC, &start);    for(int i=0; i<THREAD_NUM; i++)    {        pthread_create(&tid[i], NULL, spin_add, NULL);    }    for(int i=0; i<THREAD_NUM; i++)    {        pthread_join(tid[i], NULL);    }    clock_gettime(CLOCK_MONOTONIC, &end);    spin_cost = calc_cost(start, end);    pthread_spin_destroy(&spinlock);    // ========== 测试互斥锁性能 ==========    clock_gettime(CLOCK_MONOTONIC, &start);    for(int i=0; i<THREAD_NUM; i++)    {        pthread_create(&tid[i], NULL, mutex_add, NULL);    }    for(int i=0; i<THREAD_NUM; i++)    {        pthread_join(tid[i], NULL);    }    clock_gettime(CLOCK_MONOTONIC, &end);    mutex_cost = calc_cost(start, end);    pthread_mutex_destroy(&mutex);    // ========== 输出结果 ==========    printf("=====================================\n");    printf("自旋锁测试结果：\n");    printf("  最终计数：%lld\n", g_spin_count);    printf("  总耗时：%.3f秒\n", spin_cost);    printf("  每秒操作：%.0f次\n", (double)(THREAD_NUM*ADD_NUM)/spin_cost);    printf("互斥锁测试结果：\n");    printf("  最终计数：%lld\n", g_mutex_count);    printf("  总耗时：%.3f秒\n", mutex_cost);    printf("  每秒操作：%.0f次\n", (double)(THREAD_NUM*ADD_NUM)/mutex_cost);    printf("性能提升：%.1f倍\n", mutex_cost/spin_cost);    printf("=====================================\n");    return 0;}

运行结果（4 核 CPU）

六、pthread 自旋锁 的优缺点（客观全面，选型参考）

✅ 优点（核心优势，无可替代）

1. 1. 极致的加解锁性能：纯用户态操作，无内核态 / 用户态切换、无线程上下文切换开销，短持有场景下性能是互斥锁的 10-100 倍；
2. 2. 延迟可预测：自旋锁的加解锁延迟是纳秒级，满足实时系统的低延迟要求；
3. 3. 实现简单：接口极少，逻辑清晰，核心是原子操作 + 循环重试，易于理解和使用；
4. 4. 无内核资源占用：自旋锁不依赖内核调度器，无需创建等待队列，资源开销极小；
5. 5. 多核 CPU 友好：多核环境下，自旋线程和持有锁线程可在不同核心执行，锁释放时可立即获取。

✅ 缺点（局限性，客观认知）

1. 1. CPU 利用率极高：自旋期间 CPU 100% 占用，锁持有时间过长会导致系统卡顿、其他线程饥饿；
2. 2. 仅适配多核 CPU：单核 CPU 下自旋锁性能远低于互斥锁，甚至导致死自旋；
3. 3. 死锁风险高：嵌套使用、递归加锁会导致永久自旋，且无法被内核干预；
4. 4. 不适合高竞争场景：大量线程自旋会浪费 CPU 资源，整体吞吐量暴跌；
5. 5. 不支持超时加锁：pthread 自旋锁无timedlock接口，无法设置自旋超时，易导致永久忙等；
6. 6. 持有锁时不能阻塞：持有自旋锁时调用阻塞接口，会导致其他线程永久自旋。

全文核心总结

1. 1. 自旋锁的核心是「忙等无切换」，仅适配「短持有（<1μs）+ 低竞争 + 多核 CPU」场景；
2. 2. 防坑黄金法则：不嵌套、不长持、单核不用、高竞争不用、不调用阻塞接口；
3. 3. 核心接口：初始化（spin_init）→加锁（spin_lock/trylock）→解锁（spin_unlock）→销毁（spin_destroy），无静态初始化；
4. 4. 最核心场景是高频原子操作，其次是多核低竞争共享资源、实时系统轮询；
5. 5. 优点是性能极致、延迟可预测，缺点是 CPU 占用高、死锁风险大，整体瑕不掩瑜；
6. 6. 选型原则：先看锁持有时间，再看竞争率和 CPU 核心数，短 + 低 + 多核→自旋锁，否则→互斥锁。