读者优先

读者优先的解决方案：

互斥信号量 wrt，初值是 \(1\)，代表一个共享文件，解决 “读－写”互斥，“写－写”互斥。

一个记数器，即整型变量 readcount，记录读者数，初值是 \(0\)。 来一个读者， readcount 加 \(1\) 当 \(readcount ＝1\) 表示是第一个读者， 则需要执行 \(P\) 操作抢占文件；否则表示已有读者在安全的读数据。走一个读者，readcount 减 \(1\) 当 \(readcount ＝0\) 表示是最后一个读者，则需要 \(V\)

readcount 为多个读者共享的变量，是临界资源。用互斥信号量 mutex 控制, mutex 初值是 \(1\)

int readcount=0; 
semaphore mutex=1, wrt=1 ; 
 
读者进程：
    wait (mutex);
	readcount++;	
	if (readcount == 1)
	       wait(wrt);
	signal (mutex);
		…
	   reading is performed
		 …
	wait (mutex);
	readcount--;
	if (readcount == 0)
		signal (wrt);
	signal (mutex);
 
 
写者进程：     
      wait(wrt);
	    …
         writing is performed
	    …
      signal(wrt);

写者优先

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

解决方案：

在读者优先的基础上

增加信号量 \(r\)，初值是 \(1\)：当至少有一个写进程准备访问数据区时，用于禁止所有的读进程。

增加一个记数器，即整型变量 writecount ，记录写者数，初值是 \(0\) 。 \(writecount\) 为多个写者共享的变量，是临界资源。用互斥信号量 \(mutex2\) 控制, \(mutex2\) 初值是 \(1\)。

增加 \(mutex3\) ，初值是 \(1\) ：在 \(r\) 上不允许建造长队列，否则写进程将不能跳过这个队列，因此，只允许一个读进程在 \(r\) 上排队，而所有其他读进程在等待 \(r\) 之前，在信号量 \(mutex3\)

int readcount=0, writecount=0; 
semaphore mutex1=1, mutex2=1, mutex3=1, w=1, r=1 ; 
 
读者进程：
P(mutex 3);
   P(r);
      P(mutex 1);
         readcount++;
         if (readcount == 1 ) 
            P(w);
      V(mutex 1);
    V(r);
V(mutex 3);
      reading is performed
P(mutex 1);
    readcount --;
    if (readcount == 0 )
             V(w);
V(mutex 1);
 
写者进程：     
P(mutex 2);
    writecount++;
    if (writecount == 1 )
           P(r);
V(mutex 2);
P(w);
    writing is performed
V(w);
P(mutex 2);
    writecount --;
    if (writecount == 0)
           V(r);
V(mutex 2);

读写公平

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

解决方案：

具体实现：

  1. 设置file信号量实现对临界资源的互斥访问。
  2. 设置计数器 \(readCount\) 实现多个读者访问临界资源，通过设置信号量 \(mutex\) 实现对 \(readCount\)
  3. 设置信号量 \(w\)
  4. 设置信号量 \(rw\) 实现只有读者队列或写者阻塞在 \(w\)（对资源的访问控制）
int readcount=0; 
semaphore mutex=1, rw=1 w=1; 
 
读者进程：
        wait (w);
        wait (mutex);
        if (readcount == 0)
	       wait(rw);
    	readcount++;	
    	signal (mutex);
        signal (w);
		…
    	   reading is performed
		 …
    	wait (mutex);
    	readcount--;
    	if (readcount == 0)
    		signal (rw);
    	signal (mutex);
 
 
写者进程：     
    wait(w);
    wait(rw);
	    …
         writing is performed
	    …
    signal(rw);
    signal(w);