最近想自己写个简单的 WEB SERVER ，为了先练练手，熟悉下在LINUX系统使用基本的进程、线程、互斥等，就拿以前学过的 OS 问题开开刀啦。记得当年学读者写者问题，尤其是写者优先的时候，那是真心纠结啊。刚才还觉得理解了，过一会儿又糊涂了。现在重新再看，还是容易纠结。没办法，用得少。我把读者优先和写者优先都实现了一下。选择性重看了小部分《unix高程》使用了多线程+互斥量实现。

互斥量如其名，同一时间只能被一个线程占有，实现线程间对某种数据结构的互斥访问。试图对一个已经加锁的互斥量加锁，会导致线程阻塞。允许多个线程对同一个互斥量加锁。当对互斥量解锁时，阻塞在该互斥量上的线程会被唤醒，它们竞争对该互斥量加锁，加锁成功的线程将停止阻塞，剩余的加锁失败于是继续阻塞。注意到，谁将竞争成功是无法预料的，这一点就类似于弱信号量。（强信号量把阻塞在信号量上的进程按时间排队，先进先出）

互斥量区别于信号量的地方在于，互斥量只有两种状态，锁定和非锁定。它不像信号量那样可以赋值，甚至可以是负值。共性方面，我所体会到的就一句话，都是用来实现互斥的。至于其它区别或联系，用不上，不作研究。

只要有一个读者正在读，那么后续的读者都能立即读，不管有多少写者在等待。可能导致写者饥饿。

当新的写者希望写时，不允许该写者后续的读者访问数据区，但必须保证之前的读者读完。

首先，写者的代码应该是这样一种形式,才能保证同一时刻只有一个写者修改数据:

考虑到写者对读者的影响是:当任何写者想写时，读者都必须被阻塞；并且，写者阻塞了读者并停止阻塞之前，后续的任何写者都会优先于读者执行。这就如同有一个写者队列，当第一个写者入队时，读者完全被阻塞，直到最后一个写者离开队列。

据此，可以用 writerCnt 来统计写者的数量，而用互斥量 accessWriterCnt 来互斥各线程对 writerCnt 的访问。代码应作如下调整：

4. 读者的实现

读者的实现首先必须保证支持多个读者同时读，因此下面的代码不合适：

在上面的实现中，很明显的问题是，当一个读者执行 read() 的同时，不可能有另外的读者进入临界区并执行 read() 函数了。因此，必须确保在执行 read() 函数之前对readerLock解锁。代码类似于:

于是乎，现在我们可以注意到，假如写者率先锁定了 readerLock , 那么后续的读者被阻塞在 pthread_mutex_lock(&readerLock); 了，这点很正确。在写者最终释放 readerLock 之前，可能有成千上万的读者都被阻塞在 readerLock 上， readerLock 释放之后，这些读者会竞争这 readerLock，嗯，这没什么问题。问题在于，此后，将可能有新的写者有写需求并希望获得这把锁（参照一下写者代码吧），那么，此时，写者不得不和成千上万的读者一起竞争 readerLock，由于将占有 readerLock 的人使随机的，写者在数量上不占优势，将进入饥饿状态。因此，这种实现无法满足“写者优先”的需求。

通过添加另一个互斥量，我们可以把写者的这些成千上万的竞争者不再竞争 readerLock ，下面的方案里，当读者释放锁时，假如写者想获得这把锁，那么它能立即得到。

为了防止执行 read() 的同时，写者正在执行 write()，所以，有必要在读者的代码中，等待 write() 函数执行完，注意到写者的代码中，使用writeLock 互斥量来保护数据：

因而，读者也可以通过对 writeLock 加锁以保证读的时候没有同时写，但是下面这种做法又导致读者无法并发：

1.  1 while(1)
    2 {
    3     pthread_mutex_lock(&outerLock);//成千上万的读者被锁在这里
    4     pthread_mutex_lock(&readerLock);//只被一个读者占有
    5
    6     pthread_mutex_unlock(&readerLock);//释放时,写者将优先获得readerLock
    7     pthread_mutex_unlock(&outerLock);
    8
    9     pthread_mutex_lock(&writeLock);//每个执行到这里的读者都企图对 writeLock 加锁
   10     {//临界区
   11         read();//同一时刻只能有一个读者在这里，无法实现读并发
   12     }
   13     pthread_mutex_unlock(&writeLock);
   14 }  

我们需要更合理地安排 lock(&writeLock) 的位置，并且需要避免每个读者都对 writeLock 加锁，即，只让某个读者对 writeLock 加锁，同时还保证读的时候，没有写者在写 。

注意到，假如有多个读者并发地执行 read() 函数，那么，只要在第一个读者开始读之前锁住 writeLock 在最后一个读者执行 read() 之后解锁 writeLock，就可以解决读者并发的问题。

我们需要为读者添加两段代码：

代码段1：

1. 1 pthread_mutex_lock(&accessReaderCnt);
   2 {//临界区
   3     readerCnt++;
   4     if(readerCnt == 1){//第一个并发读线程
   5         pthread_mutex_lock(&writeLock);//在第一个并发读者这里开始禁止写者执行写操作
   6     }
   7 }
   8 pthread_mutex_unlock(&accessReaderCnt);  

代码段2：

1. 1 pthread_mutex_lock(&accessReaderCnt);
   2 {//临界区
   3     readerCnt--;
   4     if(readerCnt == 0){//最后一个并发读线程
   5         pthread_mutex_unlock(&writeLock);//在最后一个并发读者read()结束后写者可以执行写操作
   6     }
   7 }
   8 pthread_mutex_unlock(&accessReaderCnt);  

代码段2 明显应该放在 read() 函数之后；

经典的做法是把代码段1放到位置2，如果是这样，那么代码如下，我故意用了很多块作用域（用花括号{}表示）来凸显临界区：

如此布局的意义在于，必须放在 lock(&readerLock) 和 unlock(&readerLock) 之间锁定 writeLock 。否则，一旦读者释放了 readerLock ，后续的写进程（如果有）可能会率先获得 writeLock 锁，从而导致比读者后发生的写者先执行。
提示：读者在lock(&readerLock) 和 unlock(&readerLock) 之间锁定 writeLock 是绝对不会阻塞的。因为读者已经占据了 readerLock 互斥量，这意味着，即便有写者，它也不可能已经占据了 writeLock 锁。

将片段1放在其它位置 无法起到这种效果。但我觉得这么做没啥意义，因为会导致代码本身的矛盾：

1）按照老 写者、读者、新写者的出现顺序，假设新写者出现时，老写者还没完（此时读者是阻塞的），那么新写者就可以打破顺序，优先于读者执行。

2）按照 读者、写者的出现顺序，假设写者出现时读者还没完，那代码会要求必须等读者执行完。

与其做作地无意义，不如淫荡地统一。

频率调高时，眼花缭乱，我把输出重定向到文件里，然后使用 cat data.out | uniq 去除一些重复的输出，虽然不能说明代码正确，不过没有看到错误~

read 0
write 383
write 886
read 886
write 777
write 915
read 915
write 793
write 335
read 335

没出现什么乱子

1.  1 /*
    2 *  多线程,读者优先
    3 */
    4
    5 #include "stdio.h"
    6 #include <stdlib.h>
    7 #include <pthread.h>
    8
    9
   10 #define N_WRITER 3 //写者数目
   11 #define N_READER 5 //读者数目
   12 #define W_SLEEP  1 //控制写频率
   13 #define R_SLEEP  1 //控制读频率
   14
   15
   16 pthread_t wid[N_WRITER],rid[N_READER];
   17 const int MAX_RAND = 1000;//产生的最大随机数
   18 pthread_mutex_t writeLock = PTHREAD_MUTEX_INITIALIZER;//同一时间只能一个人写文件,互斥
   19 pthread_mutex_t accessReaderCnt = PTHREAD_MUTEX_INITIALIZER;//同一时间只能有一个人访问 readerCnt
   20 int data = 0;
   21 int readerCnt = 0;
   22 void write()
   23 {
   24     int rd = rand();
   25     printf("write %d\n",rd);
   26     data = rd;
   27 }
   28 void read()
   29 {
   30     printf("read %d\n",data);
   31 }
   32 void * writer(void * in)
   33 {
   34     while(1)
   35     {
   36         pthread_mutex_lock(&writeLock);
   37         write();
   38         pthread_mutex_unlock(&writeLock);
   39         sleep(W_SLEEP);
   40     }
   41     pthread_exit((void *) 0);
   42 }
   43
   44 void * reader (void * in)
   45 {
   46     while(1)
   47     {
   48         pthread_mutex_lock(&accessReaderCnt);
   49         readerCnt++;
   50         if(readerCnt == 1){
   51             pthread_mutex_lock(&writeLock);
   52         }
   53         pthread_mutex_unlock(&accessReaderCnt);
   54
   55         read();
   56
   57         pthread_mutex_lock(&accessReaderCnt);
   58         readerCnt--;
   59         if(readerCnt == 0){
   60             pthread_mutex_unlock(&writeLock);
   61         }
   62         pthread_mutex_unlock(&accessReaderCnt);
   63         sleep(R_SLEEP);
   64     }
   65     pthread_exit((void *) 0);
   66 }
   67
   68 int main()
   69 {
   70     int i = 0;
   71     for(i = 0; i < N_READER; i++)
   72     {
   73         pthread_create(&wid[i],NULL,reader,NULL);
   74     }
   75     for(i = 0; i < N_WRITER; i++)
   76     {
   77         pthread_create(&rid[i],NULL,writer,NULL);
   78     }
   79     while(1){
   80         sleep(10);
   81     }
   82     return 0;
   83 }  

1.   1 #include "stdio.h"
     2 #include <stdlib.h>
     3 #include <pthread.h>
     4
     5
     6 #define N_WRITER 2 //写者数目
     7 #define N_READER 20 //读者数目
     8 #define W_SLEEP 1 //控制写频率
     9 #define R_SLEEP  0.5 //控制读频率
    10
    11
    12 pthread_t wid[N_WRITER],rid[N_READER];
    13 const int MAX_RAND = 1000;//产生的最大随机数
    14 int data = 0;
    15 int readerCnt = 0, writerCnt = 0;
    16 pthread_mutex_t accessReaderCnt = PTHREAD_MUTEX_INITIALIZER;
    17 pthread_mutex_t accessWriterCnt = PTHREAD_MUTEX_INITIALIZER;
    18 pthread_mutex_t writeLock = PTHREAD_MUTEX_INITIALIZER;
    19 pthread_mutex_t readerLock = PTHREAD_MUTEX_INITIALIZER;
    20 pthread_mutex_t outerLock = PTHREAD_MUTEX_INITIALIZER;
    21
    22 void write()
    23 {
    24     int rd = rand()%MAX_RAND;
    25     printf("write %d\n",rd);
    26     data = rd;
    27 }
    28 void read()
    29 {
    30     printf("read %d\n",data);
    31 }
    32 void * writer(void * in)
    33 {
    34     while(1)
    35     {
    36         pthread_mutex_lock(&accessWriterCnt);
    37         {//临界区,希望修改 writerCnt,独占 writerCnt
    38             writerCnt++;
    39             if(writerCnt == 1){
    40                 //阻止后续的读者加入待读队列
    41                 pthread_mutex_lock(&readerLock);
    42             }
    43         }
    44         pthread_mutex_unlock(&accessWriterCnt);
    45
    46
    47         pthread_mutex_lock(&writeLock);
    48         {//临界区，限制只有一个写者修改数据
    49             write();
    50         }
    51         pthread_mutex_unlock(&writeLock);
    52
    53         pthread_mutex_lock(&accessWriterCnt);
    54         {//临界区,希望修改 writerCnt,独占 writerCnt
    55             writerCnt--;
    56             if(writerCnt == 0){
    57                 //阻止后续的读者加入待读队列
    58                 pthread_mutex_unlock(&readerLock);
    59             }
    60         }
    61         pthread_mutex_unlock(&accessWriterCnt);
    62         sleep(W_SLEEP);
    63     }
    64     pthread_exit((void *) 0);
    65 }
    66
    67 void * reader (void * in)
    68 {
    69     while(1)
    70     {
    71         //假如写者锁定了readerLock,那么成千上万的读者被锁在这里
    72         pthread_mutex_lock(&outerLock);
    73         {//临界区
    74             pthread_mutex_lock(&readerLock);//只被一个读者占有
    75             {//临界区
    76                 pthread_mutex_lock(&accessReaderCnt);//代码段 1
    77                 {//临界区
    78                     readerCnt++;
    79                     if(readerCnt == 1){
    80                         pthread_mutex_lock(&writeLock);
    81                     }
    82                 }
    83                 pthread_mutex_unlock(&accessReaderCnt);
    84             }
    85             pthread_mutex_unlock(&readerLock);//释放时,写者将优先获得readerLock
    86         }
    87         pthread_mutex_unlock(&outerLock);
    88
    89         read();
    90
    91         pthread_mutex_lock(&accessReaderCnt);//代码段2
    92         {//临界区
    93             readerCnt--;
    94             if(readerCnt == 0){
    95                 pthread_mutex_unlock(&writeLock);//在最后一个并发读者读完这里开始禁止写者执行写操作
    96             }
    97         }
    98         pthread_mutex_unlock(&accessReaderCnt);
    99
   100         sleep(R_SLEEP);
   101     }
   102     pthread_exit((void *) 0);
   103 }
   104
   105 int main()
   106 {
   107     int i = 0;
   108     for(i = 0; i < N_READER; i++)
   109     {
   110         pthread_create(&rid[i],NULL,reader,NULL);
   111     }
   112     for(i = 0; i < N_WRITER; i++)
   113     {
   114         pthread_create(&wid[i],NULL,writer,NULL);
   115     }
   116     while(1){
   117         sleep(10);
   118     }
   119     return 0;
   120 }  

转自：http://blog.csdn.net/yaozhiyi/article/details/7563869