操作系统总复习（计算题&分析题）

1、设在批处理系统中有四道作业。它们进入系统的时间及运行时间如下：

作业号	进入时刻（h）	运行时间（h）
1	8：00	2.00
2	8：30	0.50
3	9：00	0.10
4	9：30	0.20

设系统每次只选择一个作业装入主机，分别给出在下列算法中这组作业的运行顺序、平均周转时间和平均带权周转时间
周转时间=作业完成时间-作业到达时间
带权周转时间=作业周转时间 / 作业实际运行的时间

（1）FCFS算法（先来先调度）

运行顺序为：1–>2–>3–>4
周转时间：

作业号	周转时间（h）
1	2-0=2
2	2+0.5-0.5=2
3	2+0.5+0.1-1=1.6
4	2+0.5+0.1+0.2-1.5=1.3

平均周转时间：(2+2+1.6+1.3)/4=1.725
带权周转时间：

作业号	带权周转时间（h）
1	2/2=1
2	2/0.5=4
3	1.6/0.1=16
4	1.3/0.2=6.5

平均带权周转时间：(1+4+16+6.5)/4=6.875

（2）SJF算法（最短者优先）

运行顺序为：1–>3–>4–>2

作业号	周转时间（h）
1	2-0=2
3	2+0.1-1=1.1
4	2+0.1+0.2-1.5=0.8
2	2+0.1+0.2+0.5-0.5=2.3

平均周转时间：(2+1.1+0.8+2.3)/4=1.55
带权周转时间：

作业号	带权周转时间（h）
1	2/2=1
3	1.1/0.1=11
4	0.8/0.2=4
2	2.3/0.5=4.6

平均带权周转时间：(1+11+4+4.6)/4=5.15

2、在银行家算法中，若出现下述资源分配情况（见下表）

process	allocation	need	available
	r1 r2 r3 r4	r1 r2 r3 r4	r1 r2 r3 r4
P0	0 0 3 2	0 0 1 2	1 6 2 2
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

request(i)是进程P(i)的请求向量。
request(i)[j] = n,表示进程P(i)需要n个r(j)类型的资源。
(1) 如果request(i)[j] <= need[i,j],便转向步骤2,否则出错；
(2) 如果request(i)[j] <= available[j],便转向步骤3，否则出错；
(3) 系统试探着把资源分配给进程P,并修改下面数据结构中的数值:
available[j] = avaliable[j] - request(i)[j];
allocation[i,j] = allocation[i,j] + request(i)[j];
need[i,j] = need[i,j] - request(i)[j];
(4) 检查此次资源分配后系统是否处于安全状态。安全则分配，否则分配作废

（1）该状态是否安全

进行安全性检查:

	work	need	allocation	work+allocation	finish
	r1 r2 r3 r4	r1 r2 r3 r4	r1 r2 r3 r4	r1 r2 r3 r4
P0	1 6 2 2	0 0 1 2	0 0 2 3	1 6 4 5	true
P3	1 6 4 5	0 6 5 2	0 3 3 2	1 9 7 7	true
P4	1 9 7 7	0 6 5 6	0 0 1 4	1 9 8 11	true
P1	1 9 8 11	1 7 5 0	1 0 0 0	2 9 8 11	true
P2	2 9 8 11	2 3 5 6	1 3 5 4	3 12 13 15	true

得到以下安全性序列（P0, P3, P4, P1, P2）,所以该状态安全。

（2）如果进程P2提出请求request2(1,2,2,2)后，系统能否将资源分配后给它

银行家算法步骤 :
Step1: request(1,2,2,2) <= need(2,3,5,6)，继续第二步，否则认为出错，因为它所需要的资源数已经超过它所宣布的最大值。
Step2: request(1,2,2,2) <= available(1,6,2,2)，继续第三步,否则表示尚无足够资源，Pi需要等待。
Step3: 系统试探着把资源分配给P2,并进行下面的修改:
avaliable[j] : (1,6,2,2) - (1,2,2,2) … = avaliable(0,4,0,0);
allocation[2,j] : (1,3,5,4) + (1,2,2,2) = allocation(2,5,7,6);
need[2,j] : (2,3,5,6) - (1,2,2,2) = need(1,1,3,4);
为P2分配资源后：

process	allocation	need	available
	r1 r2 r3 r4	r1 r2 r3 r4	r1 r2 r3 r4
P0	0 0 3 2	0 0 1 2	0 4 0 0
P1	1 0 0 0	1 7 5 0
P2	2 5 7 6	1 1 3 4
P3	0 3 3 2	0 6 5 2
P4	0 0 1 4	0 6 5 6

Step4: 进行安全检查：发现可用资源(0,4,0,0),不能满足任何一个进程的need的需要。所以系统进入不安全的状态，此时不进行系统资源的分配。

所以，系统不能将资源分配给它。

3、对于如下的页面访问序列：

1,2,3,4,1,2,5,1,2,3,4,5

当内存块数分别为3和4时，问：

（1）使用FIFO产生的缺页中断是多少

FIFO（发生缺页时的调入顺序即为淘汰顺序）

内存块数为3时

1、访问1，缺页，调入1，内存中为 1, , ;
2、访问2，缺页，调入2，内存中为 1,2, ;
3、访问3，缺页，调入3，内存中为 1,2,3;
4、访问4，缺页，调入4，内存中为 4,2,3;
5、访问1，缺页，调入1，内存中为 4,1,3;
6、访问2，缺页，调入2，内存中为 4,1,2;
7、访问5，缺页，调入5，内存中为 5,1,2;
8、访问1，不缺页，内存中为 5,1,2;
9、访问2，不缺页，内存中为 5,1,2;
10、访问3，缺页，调入3，内存中为 5,3,2;
11、访问4，缺页，调入4，内存中为 5,3,4;
12、访问5，不缺页，内存中为 5,3,4;
共9次缺页

内存块数为4时

1、访问1，缺页，调入1，内存中为 1, , , ;
2、访问2，缺页，调入2，内存中为 1,2, , ;
3、访问3，缺页，调入3，内存中为 1,2,3, ;
4、访问4，缺页，调入4，内存中为 1,2,3,4;
5、访问1，不缺页，内存中为 1,2,3,4;
6、访问2，不缺页，内存中为 1,2,3,4;
7、访问5，缺页，调入5，内存中为 5,2,3,4;
8、访问1，缺页，调入1，内存中为 5,1,3,4;
9、访问2，缺页，调入2，内存中为 5,1,2,4;
10、访问3，缺页，调入3，内存中为 5,1,2,3;
11、访问4，缺页，调入4，内存中为 4,1,2,3;
12、访问5，缺页，调入5，内存中为 4,5,2,3;
共10次缺页

（2）使用LRU置换算法产生的缺页中断是多少

LRU（通过栈来实现，新访问的放入栈底，每次淘汰栈顶）

内存块数为3时

1、访问1，缺页，调入1，内存中为 1, , ;
2、访问2，缺页，调入2，内存中为 1,2, ;
3、访问3，缺页，调入3，内存中为 1,2,3;
4、访问4，缺页，调入4，内存中为 2,3,4;
5、访问1，缺页，调入1，内存中为 3,4,1;
6、访问2，缺页，调入2，内存中为 4,1,2;
7、访问5，缺页，调入5，内存中为 1,2,5;
8、访问1，不缺页，内存中为 2,5,1;
9、访问2，不缺页，内存中为 5,1,2;
10、访问3，缺页，调入3，内存中为 1,2,3;
11、访问4，缺页，调入4，内存中为 2,3,4;
12、访问5，缺页，调入5，内存中为 3,4,5;
共10次缺页

内存块数为4时

1、访问1，缺页，调入1，内存中为 1, , , ;
2、访问2，缺页，调入2，内存中为 1,2, , ;
3、访问3，缺页，调入3，内存中为 1,2,3, ;
4、访问4，缺页，调入4，内存中为 1,2,3,4;
5、访问1，不缺页，内存中为 2,3,4,1;
6、访问2，不缺页，内存中为 3,4,1,2;
7、访问5，缺页，调入5，内存中为 4,1,2,5;
8、访问1，不缺页，内存中为 1,2,5,1;
9、访问2，不缺页，内存中为 2,5,1,2;
10、访问3，不缺页，内存中为 5,1,2,3;
11、访问4，缺页，调入4，内存中为 1,2,3,4;
12、访问5，缺页，调入5，内存中为 2,3,4,5;
共7次缺页