处理机调度与死锁习题

1.对于下列三个作业，采用不可抢占的调度方式：先来先服务（ＦＩＦＯ）和短作业优先（ＳＪＦ）调度算法，分别计算它们的平均周转时间。

JOB	到达队列时间	需运行时间
1	0.0	8
2	0.4	4
3	1.0	1

解析
周转时间=完成时间-到达时间
带权周转时间=周转时间÷运行时间
技巧：根据到达队列的时间及算法找出进程调度顺序并分别写出到达时间、需运行的时间、开始时间、结束时间、周转时间

(1) 先来先服务(F I FO) :

作业1的周转时间: 8-0=8

作业2的周转时间: 12-0.4=11.6

作业3的周转时间: 13-1.0=12

调度顺序：1、2、3

所以平均周转时间= (8+11.6+12) /3=10.53

短作业优先(SJF):

作业1的周转时间: 8-0=8

作业2的周转时间: 9-1 .0=8

作业3的周转时间: 13-0.4=12.6

调度顺序1、3、2

所以平均周转时间= (8+8+12.6) /3=9.535

(2)若调度在一个时间单位以后才开始，采用短作业优先(SJF)，作业1 2 3到达时间都在1内所以按照短作业优先原则先是作业3-作业2-作业1:

作业1的周转时间: 14-0=14

作业2的周转时间: 6-0.4=5.6

作业3的周转时间: 2-1.0=1

所以平均周转时间= (14+5.6+1) /3=6.86

2.在银行家算法中，若出现下述资源分配情况，试问：

Process	Allocation	Need	Available
P0	0032	0012	1622
P1	1000	1750
P2	1354	2356
P3	0332	0652
P4	0014	0656

(1). 该状态是否安全？
(2).若进程P2提出请求Request(1,2,2,2后)，系统能否将资源分配给它？

答题技巧:
能否找到安全序列
预分配后是否安全（明显可以看出Available1622>P0,P3,P4的Need，所以P0,P3,P4可直接加入安全序列，只是资源数量为1622+ALL（P0 P3 P4 ）=1 9 9 10），1 9 9 10大于P1的Need,然后执行完P1释放资源ALL，两者相加为2 9 9 10大于P2的2 3 5 6，所以肯定有安全序列

解析：

[解] (1) 利用安全性算法对上面的状态进行分析(见下表)，找到了一个安全序列{P0,P3,P4,P1,P2}，故系统是安全的。

(2) P2发出请求向量Request(1,2,2,2),系统按银行家算法进行检查:

①Request2(1,2,2,2)<=Need2(2,3,5,6)

②Request2(1,2,2,2)<=Available(1,6,2,2)

③系统先假定可为P2分配资源，并修改Available, Allocation2和Need2向量 :Available=(0,4,0,0)=原来的1,6,2,2-1,2,2,2

Allocation2=(2,5,7,6)=原来的1,3,5,4+1,2,2,2

Need2=(1,1,3,4)=原来的2,3,5,6-1,2,2,2

④进行安全性检查:此时对于所有的进程，条件NeedisAvailable(0,4,0,0)都不成立，即Available不能满足任何进程的请求，故系统进入不安全状态。

因此，当进程P2提出Request(1,2,2,2)后，系统不能将资源分配给它。

3.设系统有三类资源A、B和C，又设系统中有5个进程P1，P2，P3，P4和P5，在T0时刻系统状态如下：

(1)系统是否处于安全状态？如是，则给出进程安全序列，(要有详细过程)
(2)如果进程P5申请1个资源类A，1个资源类B和1个资源类C，能否实施分配，为什么？

解析：(1)

系统是处于安全状态,安全序列为:P4,P2,P1,P3,P5

Available=(2,1,1)//发现只大于P4的Need。

p4:work=(2,1,1)+( 3,2,2)=(5,3,3)

p2:work= (5,3,3) +( 3,1,1)=(8,4,4)

p1:work= (8,4,4) +(1 ,2,1)=(9,6,5)

p3 :work= (9,6,5) +( 4,1,3)=(13,7,8)

p5:work=( 13,7,8 )+( 1,1,3)=(14,8,11)

(2) P5申请(1,1,1)

不能实施分配,因为分配后找不到安全序列,系统将处于不安全状态.

因为这时候P5的已分配数量为2 2 4，Need需求量为3 2 2 ，但是原有的Available数量需要减去1 1 1就等于1 0 0 ，这时候的Available的值不大于任何一个进程的Need资源量，所以处于不安全状态。

4.系统中有五个进程P1、P2、P3、P4、P5，有三种类型的资源：R1、R2、和R3。在T0时刻系统状态如表所示。若采用银行家算法实施死锁避免策略，回答下列问题：

（1）T0时刻是否为安全状态？为什么？

（2）若这时P4请求资源（1，2，0），是否能实施资源分配？为什么？（记住 只要请求了资源，那么原来的Allocation，Need，Available3个值就会改变）

（3）在上面的基础上，若进程P3请求资源（0，1，0），是否能实施资源分配？为什么？

T0时刻系统状态如下表

答案：

1. T0时刻是安全的， 安全序列为: P1,P4，P5，P2, P3

解析：

Need
R1	R2	R3
0	0	0
0	7	5
6	6	2
3	2	0
0	3	2

 可以发现剩余资源量3 3 0大于P1的Need，先执行P1后，P1释放资源0 0 1，这样work就为3 3 1，在执行P4，work为4 4 6.。。。。。。。这样一直下面发现是安全的序列

1. P4请求资源(1, 2, 0)，根据银行家算法，预分配后系统是安全的，安全序列为:P1，P4, P5，P2，P3

解析：这时候P4的已分配资源量为2 3 5；Need值就为2 0 0；剩余资源量 2 1 0

Need
R1	R2	R3
0	0	0
0	7	5
6	6	2
2	0	0
0	3	2

可以发现按照第一问的那个安全序列也是对的，起初的work（剩余资源量）2 1 0大于P1的Need，先执行P1后，P1释放资源0 0 1，这样work就为2 1 1，在执行P4，work为4 4 5（这时候因为P4又申请了资源，所以已分配的资源增加为了2 3 5，这样P4执行完后的释放资源量也就变为了2 1 1+2 3 5 =4 4 5）.。。。。。。。这样一直下面发现是安全的序列

1. P3请求资源(1, 1, 0) ,根据银行家算法，预分配后系统不安全，所以不能实施资源分配。

解析：这时候P3的已分配资源量为1 1 3；Need值就为5 5 2；剩余资源量 2 2 0

Need
R1	R2	R3
0	0	0
0	7	5
5	5	2
3	2	0
0	3	2

这时候因为剩余资源量2 2 0大于P1的0 0 0，先执行P1后，P1释放资源0 0 1，P1进去安全序列。这时候资源量为2 2 1，但是2 2 1不大于剩下的进程的Need，所以系统不安全了

5. 在一个两道作业的操作系统中。设在一段时间内先后到达4个作业。它们的提交时刻和运行时间由下表给出。

若作业调度采用短作业优先的调度算法。进程调度采用优先权调度算法(数值越小，优先级越高)

• 完成下列表格

⑵计算平均周转时间、平均带权周转时间（小数点后保留两位) 。

解答：

• 平均周转时间=(5+7+10+11)÷4=8.25

平均带权周转时间=(1+2+2.33+5.5)÷4=2.70

6. 在一个多道作业的操作系统中，设在一段时间内先后到达4个作业，它们的提交时刻和运行时间由下表给出。进程调度采用时间片轮转调度算法，时间片大小为2。
⑴完成下列表格

⑵计算平均周转时间、平均带权周转时间（小数点后保留两位)

解答：
⑴
⑵平均周转时间=(7+13+11+6) /4=9.25
平均带权周转时间=(2.33+2.6+2.75+3) /4=2.67
解析：

7. 有一个单CPU的多道批处理系统(内存中可同时装入两道作业)，作业调度采用“短作业优先”调度算法，进程调度采用“优先数抢占式”调度算法，且优先数越小优先级越高，列出所有作业进入内存的时间及结束时间并计算平均周转时间填入下表。

作业	到达时间	运行时间	优先数
1	8:00	40分钟	5
2	8:20	30	3
3	8:30	50	4
4	8:50	20	6

答案

作业	到达时间	运行时间	优先数	进入内存时间
1	8:00	40分钟	5	8：00
2	8:20	30	3	8：20
3	8:30	50	4	9：10
4	8:50	20	6	8：50
2	8:20	30	3	8：20
3	8:30	50	4	9：10

首先必须读清楚题目，可知道内存同时装入两道作业，而且作业调度采用短作业优先，进程调度采用优先数抢占式，这个必须要理解明白

第一，8：00，P1从外存调入内存，进行进程调度，上处理机

第二，8：20，P2从外村调入内存，因为内存可以装入两道作业，进入内存后，这时候P1在处理机进行，并且已经运行了20分钟，还有20分钟没运行，但是内存中进行进程调度时，采取优先级，内存中P2（30）优先级大于P1（20），P1（20）下处理机，P2（30）上处理机运行，这时候内存中是P1（20）

第三，8：30，因为内存中有两个作业P1P2，所以P3还在外存

第四，8.50，P2完成，这时候因为内存只有一个P1，所以P1上处理机，然后这时候外存有P3P4，但是P3P4进行的是作业调度，采用短作业优先，于是P4进内存，这时候内存是P1P4，然后内存进行进程调度，可是发现P1的优先级比P4的优先级优先，于是P1不下处理机，继续运行。

第五．9：10，P1剩下的20也运行完了，内存中只有P4，直接上处理机，这时候内存作业数不够2个，从外存调入P3，然后在内存中进行进程调度，发现P3的优先级要优于P4的优先级，于是抢占处理机，P4下处理机，P3上处理机运行

第六，10：00，P3运行完，P4上处理机

第七，10：20，P4运行完。

解析：

8.某系统有A、B、C三类资源可供五个进程P1、P2、P3、P4、P5共享。进程对资源的需求和分配情况如下：

进程	最大需求 A  B  C	已分配 A  B  C	可用 A  B  C
P1	7    6  4	2    2  1	0    1  2
P2	4    3  3	3    1  1
P3	10    1  3	4    1  3
P4	3    3  3	3    2  2
P5	4    4  6	1    1  3

按银行家算法回答下列问题：
(1)请写出尚需资源矩阵need;

答案：need=最大需求-已分配

A	B	C
5	4	3
1	2	2
6	0	0
0	1	1
3	3	3

(2)现在系统是否处于安全状态？为什么？（如果有安全序列，请写出）

答案：

进程	Work	Need	Allocation	Work+Allaction	Finish
P4	0 1 2	0 1 1	3 2 2	3 3 4	True
P5	3 3 4	3 3 3	1 1 3	4 4 7	True
P2	4 4 7	1 2 2	3 1 1	7 5 8	True
P3	7 5 8	6 0 0	4 1 3	11 6 11	True
P1	11 6 11	5 4 3	2 2 1	13 8 12	True

此时存在安全序列 P4 P5 P2 P3 P1

现在系统处于安全状态

解析：1.从可用资源数可以看出仅仅只大于P4的need，于是先吧资源分配给P4，P4放入安全序列中，P4结束后释放资源后，这时候可用资源数=P4已分配的资源数+起初的可用资源数=3 2 2+0 1 2=3 3 4，这个结果也是P4的Work+Allaction的值。

2.发现现在可用资源数为3 3 4大于了P2 P5的need数,因此就可以知道P2P5也可以加入安全序列，然后现在的可用资源数等于了3 3 4+P2 P5三者的已分配数量也是大于了P4 P5的Need数，因此，一定存在安全序列的，这里就不算了，按照第一步直接计算即可

(3)P5资源请求request (0, 1, 1)可否满足，为什么？

Request（0 1 1）<=need(0 1 1);

Request（0 1 1）<available(0 1 2);

假设请求可满足

进程	Work	Need	Allocation	Work+Allaction	Finish
P4	0 0 1	0 1 1	3 2 2	3 2 3	false

此时不存在安全序列，系统处于不安全状态，所以假设不成立。

解析：假设请求满足的话，这三个就改变了Need=0 0 0 Allocation=3 3 3；Available=0 0 1；这时候可分配资源只有0 0 1不满足大于任何一个进程的Need，所以一定不存在安全序列。

9.一个多道程序系统，有一个作业序列，作业的提交时间及运行时间在下表中所列。当第一个作业进入系统后开始调度，假定作业都是仅作计算。请列出在分别采用先来先服务算法和计算时间短的优先算法管理作业时各个作业的开始时间、完成时间和周转时间。注意：忽略系统开销。

作业号	到达输入时刻	需计算时间
1	10:00	2小时
2	10：10	1小时
3	10：20	0.5小时
4	10：30	0.2小时

答案：

先来先服务：

T=10：00，P1进入内存，  T=10：10 P2等待，P1(1小时50分钟)

T=10：20，P3到达但也是等待，P2-P3，P1还在运行，P1（1小时40分钟）

T=10：30，P4到达但也是等待，P2-P3-P4, P1还在运行，P1（1小时30分钟）

T=12：00，P1完成

T=13：00,P2完成

T=13：30，P3完成

T=13：42，P4完成

作业号	到达时间	计算时间	开始时间	完成时间	周转时间
1	10：00	2小时	10：00	12：00	120分钟
2	10：10	1小时	12：00	13：00	170分钟
3	10：20	0.5小时	13：00	13：30	160分钟
4	10：30	0.2小时	13：30	13：42	162分钟

短作业优先：

T=10：00，P1进入内存，

T=10：10，P1（110）P2（60）//这个时候P1下处理机，P2上处理机

T=10：20，P1（110）P2（50）P3（30）//P2下处理机，  放在就绪队列P1 P2，P3上处理机

T=10：30，P1（110）P2（50）P3（20）P4（12）//P3下处理机，放在就绪队列P1，P2，P3，然后P4上处理机。

T=10：42，P4完成， P1（110）P2（50）//P3（20）P3上处理机

T=11：22，P3完成，P1（110）P2（50）//P2上处理机

T=11：52，P2完成，P1（110）//P1上处理机

T=13：42，P1完成

作业号	到达时间	计算时间	开始时间	完成时间	周转时间
1	10：00	2小时	10：00	13：42	222分钟
2	10：10	1小时	10：10	11：52	102分钟
3	10：20	0.5小时	10：20	11：02	42分钟
4	10：30	0.2小时	10：30	10：42	12分钟

10. 设有按P1、P2、P3、P4次序到达的4个进程，CPU阵法时间如表所示，采用先到先得服务算法和最短作业优先算法，画出甘特图，并计算各自的平均等待时间。

进程	CPU阵发时间/ms
P1	20
P2	8
P3	5
P4	18

（1）采用先到先得服务算法，甘特图如下：

P1

P2

P3

P4

 0                   20     28  33                  51

 平均等待时间=(0 ＋20+28 +33 )/4 ms = 20.25 ms。

（2）采用最短作业优先算法，甘特图如下：

P3

P2

P4

P1

0      5     13         31                          51

 平均等待时间=(0+5+ 13 +31)/4 ms = 12.25 ms。

11. 设有4个作业J1、J2、J3、J4，其提交时刻与运行时间如下。试采用先到先服务、最短作业优先、最高响应比优先算法,分别求出各个作业的周转时间，带权周转时间,以及所有作业的平均周转时间，平均带权周转时间。

解析：周转时间：是指从作业被提交给系统开始，到作业完成为止的时间间隔。

（作业）周转时间=作业完成时的时间-作业提交时间

              平均周转时间=各作业周转时间之和/作业数

1. 执行时间顺序为J1-J2-J3-J4

作业的平均周转时间=（120+160+160+188）/4=157 min  约为2.62h

平均带权周转时间=(120/120+160//60+160/30+188/48)/4=3.23

2. SJB执行时间顺序为J1-J3-J4-J2，如图所示。

作业的平均周转时间=（120+238+100+128）/4=146.5min约为2.44h

平均带权周转时间=(120/120+238/60+100/30+128/48)/4=2.74

3. HRN执行时间顺序为J1-J3-J2-J4，如图所示。

作业的平均周转时间=（120+190+100+188）/4=149.5min约为2.49h

平均带权周转时间=(120/12/+190/60+100/30+188/48)/4=2.85

12. 在银行家算法中，若出现如下资源分配情况：

进程	Allocation	Need	Available
	A  B  C  D	A  B  C  D	A  B  C  D
P0	0  0  3  2	0  0  1  2	1  6  2  3
P1	1  0  0  0	1  7  5  0
P2	1  3  5  4	2  3  5  6
P3	0  3  3  2	0  6  5  2
P4	0  0  1  4	0  6  5  6

试问：

(1)当前状态是否安全？

(2)如果进程P2提出安全请求Request[2]=(1,2,2,2),系统能否将资源分配给它？说明原因．

解：

（1）当前状态是安全状态。可以找到一个安全进程序列<p0,p3，p4，p1,p2>，它使Finish[i]=true，因而可以断言系统当前处于安全状态．

（2）系统不能将资源分配给它。运行银行家算法，由于Request[2]=（1, 2, 2, 2）<Need[2]=（2, 3, 5, 6），因而请求合法。进一步，Request[2]=（1, 2, 2, 2）<Available=（1, 6, 2, 3），故该请求是可以满足的。假设将资源分配给p2，则系统状态变为:

进程	Allocation	Need	Available
	A  B  C  D	A  B  C  D	A  B  C  D
P0	0  0  3  2	0  0  1  2
P1	0  4  0  1	1  7  5  0
P2	2  5  7  6	1  1  3  4
P3	0  3  3  2	0  3  1
P4	0  0  1	0 0  0

运行安全性检测算法，Work=Available=（0, 4, 0, 1），Finish[i]=false，此时所有Need[i]<=Work[i]均不成立，结果Finish[i]均为false，不存在安全进程序列，系统处于不安全状态。系统将取消资源分配并恢复原来状态，进程p2等待。

解析：

1. 根据Available1 6 2 3可以发现大于P0的need0 0 1 2，于是把P0放进处理机运行，结束后，Availbale的值为1 6 5 5，P0放入安全序列中，1 6 5 5 大于P3的need，于是按照刚刚P0的操作，这时候Availbale的值为1 9 8 7，P3放入安全序列中，

1 9 8 7大于P4也大于P1，这里默认从P4开始，（于是按照刚刚P0的操作，）这时候Availbale的值为1 9 9 8，P4放入安全序列中，

1 9 9 8大于P1，（于是按照刚刚P0的操作，）这时候Availbale的值为2 9 9 8，P1放入安全序列中，（于是按照刚刚P0的操作，）这时候Availbale的值为2 9 9 8大于P2的need，P2放入安全序列，所以有安全序列p0,p3，p4，p1,p2

1. Request[2]=(1,2,2,2)<=Need(2 3 5 6)

Request[2]=(1,2,2,2)<=Available(1 6 2 3)

    这时候假设请求满足了，那么Available的值就为0 4 0 1；

    Allocation=2 5 7 6；Need=1 1 3 4，可发现Available的值不大于也不存在等于某一个进程的Need，故系统不能将资源分配给它。

13. 某系统采用死锁检测手段发现死锁，设系统中资源类集合为{A，B，C}，资源类A中共有8个实例，资源类B中共有6个实例，资源类C中共有5个实例．又设系统中进程集合为{p1,p2,p3,p4,p5,p6}，某时刻系统状态如下：

进程	Allocation	Need	Available
	A  B  C	A  B  C	A  B  C
P1	1  0  0	0  0  0	2  2  1
P2	3  2  1	0  0  0
P3	0  1  2	2  0  2
P4	0  0  0	0  0  0
P5	2  1  0	0  3  1
P6	0  0  1	0  0  0

在上述状态下系统依次接受如下请求：Request[1]=(1,0,0)；Request[2]=(2,1,0)；Request[4]=(0,0,2)。给出系统状态变化情况，并说明没有死锁。

在由(1)所确定的状态下系统接收如下请求：Request[1]=(0,3,1)，说明此时已发生死锁，并找出参与死锁的进程。

解：

（1）①系统接受请求：Request[1]=(1,0,0)，Request[1]< Available，因为P1所需的Need为0 0 0，也就是说没有需求，也就是说可以执行分配，那么系统状态变为：

进程	Allocation	Need	Available
	A  B  C	A  B  C	A  B  C
P1	2  0  0	0  0  0	1  2  1
P2	3  2  1	0  0  0
P3	0  1  2	2  0  2
P4	0  0  0	0  0  0
P5	2  1  0	0  3  1
P6	0  0  1	0  0  0

在该状态下运行死锁检测算法，可以找到一个进程序列<p4,p1,p2,p3,p5,p6>，它使Finish[i]=true，对于所有1≤i≤6，因而可以断言系统当前没有进入死锁状态。

②系统接受请求：Request[2]=(2,1,0)，Request[2]>Available，因为不满足小余等于Available，因此把Request的值直接写入所在Need中，然后从其他进程开始进行安全序列检测,系统只接受请求，无法实现资源分配，那么系统状态变为：

进程	Allocation	Need	Available
	A  B  C	A  B  C	A  B  C
P1	2  0  0	0  0  0	1  2  1
P2	3  2  1	2  1  0
P3	0  1  2	2  0  2
P4	0  0  0	0  0  0
P5	2  1  0	0  3  1
P6	0  0  1	0  0  0

在该状态下运行死锁检测算法，可以找到一个进程序列<p4,p1,p2,p3,p5,p6>，它使Finish[i]=true，对于所有1≤i≤6，因而可以断言系统当前没有进入死锁状态。

③系统接受请求：Request[4]=(0,0,2)，Request[4]>Available,系统只接受请求，无法实现资源分配，那么系统状态变为：

        Allocation        Need          Available

         A  B  C        A  B  C         A  B  C

p1:    2  0  0        0  0  0         1  2  1

p2:    3  2  1        2  1  0

p3:     0  1  2        2  0  2

p4:     0  0  0        0  0  2

p5:     2  1  0        0  3  1

p6:     0  0  1        0  0  0

在该状态下运行死锁检测算法，可以找到一个进程序列< p1,p2,p3, p4,p5,p6>，它使Finish[i]=true，对于所有1≤i≤6，因而可以断言系统当前没有进入死锁状态。

(2)在（1）状态下系统接收如下请求：Request[1]=(0,3,1)，Request[1]>Available,系统只接受请求，无法实现资源分配，则系统状态变为：

        Allocation        Need          Available

         A  B  C        A  B  C         A  B  C

p1:    2  0  0        0  3  1         1  2  1

p2:    3  2  1        2  1  0

p3:     0  1  2        2  0  2

p4:     0  0  0        0  0  2

p5:     2  1  0        0  3  1

p6:     0  0  1        0  0  0

在该状态下运行死锁检测算法，找不到一个进程序列使Finish[i]=true，对于所有1≤i≤6，因为存在i∈{1，2，3，5}，使Finish[i]=false，因而可以断言系统已经进入死锁状态，进程p1,p2,p3,p5卷入死锁．

13.

从P1到P4有4个进程,每个进程的到达时间和运行时间如下表所示:

进程	到达时间	执行时间
P1	0	8
P2	1	4
P3	2	9
P4	3	5

先来先服务调度算法:按照进程到达先后顺序执行进程:P1,P2,P3,P4

方法一:

进程	到达时间	执行时间	开始时间	结束时间	等待时间	周转时间	带权周转时间
P1	0	8	0	8	0	8	1
P2	1	4	8	12	7	11	2.75
P3	2	9	12	21	10	19	2.11
P4	3	5	21	26	18	23	4.6

等待时间 = 开始时间 - 到达时间

周转时间 = 结束时间 - 到达时间(就是进程从就绪队列等待开始到进程结束所需要的时间)

带权周转时间 = 周转时间/执行时间

方法二:Gantt图

短作业优先调度算法SJF

非抢占:就是进程从开始执行就一直是该进程执行到结束再执行其他进程

按照进程长度,进程越短越先执行: P1,P2,P4,P3

进程	到达时间	执行时间	开始时间	结束时间	等待时间	周转时间	带权周转时间
P1	0	8	0	8	0	8	1
P2	1	4	8	12	7	11	2.75
P4	3	5	12	17	9	14	2.8
P3	2	9	17	26	15	24	2.67

高响应比优先调度算法:按优先权 = (等待时间+执行时间)/执行时间优先执行等待时间长执行时间短的进程!

非抢占:先执行P1

计算后面3个进程优先权:

P2 = (7+4)/4

P3 = (5+5)/5

p4 = (6+9)/9

这里P2的优先权更大!先执行P2

进程	到达时间	执行时间	开始时间	结束时间	等待时间	周转时间	带权周转时间
P1	0	8	0	8	0	8	1
P2	1	4	8	12	7	11	2.75
P4	3	5	12	17	9	14	2.8
P3	2	9	17	26	15	24	2.67