读写锁实现中，读锁“饿死”的问题

LaoLiulaoliu

今天搜到一个用mutex和条件变量实现读写锁的代码。

1. #include <pthread.h>
   
2. 
   
3. struct rwlock {
   
4.     pthread_mutex_t lock;
   
5.     pthread_cond_t read, write;
   
6.     unsigned readers, writers, read_waiters, write_waiters;
   
7. };
   
8. 
   
9. void reader_lock(struct rwlock *self) {
   
10.     pthread_mutex_lock(&self->lock);
    
11.     if (self->writers || self->write_waiters) {
    
12.         self->read_waiters++;
    
13.         do pthread_cond_wait(&self->read, &self->lock);
    
14.         while (self->writers || self->write_waiters);
    
15.         self->read_waiters--;
    
16.     }
    
17.     self->readers++;
    
18.     pthread_mutex_unlock(&self->lock);
    
19. }
    
20. 
    
21. void reader_unlock(struct rwlock *self) {
    
22.     pthread_mutex_lock(&self->lock);
    
23.     self->readers--;
    
24.     if (self->write_waiters)
    
25.         pthread_cond_signal(&self->write);
    
26.     pthread_mutex_unlock(&self->lock);
    
27. }
    
28. 
    
29. void writer_lock(struct rwlock *self) {
    
30.     pthread_mutex_lock(&self->lock);
    
31.     if (self->readers || self->writers) {
    
32.         self->write_waiters++;
    
33.         do pthread_cond_wait(&self->write, &self->lock);
    
34.         while (self->readers || self->writers);
    
35.         self->write_waiters--;
    
36.     }
    
37.     self->writers = 1;
    
38.     pthread_mutex_unlock(&self->lock);
    
39. }
    
40. 
    
41. void writer_unlock(struct rwlock *self) {
    
42.     pthread_mutex_lock(&self->lock);
    
43.     self->writers = 0;
    
44.     if (self->write_waiters)
    
45.         pthread_cond_signal(&self->write);
    
46.     else if (self->read_waiters)
    
47.         pthread_cond_broadcast(&self->read);
    
48.     pthread_mutex_unlock(&self->lock);
    
49. }
    
50. 
    
51. void rwlock_init(struct rwlock *self) {
    
52.     self->readers = self->writers = self->read_waiters = self->write_waiters = 0;
    
53.     pthread_mutex_init(&self->lock, NULL);
    
54.     pthread_cond_init(&self->read, NULL);
    
55.     pthread_cond_init(&self->write, NULL);
    
56. }

复制代码

很好的解决了，如果存在写锁等待，就不再增加读锁的问题。但这样处理会存在另一个问题，就是如果总是有一个以上写锁等待，读锁就会“饿死”。
请问有什么解决读锁“饿死”的方法吗？

LaoLiulaoliu

在apue2里面找到了这样一句话，使得这个问题看起来无解。

Although implementations vary, readerwriter locks usually block additional readers if a lock is already held in read mode and a thread is blocked trying to acquire the lock in write mode. This prevents a constant stream of readers from starving waiting writers.

chenzhanyiczy

今天搜到一个用mutex和条件变量实现读写锁的代码。很好的解决了，如果存在写锁等待，就不再增加读锁的问题。 ...
LaoLiulaoliu 发表于 2010-12-13 22:26

    这种情况当然是写锁要先处理,读锁只有当前没有写锁或者没有其他写锁在等待时才能轮到它

LaoLiulaoliu

回复 3# chenzhanyiczy


    请问当然的原因呢？
如果写锁先处理就会有读锁饿死，如果读锁先处理，就会有写锁饿死。这个是一对矛盾体吧？

drangon

从锁的角度来说，本来就不应该锁太长时间，出现需要等待的情况也应该很少，否则本身就是个瓶颈

一般读写锁的应用环境，都是读多写少，因此写优先级高一些也无所谓，不会饿到读，如果真是出现频繁写的情况，设计本身就有问题

如果真的要公平，就要做一个等待队列，按顺序激活下一个（或多个读的）等待者

davelv

回复 5# drangon

恩，可以参考进程队列模型，把等待的操作列队列，给与适当的优先级即可。

LaoLiulaoliu

回复 5# drangon


    思想很全面，谢谢

hxdqwe123

学习了，UPUP