操作系统习题（第三章）

第三章互斥与同步
1.设有N个进程，共享一个资源R，但每个时刻只允许一个进程使用R。算法如下：
设置一个整型数组flag[N]，其每个元素对应表示一个进程对R的使用状态，若为0表示该进程不在使用R，为1表示该进程要求或正在使用R，所有元素的初值均为0。
process Pi
{
…
flag[i] = 1;
for (j=0; j<i; j++)
do while (flag[i]) ;
for (j=i+1; j<N; j++)
do while (flag[i]) ;
use resource R ;
flag[i] = 0;
…
}
试问该算法能否实现上述功能？为什么？若不能请用P、V操作改写上述算法。

当每个进程均执行了flag[i] = 1后再执行for语句时出现了循环等待，发生永远等待的错误情况。
semaphore mutex;
mutex.value=1;
process Pi
{
…
P(&mutex);
use resource R ;
V(&mutex);
…
}

2.有三个进程R, M, P，R负责从输入设备读入信息并传送给M，M将信息加工并传送给P，P将打印输出，写出下列条件下的并发进程程序描述。
(1)一个缓冲区，其容量为K；
（2）两个缓冲区，每个缓冲区容量均为K。
正确答案：
（1）一个缓冲区，其容量为K
semaphore sr,sm,sp;
int lr, lm, lp;
Datatype B[K];
lr=lm=lp=0;
sr.value=K ; sm.value=0; sp.value=0;
cobegin
repeat R;
repeat M;
repeat P;
coend
Process R {
read data;
P(&sr);
B[lr]=data;
lr=(lr+1)%K;
V(&sm);
}
Process M
{
P(&sm);
data=B[lm];
对data进行加工处理；
B[lm] =data;
lm=(lm+1)%K;
V(&sp);
}
Process P
{
P(&sp);
data = B[lp];
lp=(lp+1)%K;
V(&sr);
print data;
}

（2）两个缓冲区，每个缓冲区容量均为K
semaphore sr,sm1,sm2,sp;
int lr, lm1, lm2,lp;
Datatype B1[K]， B2[K];
lr=lm1= lm2= lp=0;
sr.value=K ; sm1.value=0; sm2.value= K; sp.value=0;
cobegin
repeat R;
repeat M;
repeat P;
coend
Process R
{ Datatype data ;
read data;
P(&sr);
B1[lr]=data;
lr=(lr+1)%K;
V(&sm1);
}

Process M
{ Datatype data;
P(&sm1);
data = B1[lm1];
lm1=(lm1+1)%K;
V(&sr);
加工data ；
P(&sm2);
B2[lm2] = data;
lm2=(lm2+1)%K;
V(&sp);
}

Process P
{ Datatype data;
P(&sp);
data = B2[lp];
lp=(lp+1)%K;
V(&sm2);
print data;
}

3.假定一个阅览室最多可以容纳100人阅读,读者进入和离开阅览室时,都必须在阅览室门口的一个登记表上注册或注销。假定每次只允许一个人注册或注销,设阅览室内有100个座位。
（1）试问：应编制几个程序和设置几个进程？程序和进程的对应关系如何？
（2）试用P、V操作编写读者进程的同步算法。

正确答案：
(1)应编制一个读者程序。有N个读者应设置N个读者进程。程序和进程的对应关系1： N，读者程序为N个读者进程共享。
（2）读者进程的同步算法：
semaphore full, mutex;
PID seat[100];
int i;
full.value= 100; mutex.value=1;
for (i=0; i<100; i++) seat[i]=-1;
Process reader(PID procid )
{ int i;
P(&full);
P(&mutex);
i=0;
while (seat[i] != -1) i++ ;
seat [i] = procid;
V(&mutex);
read at seat i;
P(&mutex);
seat[i]= -1;
V(&mutex);
V(&full);
}

4.写一个用信号量解决哲学家就餐问题不产生死锁的算法。
正确答案：
semaphore chopstick[5]={l，1，l，1，1}；
void philosopher(int i) ／哲学家进程／
{
while (true)
{
if（（i+1)%5<i){
P(chopstick[(i+1)％5])；
P(chopstick[i])；
}
else{
P(chopstick[i])；
P(chopstick[(i+1)％5])；
}
…；
eat； ／进餐／
…：
V(chopstick[i])；
V(chopstick[(i+1)％5])；
…：
think； ／思考／
…；
}
}

5.系统有输入机和打印机各一台，有两进程都要使用它们，采用P、V操作实现请求使用和归还释放后，还会产生死锁吗？若不会，说明理由；若会，你认为应怎样来防止死锁。
正确答案：
会发生死锁。
例如，
semaphore sr, sp;
sr.value=sp.value=1;；
Process p1()
{
P(&sr)；//申请输入机
使用输入机输入数据；
P(&sp)；//申请输出机
…；

    V(&sp)；
    V(&sr)；      
 }

Process p2()
{
P(&sp)；//申请输出机
使用输出机输出数据；
P(&sr)；//申请输入机
…；

    V(&sp)；
    V(&sr)；    

}
出现循环等待的情形。
修改：用层次分配方法防止死锁。
semaphore sr, sp;
sr.value=sp.value=1;
Process p1()
{
P(&sr)；//申请输入机
使用输入机输入数据；
……:
P(&sp)；//申请输出机
使用输出机输出打印；
V(&sp)；
V(&sr)；
}
Process p2()
{
P(&sr)；//申请输入机
P(&sp)；//申请输出机
使用输出机输出数据；
…；
使用输入机输入数据；
…；
V(&sp)；
V(&sr)；
}

6.若系统有同类资源m个，被n个进程共享，问：当m>n和m≤n时，每个进程最多可以请求多少个这类资源，使系统一定不会发生死锁？
正确答案：
【原理：死锁的避免-银行家算法】
设最大请求资源数为k。
当n个进程，每个进程都获得k-1个资源，系统还剩下一个资源时，即n(k-1)=m-1;
则k=[(m-1)/n]+1,此时k为最大，故k≤[(m-1)/n]+1。
当m>n时：每个进程分配[(m-1)/n]+1的上限。
当m=n时：每个进程分配一个。
当m<n时：每个进程最多分配一个。

7.设系统有某类资源共12个，用银行家算法判断下列每个状态是否安全。如果是安全的，说明所有进程是如何能运行完毕的。如果是不安全的，说明为什么可能产生死锁。

正确答案：
状态A
进程 占有资源熟 最大需求 尚需资源情况
进程1 2 6 4
进程2 4 7 3
进程3 5 6 1
进程4 0 2 2
系统剩余资源=12-2-4-5=1
将剩余的1个资源分配给进程3，进程3获得全部资源执行完毕后，系统收回6个资源，这样分配给其余任何一个进程都可执行完毕，因此系统是安全的。

状态B
进程 占有资源熟 最大需求 尚需资源情况
进程1 4 8 4
进程2 2 6 4
进程3 5 7 2
系统剩余资源=12-4-2-5=1，由于系统所剩资源不能满足任何一个进程的最大需求，因此系统是不安全的。

8.某银行提供1个服务窗口和10个供顾客等待的座位。顾客到达银行时，若有空座位，则到取号机上领取一个号，等待叫号。取号机每次仅允许一位顾客使用。当营业员空闲时，通过叫号选取一位顾客，并为其服务。请用信号量和P、V操作描述顾客和营业员的互斥与同步。要求写出完整的过程，说明信号量的含义并赋初值。
正确答案：
semaphore mutex, empty, full,service；
mutex.value=1; //互斥使用取号机
empty.value=10; //空座位数
full.value=0; //已占座位数
service.value=0; //等待服务
cobegin{
process 顾客i {
P(&empty); P(&mutex);
从取号机获得一个号码;
V(&mutex); V(&full);
P(&service); //等待叫号；
获得服务；
}
process 营业员{
while (TRUE){
P(&full);
V(&empty);
V(&service); //叫号；
为顾客服务；
}
}
}coend