大学操作系统期末考试复习经典计算题快速回顾

操作系统期末考试复习经典计算题

1.银行家算法
2.计算周转时间
- 2.1 先来先服务（FCFS）
- 2.2 短作业优先调度算法（SJF）
- 2.3 优先级调度算法和高响应比优先调度算法
3.页面置换算法（虚拟存储器）
4.磁盘调度算法
5.存储器管理：基于顺序搜索的动态分区分配算法
6.存储器管理-分页存储方式：计算物理地址和有效访问时间（EAT）
7.存储器管理和进程调度，作业调度相结合
8.哲学家进餐

1.银行家算法

在银行家算法的例子中，如果出现下述资源分配情况，试问：
Process Allcation Need Available
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
（1）该状态是否安全？
（2）进程P2提出请求Request(1,2,2,2)后，系统是否能将资源分配给它？
解：（1）利用安全性算法，对上述资源进行分配后找到可分配序列，<P0,P3,P1,P2,P4>，所以是安全的
Process Work Allcation Need work(Work+Allocation) Finish
P0 1 6 2 2 0 0 3 2 0 0 1 2 1 6 5 4 true
P1 1 9 8 6 1 0 0 0 1 7 5 0 2 9 8 6 true
P2 2 9 8 6 1 3 5 4 2 3 5 6 3 12 13 10 true
P3 1 6 5 4 0 3 3 2 0 6 5 2 1 9 8 6 true
P4 3 12 13 10 0 0 1 4 0 6 5 6 3 12 14 14 true
(2)首先Request2(1,2,2,2)<=Need2;Request2(1,2,2,2)<=Available，于是假定系统对其进行资源分配
并修改Available、Allcation2、Need2向量，修改结果为Available(0,4,0,0),Allcation2(2,5,7,6),Need2(1,1,3,4)

Process      Work        Allcation       Need        work(Work+Allocation)  Finish
P0                      0 0 3 2         0 0 1 2
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

资源分配后对程序进行安全性检查，发现对于任意Needi<=Available(0,4,0,0)不成立。即Available不能满足任何进程的请求，系统进入不安全状态。所以不能分配!

2.计算周转时间

2.1 先来先服务（FCFS）

周转时间=完成时间-到达时间
带权周转时间=周转时间/服务时间

举例：在一个单道批处理系统中，有一组作业的提交时刻和运行时间如下
作业名 A B C D
提交时间 8.0 8.5 9.0 9.1
运行时间 1.0 0.5 0.2 0.1
采用先来先服务算法，请计算该组作业的平均周转时间和平均带权周转时间。

解：
作业名     A       B       C        D      平均
提交时间    8.0     8.5     9.0     9.1
开始时间    8.0     9.0     9.5     9.7
完成时间    9.0     9.5     9.7     9.8
周转时间    1.0     1.0     0.7     0.7     0.85
带权周转时间  1.0     2.0     3.5     7.0     3.375
所以，平均周转时间T=(1.0+1.0+0.7+0.7)/4=0.85
平均带权周转时间W=(1.0+2.0+3.5+7.0)/4=3.375

2.2 短作业优先调度算法（SJF）

注意与SPF短进程调度算法的差别

举例：在一个单道批处理系统中，有一组作业的提交时刻和运行时间如下表所示
作业名 A B C D
提交时间 8.0 8.5 9.0 9.1
运行时间 1.0 0.5 0.2 0.1
采用短作业优先的调度算法，请计算该组作业的平均周转时间和平均带权周转时间。

解：
作业名     A       B       C        D      平均
提交时间    8.0     8.5     9.0     9.1
开始时间    8.0     9.3     9.0     9.2
完成时间    9.0     9.8     9.2     9.3
周转时间    1.0     1.3     0.2     0.2     0.675
带权周转时间  1.0     2.6     1.0     2.0     1.65
所以，平均周转时间 T=(1.0+1.3+0.2+0.2)/4=0.675
平均带权周转时间    W=(1.0+2.6+1.0+2.0)/4=1.65

2.3 优先级调度算法和高响应比优先调度算法

优先权=（等待时间+要求服务时间）/要求服务的时间==相应时间/要求服务时间

举例：在一个单道批处理系统中，有一组作业的提交时刻和运行时间如下表所示
作业名 A B C D
提交时间 8.0 8.5 9.0 9.1
运行时间 1.0 0.5 0.2 0.1
采用采用作业响应比高优先的调度算法，请计算该组作业的平均周转时间和平均带权周转时间。

解：
9.0时，计算响应比：B的响应比=1+0.5/0.5=2C的响应比=1+0/0.2=1D没有到达(先执行B)
9.5时，计算响应比C的响应比 =1+0.5/0.2=3.5D的响应比=1+0.4/0.1=5(先执行D)作业名       A   B   C   D   平均
提交时间    8.0 8.5 9.0 9.1
开始时间    8.0 9.0 9.5 9.6
完成时间    9.0 9.5 9.6 9.8
周转时间    1.0 1.0 0.5 0.8 0.825
带权周转时间  1.0 2.0 5.0 4.0 3
所以，平均周转时间T=(1.0+1.0+0.5+0.8)/4=0.825
平均带权周转时间W=(1.0+2.0+5.0+4.0)/4=3

3.页面置换算法（虚拟存储器）

假定系统为某进程分配了三块物理页，并有以下页面：
7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1
Y表示缺页，N表示不缺页。（初始的三次千万记得要加！！）

OPT最佳置换算法：每次选择未来长时间不被访问的或者以后永不使用的页面进行淘汰。(虽好，但不可能实现)
页面走向 7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
物理块0 7 7 7 2 2 2 2 2 2 2 2 2 2 2 2 2 2 7 7 7
物理块1 0 0 0 0 0 0 4 4 4 0 0 0 0 0 0 0 0 0 0
物理块2 1 1 1 3 3 3 3 3 3 3 3 1 1 1 1 1 1 1
缺页 Y Y Y Y N Y N Y N N Y N N Y N N N Y N N
缺页次数 9
页面置换次数 6
缺页率 9/20
FIFO先进先出页面置换算法：把内存中最先进入的页面予以淘汰。

页面走向   7   0   1   2   0   3   0   4   2   3   0   3   2   1   2   0   1   7   0   1
物理块0    7   7   7   2   2   2   2   4   4   4   0   0   0   0   0   0   0   7   7   7
物理块1      0   0   0   0   3   3   3   2   2   2   2   2   1   1   1   1   1   0   0
物理块2          1   1   1   1   0   0   0   3   3   3   3   3   2   2   2   2   2   1
缺页       Y   Y   Y   Y   N   Y   Y   Y   Y   Y   Y   N   N   Y   Y   N   N   Y   Y   Y

缺页次数 15
页面置换次数 12
缺页率 15/20

LRU最久未使用页面置换算法：选择最近且最久未被使用的页面进行淘汰。

页面走向   7   0   1   2   0   3   0   4   2   3   0   3   2   1   2   0   1   7   0   1
物理块0    7   7   7   2   2   2   2   4   4   4   0   0   0   1   1   1   1   1   1   1
物理块1        0   0   0   0   0   0   0   0   3   3   3   3   3   3   0   0   0   0   0
物理块2            1   1   1   3   3   3   2   2   2   2   2   2   2   2   2   7   7   7
缺页       Y   Y   Y   Y   N   Y   N   Y   Y   Y   Y   N   N   Y   N   Y   N   Y   N   N

缺页次数 12
页面置换次数 9
缺页率 12/20

4.磁盘调度算法

假定某磁盘共有200个柱面，编号为0-199，如果在为访问100号柱面的请求者服务后，同时有若干请求者在等待服务，它们每次要访问的柱面号为 55，58，39，18，90，160，150，38，184。求总寻道长度和平均寻道长度。总长=每次寻道距离之和，平均寻道长度=总长/移动次数。

先来先服务算法（FCFS）：根据进程请求访问磁盘的先后次序进行调度。

最短寻道时间优先算法（SSTF）：其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短

FCFS                             SSTF
(从100号磁道开始)                     (从100号磁道开始)
被访问的下一个磁道号 移动距离(磁道数)    被访问的下一个磁道号 移动距离(磁道数)
55                45                90                10
58                3                 58                32
39                19                55                3
18                21                39                16
90                72                38                1
160               70                18                20
150               10                150               132
38                112               160               10
184               146               184               24平均寻道长度：55.3                  平均寻道：27.5
总结：移动距离(磁道数)=先前磁道号-本次磁道号

循环扫描算法（FSCAN）：循环扫描算法规定磁头单向移动。例如，只自里向外移动，当磁头移到最外的被访问磁道时，磁头立即返回到最里的欲访磁道，即将最小磁道号紧接着最大磁道号构成循环，进行扫描

扫描算法（SCAN）：扫描算法不仅考虑到欲访问的磁道与当前磁道的距离，更优先考虑的是磁头的当前移动方向。例如，当磁头正在自里向外移动时，扫描算法所选择的下一个访问对象应是其欲访问的磁道既在当前磁道之外，又是距离最近的。这样自里向外地访问，直到再无更外的磁道需要访问才将磁臂换向，自外向里移动。

FSCAN                                        SCAN
(从100号磁道开始,向磁道号增加方向访问)          (从100号磁道开始,向磁道号增加方向访问)
被访问的下一个磁道号 移动距离(磁道数)            被访问的下一个磁道号 移动距离(磁道数)
150                 50                      150                 50
160                 10                      160                 10
184                 24                      184                 24
18                  166                     90                  94
38                  20                      58                  32
39                  1                       55                  3
55                  16                      39                  16
58                  3                       38                  1
90                  32                      18                  20
平均寻道长度：35.8                          平均寻道：27.8

5.存储器管理：基于顺序搜索的动态分区分配算法

首先（最先）适应算法（FF）：
要求空闲分区按首址递增的次序组织空闲分区表（队列）。每次分配和回收后空闲分区表或空闲分区队列都要按首址递增的次序排序。

循环首次适应算法（next fit，NF）：
按分区的先后次序，从上次分配的分区起查找（到最后分区时再回到开头），找到符合要求的第一个分区。

最佳适应算法（best fit，BF）：
要求按空闲区大小递增的次序组成空闲分区表（队列）。分配和回收后要对空闲区表(队列)重新排序。

最坏适应算法（worst fit，WF）：
要求空闲区按大小递减的顺序组织空闲区表（或队列）。

另一种解释：
1.首次适应算法（First Fit）
算法思想：将空闲分区链以地址递增的顺序连接；在进行内存分配时，从链首开始顺序查找，直到找到一块分区的大小可以满足需求时，按照该作业的大小，从该分区中分配出内存，将剩下的空闲分区仍然链在空闲分区链中。
优点：高址部分的大的空闲分区得到保留，为大作业的内存分配创造了条件；
缺点：（1）每次都是优先利用低址部分的空闲分区，造成低址部分产生大量的外碎片。
（2）每次都是从低址部分查找，使得查找空闲分区的开销增大；

2.循环首次适应算法（Next Fit）
算法：分配内存时不是从链首进行查找可以分配内存的空闲分区，而是从上一次分配内存的空闲分区的下一个分区开始查找，直到找到可以为该进程分配内存的空闲分区；
优点：（1）使得空闲分区分布更加均匀；
（2）空闲分区的查找开销小；
缺点：高址部分的大空闲分区被分小，使得大作业进入无法分配内存；

3.最佳适应算法（Best Fit）
算法：将空闲分区链中的空闲分区按照空闲分区由小到大的顺序排序，从而形成空闲分区链。每次从链首进行查找合适的空闲分区为作业分配内存，这样每次找到的空闲分区是和作业大小最接近的，所谓“最佳”。
优点：第一次找到的空闲分区是大小最接近待分配内存作业大小的；
缺点:产生大量难以利用的外部碎片。

4.最坏适应算法（Worst Fit）
算法：与最佳适应算法刚好相反，将空闲分区链的分区按照从大到小的顺序排序形成空闲分区链，每次查找时只要看第一个空闲分区是否满足即可。
优点：效率高，分区查找方便；
缺点：当小作业把大空闲分区分小了，那么，大作业就找不到合适的空闲分区。

例题：
某操作系统采用可变分区分配存储管理方法，用户区为512K且始址为0。若分配采用分配空闲区低地址部分的方案，对下述申请序列：
申请310K，申请100K，释放310K，申请150K，申请40K，申请30K。
分别采用首次适应算法、最佳适应算法，回答下列问题：
（1）给出每一步的已分配空间、空闲分区（给出始址，大小）？
（2）若再申请120K，还能分配这120K存储空间吗？
答：
首次适应算法：

操作：	已分配空间	空闲块
初始	无	（0，512K）
申请310K	（0，310K）	（310K，202K）
申请100K	（0，310K）（310K，100K）	（410K，102K）
释放310K	（310K，100K）	（0，310K）（410K，102K）
申请150K	（0，150K）（310K，100K）	（150K，160K）（410K，102K）
申请40K	（0，150K）（150K，40K）（310K，100K）	（190K，120K）（410K，102K）
申请30K	（0，150K）（150K，40K）（190K，30K）（310K，100K）	（220K，90K）（410K，102K）

如再申请空间120K空间，由上述结果可知，采用首次适应算法后剩下的空闲分区没有大于120K的空闲空间，不能满足这一申请要求。

最佳适应算法：

操作：	已分配空间	空闲块
初始	无	（0，512K）
申请310K	（0，310K）	（310K，202K）
申请100K	（0，310K）（310K，100K）	（410K，102K）
释放310K	（310K，100K）	（0，310K）（410K，102K）
申请150K	（0，150K）（310K，100K）	（150K，160K）（410K，102K）
申请40K	（0，150K）（310K，100K）（410K，40K）	（150K，160K）（450K，62K）
申请30K	（0，150K）（310K，100K）（410K，40K）（450K，30K）	（150K，160K）（480K，32K）

如再申请空间120K空间，由上述结果可知，采用最佳适应算法后剩下的空闲分区有大于120K的空闲空间（空闲块（150K,160K）），能满足这一申请要求。

6.存储器管理-分页存储方式：计算物理地址和有效访问时间（EAT）

计算物理地址：
在采用页式存储管理的系统中，某进程的逻辑地址空间为4页（每页2048字节）。已知该进程的页面映像表（页表）如下，计算有效逻辑地址4865所对应的物理地址。
页号：0 1 2 3
块号：2 4 6 8

地址转换：绝对地址=块号*块长+块内地址

求页号：d=4865/2048=2…769(2为页号，769为块内地址)
对页表：即块号为6
计算物理地址：6*2048+769=13057

计算有效访问时间（EAT）：
EAT=（1-p）内存访问时间+p平均页面错误服务时间
注：p是页面错误率，命中率为1-p

案例：有一个将页表存放在内存中的一级页表的分页系统，下面两种情况下，请计算有效访问时间分别是多少。

1.系统中没有快表，访问一次内存需要0.2us；
2.系统中有快表，快表命中率为90%，假定查快表花费的时间为λ，访问一次内存仍需0.2us。

分析：一级页表，访问内存中的一个数据需要两次访问内存，第一次是查页表找地址，第二次是根据地址找数据。
这个题目很简单：
对于问题1，如果页面在内存中，那么时间就是0.2+0.2=0.4us
对于问题2，如果页面在内存中，并且快表有记录，那么时间就是λ+0.2（查快表λ+找数据），如果快表没有记录，那么时间就是λ+0.2+λ+0.2（找快表λ+找页表+更新快表λ+找数据）；此时再根据百分比计算就好了。

数据在内存中，怎么都好说，就怕数据不再内存中，就麻烦了。因为数据不再内存中就得到外存去找，这时就要发生中断，假设中断的处理时间是τ，那么这是查找一次数据的时间是多少呢？先看看流程：
先查快表不中λ，再查页表不中0.2，发生中断τ（把数据存入了内存），更新页表0.2，更新快表λ,查找数据0.2，

此时总的时间是：λ+0.2+τ+0.2+λ+0.2。

7.存储器管理和进程调度，作业调度相结合

举例：有一多道程序设计系统，采用不允许移动的可变分区方式管理主存的用户空间，设用户空间为100K,采用最先适用分配算法分配主存，作业调度和进程调度均采用先来先服务算法，今有如下作业序列：
注意:不允许移动的意思是空闲的分区不能合并，即20K和20K两个存储空间不能装一个25K主存量的作业，然后最先适用是指空闲分区每次分配后都按照地址递增的顺序，从头开始寻找。

作业名	进入系统时间	需执行时间	主存量需求
A	10.1h	0.3h	15K
B	10.3h	0.2h	60K
C	10.5h	0.4h	50K
D	10.6h	0.4h	10K
E	10.7h	0.2h	20K

假设所有的作业都是计算型作业且忽略系统调度时间，请回答：
（1）作业被装入主存的次序为 ____________(答案：ABDEC)
（2）把每个作业装入主存的时间填入下表：
作业名 A B C D E
装入时间 10.1h 10.3h 10.9h 10.6h 10.7h 咳，这答案错的！！！
没错！是说装入时间！然后装入时间会影响执行顺序！

注：同类题!注意题目要求就好

8.哲学家进餐

五个哲学家共用一张圆桌，分别坐在周围的五张椅子上，在桌子上有五只碗和五只筷子，他们的生活方式是交替地进行思考和进餐。平时，一个哲学家进行思考，饥饿时便试图取用其左右最靠近他的筷子，只有在他拿到两只筷子时才能进餐。进餐毕，放下筷子继续思考。

为避免死锁，可以使用以下三种策略：
策略一：至多只允许四个哲学家同时进餐，以保证至少有一个哲学家能够进餐，最终总会释放出他所使用过的两支筷子，从而可使更多的哲学家进餐。定义信号量count，只允许4个哲学家同时进餐，这样就能保证至少有一个哲学家可以就餐。
策略二：仅当哲学家的左右两支筷子都可用时，才允许他拿起筷子进餐。可以利用AND 型信号量机制实现，也可以利用信号量的保护机制实现。利用信号量的保护机制实现的思想是通过记录型信号量mutex对取左侧和右侧筷子的操作进行保护，使之成为一个原子操作，这样可以防止死锁的出现。通过记录型或AND型信号量实现。
策略三：规定奇数号的哲学家先拿起他左边的筷子，然后再去拿他右边的筷子；而偶数号的哲学家则先拿起他右边的筷子，然后再去拿他左边的筷子。按此规定，将是1、2号哲学家竞争1号筷子，3、4号哲学家竞争3号筷子。即五个哲学家都竞争奇数号筷子，获得后，再去竞争偶数号筷子，最后总会有一个哲学家能获得两支筷子而进餐。

补充：1.想给大家分享我整理好的txt版本，可是不知如何链接到本地，若有大能，欢迎评论；
2.本文档使用chrome浏览器观看更好