读者-写者问题(多进程共享一个资源)

1.多个进程共享一个资源

①读者优先

读者：

a.新读者进，无读、写者，新读者读

b.新读者进，无写者，新读者读

c.新读者进，有写者，新读者等待

写者：

a.新写者进，无写者，新写者写

b.新写者进，有写者，新写者等待

readCount:读进程数  readCountMutex:读进程数信号量(读进程互斥访问readCount)

rwMutex:读写互斥信号量 

我的理解：wait signal 相当于锁，是一个原子操作

读者：

read(){

     wait(readCountMutex);

          if(readCount==0) wait(rwMutex);//第一个访问临界资源的reader process 操作 读写互斥信号量

          readCount = readCount+1;//访问临界资源 read process 加1

     signal(readCountMutex);

     read  data ；

     wait(readCountMutex);

        readCount = readCount-1;//read over 将临界资源 read process count -1；

       if(readCount == 0) signal(rwMutex);//如果是最有一个访问临界资源 的 read process ，则 操作 读写互斥信号量 ，以便让 write process execute

    signal(readCountMutex);

}

写者：

write(){

      wait(rwMutex);

          write data;

     signal(rwMutex);

}

②写者优先

读者：

a.新读者进，如果没有写者，则访问，如果是第一个读者进，则访问，且阻塞写者进程

b.新读者进，如果有写着，则阻塞

写者：

a.新写者进，如果有读者访问临界区，则阻塞

b.新读者进，如果有写者访问临界区，则阻塞，且阻塞之后读进程

readCount(读进程数) writeCount(写进程数) readCountMutex(读进程数信号量) writeCountMutex(写进程数信号量)

writeMutex(读进程信号量) readMutex(写进程信号量)

read(){

     wait(writeMutex);

     wait(readMutex);

     wait(readCountMutex);

           if(recordCount==0) wait(writeMutex);

           recordCount  = recordCount+1;

     signal(recordCountMutex);

     signal(readMutex);

     

      read data;

    

      wait(recordCountMutex);

          recordCount = recordCount-1;

          if(recordCount == 0) signal(writeMutex);

     signal(recordCountMutex);

}

write(){

      

       wait(writeCountMutex);

              if(writeCount == 0) wait(readMutex); 

                  writeCount = writeCount+1;

       signal(writeCountMutex);

       signal(writeMutex);      

       wait(writeMutex);//保证在写数据时，只有一个写进程

       write data;

       signal(writeMutex);

      

       wait(writeCountMutex);

              writeCount = writeCount-1;

              if(writeCount == 0) signal(readMutex);

       signal(writeCountMutex);

       

}

③读写平衡

读者：

a.新读者进，如果有写者在访问临界资源，则等待，否则访问

b.新读者进，如果没有写者访问临界资源，则访问，如果是第一个读者进入临界区，

                       访问临界区，且阻塞写进程

写者：

a.新写者进，如果有读者在访问临界区，则阻塞，

b.新写者进，如果有写者在临界区，则阻塞，如果没有写者访问，则访问临界区，且阻塞读进程

recordCount(访问临界资源读进程数量)  recordCountMutex(读进程访问临界资源信号量)

writeMutex(写进程信号量) readMutex(写进程封锁其后读进程信号量)

read(){

     wait(readMutex);//有写进程在访问临界资源 则 在 read 队列上排队

     wait(recordCountMutex);

          if(recordCount==0); wait(writeMutex);//判断在临界区是否有写进程，有则等待，无则访问

          recordCount = recordCount+1;

     signal(recordCountMutex);

     signal(readMutex);

    

     read data;

     wait(recordCountMutex);

         recordCount = recordCount-1;

        if(recordCount==0) signal(writeMutex);//最后一个读进程，执行 signal操作，方便写进程访问临界资源

     signal(recordCountMutex);

}

write(){

       wait(readMutex);//看有读进程访问临界资源不，有则等待，并且阻塞后来的读进程，无则进入

       wait(writeMutex);

           write data;

       signal(writeMutex);

       signal(readMutex); 

}