读者-写者问题

读者-写者问题

该问题设计需要考虑的并发情况：
读者1 → 读者2
写者1 → 写者2
写者1 → 读者1
读者1 → 写者1 → 读者2
写者1 → 读者1 → 写者2

读写公平

相对公平的先来先服务原则

semaphore rw = 1; // 保证读写的互斥
int count 0; // 记录当前有几个读线程在访问
semaphore mutex = 1; // 用于保证对count变量修改的原子性
semaphore w = 1; // 防止写线程饿死，当读线程都在读取文件即 V(w) 后，读线程获取P(w) 进行占位，可以在读线程释放 V(rw) 后进入写操作

writer(){
	while(1){
		P(w);
		P(rw);
		写文件...
		V(rw);
		V(w);
	}
}

read(){
    while(1){
        P(w);
        P(mutex);
        if(count==0)
            P(rw);
        count++;
        V(mutex);
        V(w);
        读文件...
        P(mutex);
        count--;
        if(count==0)
            V(rw);
        V(mutex);
    }
}

读优先

写线程存在饥饿的情况

semaphore rw = 1; // 保证读写的互斥
int count 0; // 记录当前有几个读线程在访问
semaphore mutex = 1; // 用于保证对count变量修改的原子性

writer(){
	while(1){
		P(rw);
		写文件...
		V(rw);
	}
}

read(){
    while(1){
        P(mutex);
        if(count==0)
            P(rw);
        count++;
        V(mutex);
        读文件...
        P(mutex);
        count--;
        if(count==0)
            V(rw);
        V(mutex);
    }
}

写优先

读线程存在饥饿的情况

semaphore write = 1; // 进程优先互斥
semaphore mutex = 1; // 临界资源互斥
semaphore RCsignal = 1; // 读者数Rcount修改互斥
semaphore WCsignal = 1; // 写者数Rcount修改互斥
int Rcount = 0; // 读者数
int Wcount = 0; // 写者数

writer(){
    while(1){
        P(WCsignal);
        if(WCount==0)
            P(write);
        Wcount++;
        V(WCsignal);
        P(mutex);
        写;
        V(mutex);
        P(WCsignal);
        Wcount--;
        if(Wcount==0)
            V(write);
        V(WCsignal);
    }
}

reader(){
    while(1){
        P(write); 
        P(RCsignal);
        if(Rcount==0)
            P(mutex);
        Rcount++;
        V(RCsignal);
        V(write);
        读;
        P(RCsignal);
        Rcount--;
        if(Rcount==0)
            V(mutex);
        V(RCsignal);
    }
}

P(write)为关键处，读获取锁后，写操作大概率能够获得到该锁的使用权，反之，写获取锁后，读操作则不能。每次新入的读操作需要与写操作争夺锁的占有权，但是如果写操作占有锁，新入的写操作则直接获取到占有权，直至所有的写操作完毕