读者写者问题（读者优先、写者优先、公平竞争）

读者优先:
1.写者、读者互斥访问文件资源。
2.多个读者可以同时访问文件资源。
3.只允许一个写者访问文件资源。

具体实现:
1.设置信号量fileSrc实现读写者对临界资源的访问。
2.设置计数器readCount来统计访问临界资源的读者数目，设置信号量readCountSignal完成对readCount计数器资源的互斥访问。

/*初始化读者队列为0，文件资源的初始值为1*/

int readCount = 0;
semaphore readCountSignal = 1;

reader()
{
      while(true)
     {
         
        wait(readCountSignal); //申请读者队列计数器
      
        if(!readCount)         //如果读者队列为空，申请文件资源
         
           wait(fileSrc); 
      
        readCount++;

        signal(readCountSignal); //释放读者计数器资源
     
        ...
      
        perform read operation //执行临界区代码     
        ...
 
   
        wait(readCountSignal);   //申请读者计数器资源
      
        readCount--;
      
        if(!readCount)          //如果读者队列为空，释放文件资源
         
          signal(fileSrc);
    
        signal(readCountSignal); //释放读者计数器资源
    
      }

}

writer()
{
     while(true)
     {
       wait(file);               //申请文件资源

       ...
     
       perform write operation   //执行临界区代码
       ...

       signal(fileSrc);          //释放文件资源
   
      }
}

写者优先:
1.写者线程的优先级高于读者线程。
2.当有写者到来时应该阻塞读者线程的队列。
3.当有一个写者正在写时或在阻塞队列时应当阻塞读者进程的读操作，直到所有写者进程完成写操作时放开读者进程。
4.当没有写者进程时读者进程应该能够同时读取文件。

具体实现:
1.通过添加信号量read实现写者到来时能够打断读者进程。
2.设置信号量fileSrc实现读写者对临界资源的访问。
3.设置计数器writeCount来统计当前阻塞的写者进程的数目，设置信号量writeCountSignal完成对writeCount计数器资源的互斥访问。
4.设置计数器readCount来统计访问临界资源的读者数目，设置信号量readCountSignal完成对readCount计数器资源的互斥访问。

/*初始化读者、写者队列为0，初始化令牌资源、读写计数器资源的初始值为1*/
int readCount = 0;
int writeCount = 0;
semaphore read = 1;
semaphore readCountSignal = 1;
semaphore writeCountSignal = 1;

reader()
{
      while(true)
     {
        wait(read);            //申请令牌
        wait(readCountSignal); //申请读者队列计数器

        if(!readCount)         //如果读者队列为空，申请文件资源
           wait(fileSrc); 
        readCount++;

        signal(readCountSignal); //释放读者计数器资源
        signal(read);            //释放令牌
  
        ...
        perform read operation //执行临界区代码     
        ...
 
        wait(readCountSignal);   //申请读者计数器资源
        readCount--;
        if(!readCount)          //如果读者队列为空，释放文件资源
          signal(fileSrc);
        signal(readCountSignal); //释放读者计数器资源
      }
}

writer()
{
     while(true)
     {
       wait(writeCountSignal);  //申请写者计数器资源
       if(!writeCount)          //如果写者队列为空则申请令牌
         wait(read);
       writeCount++;
       signal(writeCountSignal); //释放写者计数器资源
       wait(file);               //申请文件资源

       ...
       perform write operation   //执行临界区代码
       ...
 
       signal(fileSrc);          //释放文件资源
       wait(writeCountSignal);   //申请写者计数器资源
       writeCount--;
       if(!writeCount)           //如果写者队列为空则释放令牌
          signal(read);
       signal(writeCountSignal); //释放写者计数器资源
      }
}

公平竞争：
1.优先级相同。
2.写者、读者互斥访问。
3.只能有一个写者访问临界区。
4.可以有多个读者同时访问临界资源。

具体实现：
1.设置file信号量实现对临界资源的互斥访问。
2.设置计数器readCount实现多个读者访问临界资源，通过设置信号量readCountSignal实现对readCount计数器的互斥访问。
3.设置信号量keySignal实现读者和写者的公平竞争（令牌）。
4.设置信号量OneSignal实现只有读者队列或写者阻塞在keySignal（对令牌资源的访问控制）。

/* 读者队列初始值为0，其他资源初始值为1*/
int readCount = 0;
semaphore keySignal = 1;
semaphore OneSignal = 1;
semaphore readCountSignal = 1;

reader()
{
    while(true)
    {
      wait(keySignal);        //申请令牌
      wait(readCountSignal);  //申请计数器资源
      if(!readCount)          //为零则申请文件资源
         wait(fileSrc);
      readCount++;
      signal(readCountSignal); //释放计数器资源
      signal(keySignale);      //释放令牌

      ...
      perform read operation  //执行临界区代码
      ...
  
      wait(readCountSignal);  //申请计数器资源
      readCount--;
      if(!readCount)                //为零则释放文件资源
         signal(fileSrc);
    signal(readCountSignal); //释放读者计数器资源
    }
}

writer()
{
     while(true)
     {
        wait(OneSignal);     //申请令牌资源
        wait(keySignal);     //申请令牌
        wait(fileSrc);       //申请文件资源

        ...
        perform write operation //执行临界区代码
        ...

        signal(fileSrc);   //释放文件资源
        signal(keysignal); //释放令牌
        signal(OneSignal); //释放令牌资源
     }
}