读者写者

/********************读者优先代码*******************************/
/*
 只要有一个读者正在读，那么后续的读者都能立即读，不管有多少写者在等待。可能导致写者饥饿
 */
#include "stdio.h"  
#include  
#include  
 
 
#define N_WRITER 3 //写者数目  
#define N_READER 5 //读者数目  
#define W_SLEEP  1 //控制写频率  
#define R_SLEEP  1 //控制读频率  
 
 
pthread_t wid[N_WRITER],rid[N_READER];  // 定义写者/读者线程
const int MAX_RAND = 1000;//产生的最大随机数  
pthread_mutex_t writeLock = PTHREAD_MUTEX_INITIALIZER;//同一时间只能一个人写文件,互斥  
pthread_mutex_t accessReaderCnt = PTHREAD_MUTEX_INITIALIZER;//同一时间只能有一个人访问 readerCnt  
int data = 0;  
int readerCnt = 0; //readerCnt统计读者的数量
//写函数
void write()  
{  
    int rd = rand();  //产生随机数
    printf("write %d\n",rd);  
    data = rd;  
}
//读函数
void read()  
{  
    printf("read %d\n",data);  
}  
//写者线程
void * writer(void * in)  
{  
    while(1)  
    {  
        pthread_mutex_lock(&writeLock);  //临界区，限制只有一个写者修改数据
        write();  
        pthread_mutex_unlock(&writeLock);  
        sleep(W_SLEEP);  
    }  
    pthread_exit((void *) 0);  
}  
 //读者线程  
void * reader (void * in)  
{  
    while(1)  
    {  
        pthread_mutex_lock(&accessReaderCnt); //临界区   
        readerCnt++;  
        if(readerCnt == 1){   //第一个并发读线程  
            pthread_mutex_lock(&writeLock);  //在第一个并发读者这里开始禁止写者执行写操作
        }  
        pthread_mutex_unlock(&accessReaderCnt);  
          
        read();  
          
        pthread_mutex_lock(&accessReaderCnt);   //临界区   
        readerCnt--;  
        if(readerCnt == 0){  //最后一个并发读线程
            pthread_mutex_unlock(&writeLock); //在最后一个并发读者读完这里开始禁止写者执行写操作   
        }  
        pthread_mutex_unlock(&accessReaderCnt);  
        sleep(R_SLEEP);  
    }  
    pthread_exit((void *) 0);  
}  
 
int main()  
{  
    int i = 0;  
    for(i = 0; i < N_READER; i++)  
    {  
        pthread_create(&wid[i],NULL,reader,NULL);   //创建读者线程
    }  
    for(i = 0; i < N_WRITER; i++)  
    {  
        pthread_create(&rid[i],NULL,writer,NULL);  //创建写者线程
    }  
    while(1){  
        sleep(10);  
    }  
    return 0;  
}  

/************************写者优先代码************************************/
/***************************************************************************************************
  当新的写者希望写时，不允许该写者后续的读者访问数据区，但必须保证之前的读者读完
必须在 lock(&readerLock) 和 unlock(&readerLock) 之间锁定 writeLock 。否则，一旦读者释放了 readerLock ，后续的写进程（如果有）可能会率先获得 writeLock 锁，从而导致比读者后发生的写者先执行。
提示：读者在lock(&readerLock) 和 unlock(&readerLock) 之间锁定 writeLock 是绝对不会阻塞的。因为读者已经占据了 readerLock 互斥量，这意味着，即便有写者，它也不可能已经占据了 writeLock 锁。
*******************************************************************************************/

#include "stdio.h"  
#include  
#include  
 
 
#define N_WRITER 2 //写者数目  
#define N_READER 20 //读者数目  
#define W_SLEEP 1 //控制写频率  
#define R_SLEEP  0.5 //控制读频率  
 
 
pthread_t wid[N_WRITER],rid[N_READER]; // 定义写者/读者线程
const int MAX_RAND = 1000;//产生的最大随机数  
int data = 0;  
int readerCnt = 0, writerCnt = 0;  //writerCnt统计写者的数量，readerCnt统计读者的数量
pthread_mutex_t accessReaderCnt = PTHREAD_MUTEX_INITIALIZER;    //同一时间只能有一个人访问 readerCnt    
pthread_mutex_t accessWriterCnt = PTHREAD_MUTEX_INITIALIZER;      //同一时间只能有一个人访问 WriterCnt
pthread_mutex_t writeLock = PTHREAD_MUTEX_INITIALIZER;      //同一时间只能一个人写文件,互斥
pthread_mutex_t readerLock = PTHREAD_MUTEX_INITIALIZER;      //同一时间只能一个人读文件,互斥
pthread_mutex_t outerLock = PTHREAD_MUTEX_INITIALIZER;  
 //写函数
void write()  
{  
    int rd = rand()%MAX_RAND;  //产生随机数
    printf("write %d\n",rd);  
    data = rd;  
}
//读函数
void read()  
{  
    printf("read %d\n",data);  
}
//写者线程
void * writer(void * in)  
{  
    while(1)  
    {  
        pthread_mutex_lock(&accessWriterCnt);  
        {//临界区,希望修改 writerCnt,独占 writerCnt  
            writerCnt++;  
            if(writerCnt == 1){  
                // 读者与写者互斥;使用readerLock来描述;  
                pthread_mutex_lock(&readerLock);  
            }  
        }  
        pthread_mutex_unlock(&accessWriterCnt);  
          
          
        pthread_mutex_lock(&writeLock);  
        {//临界区，限制只有一个写者修改数据  
            write();  
        }  
        pthread_mutex_unlock(&writeLock);  
          
        pthread_mutex_lock(&accessWriterCnt);  
        {//临界区,希望修改 writerCnt,独占 writerCnt  
            writerCnt--;  
            if(writerCnt == 0){  
                //阻止后续的读者加入待读队列  
                pthread_mutex_unlock(&readerLock);  
            }  
        }  
        pthread_mutex_unlock(&accessWriterCnt);  
        sleep(W_SLEEP);  
    }  
    pthread_exit((void *) 0);  
}  
 //读者线程 ,读者的实现首先必须保证支持多个读者同时读
void * reader (void * in)  
{  
    while(1)  
    {  
        //假如写者锁定了readerLock,那么成千上万的读者被锁在这里  
        pthread_mutex_lock(&outerLock);  //成千上万的读者被锁在这里
        {//临界区  
            pthread_mutex_lock(&readerLock);//只被一个读者占有  
            {//临界区  
                pthread_mutex_lock(&accessReaderCnt);  
                {//临界区  
                    readerCnt++;  
                    if(readerCnt == 1){  //第一个并发读线程  
                        pthread_mutex_lock(&writeLock);     //在第一个并发读者这里开始禁止写者执行写操作   
                    }  
                }  
                pthread_mutex_unlock(&accessReaderCnt);  
            }  
            pthread_mutex_unlock(&readerLock);//释放时,写者将优先获得readerLock  
        }  
        pthread_mutex_unlock(&outerLock);  
 
        read();  
          
        pthread_mutex_lock(&accessReaderCnt);  
        {//临界区  
            readerCnt--;  
            if(readerCnt == 0){  //最后一个并发读线程
                pthread_mutex_unlock(&writeLock);    //在最后一个并发读者读完这里开始禁止写者执行写操作  
            }  
        }  
        pthread_mutex_unlock(&accessReaderCnt);  
          
        sleep(R_SLEEP);  
    }  
    pthread_exit((void *) 0);  
}  
 
int main()  
{  
    int i = 0;  
    for(i = 0; i < N_READER; i++)  
    {  
        pthread_create(&rid[i],NULL,reader,NULL);  //创建读者线程
    }  
    for(i = 0; i < N_WRITER; i++)  
    {  
        pthread_create(&wid[i],NULL,writer,NULL); //创建写者线程
    }  
    while(1){  
        sleep(10);  
    }  
    return 0;  
}