操作系统习题集---2---进程管理

习题集 - 2 - 进程管理
1. 在优先级调度中，__________类进程可能被“饿死〞，即长时间得不到调度。

A．短进程 B．长进程 C．低优先级进程 D．大内存进程
解： C。

优先级调度算法〔PRI〕的根本思想是：内核为每个进程赋予一个优先级，进程按照优先级的大小顺序在就绪队列中排队，内核将CPU分配给就绪队列头部的第一个进程——优先级最大的进程。

因此，进程的优先级越低，在就绪队列中的排队位置就越靠近队列尾，获得运行之前的等待时间就越长。

低优先级的进程必须等待所有高优先级进程运行完毕后才会被调度运行。

如果不断有高优先级的进程参加就绪队列，那么低优先级进程就会一直等待下去。

这就是所谓的“饿死〞现象。

2. 在下面的系统调用中，__________不会导致进程阻塞。

A．读/写文件 B．获得进程PID C．申请内存 D．发送消息
解： B。

当正在执行的进程需要使用某种资源或等待某个事件时，如果资源已被其他进程占用或事件尚未出现，该进程不能获得所需的资源而无法继续运行，于是，进程将被阻塞。

进程在阻塞状态中等待资源被释放，或等待事件的发生。

所以，进程在执行系统调用时，如果需要使用某种资源，就可能导致进程阻塞。

“读/写文件〞需要使用设备和文件缓冲区；“申请内存〞需要分配内存资源；“发送消息〞需要使用消息缓冲区。

3. 下面关于临界区的表达中，正确的选项是__________
A．临界区可以允许规定数目的多个进程同时执行
B．临界区只包含一个程序段
C．临界区是必须互斥地执行的程序段
D．临界区的执行不能被中断
解： C。

临界段〔临界区〕的概念包括两个局部：①临界资源：必须互斥访问的资源。

例如，需要独占使用的硬件资源，多个进程共享的变量、构造、队列、栈、文件等软件资源。

②临界区：访问临界资源的、必须互斥地执行的程序段。

即，当一个进程在某个临界段中执行时，其他进程不能进入一样临界资源的任何临界段。

4. 资源顺序分配法破坏了死锁发生的__________必要条件。

A．互斥占用 B．占有等待 C．非剥夺 D．循环等待
解： D。

资源顺序分配方法是：给系统中的每类资源赋予一个自然数的序号，限制进程只能严格按照资源序号由小到大的顺序申请资源。

该方法可以防止“循环等待〞的情况发生。

因为，假设出现循环等待，那么必会有进程在获得大序号资源后申请小序号资源。

5. 假设某操作系统采用RR调度策略，分配给A类进程的时间片为100 ms，分配给B类进程的时间片为400 ms，就绪进程队列的平均长度为5〔包括正在运行的进程〕，其中A类进程有4个，B类进程有1个，所有进程的平均效劳时间为2 s，问A类进程和B类进程的平均周转时间各为多少？〔不考虑IO情况〕
解析:时间片轮转调度〔RR〕是轮流地调度就绪队列中的每个进程，进程每次占用CPU的时间长度限制为时间片的大小。

当采用固定的时间片大小时，每个进程按照固定周期被循环地执行。

所以，进程的执行速度是由该进程的时间片大小在一个循环周期中所占的比例决定的，比例越高，进程的相对执行速度就越快。

解:因为就绪进程队列的平均长度为5，单个RR调度循环周期的时间为
4×100＋1×400＝800〔ms〕
A类进程需要20个时间片的执行时间，B类进程需要5个时间片的执行时间〔1 s＝1 000 ms〕。

A类进程的平均周转时间为
20×0.8＝16(s)
B类进程的平均周转时间为
5×0.8=4(s)
6. 某多道程序设计系统中配有一台处理器CPU和两台输入/输出设备IO1、IO2，现有优先级由高到低
的3个进程P1、P2、P3同时存在，它们使用资源的先后顺序和占用时间分别是：
进程P1：IO2(30 ms)，CPU(10 ms)，IO1(30 ms)，CPU(10 ms)，IO2(10 ms)。

进程P2：IO1(20 ms)，CPU(20 ms)，IO1(40 ms)。

进程P3：CPU(30 ms)，IO2(20 ms)。

假设进程调度采用“可抢占的最高优先级〞调度算法，且忽略调度等所需的时间，请答复以下问题：
(1) 进程P1、P2、P3从开场到完成所用的时间分别是多少?(要求用坐标画出进程P1、P2、P3的工作
过程，其中横坐标表示时间，纵坐标表示CPU和IO设备。

)
(2) 这3个进程从开场到全部完成时CPU的利用率为多少?IO1、IO2的利用率为多少?
解析:在“可抢占的最高优先级〞调度中，任何时刻内核都将处理机分配给当前最高优先级的就绪进程。

也就是说，只有当高优先级进程主动放弃CPU时，低优先级进程才有时机运行，并且，一旦高优先级进程需要使用CPU时，内核就会剥夺低优先级进程的CPU，分配给它使用。

在此题中，由于进程P1和P2在开场执行时先需要进展IO，所以最低优先级的进程P3获得了CPU。

但是，P3运行了20 ms后就被P2抢占了CPU，因为P2刚好完成了IO，并且P2的优先级大于P3。

同样的原因，P2运行了10 ms后，就被P1抢占了CPU。

P1在CPU上运行10 ms之后再次需要进展IO 而放弃CPU，于是，P2、P1获得继续运行的时机。

以此方式，P1、P2和P3相继完成自己的运行过程。

解:根据“可抢占的最高优先级〞调度算法，画出进程P1、P2、P3的工作过程(见图29)。

图2.9进程P1、P2、P3
进程P1、P2、P3从开场到完成所用的时间分别是90 ms、110 ms、80 ms。

这3个进程从开场到全部完成时的时间为110〔ms〕，在此期间内：
CPU的利用率＝(30+20+10+10)/110=63.6%
IO1的利用率=(20+30+40)/110=81.8%
IO2的利用率=(30+20+10)/110=54.5%
7. 论述以下解决双进程临界区问题的软件算法是错误的。

ProcessP0:
do {
flag［0］=true；①
while(flag［1］)；③
临界区
flag［0］=false；
}while(1)；
ProcessP1：
do {
flag［1］=true；②
while(flag［0］)；④
临界区
flag［1］=false；
}while(1)；
解析: 在算法中，两个进程P1和P2各自拥有自己的标志牌flag［0］和flag［1］。

当进程需要进入临界区时，举起标志牌〔设置值为true〕。

然后观察对方是否举起标志牌，是那么等待并继续观察〔while语句〕，直到对方放下标志牌〔设置值为false〕。

这时，进程才进入临界区。

进程退出临界区时，放下标志牌〔设置值为false〕。

解:通过使用标志牌flag［0］和flag［1］，能够保证满足“互斥〞条件。

但是，当两个进程按照①②③④的顺序执行程序时，它们各自举起了标志牌，同时都因为观察到对方也举起了标志牌而等待在while语句中。

由于两个进程都不会放下自己的标志牌，因此都无法进入临界区，不能满足“有限等待〞的条件。

所以，上述解决双进程临界区问题的算法是错误的。

8. 以下解决双进程访问共享变量count的程序是否存在错误？试用信号量实现。

Share：count=0；
Int: flag[2];
cobegin
Process P0:
do {
flag[0]=true；①
while(flag[1])；③
count=count+1；
flag[0]=false；
}while(1)；
Process P1：
do {
flag[1]=true；②
while(flag[0])；④
count=count+1；
flag[1]=false；
}while(1)；
coend
解：在上述程序中，访问共享变量的语句count=count+1构成临界区。

两个进程P0和P1各自拥有自己的标志牌flag[0]和flag[1]。

当进程需要进入临界区时，举起标志牌〔设置值为true〕。

然后观察对方是否举起标志牌，是那么等待并继续观察〔while语句〕，直到对方放下标志牌〔设置值为false〕。

这时，进程才进入临界区。

进程退出临界区时，放下标志牌〔设置值为false〕。

通过使用标志牌flag[0]和flag[1]，能够保证满足“单一进入〞的条件。

但是，当两个进程按照①、②、③、④的顺序执行程序时，它们各自举起了标志牌，同时都因为观察到对方也举起了标志
牌而等待在while语句中。

由于两个进程都不会放下自己的标志牌，因此都无法进入临界区，不能满足“有限等待〞的条件。

所以，上述程序是错误的。

设置信号量S实现对共享变量count的互斥访问。

Share：count=0；
struct semaphore S=1；
cobegin
Process P0:
do {
P(S);
count=count+1；
V(S);
}while(1)；
Process P1：
do {
P(S);
count=count+1；
V(S);
}while(1)；
coend
9. 假定一个阅览室最多可容纳100人，读者进入和离开阅览室时都必须在阅览室门口的一个登记表上进展登记，而且每次只允许一人进展登记操作。

用信号量实现该过程。

解：设置信号量S：控制进入阅览室的人数。

初值=100。

设置信号量mutex：控制登记表的互斥使用。

初值=1。

struct semaphore s=100,mutex=1;
cobegin
reader (i ) (i=1,2,…,k)
{
P(S);
P(mutex);
写登记表；
V(mutex);
阅读；
P(mutex);
写登记表;
V(mutex);
V(S);
离开；
}
coend
10. 在具有N个进程的系统中，允许M个进程(N≥M≥1)同时进入它们的共享区，其信号量S的值的变化范围是〔1〕，处于等待状态的进程数最多是〔2〕个。

解：信号量S用于控制进入共享区的进程数，初值为M。

极端情况是N个进程都需要进入共享区。

〔1〕〔M－N，M〕；〔2〕N－M
11. 在测量控制系统中，数据采集任务把所采集的数据送一单缓冲区；计算任务从该缓冲区中取出数据进展计算。

试写出利用信号量机制实现两者共享单缓冲区的同步操作算法。

解：设置信号量S1和S2控制数据采集任务与计算任务之间的同步。

初值：S1=1，S2=0。

struct semaphore S1=1, S2=0;
cobegin
数据采集任务：计算任务：
begin begin
While〔true〕{ While〔true〕{
采集数据；P(S2);
P(S1); 从缓冲区读出数据；
数据写入缓冲区；V(S1);
V(S2); 计算；
} }
end end
coend
12. 有n+1个进程A1,A2,…,A n和B，A1,…,A n通过同一缓冲区各自不断向B发消息，B不断取消息，它必须取走发来的每一个消息。

刚开场时缓冲区为空，试用P、V操作正确实现之。

解：设置信号量S1和S2控制进程Ai与进程B之间的同步。

初值：S1=1，S2=0。

设置信号量S控制进程Ai之间互斥地使用缓冲区。

初值：S=1。

struct semaphore S1=1, S2=0, S=1;
cobegin
进程Ai〔i=1,2，···，n〕：进程B：
begin begin
While〔true〕{ While〔true〕{
P(S1)；P(S2);
P(S); 从缓冲区读出消息；
消息写入缓冲区；V(S1);
V(S); }
V(S2);
} end
end
coend
13. 桌子上有一只盘子，每次只能放入或取出一个水果。

现有许多苹果和橘子。

一家四口人各行其职。

爸爸专向盘子中放苹果，妈妈专向盘子中放橘子，儿子专等吃盘子中的橘子，女儿专等吃盘子中的苹果。

请用PV操作来实现四人之间的同步算法。

解：设置信号量empty表示盘子的状态。

初值：empty =1。

设置信号量apple表示盘子中的苹果。

初值：apple =0。

设置信号量orange表示盘子中的橘子。

初值：orange =0。

struct semaphore empty =1, apple =0, orange =0;
Parbegin
爸爸: begin
L1: P(empty);
放苹果;
V(apple);
Goto L1;
End;
妈妈：begin
L2: P(empty);
放橘子;
V(orange);
Goto L2;
End;
女儿：begin
L3: P(apple);
取苹果;
V(empty);
Goto L3;
End;
儿子：begin
L4: P(orange);
取橘子;
V(empty);
Goto L4;
End;
Parend
14. 下面是两个并发执行的进程。

它们能正确运行吗?假设不能请举例说明，并改正之。

Parbegin
Var x：integer；
Process P1 Process P2
Var y，z：integer；Var t，u：mteger；
Begin Begin
x:=1；①x:=0；②
y:=0；③t:=0；⑥
if x>=1 then y:=y+1；④if x<=1 then t:=t+2；⑦
z:=y；⑤u:=t; ⑧
end end
Parend
解：变量x是两个进程的共享资源。

假设先执行P1，后执行P2，结果为Y=1，Z=1，T=2，U=2；假设并发执行P1和P2，并按图中标示的顺序执行，那么结果为Y=0，Z=0。

即不能正确运行。

改正的方法是为临界资源x设置信号量S，初值为1。

程序如下：
Parbegin
Var x:integer;
struct semaphore S=1;
Process P1 Process P2
Var y，z：integer；Var t，u：mteger；
Begin Begin
P(S); P(S);
x：=1；①x：=0；②
y：=0；③t：=0；⑥
if x>=1 then y：＝y+1；④if x<=1 then t：=t+2；⑦
V(S); V(S);
z：=y；⑤u: =t; ⑧
end end
Parend
15. 兄弟俩共同使用一个账号，每次限存或取10元，存钱与取钱的进程分别如下所示：
begin
amount：integer；
amount：=0；
cobegin
process SAVE
m1：integer；
begin
m1：=amount；①
m1：=m1+10；
amount：=m1；②
end；
process TAKE
m2：integer；
begin
m2：=amount；③
m2：=m2-10；
amount：=m2；④
end；
eoend；
end；
由于兄弟俩可能同时存钱和取钱，因此两个进程是并发的。

假设哥哥先存了两次钱，但在第三次存钱的时候，弟弟在取钱，请问最后账号amount上面可能出现的值? 如何用P、V操作实现两并发进程的正确执行?
解：哥哥存两次钱后，amount=20, 第三次存钱时，弟弟正在取钱，因没有对amout互斥操作，那么可能发生下面的情况；
〔1〕执行顺序为①②③④或③④①②： amount=20；
〔2〕执行顺序为①③②④或③①②④： amount=10；
〔3〕执行顺序为①③④②或③①④②： amount=30；
设信号量mutex(初值为1)控制两进程对变量amount的互斥使用。

正确过程如下：begin
amount：integer；
amount：=0；
struct semaphore mutex =1;
cobegin
process SAVE
m1：integer；
begin
P(mutex);
m1：=amount；①
m1：=m1+10；
amount：=m1；②
V(mutex);
end；
process TAKE
m2：integer；
begin
P(mutex);
m2：=amount；③
m2：=m2-10；
amount：=m2；④
V(mutex);
end；
eoend；
end；
16. 战地指挥官通过无线电不断地向他的三个士兵下达作战指令，但是他必须在得到所有士兵对前一条指令的“确认〞之后才能下达新的指令。

请使用P、V操作进展指挥官和士兵之间的协同管理。

解：设置信号量S1表示士兵1的“确认〞信息。

初值：S1 =1。

设置信号量S2表示士兵2的“确认〞信息。

初值：S2 =1。

设置信号量S3表示士兵3的“确认〞信息。

初值：S3 =1。

begin
struct semaphore S1=1, S2=1,S3=1;
cobegin
process 指挥官：
begin
while〔true〕{
P(S1); P(S2); P(S3);
向士兵1发送指令；
向士兵2发送指令；
向士兵3发送指令；
}
end；
process 士兵1
begin
while〔true〕{
接收指挥官的指令；
V(S1);
}
end；
process 士兵2
begin
while〔true〕{
接收指挥官的指令；
V(S2);
}
end；
process 士兵3
begin
while〔true〕{
接收指挥官的指令；
V(S3);
}
end；
eoend；
end；
17. 三个并发进程通过缓冲区bufl，buf2以及信号量nonel，nonfl，none2，nonf2，sl和s2协作完成如以下图的任务，bufl，buf2的大小分别为n1，n2。

nonel none2
nonel none2
18. 三个进程如下，试补充完整：
初值：nonel=none2=0；nonfl=nl，nonf2=n2， sl=1，s2=1。

输入进程：
while(1){
(1)
P(s1)；
输入一个字符到bufl；
V(s1)；
(2) ；
}
加工进程：
while(1){
P(nonel)；
(3) ；
从buf1中取一个字符到ch；
(4) ；
V(nonfl)；
P(nonf2)；
P(s2)；
ch送bur2；
V(s2)；
V(none2)；
}
输出进程：
while(1){
(5) ；
(6) ；
从bur2取一个字符到打印口；
(7) ；
(8) ；
}
解：通过分析程序可知，信号量s1和s2分别用于实现对缓冲区buf1，buf2的互斥访问；nonel和nonfl 用于实现输入进程与加工进程之间的同步，none2和nonf2用于实现加工进程与输出进程之间的同步。

(1) P(nonfl) (2) V(nonel) (3) P(s1) (4) V(s1)
(5) P(none2) (6) P(s2) (7) V(s2) (8) V(nonf2)
19. 一个仓库，可以存放A和B两种产品，但要求：
(1)每次只能存人一种产品(A或B)；
(2)A产品数量—B产品数量<M；
(3)B产品数量—A产品数量<N；
其中，M、N是正整数，试用P、V操作描述产品A与产品B的入库过程。

解：条件〔1〕说明产品A与产品B必须互斥地放入仓库。

条件〔2〕和〔3〕说明每放入一个产品B，就可以多放入一个产品A；反之亦然。

设置信号量mutex控制产品A与产品B互斥地放入仓库。

初值：mutex=1。

设置信号量Sa表示可以放入仓库的产品A的数目。

初值：Sa=M-1。

设置信号量Sb表示可以放入仓库的产品B的数目。

初值：Sb=N-1。

产品A与产品B的入库过程如下：
Semaphore： Sa, Sb, mutex;
Sa = m－1; Sb= n－1; mutex = 1;
process_A ( ) {
while〔1〕{
P(Sa)；
P(mutex)；
A产品入库；
V(mutex)；
V(Sb)；
}
}
process_B ( ) {
while〔1〕{
P(Sb)；
P(mutex)；
B产品入库；
V(mutex)；
V(Sa)；
}
}
20. 今有A、B两组进程共享文件P，规定同组进程可以同时读文件P，但当有A组(或B组)进程在读文件P时，就不允许B组(或A组)进程读文件P。

现定义两个计数器C1和C2，分别记录A组和B组中读文件P 的进程数。

当用P、V操作进展管理时，需要三个信号量S1、S2和SAB才能保证正确地并发执行。

程序构造如下：
begin
S1, S2, SAB: semaphore;
C1, C2: integer;
S1: = 1;S2: = 1;SAB: = 1;C1: =0;C2: =0;
cobegin
process Ai(i = 1,2,··· )
begin
( ); /*(1)*/
C1: =C1+1;
If Cl=l then( ); /*(2)*/
( ); /*(3) */
read P;
( ); /*(4)*/
C1:=C1-1;
if C1 =0 then( ); /* (5) */
( ); /*(6)*/
end;
process Bj(j = 1,2, ···)
begin
( ); /*(7)*/
C2: =C2+1;
If C2=l then( ); /*(8)*/
( ); /*(9)*/
read P;
( ); /*(l0) /
C2: = C2 - 1;
if C2 = 0 then( ); /*(11) */
( ); /* (12)*/
end;
eoend;
end；
请答复：
(1)说明信号量S1，S2，SAB的作用：
(2)在上述程序的填空处填上适当的P、V操作，以保证它们能够正确地并发执行。

解：S1的作用是控制计数器C1的互斥使用。

S2的作用是控制计数器C2的互斥使用。

SAB 的作用是控制A组和B组对文件的互斥使用。

(1) P(S1) (2) P(SAB) (3) V(S1) (4) P(S1) (5) V(SAB) (6) V(S1) (7) P(S2) (8) P(SAB) (9) V(S2) (10) P(S2) (11) V(SAB) (12) V(S2)
21. 一条南北方向的公路桥，任何时刻同时只能允许一个方向的汽车通过它。

试用P、V操作写出南或北向的一辆车过桥的同步算法(桥上可有多辆车)。

解：该题的条件与12题一样。

由南向北的车流相当于进程组A，由北向南的车流相当于进程组B。

22. 有座东西方向架设、可双向通行的单车道简易桥，最大载重负荷为4辆汽车。

请定义适宜的信号量，正确使用PV操作，给出任一车辆通过该简易桥的管理算法，
解：单车道意味着双向车流必须互斥地通过桥。

该题的条件与13题类似，多了一个最大载重负荷的限制。

定义两个计数器C1和C2，分别记录由东向西行的车辆数和由西向东行的车辆数。

设置信号量S1控制计数器C1的互斥使用。

初值S1=1。

设置信号量S2控制计数器C2的互斥使用。

初值S2=1。

设置信号量mutex控制双向车流对桥的互斥使用。

初值mutex=1。

设置信号量S表示可以上桥行驶的车辆数。

初值S=4。

Semaphore： S1=1, S2=1, mutex=1, S=4;
int: C1, C2;
C1 =0; C2 = 0;
cobegin
由东向西行的车辆：
begin
P(S1);
C1 = C1+1;
if ( Cl = = l ) then P(mutex);
V( S1 );
P(S)；
过桥;
V(S);
P(S1);
C1 = C1-1;
if ( C1 = = 0) then V( mutex );
V(S1);
end
由西向东行的车辆：
begin
P(S2);
C2 = C2+1;
if ( C2 = = l ) then P(mutex);
V( S2 );
P(S);
过桥;
V(S);
P(S2);
C2 = C2-1;
if ( C2 = = 0) then V( mutex );
V(S2);
end
coend
23. 在一个飞机订票系统中，多个用户共享一个数据库。

多用户可以同时查询数据库，但假设一个用户要订票需更新数据库时，其余所有用户都不可以访问数据库。

请给出用户查询与订票的逻辑流程。

要求：当一个用户订票而需要更新数据库时，不能因不断有查询者的到来而使其长期等待。

解：该题的条件与12题类似，不同的是订票的用户组必须互斥地使用数据库。

另外，为保证订票用户不因查询者的不断到来而长期等待，当有用户需要订票时，暂停多用户的同时查询。

设置一个计数器C1和C2分别记录需要查询和订票的用户数。

设置信号量S1控制计数器C1的互斥使用。

初值S1=1。

设置信号量S2控制计数器C2的互斥使用。

初值S2=1。

设置信号量mutex控制对数据库的互斥使用。

初值mutex=1。

Semaphore： S1=1, S2=1, mutex=1;
int: C1, C2;
C1 =0; C2 = 0;
cobegin
查询用户：
Begin
If ( C2 ! =0 ) then {
P(mutex);
查询数据库;
V( mutex );
} else {
P(S1);
C1 = C1+1;
if ( Cl = = l ) then P(mutex);
V( S1 );
查询数据库;
P(S1);
C1 = C1-1;
if ( C1 = = 0) then V( mutex );
V(S1);
}
end
订票用户：
begin
P(S2);
C2 = C2+1;
V( S2 );
P(mutex);
修改数据库;
V( mutex );
P(S2);
C2 = C2-1;
V(S2);
end
coend
死锁
1.系统有同类资源m个，供n个进程共享，如果每个进程对资源的最大需求量为k，问：当m，n，k的
值分别是以下情况时，是否会发生死锁？
解：系统中某种资源的个数为m，共享该资源的进程数为n，每个进程对该资源的最大需求量为k。

最极端的资源分配情况是，每个进程都已经占有了k－1个资源，同时都需要再分配一个资源。

这时，如果要保证不发生死锁，系统中必须至少还有一个可分配的资源。

即m满足下面的关系式：
m≥n ( k－1)＋1
因此，保证系统不会发生死锁的最小m值可以从下面的公式获得：
m＝n(k－1)＋1
根据上述公式，只有〔1〕会发生死锁。

如果将n个进程对资源的需求总量记作T＝nk，那么可得到系统不会发生死锁的最大需求总量：
T＝m＋n－1
2.一个系统中存在某类资源m个，被n〔n≤m〕个进程共享，每个进程至少需要一个资源。

资源的分配
和释放必须一个一个地进展。

如果所有进程需要的资源总数小于m+n，请证明系统是否会发生死锁。

解：根据1题中的分析结果可知，如果所有进程需要的资源总数小于m+n，系统不会发生死锁。

3.在著名的“哲学家就餐问题〞中，当5位哲学家同时饿了，同时取得左手的筷子，再同时申请右手的
筷子，此时发生死锁。

请分别用死锁预防、死锁防止、死锁检测与恢复的方法改造系统。

解：死锁预防：
·破坏占有等待条件：每位哲学家拿筷子时必须左右筷子同时申请，即采用资源一次性分配法，假设缺一那么不可获得资源分配。

·破坏非剥夺条件：第1位哲学家拿筷子时，假设左右邻居中有等待资源者，那么可强行抢夺其已经占有的筷子。

·破坏循环等待：对5根筷子顺序编号，即1，2，3，4，5，每位哲学家只能按由小到大的顺序申请(资源顺序分配法)。

死锁防止：每位哲学家申请筷子时，先看分配后是否会发生死锁，假设不会那么分配，否那么拒绝分配。

例如最易发生死锁的情况：已有四位拿到左手的筷子，此时第五位申请左手的筷子，那么不可分配。

死锁检测与恢复：对筷子的申请和分配不加限制，但定期〔例如每隔5秒〕检测是否已发生死锁，是那么剥夺其中一位哲学家的筷子分配给其他人。

27. 某银行计算机系统要实现一个电子转账系统，根本的业务流程是首先对转出方和转入方的账户进展加锁，然后进展转账业务，最后对转出方和转入方的账户进展解锁。

如果不采取任何措施，系统会不会发生死锁? 为什么? 请设计一种能够防止死锁的方法。

解：会死锁。

因为对两个账户进展加锁操作是可以分割进展的，假设此时有两个用户同时进展转账，P1先对帐户A进展加锁，再申请帐户B；P2先对帐户B进展加锁，再申请账户A，此时死锁。

解决方法是：可以采用资源顺序分配法，将A、B账户进展编号，用户转账时，只能按照编号由小到大的顺序进展加锁；也可以采用资源预分配法，要求用户在使用资源之前将所有资源一次性申请到。

4.28. 有三个进程P1，P2和P3并发工作。

进程P1需用资源S3和S1；进程P2需用资源S1和S2；进程P3需
用资源S2和S3。

〔1〕假设对资源分配不加限制，会发生什么情况？为什么？
〔2〕为保证进程正确工作，应采用怎样的资源分配策略？列举出所有可能的方法。

解：〔1〕可能会发生死锁
例如：进程P1，P2和P3分别获得资源S3，S1和S2后，再继续申请资源时，发生循环等待，即发生死锁。

〔2〕可以采用下面的资源分配方法：
A. 采用预分配方法
进程在运行前先获得需要的资源。

给资源S1，S2和S3顺序编号为1,2,3。

进程P1申请资源的顺序是S1和S3；进程P2申请资源的顺序是S1和S2；进程P3申请资源的顺序是S2和S3。

C.采用银行家算法
在分配时，保证系统处于平安状态。

5.在银行家算法中，假设出现以下资源分配情况：
进程资源最大需求已分配资源
P0 7， 5， 3 0， 1， 0
P1 3， 2， 2 2， 1， 0
P2 9， 0， 2 3， 0， 2
P3 2， 2， 2 2， 1， 1
P4 4， 3， 3 0， 0， 2
系统剩余资源数量；(3，2，2)。

(1)该状态是否平安(给出详细的检查过程)?
(2)如果进程依次有如下资源请求：
P1：资源请求request(1，0，2)
P4：资源请求request(3，3，0)
P0：资源请求request(0，1，0)
那么系统如何进展资源分配，才能防止死锁?
解：〔1〕计算各进程还需要的资源:
进程资源最大需求已分配资源还需要的资源 P0 7， 5， 3 0， 1， 0 7， 4， 3
P1 3， 2， 2 2， 1， 0 1， 1， 2
P2 9， 0， 2 3， 0， 2 6， 0， 0
P3 2， 2， 2 2， 1， 1 0， 1， 1
P4 4， 3， 3 0， 0， 2 4， 3， 1 系统剩余资源数量(3，2，2)只能满足P1或P3的需求。

计算是否存在平安序列。

可以完成的进程系统剩余资源数
P1 5, 3, 2
P4 5， 3， 4
P3 7， 4， 5
P0 7， 5， 5
P2 10, 5, 7
P1, P4, P3, P0, P2是平安序列，所以该状态是平安的。

〔2〕系统剩余资源数量(3，2，2)只能满足P0或P1的资源请求。

如果满足P1的资源请求(1，0，2)，系统状态变成
进程资源最大需求已分配资源还需要的资源
P0 7， 5， 3 0， 1， 0 7， 4， 3
P1 3， 2， 2 3， 1， 2 0， 1， 0
P2 9， 0， 2 3， 0， 2 6， 0， 0
P3 2， 2， 2 2， 1， 1 0， 1， 1
P4 4， 3， 3 0， 0， 2 4， 3， 1
系统剩余资源数量(2，2，0)。

显然，P1, P4, P3, P0, P2是平安序列。

所以，可以为P1分配资源。

如果继续满足P0的资源请求(0，1，0)，系统状态变成
进程资源最大需求已分配资源还需要的资源
P0 7， 5， 3 0， 2， 0 7， 3， 3
P1 3， 2， 2 3， 1， 2 0， 1， 0
P2 9， 0， 2 3， 0， 2 6， 0， 0
P3 2， 2， 2 2， 1， 1 0， 1， 1
P4 4， 3， 3 0， 0， 2 4， 3， 1
系统剩余资源数量(2，1，0)。

此时，仍有平安序列P1, P4, P3, P0, P2。

所以，可继续为P0分配资源。