PV操作经典问题
一、5位哲学家就餐问题
semaphore fork[5];
for (int i=0;i<5;i++)
fork[i]=1;
cobegin
process philosopher_i( ) { //i= 0,1,2,3,4
while(true) {
think( );
P(fork[i]); //先取右手的叉子
P(fork[(i+1)%5]); //再取左手的叉子
eat( );
V(fork[i]);
V(fork[(i+1)%5]);
}
}
coend
这个解法会出现死锁！
为了避免死锁
1.至多允许四个哲学家同时取叉子
2.奇数号先取左手边的叉子，偶数号先取右手边的叉子
3.每个哲学家取到手边的两把叉子才吃，否则一把叉子也不取
semaphore fork[5];
for (int i=0;i<5;i++)
fork[i]= 1;
semaphore room=4; //增加一个侍者
cobegin
process philosopher_i( ){/*i=0,1,2,3 */
while(true) {
think( );
P(room); //控制最多允许4为哲学家取叉子
P(fork[i];
P(fork[(i+1)%5] ) ;
eat( );
V(fork[i]);
V(fork([i+ 1] % 5);
V(room);
}
}
coend
void philosopher (int i)
{ if i mod 2＝＝0 then
{
P(fork[i]); //偶数哲学家先右手
P(fork[(i+1) mod 5 ]); //后左手
eat();
V(fork[i]);
V (fork[(i+1) mod 5]);
}
else
{
P (fork[(i+1) mod 5 ]); //奇数哲学家，先左手
P (fork[i]); //后右手
eat();
V(fork[(i+1) mod 5]);
V(fork[i]);
}
}
semaphore fork[5];
for (int i=0;i<5;i++)
fork[i]= 1;
cobegin
process philosopher_i( ){/*i=0,1,2,3 */
while(true) {
think( );
P(fork[i];//先取右手的叉子 /*i=4,P(fork[0])*/
P(fork[(i+1)%5] ) ; //再取左手的叉子 /*i=4,P(fork[4])*/
eat( );
V(fork[i]);
V(fork([i+ 1] % 5);
}
}
coend通过Hoare管程求解哲学家问题
详解：
type dining_philosophers=monitor
int self_count[5];
InterfaceModule IM;
for (int i=0;i<5;i++) //初始化，i为进程号
state[i]=thinking;
define pickup,putdown;
use enter,leave,wait,signal；
void pickup(int i) { //i=0,1,...,4
enter(IM);
state[i]=hungry;
test(i);
if(state[i]!=eating)
wait(self[i],self_count[i],IM);
leave(IM);
}
void putdown(int i) { //i=0,1,2,..,4
enter(IM);
state[i]=thinking;
test((i-1)%5);
test((i+1)%5);
leave(IM);
}
void test(int k) { //k=0,1,...,4
if((state[(k-1)%5]!=eating)&&(state[k]==hungry)
&&(state[(k+1)%5]!=eating)) {
state[k]=eating;
signal(self[k],self_count[k],IM);
}
}
}
任一个哲学家想吃通心面时调用过程pickup，吃完通心面之后调用过程putdown。
cobegin
process philosopher_i( ) { //i=0,…,4
while(true) {
thinking( );
dining_philosophers.pickup(i);
eating( );
dining_philosophers.putdown(i);
}
}
coend
(A) 假设一开始3号哲学家，第一个做pickup，他会很顺畅，在pickup中通过enter(IM)进入管程，修改自身状态state[3]=hungry, 接着test(3)中if条件通过，修改自身状态state[3]=eating, 因为这时候没有进程(哲学家)阻塞在self[3]上，即self_count[3]==0，对照signal(self[3], self_count[3], IM)中的PV实现，实际上此时signal什么也不做。然后，判断if (state[3]!=eating)不成立，因此wait操作也不做。再然后，3号哲学家执行leave(IM)退出管程，以便让其他哲学家进入管程。
分析：实际上这里3号哲学家成功的取到他需要的两个叉子。他通过将自己的状态改为eating，对于i=2号哲学家在取叉子的时需要做test(i)，state[i+1]!=eating不成立；对于i=4号哲学家在取叉子的时需要做test(i)，state[i-1]!=eating不成立；从而封堵其左右哲学家转入eating状态，2、4号哲学家不能成功转入eating状态，将执行wait操作，也即在3号哲学家没有执行putdown中的test((i-1)%5)和test((i+1)%5)之前，左右哲学家不能成功取到叉子。
(B) 接着，在3号哲学家还没有putdown之前，如果1号哲学家执行pickup，他也会很顺畅，与之前的3号哲学家pickup时的情形类似，在pickup中通过enter(IM)进入管程，修改自身状态state[1]=hungry, 接着test(1)中if条件通过，修改自身状态state[1]=eating, 因为这时候没有进程(哲学家)阻塞在self[1]上，即self_count[1]==0，对照signal(self[1], self_count[1], IM)中的PV实现，实际上此时signal什么也不做。然后，判断if (state[1]!=eating)不成立，因此wait操作也不做。再然后，3号哲学家执行leave(IM)退出管程，以便让其他哲学家进入管程。
分析：实际上这里1号哲学家成功的取到他需要的两个叉子。他通过将自己的状态改为eating，从而封堵其左右哲学家转入eating状态，0、2号哲学家不能成功转入eating状态，也即在1号哲学家没有执行putdown中的test((i-1)%5)和test((i+1)%5)之前，不能成功取到叉子。
(C) 接着，在1和3号哲学家没有putdown之前，此时，state[1]==eating，state[3]==eating。如果2号哲学家执行pickup，他会很不顺畅，在pickup中通过enter(IM)进入管程，修改自身状态state[2]=hungry，接着test(2)中的if条件state[1]!=eating，state[3]!=eating都不成立，因此2号哲学家没有成功把自身状态修改为eating，也不用做test(2)中signal(self[2], self_count[2], IM)操作，再接着判断if (state[2]!=eating)成立，因此做wait(self[2], self_count[2], IM)操作，对照wait操作的PV实现，此时，self[2]_count++表示在self[2]等待的进程数加1，然后判断if (IM.next_count>0)，如果此时1和3号进程都没有执行putdown中的signal操作，那么该条件不成立，然后执行V(IM.mutex)退出管程，接着P(self[2])阻塞自己，等待1和3号哲学家执行putdown中的signal操作唤醒之。
(D) 接着，假设1号哲学家吃完，执行putdown，在putdown中通过enter(IM)进入管程，并修改自身状态state[1]=thinking，然后test((i-1)%5)，即test(0)，其中state[(0-1)%5]即state[4]!=eating成立，state[0]==hungry不成立(表示0号哲学家没有执行pickup)，state[(0+1)%5]即state[1]!=eating成立，即整个if条件不成立，if下的语句不做。然后test((i+1)%5)，即test(2)，其中state[(2-1)%5]即state[1]!=eating成立，state[2]==hungry(表示之前2号哲学家已经执行了pickup，且没有成功取到叉子)，state[(2+1)%5]即state[3]!=eating不成立，即整个if条件还是不成立，然后1号哲学家执行leave(IM)退出管程，以便其他哲学家进入管程。
分析: 1号哲学在putdown的时候执行test(0)和test(2)，test(0)用意在于唤醒右邻居0号哲学家，但是0号哲学家还没有执行pickup，也就没有把自身状态修改为hungry，1号哲学家的这份好心浪费了；接着test(2)用意在于唤醒左邻居2号哲学家，但是2号哲学家成功取到叉子之前要判断3号是否eating，实际上此时3号依然eating，因此test(2)的用意没有真正成功。看来还真不简单，不要紧，继续往下看。
(E) 当1号哲学家在putdown中退出管程，此时state[1]==thinking，state[2]==hungry，假设此时3号哲学家开始执行putdown，在putdown中通过enter(IM)进入管程，并修改自身状态state[3]=thinking，然后test((i-1)%5)，即test(2)，其中state[(2-1)%5]即state[1]!=eating成立，state[2]==hungry成立(表示之前2号哲学家已经执行了pickup，且没有成功取到叉子)，state[(2+1)%5]即state[3]!=eating成立，即整个if条件成立，看到希望了，接着执行signal(self[2], self_count[2], IM)，因为之前，2号哲学家已经在self[2]上等待许久了，对照signal操作的PV实现，self_count[2]>0，执行IM.next_count++，V(self[2]) (注:终于把2号哲学家等待许久的self[2]释放，唤醒2号哲学家)，P(IM.next)阻塞自己。
分析：对于2号哲学家被唤醒之后，他将执行其pickup中P(self[2])之后的语句，self_count[2]--，即self_count[2]恢复为0，并最终执行pickup中leave(IM)，在leave(IM)中参考Hoare管程leave操作的PV实现，判断if (IM.next_count)>0成立，则执行V(IM.next) 唤醒3号哲学家之前在P(IM.next)上的等待，并有机会执行后续语句IM.next_count--，即计数恢复为0，最终执行putdown中的leave(IM)退出管程，以便其他进程能够再进入管程，这里可以看出对于Hoare管程的实现，signal操作不必是过程体的最后一个操作。对于3号哲学家通过test(2)完成了唤醒2号哲学家的任务，然而他自己暂时阻塞在IM.next上，暂时不能执行putdown中后续的test((i+1)%5)，即不能执行test(4)。
(F) 接着，假设在2号哲学家被唤醒取到叉子之后开始吃，3号哲学家执行完putdown中的leave(IM)退出管程，如果1号哲学家想再一次取叉子，此时state[0]==state[3]==thinking，state[2]==eating，1号不如之前顺畅，在pickup中通过enter(IM)进入管程，修改自身状态state[1]=hungry, 接着test(1)中，state[2]!=eating不成立，即if条件不通过，因此1号哲学家没有成功把自身状态修改为eating，也不用做test(1)中signal(self[1], self_count[1], IM)操作，再接着判断if (state[1]!=eating)成立，因此做wait(self[1], self_count[1], IM)操作，对照wait操作的PV实现，此时，self[1]_count++表示在self[1]等待的进程数加1，然后判断if (IM.next_count>0)，如果此时2号进程还没有执行putdown中的signal操作，那么该条件不成立，然后执行V(IM.mutex)退出管程，接着P(self[1])阻塞自己，等待2号哲学家执行putdown中的signal操作唤醒之。
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
二、生产者消费者问题
多个生产者/多个消费者/多个缓冲单元
B : ARRAY[0..k-1] OF integer;
sput: semaphore； /* 可以使用的空缓冲区数 */
sget: semaphore; /* 缓冲区内可以使用的产品数 */
sput := k; /* 缓冲区内允许放入k件产品 */
sget := 0; /* 缓冲区内没有产品 */
putptr, getptr : integer;
putptr := 0; getptr := 0;
s: semaphore； /* 互斥使用putptr, getptr */
s := 1；
process Producer_i
begin
L1:produce a product；
P(sput);
P(s1);
B[putptr] := product；
putptr :=(putptr+1) mod k;
V(s1);
V(sget);
goto L1;
end;
process Consumer_ j
begin
L2:P(sget);
P(s2);
Product:= B[getptr]；
getptr:=(getptr+1) mod k;
V(s2);
V(sput);
consume a product；
goto L2;
end;
应先执行同步信号量的P操作，然后再执行互斥信号量的P操作，否则可能造成进程死锁。
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
三、读者写者问题
写者优先：
semaphore rmutex，wmutex，S；
rmutex=1; wmutex=1; S=1; //增加互斥信号量S
int readcount=0; //读进程计数
process reader_i( ) {
while (true) {
P(S);
P(rmutex);
if (readcount==0) P(wmutex);
readcount++;
V(rmutex);
V(S);
读文件；
P(rmutex);
readcount--;
if(readcount==0) V(wmutex);
V(rmutex);
}
}
process writer_i( ) {
while(true) {
P(S);
P(wmutex);
写文件；
V(wmutex);
V(S);
}
}int readcount = 0, writecount = 0;
semaphore x=1, y=1, z=1; // readcount,writecount互斥
semaphore rmutex=1,wmutex=1； // 读锁，写锁
process reader
{
P(z);
P(rmutex);
P(x);
readcount++;
if (readcount==1) P(wmutex);
V(x);
V(rmutex);
V(z);
read;
P(x);
readcount--;
if (readcount==0) V(wmutex);
V(x)
};
process writer
{
P(y);
writecount++;
if (writecount==1) P(rmutex);
V(y);
P(wmutex);
write;
V(wmutex)
P(y);
writecount--;
if (writecount==0) V(rmutex);
V(y);
};
至今不明白z变量的作用