Linux：读写锁与自旋锁

一、读写锁

1. 什么是读者写者问题？

读者写者模型是一种多线程同步策略，适用于高频读、低频写的场景。
比如博客文章：作者（写者）发布后很少修改，而读者（读者）频繁访问。
在这种场景下，使用读写锁可以比互斥锁减少很多锁冲突。

2. 读者写者问题的"321"原则

• 3种关系：

  • 读者与读者：互斥（但实际允许多个读者同时读）
  • 读者与写者：互斥和同步（读时不能写，写时不能读）
  • 写者与写者：互斥（不能同时写）

• 2种角色：读者和写者

• 1个交易场所：共享内存空间（如黑板、缓冲区）

3. 读写锁 vs 生产者消费者模型

为什么写者之间需要互斥，而消费者之间也需要互斥？关键区别在于：

• 消费者会取走数据，修改缓冲区
• 写者只修改数据，不取走，但修改操作仍需互斥保护

4. 读写锁实现原理

// 伪代码实现uint32_treader_count=0;lock_t count_lock;// 保护读者计数器的锁lock_t writer_lock;// 写者锁// 读者lock(count_lock);if(reader_count==0)lock(writer_lock);// 第一个读者阻止写者++reader_count;unlock(count_lock);// 执行读操作lock(count_lock);--reader_count;if(reader_count==0)unlock(writer_lock);// 最后一个读者唤醒写者unlock(count_lock);// 写者lock(writer_lock);// 执行写操作unlock(writer_lock);

5. POSIX 线程库接口

#include<pthread.h>// 初始化读写锁intpthread_rwlock_init(pthread_rwlock_t*restrict rwlock,constpthread_rwlockattr_t*restrict attr);// 销毁读写锁intpthread_rwlock_destroy(pthread_rwlock_t*rwlock);// 读者加锁intpthread_rwlock_rdlock(pthread_rwlock_t*rwlock);// 写者加锁intpthread_rwlock_wrlock(pthread_rwlock_t*rwlock);// 解锁intpthread_rwlock_unlock(pthread_rwlock_t*rwlock);

6. 完整示例代码

#include<iostream>#include<pthread.h>#include<unistd.h>#include<vector>#include<cstdlib>#include<ctime>intshared_data=0;pthread_rwlock_t rwlock;void*Reader(void*arg){intnumber=*(int*)arg;while(true){pthread_rwlock_rdlock(&rwlock);std::cout<<"读者-"<<number<<" 读取数据: "<<shared_data<<std::endl;sleep(1);pthread_rwlock_unlock(&rwlock);}delete(int*)arg;returnNULL;}void*Writer(void*arg){intnumber=*(int*)arg;while(true){pthread_rwlock_wrlock(&rwlock);shared_data=rand()%100;std::cout<<"写者-"<<number<<" 写入数据: "<<shared_data<<std::endl;sleep(2);pthread_rwlock_unlock(&rwlock);}delete(int*)arg;returnNULL;}intmain(){srand(time(nullptr)^getpid());pthread_rwlock_init(&rwlock,NULL);constintreader_num=2;constintwriter_num=2;constinttotal=reader_num+writer_num;pthread_t threads[total];// 创建读者线程for(inti=0;i<reader_num;++i){int*id=newint(i);pthread_create(&threads[i],NULL,Reader,id);}// 创建写者线程for(inti=reader_num;i<total;++i){int*id=newint(i-reader_num);pthread_create(&threads[i],NULL,Writer,id);}for(inti=0;i<total;++i){pthread_join(threads[i],NULL);}pthread_rwlock_destroy(&rwlock);return0;}

7. 写者饥饿问题

读写锁允许多个读者同时读，可能导致读者连续进入，写者长期无法获得锁，造成写者饥饿。

8. 读者优先 vs 写者优先

注：读写锁默认采用读者优先策略

二、自旋锁

1. 什么是自旋锁？

自旋锁是一种多线程互斥机制，与互斥锁的区别在于锁获取失败时的行为：

• 互斥锁：失败后线程阻塞，上下文切换
• 自旋锁：失败后线程循环检查，忙等待

2. 适用场景

3. 实现原理

// 原子操作实现atomic_flag lock=ATOMIC_FLAG_INIT;// 加锁while(atomic_flag_test_and_set(&lock)){// 自旋等待}// 临界区// 解锁atomic_flag_clear(&lock);

4. POSIX 自旋锁接口

#include<pthread.h>// 初始化自旋锁intpthread_spin_init(pthread_spinlock_t*lock,intpshared);// 销毁自旋锁intpthread_spin_destroy(pthread_spinlock_t*lock);// 加锁intpthread_spin_lock(pthread_spinlock_t*lock);intpthread_spin_trylock(pthread_spinlock_t*lock);// 解锁intpthread_spin_unlock(pthread_spinlock_t*lock);

5. 自旋锁的优缺点

优点

• ✅ 避免线程阻塞/唤醒的上下文切换开销
• ✅ 适合短时间锁持有场景

缺点

• ❌ 浪费CPU资源（空转）
• ❌ 可能导致活锁（多个线程相互等待）
• ❌ 可能加剧系统负载

三、总结对比