读写锁(read-write lock)把访问分成两类:读锁可以多人同时持有,写锁只能一个人持有,而且和任何读锁互斥。用一张表就能把规则说完:

当前状态来一个读请求来一个写请求
没人持有立刻进立刻进
有人在读立刻进,读者计数加一排队等
有人在写排队等排队等

这三行是契约,任何叫"读写锁"的实现都得满足。契约没规定的是"排队的人按什么顺序叫号",读者优先和写者优先的全部区别就在这个没写进契约的地方。

读者写者问题和生产者消费者差在哪

生产者消费者里,消费者取走一条,那条就没了,第二个消费者必须等新的。读者写者里,读者读完,数据原封不动留在原地,第二个读者可以直接进。这条差别决定了同步结构:前者需要两个信号量做双向配额,后者只需要"互斥加计数"。

课件给的模型是两个锁加一个计数:

uint32_t reader_count = 0;
lock_t   count_lock;      /* 保护 reader_count */
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);

写者只碰 writer_lock:加锁、写、解锁。

这段伪代码能成立,靠三条不变量:reader_count 的所有读写都在 count_lock 下;计数从 0 变 1 时同时拿到 writer_lock,从 1 变 0 时放开它;加锁顺序永远是 count_lock → writer_lock 一个方向,不会成环。

最容易写错的是解锁那几行。把 unlock(count_lock) 提到判断之前:

lock(count_lock);
--reader_count;
unlock(count_lock);       /* 错:计数已经不受保护 */
if (reader_count == 0)
    unlock(writer_lock);

两个读者同时收尾时,A 把计数减到 1、放锁,B 减到 0、放锁,然后 A 和 B 都去看计数。A 可能读到 0,于是也去放 writer_lock;B 看到 0 也会去放。至少有一次是重复放,或者由没持有它的那个读者放。轻则丢锁,重则两个写者同时进入。

同样的逻辑用信号量写,饥饿从排队规则里来

把两把锁换成信号量,结构不变:

#include <semaphore.h>
 
static sem_t g_mutex;     /* 保护 g_readers */
static sem_t g_wrt;       /* 读写互斥 */
static sem_t g_turnstile; /* 写者优先的闸门 */
static int   g_readers;
 
static void RwInit(void)
{
    sem_init(&g_mutex, 0, 1);
    sem_init(&g_wrt, 0, 1);
    sem_init(&g_turnstile, 0, 1);
}
 
static void ReaderEnter(void)
{
    sem_wait(&g_turnstile);
    sem_post(&g_turnstile);
 
    sem_wait(&g_mutex);
    if (++g_readers == 1)
        sem_wait(&g_wrt);
    sem_post(&g_mutex);
}
 
static void ReaderExit(void)
{
    sem_wait(&g_mutex);
    if (--g_readers == 0)
        sem_post(&g_wrt);
    sem_post(&g_mutex);
}
 
static void WriterEnter(void)
{
    sem_wait(&g_turnstile);
    sem_wait(&g_wrt);
}
 
static void WriterExit(void)
{
    sem_post(&g_wrt);
    sem_post(&g_turnstile);
}

g_turnstile 是写者优先的开关。写者先占住闸门再去等 g_wrt,期间新读者卡在 sem_wait(&g_turnstile) 上,不能继续插队;已经在读的读者散场后,写者拿到 g_wrt。写者退出时先放 g_wrt 再放闸门。

把闸门从读者和写者两边都去掉,就退回读者优先:读者不再经过闸门,写者也只等 g_wrt,新读者可以不断插到写者前面。这正是课件说的两种策略——差别只在"新读者能不能插队"。

饥饿是策略的直接后果。读者优先、读请求源源不断时,g_readers 永远回不到 0,写者在 g_wrt 上无限等待。反过来,写者优先、写请求密集时,闸门一直被写者占着,读者也等不到。两种策略都不保证公平,公平需要队列或票据,按到达顺序叫号:写者到达后,后来的读者排到它后面,已经在读的读者不受影响。Linux 的 pthread_rwlock 没有暴露公平选项,要严格 FIFO 得自己用互斥锁加条件变量实现。

pthread_rwlock_* 的接口与 glibc 实际支持的策略

#include <pthread.h>
 
int pthread_rwlock_init(pthread_rwlock_t *rwlock,
                        const pthread_rwlockattr_t *attr);
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);

attr 传 NULL 就是默认属性。链接时加 -lpthread(或 -pthread)。要改策略,用属性对象:

pthread_rwlock_t lock;
pthread_rwlockattr_t attr;
 
pthread_rwlockattr_init(&attr);
pthread_rwlockattr_setkind_np(&attr, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP);
pthread_rwlock_init(&lock, &attr);
pthread_rwlockattr_destroy(&attr);

三个取值里,PTHREAD_RWLOCK_PREFER_READER_NP 是默认,读者优先,写者可能饿死。课件说的"读锁优先级高"描述的就是这个默认策略,不是读写锁的固有属性;换成写者优先,优先级就倒过来了。PTHREAD_RWLOCK_PREFER_WRITER_NP 在 glibc 里被忽略,行为和读者优先一样——课件写的"目前有 BUG"就是这个意思。原因不是实现偷懒:POSIX 要求同一个线程可以多次成功 pthread_rwlock_rdlock 再配对解锁,真按写者优先实现,一个已经持读锁的线程再来要读锁,会被排在它自己前面等待的写者挡住,形成自死锁。所以要让写者优先,只能用 PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,它要求写者不能递归加锁。

_np 后缀表示 non-portable,这套属性接口只在 glibc 上有,使用前要定义 _GNU_SOURCE 才能在头文件里看到声明。换到别的 libc,要么接受默认的读者优先,要么自己用互斥锁加条件变量封一层。

几个返回值和行为要记:

  • tryrdlock、trywrlock 抢不到时返回 EBUSY,是个正整数;判失败用 ret != 0,不要判 -1。
  • wrlock 在检测到自死锁时可能返回 EDEADLK,但标准只把它列为可选行为,依赖这个返回值不可移植。
  • 读锁可以递归:同一线程多次 rdlock,必须对应同样次数的 unlock。
  • 持读锁再去要写锁可能死锁:写锁要等所有读者退出,包括提出请求的自己;持写锁再去要读锁同样可能死锁。升级和降级都不是这套接口保证支持的操作。
  • destroy 之前必须确认没有线程持有锁或在等待。

课件案例看到的是调度结果,不是严格协议

课件里两个读者、两个写者,读临界区睡 1 秒、写临界区睡 2 秒,输出看起来像"写—读—写—读"交替。那只是一次调度下的可能交错,不是读写锁的保证。默认读者优先时,两个读者可以重叠读,写者要等这一批读者全部退出才进;如果读者不断到达,写者就排在所有读者后面。

案例代码里还有两处演示痕迹。sleep 放在读锁里,是为了把"持锁读"的时间拉长到肉眼可见;真实代码里不要在锁内做慢 I/O,一次 100 毫秒的读会把所有写者一起按住。delete (int *)arg 写在 while (true) 之后,永远执行不到,线程参数其实没被释放。

顺带一提,拿读锁去改数据是最常见的误用。两个读者同时 ++shared,读锁什么都没挡住。读锁保护的是"只读",不是"读为主";要更新访问计数之类的字段,得用写锁或者原子操作。

读多写少才划算

读写锁不是"更聪明的互斥锁",它的开销更高。读者加锁要做一次原子加,解锁再做一次原子减;互斥锁的快路径只要一次比较交换。临界区只有几十纳秒时,多出来的原子读改写就是全部成本的一大半。读者多、核多的时候,所有读者还在同一个计数 word 上做原子操作,这条缓存行在各核之间来回弹,名义上的并发读里藏着一个串行点。

两种场景也不划算:写多读少时,写锁语义本来就等价于互斥锁,多出来的计数和唤醒策略纯属负担;临界区里有慢 I/O 时,读锁会把写者按住很久。

判断顺序是先跑互斥锁拿到吞吐和尾延迟,确认读的占比明显高于写、临界区也不是短到几十条指令,再换读写锁。换完还要盯写者有没有饿死。读的频次高到连加锁都嫌贵时,就该考虑 seqlock——写者不等读者,读者读完校验序号、错了重来;或者 RCU——读者不做同步动作,写者等宽限期再释放旧副本。这两种方案的共同想法是:读写比例悬殊到一定程度,让写者承担同步成本比让读者排队划算。