IPC经典问题
读者写者问题
读者优先：
semaphore mutex=1;//控制对rc的访问
semaphore db=1;//控制对数据库的访问
int rc=1;//正在读或想要读的进程数
void reader(void)
{
while(1){
down(&mutex);
rc++;
if(rc==1)
down(&db);
up(&mutex);
read_database();
down(&mutex);
rc–;
if(rc==0)
up(&db);
up(&mutex);
use_data_read();
}
}
void writer(void)
{
while(1){
think_up_data();
down(&db);
write_database();
up(&db);
}
}
写者优先，条件为：
（1）多个读者可以同时进行读；
（2）写者必须互斥（只允许一个写者写，同时也不能读者、写者同时进行）；
（3）写者优先于读者（一旦有写者来，则后续读者必须等待，唤醒时优先考虑写者）。
注意唤醒时优先考虑写者这个条件
semaphore read=1;//用于阻塞读者
semaphore rmutex=1,wmutex=1;//用于控制对rcount和wcount的访问
semaphore db=1;//控制对数据库的访问
int rcount=wcount=0;
void reader(void)
{
p(read); //只要有写者等待，读者就会阻塞
p(rmutex);
rcount++;
if(rcount==1)
p(db);
v(rmutex);
v(read);//及时释放，多个读者可以同时读
read_database();
p(rmutex);
rcount–;
if(rcount==0)
v(db);
v(rmutex);
}
void writer(void)
{
p(wmutex);
wcount++;
if(wcount==1)
p(read);
v(wmutex);
p(db);
write_database();
v(db);
p(wmutex);
wcount–;
if(wcount==0)
v(read);
v(wmutex);
}
如果唤醒时读写队列平等的话
semaphore write=1;//用于阻塞写者
semaphore mutex=1;//用于控制对rc的访问
semaphore db=1;//控制对数据库的访问
int rc=0;
void reader(void)
{
p(db);
p(mutex);
rc++;
if(rc==1)
p(write); //有读者进入，互斥写操作
v(mutex);
v(db); // 及时释放读写互斥信号量，允许其它读、写进程申请资源
read_database();
p(mutex);
rc–;
if(rc==0)
v(write); //所有读者退出，允许写操作
v(mutex);
}
void writer(void)
{
p(db);// 互斥后续其它读者、写者
p(write);//如有读者正在读，等待所有读者读完
write_database();
v(write);//允许后续新的第一个读者进入后互斥写操作
v(db);//允许后续新读者及其它写者
} 
哲学家就餐问题
思路：如果一个哲学家旁边两个都不在进餐时拿起叉子是安全的。
注意状态的变化应该处于临界区，如果一个哲学家不能拿起叉子时应阻塞，
同时加入一个状态表明他饥饿，旁边的哲学家就餐完毕会通知他
#define N 5
#define LEFT (i-1)%N
#define RIGHT (i+1)%N
#define THINKING 0
#define HUNGRY 1
#define EATING 2
int state[N];//记录每个人状态的数组
semaphore mutex=1;//临界区互斥
semaphore s[N]={0};//每个哲学家一个信号量,表示能否得到两只叉子
void philosopher(int i)
{
while(1){
think();
take_forks(i);
eat();
put_forks(i);
}
}
void take_forks(int i)
{
donw(&mutex);
state[i]=HUNGRY;
test(i);//试图得到两只叉子
up(&mutex);
down(&s[i]);//如果得不到叉子就阻塞
}
void put_forks(int i)
{
down(&mutex);
stata[i]=THINKING;
test(LEFT);//看下左邻居现在是否能进餐
test(RIGHT);//看下右邻居现在是否能进餐
up(&mutex);
}
void test(int i)
{
if(state[i]==HUNGRY && state[LEFT]!=EATING && state[RIGHT]!=EATING){
state[i]=EATING;
up(&s[i]);
}
}
红黑客过河
有红客和黑客两组人员需要过河。河上有船，但是每次只能乘坐4人，且每次乘客满员时才能开船，到河对岸后空船返回。但船上乘客不能同时有3个红客 、1个黑客 或者 1个红客 、 3个黑客的组合。（其他组合安全）。请编写程序，用PV操作解决红客、黑客过河的问题。
对同步与互斥的分析：
同步关系：1. 满员才能开船；2. 红黑客满足一定的组合规则,才能有四人上船
互斥关系：红黑客对请求上船的控制
显然，此题难点在对同步关系的解决。
下面给出所写程序的算法思想：
Red():每个红客到来请求上船时执行该程序：
1.请求进入临界区；
2.首先检查本人的到来是否满足上船的组合(即4个红客或2个红客与2个黑客);
3.如果满足2个红客和2和黑客的组合，则看是否有船可上，有的话该红客上船并通知另外1个红客和2个黑客上船，然后通知船满员，并退出临界区；
4.如果满足4个红客的组合，则看是否有船可上，有的话该红客上船并通知另外3个红客上船，然后通知船满员，并退出临界区；
5.不符合上船的组合，则先退出临界区，然后在信号量S_red上等待，直到当条件满足时，有人通知其上船。
6.完毕。
Black():每个黑客到来请求上船时执行该程序,其算法与Red()完全一致；
Boat():河上的船执行该程序：
1.等待满员后开船过河；
2.空船返回，通知可以上船了，转而执行1。
////////////////////////////////////////////////////////////////////////////
semapore boats=1; //河上船只的数量
semapore full=0; //船的满员状态
semapore S_red=0; //控制红客上船
semapore S_black=0; //控制黑客上船
semapore mutex=1; //由于互斥
int reds=0; //等待上船的红客数
int blacks=0; //等待上船的黑客数
Red()
{
P(mutex);//进入临界区
reds++; //等待上船的红客数加1
if(reds >=2 && blacks >=2)
{//2个红客和黑客的组合
P(boats); //准备上船，无船则等待
take_boat();//该红客上船
reds=reds-2;//等待上船的红客数减2
V(S_red); //通知另一个红客上船
blacks=blacks-2;//等待上船的黑客数减2
//通知其他两黑客上船
V(S_black);
V(S_black);
V(full);//通知船满员
V(mutex);//退出临界区
}
else if(reds==4)
{//4个红客的组合
P(boats); //准备上船，无船则等待
take_boat(); //该红客上船
//递减等待上船的红客数，通知其他3个红客上船
while(–reds)
V(S_red);
V(full);//通知船满员
V(mutex);//退出临界区
}
else
{
V(mutex)；//退出临界区，此步必在P(S_red)之前，不然会产生死锁
//该红客等待直至条件满足时上船
P(S_red);
take_boat();
}
}
Black()
{
P(mutex);
blacks++;
if(blacks >=2 && reds >=2)
{
P(boats);
take_boat()；
blacks=blacks-2;
V(S_black);
reds=reds-2;
V(S_red);
V(S_red);
V(full);
V(mutex);
}
else if(blacks==4)
{
P(boats);
take_boat()；
while(–blacks)
V(S_black);
V(full);
V(mutex);
}
else
{
V(mutex);
P(S_black);
take_boat();
}
}
Boat()
{
while(TRUE){
P(full); //等待满员
shove_off(); //开船过河
boat_return();//空船返回
V(boats); //通知可以上船了
}
}
该算法存在一个问题是如果2红1黑时接下来来的都是红客时，会造成饥饿现象。
改进：利用5人中必有4人满足开船条件，每5个人检查一下让其中4个人过河，红黑客算法也不用分开写了。
