Linux 学习笔记(三十六):并发进阶——读写锁 vs 自旋锁,到底怎么选?

📌 核心结论(TL;DR):

  1. 选型口诀 :多读少写选读写锁 ;极短临界区+多核选自旋锁 ;复杂逻辑选互斥锁(Mutex)。

  2. 读写锁三大铁律:读读共享、读写互斥、写写互斥。

  3. 自旋锁致命缺点:如果锁被占用时间较长,线程一直原地"忙等待(自旋)",会白白把 CPU 跑满(浪费算力)。

  4. 饥饿问题:读写锁默认策略下,如果读者源源不断,写者可能会被"饿死"(长时间抢不到锁)。

一、 互斥锁的局限性

传统的互斥锁(Mutex)非常霸道:无论你是读取数据还是修改数据,只要有线程加锁,其他线程全部阻塞。但在实际开发中,往往是"多读少写"的场景。如果读操作也互斥,系统的并发性能将大打折扣。

二、 读写锁(Reader-Writer Lock)

读写锁专门针对多读少写场景设计,遵循三大核心规则:

  1. 读读共享:多个线程可以同时持有读锁。

  2. 读写互斥:写操作独占,此时不允许任何读操作。

  3. 写写互斥:多个写线程之间必须互斥。

核心 API:

  • pthread_rwlock_rdlock():加读锁。

  • pthread_rwlock_wrlock():加写锁。

  • pthread_rwlock_unlock():解锁。

(插入 rwlock_test.cc 代码)

cpp 复制代码
#include <iostream>
#include <pthread.h>
#include <unistd.h>

int shared_data = 0;
pthread_rwlock_t rwlock;

void* Reader(void* arg) {
    long id = (long)arg;
    while (true) {
        pthread_rwlock_rdlock(&rwlock); // 加读锁
        std::cout << "读者-" << id << " 正在读取数据: " << shared_data << std::endl;
        sleep(1);
        pthread_rwlock_unlock(&rwlock); // 解锁
    }
    return nullptr;
}

void* Writer(void* arg) {
    long id = (long)arg;
    while (true) {
        pthread_rwlock_wrlock(&rwlock); // 加写锁
        shared_data++;
        std::cout << "写者-" << id << " 正在写入数据: " << shared_data << std::endl;
        sleep(1);
        pthread_rwlock_unlock(&rwlock);
        sleep(1);
    }
    return nullptr;
}

三、 自旋锁(Spinlock)

自旋锁与 Mutex 的最大区别在于"等待"的方式:

  • Mutex 发现锁被占用,会让线程进入睡眠状态(阻塞态),让出 CPU。醒来时需要上下文切换,开销大。

  • Spinlock 发现锁被占用,会开启死循环原地自旋(忙等待),不放弃 CPU。

(插入 spinlock_test.cc 核心代码)

cpp 复制代码
pthread_spinlock_t spinlock; // 自旋锁

void* route(void* arg) {
    while (true) {
        pthread_spin_lock(&spinlock); // 加自旋锁
        if (ticket > 0) {
            // 极短的操作
            ticket--;
        } else {
            pthread_spin_unlock(&spinlock);
            break;
        }
        pthread_spin_unlock(&spinlock);
    }
}

四、 面试必考:如何避坑与选型?

  1. 自旋锁的坑:由于是在原地死循环,如果临界区代码很长,其他线程会白白消耗大量 CPU 资源(在单核 CPU 上尤为致命,因为自旋的线程占着 CPU,拿到锁的线程根本没法运行)。

  2. 读写锁的"写者饥饿" :在默认读者优先的策略下,如果一直有新的读者进来,写者可能永远无法获得写锁。可以通过设置 PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP 属性让写者优先。

  3. 选型总结:

    • 读操作多、写操作少 →→ 读写锁。

    • 临界区只有几条指令,且是多核 CPU →→ 自旋锁。

    • 临界区长、逻辑复杂 →→ 互斥锁 (Mutex)。

自我实战操作

咱们来写一段代码,用读写锁模拟"2 个读者,2 个写者"同时访问一个共享数据。

bash 复制代码
cd ~/linux_study
mkdir rw_spin_test
cd rw_spin_test
实战 1:读写锁测试
bash 复制代码
vim rwlock_test.cc

(输入以下代码)

cpp 复制代码
#include <iostream>
#include <pthread.h>
#include <unistd.h>

int shared_data = 0;      // 共享数据
pthread_rwlock_t rwlock;  // 读写锁

// 读者线程
void* Reader(void* arg) {
    long id = (long)arg;
    while (true) {
        pthread_rwlock_rdlock(&rwlock); // 加读锁
        std::cout << "读者-" << id << " 正在读取数据: " << shared_data << std::endl;
        sleep(1); // 模拟读取耗时
        pthread_rwlock_unlock(&rwlock); // 解锁
        // sleep(1); // 打开这个注释,写者会饿死
    }
    return nullptr;
}

// 写者线程
void* Writer(void* arg) {
    long id = (long)arg;
    while (true) {
        pthread_rwlock_wrlock(&rwlock); // 加写锁
        shared_data++;
        std::cout << "写者-" << id << " 正在写入数据: " << shared_data << std::endl;
        sleep(1); // 模拟写入耗时
        pthread_rwlock_unlock(&rwlock); // 解锁
        sleep(1); // 写者给读者留点机会
    }
    return nullptr;
}

int main() {
    pthread_rwlock_init(&rwlock, nullptr);

    pthread_t r1, r2, w1, w2;
    pthread_create(&r1, nullptr, Reader, (void*)1);
    pthread_create(&r2, nullptr, Reader, (void*)2);
    pthread_create(&w1, nullptr, Writer, (void*)1);
    pthread_create(&w2, nullptr, Writer, (void*)2);

    pthread_join(r1, nullptr);
    pthread_join(r2, nullptr);
    pthread_join(w1, nullptr);
    pthread_join(w2, nullptr);

    pthread_rwlock_destroy(&rwlock);
    return 0;
}

编译运行:

bash 复制代码
g++ rwlock_test.cc -o rwlock_test -lpthread
./rwlock_test

👉 现象:你会看到"读者-1"和"读者-2"经常一起打印(读读共享),但当"写者"打印时,两个读者必定是停住的(读写互斥)。

实战 2:自旋锁测试

(注意:自旋锁在单核虚拟机上测试效果不明显,但代码必须要会写)

bash 复制代码
vim spinlock_test.cc

(输入以下代码)

cpp 复制代码
#include <iostream>
#include <pthread.h>
#include <unistd.h>

int ticket = 1000;
pthread_spinlock_t spinlock; // 自旋锁

void* route(void* arg) {
    long id = (long)arg;
    while (true) {
        pthread_spin_lock(&spinlock); // 加自旋锁
        if (ticket > 0) {
            usleep(100); // 模拟极短的操作
            printf("线程-%ld 卖出票: %d\n", id, ticket);
            ticket--;
        } else {
            pthread_spin_unlock(&spinlock);
            break;
        }
        pthread_spin_unlock(&spinlock); // 解锁
    }
    return nullptr;
}

int main() {
    pthread_spin_init(&spinlock, PTHREAD_PROCESS_PRIVATE);
    pthread_t t1, t2, t3;
    pthread_create(&t1, nullptr, route, (void*)1);
    pthread_create(&t2, nullptr, route, (void*)2);
    pthread_create(&t3, nullptr, route, (void*)3);

    pthread_join(t1, nullptr);
    pthread_join(t2, nullptr);
    pthread_join(t3, nullptr);

    pthread_spin_destroy(&spinlock);
    return 0;
}

(编译运行 g++ spinlock_test.cc -o spinlock_test -lpthread && ./spinlock_test)

相关推荐
飞奔的瓜牛15 小时前
Nginx 生产环境运维实践:常见问题、关注要点与日常维护
运维·nginx
小七在进步18 小时前
string的实现(1)
c++·笔记·visual studio
Eyfcom18 小时前
〖物流 SaaS 实战 02〗SaaS 租户的计费与订阅模型:从“一锤子买卖”到“按需订阅”
linux·服务器·数据库·快递系统·物流saas实战
瑞克-桑切斯20 小时前
Kubernetes 1.28 保姆级新手学习教程
运维·学习·docker·云原生·容器·kubernetes
数据库急诊室_阿哲20 小时前
一次割接后的性能复核记录:基线、样本、回滚点
运维·数据库·dba
忆挽篱笙歌20 小时前
systemV进程通信
linux·运维·服务器
保利威视频SaaS小张21 小时前
企业直播接入笔记 12|企业内训直播怎么做签到和学时统计,防挂机这件事比想象中难
java·前端·数据库·笔记·视频云·polvy·polyv
lcj25111 天前
[C++] C++11
开发语言·c++·笔记
kaixin_啊啊1 天前
【三种鲑科鱼类比较基因组学分析鉴定出参与细胞内寄生菌鲑立克次体抗性的功能候选基因】论文学习
学习