SCAU期末笔记 - 操作系统 简答与计算题

一些简答和计算题的整理 主要以19和20年的为基础
括号里面年份打星代表题目不一样但是只改了数据
来吧 笔记第二篇 期末必刷题 启动！

进程状态分析题（5年4考）

例1（2020年、2017年*）

题面

画出进程的五状态转换模型，包括各状态间的转换方向和转换原因。

答案

课本原图画出来就行了，放在这里主要是方便下一题的解释

例2（2019年）

题面

假设在时刻3时，系统资源只有处理器和内存被使用，然后发生如下事件：

• 时刻6：P1执行“写磁盘”操作。
• 时刻15：P2执行“读磁盘”操作。
• 时刻23：P3时间片结束。
• 时刻28：P1“写磁盘”完成，产生中断。
• 时刻32：P4时间片结束。

请分别写出在时刻20和时刻30时，进程P1、P2、P3是什么状态。

解析

按时间一步一步来

答案

时刻20：P1阻塞态，P2阻塞态，P3运行态。
时刻30：P1就绪态，P2阻塞态，P3就绪态。

例3（2020年、2017年）

题面

设作业A、B、C的优先级递减，可抢占CPU但不能抢占I/O设备。运行轨迹如下：
A：CPU 20ms, I/O 30ms, CPU 10ms
B：CPU 40ms, I/O 20ms, CPU 10ms
C：CPU 10ms, I/O 30ms, CPU 20ms
求多道并发运行时的CPU利用率。

解析

那么按照上面说的把这个时间串盘明白了，现在就可以算CPU的利用率了，是从A进来到最后C跑完的总时间分之上面的CPU实际干了活的时间

答案

先把上面那个图画一遍，CPU利用率＝110/140＝78.6％

例4（课本习题）

题面

假设在时间5时，系统资源只有处理器和内存被使用，后续有如下事件：

• 时间5：P1执行对磁盘单元3的读操作。
• 时间15：P5的时间片结束。
• 时间18：P7执行对磁盘单元3的写操作。
• 时间20：P3执行对磁盘单元2的读操作。
• 时间24：P5执行对磁盘单元3的写操作。
• 时间28：P5被换出。
• 时间33：P3读磁盘单元2操作完成，产生中断。
• 时间36：P1读磁盘单元3操作完成，产生中断。
• 时间38：P8结束。
• 时间40：P5写磁盘单元3操作完成，产生中断。
• 时间44：P5被调入。
• 时间48：P7写磁盘单元3操作完成，产生中断。

需分别写出时间22、37和47时每个进程（P1、P3、P5、P7、P8 ）的状态。

解析

答案

22：P1阻塞态，P3阻塞态，P5就绪态，P7阻塞态，P8运行态
37：P1就绪态，P3就绪态，P5阻塞态，P7阻塞态，P8运行态
37：P1就绪态，P3就绪态，P5就绪态，P7阻塞态，P8完成态

页式存储计算（5年3考）

例1（2019年、2018年）

题面

在采用页式存储管理的系统中，若逻辑地址用 48 位表示，其中 32 位表示页号。画出逻辑地址的结构，并计算每页的最大长度及一个进程的逻辑地址空间的最大长度。

解析

逻辑地址的结构就是很朴实地吧两个东西一拼接就行了

32b页号	16b页内地址

顾名思义，这个页号相当于一个索引嘛，所以他肯定是存不了实际东西的，所以这个页的最大长度就是那个16b页内地址，那么最大长度就是整个的也就是加起来的48b

答案

逻辑地址结构：

32b页号	16b页内地址

每页最大长度：$2^{16}\text{B}=64\text{KB}$
程序地址空间最大长度：$2^{48}\text{B}=256\text{TB}$

例2（2016年）

题面

在简单分页存储管理中，逻辑地址为32位，其中18位表示页号，则允许的页面大小是____字节。

答案

页内地址为$32-18=14$位，所以允许的页面大小是$2^{14}\text{B}$

计算寻道时间（5年5考）

例1（2019年、2016年）

题面

假设磁头当前位置为40柱面，现有一个磁盘读写请求队列：20、44、40、4、80、12、76。若寻道时移动一个柱面需3ms，按最短寻道时间优先SSTF算法计算所需的寻道时间总量。

解析

最短寻道时间是什么意思呢？就是每次我都找队列里离我最近的过去，那么按照这个逻辑，我们就来盘一盘

步骤	当前磁头位置	待处理请求队列	选择的最近请求	移动距离
1	40	20、44、40、4、80、12、76	40（当前位置）	0
2	40	20、44、4、80、12、76	44（距离4）	4
3	44	20、4、80、12、76	20（距离24）	24
4	20	4、80、12、76	12（距离8）	8
5	12	4、80、76	4（距离8）	8
6	4	80、76	76（距离72）	72
7	76	80	80（距离4）	4

那么最后的总移动距离也很好算，就是全部加起来，最后再乘上单个移动的时间3ms就是时间总量了

答案

SSTF 调度顺序：40、44、20、12、4、76、80。移动总量（4+24+8+8+72+4)=120，总寻道时间=120*3ms=360ms。

例2（2020年、2017年*、2018年*）

题面

假设磁头当前位置为20柱面，现有一个磁盘读写请求队列：10、22、20、2、40、6、38。若寻道时移动一个柱面需3ms，按电梯算法（磁头正向磁道号增大方向移动）计算所需的寻道时间总量。

解析

电梯算法顾名思义就是像电梯一样，先往一个方向走到底，再回来，那么这道题题目告诉我磁头正向磁道号增大方向移动，意思就是我从20这个位置线往大了走，走到最大的40，再回来走到最小的，那么移动距离就很好算了，最后的这个总寻道时间和上面一题算法一致

答案

电梯调度顺序：20、22、38、40、10、6、2。移动总量（2+16+2+30+4+4)=58，总寻道时间=58*3ms=174ms。

例3

题面

假设磁头当前位置为 30 柱面，磁盘柱面范围是 0~100，请求队列如下：10、50、90、35、15、80、60。磁头初始向柱面号增大方向移动，寻道移动一个柱面需 2ms。按 C-SCAN 算法计算总寻道时间。

解析

SCAN就是我们刚才讲的电梯算法，C-SCAN的C指的是循环，就是说我们从30走到最大的90，然后一路跳回0（这里不算时间），再从0总到15

答案

有效寻道距离：正向处理距离 + 重新正向处理距离 = 60+15=75 柱面
总寻道时间：75×2ms=150ms

银行家算法（5年4考）

例1（2019年、2017年*、2018年*）

题面

有A,B,C,D 共4种资源，在某时刻P0~P4对资源的占有和需求情况如下表。

问：1）系统此时处于安全状态吗？若是，给出安全序列；若不是，说明原因。
2）若此时P1发出request(1,2,2,2)，系统能满足其请求吗？为什么？

解析

埃及吧怎么是dp，沟槽的dp还在追我
首先是第一问，安全序列我们得找，首先我们要算一下每个进程还需要的资源量，顾名思义就是最大需求-已分配，然后我们每一轮选择need的每一项都比available小的加入序列，在完成这个进程之后他的allocation和need就全部都还给available，所以现在available变大了，再继续找，以此类推，如果在某一时刻找不到了那就说明没有安全序列
第二问就很简单了，我们刚才已经算了每个进程的need，那么只要request的每一项都小于need那就可以，不然就不可以，原因说点套话就行

第一问

先算need

进程	Need（A,B,C,D）
P0	0,0,1,2
P1	1,7,5,0
P2	2,3,5,6
P3	0,6,5,2
P4	0,6,5,6

1. 第一轮筛选：
   检查各进程 Need 是否 ≤ 当前 Available [1,6,2,2]：

   • P0：Need [0,0,1,2] ≤ [1,6,2,2] → 可执行。
   • P1：Need [1,7,5,0] 中 B 资源 7 > 可用 6 → 不可行。
   • P2：Need [2,3,5,6] 中 A 资源 2 > 可用 1 → 不可行。
   • P3：Need [0,6,5,2] 中 C 资源 5 > 可用 2 → 不可行。
   • P4：Need [0,6,5,6] 中 C、D 资源 5、6 > 可用 2、2 → 不可行。

   选 P0 执行，完成后回收其 Allocation [0,0,3,2]，新可用资源：
   Available = [1+0, 6+0, 2+3, 2+2] = [1,6,5,4]

2. 第二轮筛选：
   可用资源 [1,6,5,4]，检查剩余进程（P1~P4）的 Need：

   • P1：Need [1,7,5,0] 中 B 资源 7 > 6 → 不可行。
   • P2：Need [2,3,5,6] 中 A 资源 2 > 1 → 不可行。
   • P3：Need [0,6,5,2] ≤ [1,6,5,4] → 可执行。
   • P4：Need [0,6,5,6] 中 D 资源 6 > 4 → 不可行。

   选 P3 执行，回收其 Allocation [0,3,3,2]，新可用资源：
   Available = [1+0, 6+3, 5+3, 4+2] = [1,9,8,6]

3. 第三轮筛选：
   可用资源 [1,9,8,6]，检查剩余进程（P1、P2、P4）的 Need：

   • P1：Need [1,7,5,0] ≤ [1,9,8,6] → 可执行。
   • P2：Need [2,3,5,6] ≤ [1,9,8,6]？A 资源 2 > 1 → 不可行。
   • P4：Need [0,6,5,6] ≤ [1,9,8,6] → 可执行。

   这里题目答案选 P4（按安全序列逻辑，选 P4 也满足条件，最终序列需覆盖所有进程）：
   选 P4 执行，回收其 Allocation [0,0,1,4]，新可用资源：
   Available = [1+0, 9+0, 8+1, 6+4] = [1,9,9,10]

4. 第四轮筛选：
   可用资源 [1,9,9,10]，剩余进程 P1、P2：

   • P1：Need [1,7,5,0] ≤ [1,9,9,10] → 可执行。
     执行后回收 Allocation [1,0,0,0]，可用资源：
     Available = [1+1, 9+0, 9+0, 10+0] = [2,9,9,10]

   • P2：Need [2,3,5,6] ≤ [2,9,9,10] → 可执行。
     执行后回收 Allocation [1,3,5,4]，可用资源：
     Available = [2+1, 9+3, 9+5, 10+4] = [3,12,14,14]

5. 安全序列验证：
   按执行顺序 P0 → P3 → P4 → P1 → P2，所有进程都能顺利完成，因此系统处于安全状态，安全序列为 <P0, P3, P4, P1, P2>。

第二问

小于所以无法满足

例2（2016年）

题面

设系统中有5个进程（P1、P2、P3、P4、P5）和4种资源（A、B、C、D），资源数量
为：A—3个，B—12个，C—14个，D—14个。在T0时刻系统状态如下表。（共9分）
（1）计算系统可用资源向量Available和需求矩阵。（4分）
（2）T0时刻是否为安全状态？若是，请给出一个安全序列。（3分）
（3）若T0时刻进程P3请求资源（1，2，2，2），是否允许该请求？为什么？（2分）

解析

主要的区别就是那个第一小问嘛，需求矩阵就是我们上文说的need，那available就是用题目给的那个总abcd减去所有的已分配的和，算出来之后结果和刚才的例1是完全一致的

死锁分析（5年2考）

例（2019年、2018年）

题面

系统资源分配图如下，请问现在是否已处于死锁状态，如果是，撤消哪个进程可以使系统代价最小地从死锁中恢复。

解析

判断这个图有没有死锁就是一个不断化简的过程，看有没有进程能够满足指向的CPU都有剩余的资源能给他，能的话就把他和他所有边全部删掉，如果没法全部删干净那就说明是死锁
删除的时候要让剥夺的资源最少就要尽量删除入度小的进程

答案

已处于死锁状态。撤消P1代价最小，因为剥夺的资源最少。

计算缺页次数（5年4考）

例（2019年、2018年、2017年*、2016年*）

题面

在一个请求分页系统中，假定系统分配给一个进程的物理帧数为3，所有帧初始均为空。此进程的页面访问顺序为4、3、2、1、4、3、5、4、3、2、1、5。试用OPT和LRU页面置换算法给出页面置换情况，并计算所发生的缺页总次数。

解析

首先我们要知道物理帧数是什么，就是说我的内存可以存多少东西，我现在要去电脑里面找一个东西，因为去内存找的开销会小很多，所以我们可以在这个内存存三个东西，如果找某个东西的时候他在内存里面那感情好，不然的话就叫一次缺页

OPT（最佳置换算法）

首先OPT是一种理想化的算法，假设我可以提前预支我所有的访问顺序，以最优的策略放东西进内存
具体怎么样的策略是最优呢，讲究一个最远不用策略，首先我如果内存没满肯定是闭着眼塞进去，那么如果内存有东西就要考虑换下去一个，换拿个就看从这里开始后续的查询顺序中谁是最晚出现的，谁最晚出现就不要谁

步骤（页面走向）	帧1	帧2	帧3	缺页标记	淘汰逻辑（若需置换）
4	4	-	-	缺	初始为空，装入4
3	4	3	-	缺	装入3
2	4	3	2	缺	装入2
1	4	3	1	缺	装入1（帧满，需置换：看未来，2 最远不用）
4	4	3	1	不缺	已在帧1
3	4	3	1	不缺	已在帧2
5	4	3	5	缺	帧满，置换：看未来，1 最远不用（后续访问在 11 步）
4	4	3	5	不缺	已在帧1
3	4	3	5	不缺	已在帧2
2	4	3	2	缺	帧满，置换：看未来，5 最远不用（后续访问在 12 步）
1	4	3	1	缺	帧满，置换：看未来，2 最远不用（后续无 2 访问）
5	4	3	5	不缺	已在帧3（第7步装入）

LRU（最近最久未使用）

但是这种预知未来发生的事情的算法现实中肯定很难遇到嘛，所以我们就有LRU这种以过去的经验来告诉我应该往里面存什么的算法
我们的逻辑就是淘汰最久未用的数据

步骤（页面走向）	帧1	帧2	帧3	缺页标记	淘汰逻辑（核心：淘汰最近最久未用的页，通过“访问队列”判断）
4	4	-	-	缺	空帧，直接装入 4
3	4	3	-	缺	空帧，直接装入 3
2	4	3	2	缺	空帧，直接装入 2
1	1	3	2	缺	帧满，淘汰最久未用的 4（访问队列：[2,3,4] → 队尾是 4）
4	1	4	2	缺	帧满，淘汰最久未用的 3（访问队列：[1,2,3] → 队尾是 3）
3	1	4	3	缺	帧满，淘汰最久未用的 2（访问队列：[4,1,2] → 队尾是 2）
5	5	4	3	缺	帧满，淘汰最久未用的 1（访问队列：[3,4,1] → 队尾是 1）
4	5	4	3	不缺	命中（帧 2 有 4），更新 4 为“最近使用”
3	5	4	3	不缺	命中（帧 3 有 3），更新 3 为“最近使用”
2	2	4	3	缺	帧满，淘汰最久未用的 5（访问队列：[3,4,5] → 队尾是 5）
1	2	1	3	缺	帧满，淘汰最久未用的 4（访问队列：[2,3,4] → 队尾是 4）
5	2	1	5	缺	帧满，淘汰最久未用的 3（访问队列：[1,2,3] → 队尾是 3）

答案

OPT 算法（缺页次数：7）

页面走向	4	3	2	1	4	3	5	4	3	2	1	5
帧 1	4	4	4	4	4	4	4	4	4	2	2	2
帧 2		3	3	3	3	3	3	3	3	3	1	1
帧 3			2	1	1	1	5	5	5	5	5	5
缺页	缺	缺	缺	缺	不缺	不缺	缺	不缺	不缺	缺	缺	不缺

LRU 算法（缺页次数：10）

页面走向	4	3	2	1	4	3	5	4	3	2	1	5
帧 1	4	4	4	1	4	4	5	4	4	2	2	2
帧 2		3	3	3	3	3	4	5	5	4	1	1
帧 3			2	2	2	2	3	3	3	3	3	5
缺页	缺	缺	缺	缺	缺	缺	缺	不缺	不缺	缺	缺	缺

计算CPU周转时间（5年5考）

例1（2019年、2017年、2016年）

题面

5个作业A～E同时到达一个单CPU系统，且以A～E的顺序进入就绪队列。估计运行时间分别为10，6，2，4和8分钟，优先级分别为3，5，2，1和4（其中5为最高优先级）。假设它们都是纯计算型作业，系统开销时间忽略不计。对下面的调度算法，计算平均周转时间。
1）优先级调度。
2）短作业优先。
3）时间片为1分钟的轮转法。

解析

首先朋友们，我们要只到平均周转时间是啥，那首先就要知道周转时间是啥，周转时间是每个作业进入系统到跑完所花的时间，中间等别人跑的时间也要算进去。那平均周转时间就很好理解了，大家伙把周转时间凑一块去个平均值

优先级调度

优先级调度顾名思义就是谁优先级高谁先跑，在这里也就是BEACD，周转时间分别是6，14，24，26，30

短作业优先

这个也很好理解嘛，谁花时间少谁先跑，在这里也就是CDBEA，周转时间分别是2，6，12，20，30

时间片为1分钟的轮转法

其实也不难理解，就是大伙轮流来，谁先进谁先跑，但是你不准跑完，跑1分钟就给你的下一位再跑1分钟，跑完你就不参与循环，大概就是这么个过程

int a[5]={10,6,2,4,8},ans[5];
int tme=0;
while(sumOf(a)>0){
    for(int i=0;i<5;i++){
        if(a[i] == 0) continue;
        tme++;
        a[i]--;
        if(a[i]==0) ans[i] = tme;
    }
}

答案

1. 优先级调度：调度顺序BEACD，平均周转时间=20分钟。
2. 短作业优先：调度顺序CDBEA，平均周转时间=14分钟。
3. 时间片为1分钟的轮转法：周转时间C-8，D-17，B-23，E-28，A-30。平均周转时间=21.2分钟。

例2（2020年）

题面

五个进程 A～E 的提交时刻和预计运行时间 Ts 如下。对于最短进程优先调度算法，填写下表，确定每个进程的周转时间、归一化周转时间 Tr/Ts、及所有进程的平均值。

进程	提交时刻	服务时间 Ts	开始时刻	结束时刻	周转时间 Tr	Tr/Ts
A	0	5
B	4	5
C	6	6
D	6	2
E	10	4
平均值	-	-	-	-

解析

这一题在上一题的基础上需要补充的是一个什么点呢？就是说你会发现这几个进程并不是同时进来的，但是假如后来进来了一个运行时间更短的，会不会顶掉呢？答案是不会（默认是非抢占式），他会加入队列，等上面正在跑的跑完，再判断谁优先级最高，谁最高谁去跑
还有就是表格里面的周转时间Tr是啥，就是他进来到他开始运行的时间。后面的Tr/Ts就是相除，不解释了就。

答案

例3（2018年）

题面

有一个三道批处理系统，作业调度采用“短作业优先调度算法”，进程调度采用“以优先数为基础的抢占式调度算法”。在下表所示的作业序列中，进程优先数越小则优先级越高。

作业名	到达时刻	预计运行时间（分钟）	进程优先数
A	10:00	40	5
B	10:20	30	3
C	10:30	60	4
D	10:50	20	6
E	11:00	20	4
F	11:10	10	4

需填充下表并计算平均带权时间（7 分）：

作业名	进入主存时刻	运行结束时刻	作业周转时间（分钟）
A
B
C
D
E
F

解析

这里又引入一个概念，就是抢占式或者非抢占式，上一题我们说的一个新的进程进来就算优先级比现在跑的那个还要高也得等正在跑的那个跑完就是非抢占式，不说的话就是默认非抢占式。那抢占式顾名思义就是假如新来的优先级比之前的高，我可以把他换下来

答案

作业名	进入主存时刻	运行结束时刻	作业周转时间（分钟）
A	10:00	12:40	160
B	10:20	10:50	30
C	10:30	11:50	80
D	10:50	13:00	130
E	12:00	12:20	80
F	11:50	12:00	50

平均带权周转时间＝(160/40+30/30+80/60+130/20+80/20+50/10)/6=3.64

动态分区问题（5年3考）

例1（2020年/2016年）

题面

某系统采用动态分区内存管理技术。设操作系统在低地址占用了100KB空间，用户空间从100KB至612KB，初始时用户空间全部为空闲，分配时截取空闲分区的低地址部分作为已分配区。若采用最佳适配算法，执行以下申请释放操作序列：请求300KB；请求100KB；释放300KB；请求150KB；请求50KB；请求90KB。画出内存分布图，并指出空闲分区的首地址和大小。

解析

最佳适配算法是啥意思呢？就是每次请求一段空间的时候，我在所有的空闲块里面找大于他且最小的一块把他放进去，按照这个逻辑我们就可以愉快地解题了（刚好借一下下面那题的图）

最后答案只需要画最下面那一行就行了

答案

空闲区有2块：块1（首地址340KB，大小60KB），块2（首地址550KB，大小62KB）。

例2（2017年）

题面

使用伙伴系统分配一个512KB的内存块。下表左侧为请求分配的空间长度和要释放哪块空间，在下表中每一行中画出分配和回收后的内存状况。

解析

上面一题是最佳适配算法，这一题是伙伴系统，其实要复杂不少，我们是把原本的大块不断二分到能装下我的最小的一块，然后把这一整块都给我

答案

逻辑地址转化（5年2考）

例1（2019年）

题面

在一页式存储管理系统中，某作业页表如下。已知页面大小为 1024 字节，问逻辑地址 1068、2566、5699 所对应的物理地址各是多少？如果需要置换一页，应该选择哪一页？置换后所对应的物理地址是多少？

页号	帧号	有效位	访问位	修改位
0	8	1	1	0
1	3	1	1	1
2		0	0	0
3	1	1	0	0
4		0	0	0
5	2	1	0	1

解析

首先一页是1024字节，那么以5699为例，他就位于$5699/1024$向下取整也就是第5页，转换回物理地址，我们就查表，发现是第2帧，那么物理地址就是$1024\times 2+5699\%1024=2627$
聪明的你一定会发现，诶那我这个2566找不到怎么办嘞，我们就要看后面的其他内容了，特别是访问位，我们在上一种题型只到我们内存优先替换的是最久没遇到的，而访问位=1表示该页最近被访问过，访问位=0表示最近未被访问，所以我优先把这个东西跟第3页或者第5页置换（要求有帧号这是肯定的），然后再看修改位，修改位什么意思呢？就是说这一页放过东西没，那3没放过东西，肯定优先置换到空的，放不下我再考虑放5啊。所以这里置换到帧号为1，就按1算就行了

答案

1. 逻辑地址1068：位于1⁣⁣#页，页内偏移44，物理地址计算为3×1024 + 44 = 3116。
2. 逻辑地址2566：位于2⁣⁣#页，页内偏移518，因该页不在内存产生缺页中断，置换时选3⁣⁣#页，置换后物理地址为1×1024 + 518 = 1542。
3. 逻辑地址5699：位于5⁣⁣#页，页内偏移579，物理地址计算为2×1024 + 579 = 2627 。

例2（2016年）

题面

在某分页管理系统中，页框大小为1KB。某个作业有4个页面，被分别装入到内存的第3、4、6、8页框中，设现执行一条指令 mov 2200, 4200，求该指令中逻辑地址为2200和4200的两个操作数所对应的物理地址。

解析

和刚才一样，2200先除一个1024（也就是1KB）也就是2，但是注意页面的下标是从0开始的，或者应该理解为说是它已经是第二个页面后面了所以是第三个页面，所以代入6计算；同理，4200的页号为4，也就是第五个页面，但是一共就四个所以这个地址不合法

答案

逻辑页（0,1,2,3）对应页框（3,4,6,8），页长1KB。
逻辑地址 2200，页号=2，页内偏移量=152，对应页框号=6，物理地址=6*1024+152=6296。
逻辑地址4200，页号=4，页内偏移量=104，越界，地址错误。

代码题

代码题其实就是semWait还有semSignal啥的嘛

例1（2017年、2018年*、2020年*）

题面

写出信号量的结构定义，semWait原语和semSignal原语的伪代码定义。

解析

理解的话就是说你定义了一个类似与锁的struct来锁住文件，我需要存的是现在还有多少进程在等着用和这些进程都是谁，然后这个计数用的是负数方便我判断，就是说小于0说明现在有人在用了用不了了

答案

信号量的结构定义：
struct semaphore{
    int count;
    queueType queue;
};

semWait原语：
semWait(semaphore s){
    s.count--;
    if(s.count<0){
        将当前进程放入s.queue;
        阻塞当前进程;
    }
}

semSignal原语：
semSignal(semaphore s){
    s.count++;
    if(s.count<=0){
        从s.queue中移除进程P；
        将进程P插入就绪队列;
    }
}

例2（2020年）

题面

不死锁的哲学家进餐问题。五支叉子放在五位哲学家之间，进餐前哲学家必须先拿起左边叉子，再拿起右边叉子，吃完后放下两支叉子。为防止死锁，只允许四位哲学家同时拿起一支或两支叉子。用信号量方法实现此不死锁的哲学家进餐问题。

解析

在这里每个叉子就是我们上面说的一个数值，那就需要一个信号量来上锁

代码

semaphore fork[5] = {1};    // 每把叉子是一个临界资源
semaphore room = {4};       // 至多允许四人同时拿起叉子

void philosopher(int i) {
    while (true) {
        think();
        
        wait(room);         // 进入房间（获取许可）
        wait(fork[i]);      // 拿起左边叉子
        wait(fork[(i+1)%5]);// 拿起右边叉子
        
        eat();
        
        signal(fork[(i+1)%5]);// 放下右边叉子
        signal(fork[i]);      // 放下左边叉子
        signal(room);         // 离开房间（释放许可）
    }
}

例3（2016年）

题意

以下两个并发执行的进程，它们能正确运行吗？如果不能，请用信号量机制改正之。（9分）

int x;
main()
{ 
    parbegin  //表示P1、P2将并发执行
    { 
        进程P1
        { 
            int y;
            x=1; 
            y=0;
            if (x>=1) 
                y=y+1;
        }

        进程P2
        { 
            int t;
            x=0; 
            t=0;
            if (x<=1) 
                t=t+2;
        }
    }
    parend
}

思路

这种修正代码的题你就疯狂加，只要这个数据出现就套一圈semwait和semsignal，可能很浪费，但是肯定没错

答案

这两个进程不能正确地并发执行。它们都对同一变量 x 进行操作，x 是一个临界资源，但没有互斥保护。

int x;
Semaphore S=1;
main()
{ 
    parbegin  //表示 P1、P2 将并发执行
    { 
        // 进程 P1
        { 
            int y;
            semWait(S);
            x=1;  
            y=0;
            if (x>=1) 
                y=y+1;
            semSignal(S);
        }

        // 进程 P2
        { 
            int t;
            semWait(S);
            x=0;  
            t=0;
            if (x<=1) 
                t=t+2;
            semSignal(S);
        }
    }
    parend
}

简答题

简答题能怎么解析呢，简单给一点我自己用来方便记忆的理解吧（不保证准确，但是能解释答案）

题1（2019年、2018年）

题面

在分页虚拟存储管理系统中，什么情况下发生缺页中断？简述缺页中断的处理过程。

答案

当CPU发出访问的逻辑地址的所在页还未调入内存时，发生缺页中断。
缺页中断的处理过程大致如下：首先判断内存中是否有空闲帧？如果没有则按照置换算法选择一个内存页淘汰，如果该页被修改过还需先写回磁盘，这样得到一个空闲帧。然后按照页表所指明的该页磁盘地址把此页调入空闲帧，修改页表，重新执行刚才那条指令。

瞎扯

缺页这个事情我们前面有一种题型已经简单讲过了，首先用现成的空着的肯定放空着的，没有就要考虑替换了嘛，先把东西放回去，这时候就创造了一个空的，然后我们就封你为新的物理地址，然后就算就行了

题2（2019年、2016年、2017年*）

题面

若检测到CPU和磁盘利用率如下，请问现在可能发生了什么情况，应采取什么措施？
1）CPU10%，磁盘94%。
2）CPU55%，磁盘3%。

答案

1. CPU 10%，磁盘94%：此时系统可能已经出现抖动，可暂停部分运行进程；
2. CPU 55%，磁盘3%：此时系统运行正常，磁盘利用率稍低，可增加进程数以提供资源利用率。

瞎扯

我们在本文的第一个题型就在讲就绪态和阻塞态的事情嘛。众所周知，阻塞态的进程基本都在无所事事的爆超磁盘，所以磁盘被超出阿黑颜那就减少几个进程，他太闲了就加几个进程

题3（2019年、2018年）

题面

简述可变分区存储管理中常用的FF、BF、WF分配算法的原理。

答案

最先适应法（FirstFit）：空闲区链表按起址递增顺序排列。分配时从链首开始查找，从第一个满足要求的空闲区中划分出作业需要的大小并分配，其余的部分作为一个新空闲区。
最佳适应法（BestFit）：空闲区链表按分区大小递增顺序排列。分配时从链首开始查找，第一个满足要求的空闲区就是满足要求的最小空闲区。
最坏适应法（WorstFit）：空闲区链表按分区大小递减顺序排列。分配时从链首开始查找，第一个空闲区不能满足要求时分配失败，否则从第一个空闲区中切出需要的大小分配。

瞎扯

我们前面讲的那个画内存分区的题型里面我们可以顾名思义了嘛，最先就是从前往后找谁先能放放谁那里；最佳就是那个最佳适配算法啊，找比他大的最小的放进去；而最坏则是恰恰相反，我偏全部挑最大的塞

题4（2020年、2017年）

题面

当一个中断正在处理时，又发生新的中断，简述此时的两种处理方式。

答案

处理多中断有两种方法。第一种方法是当正在处理一个中断时，禁止中断，顺序处理所发生的各个中断。第二种方法是中断嵌套，定义中断优先级，允许高优先级中断打断低优先级中断的处理过程。

瞎扯

简单来说就是你这个中断不能想断就断，得定个规矩，首先这个系统底层告诉我的是一次只能有一个人在中断，就好比蓝桥杯想上厕所，你一个考场去多了就容易作弊。这个时候监考老师要么是告诉所有人厕所有人的时候你不准上厕所，要么告诉所有人你可以蓝桥云课会员打断前一位同学的上厕所（并没有这个规定，蓝桥杯不要禁我的赛谢谢）

题5（2020年、2016年）

题面

简述死锁的四个必要条件。

答案

互斥：涉及的是需互斥访问的临界资源。
占有且等待：进程申请资源而阻塞时，继续占有（不释放）已分配的资源。
不可抢占：进程已占用的资源未使用完前不可强行剥夺，只能由进程自愿释放。
循环等待：进程间形成一个等待资源的循环链。

瞎扯

死锁就像两个傲娇谈恋爱，你看，两个人天天吵架是不是互斥，占有对方的爱又一直等待，有第三者来了同仇敌忾的，然后某漫画是不是天天搁那“今日の勝者は”每集都是胜负的循环

题6（2020年）

题面

简述进程的抢占式调度和非抢占式调度的区别。

答案

非抢占：在这种情况下，一旦进程处于运行态，它就不断执行直到终止，或者为等待I/O或请求某些操作系统服务而阻塞自己。
抢占：当前正在运行的进程可能被操作系统中断，并转移到就绪态。是否抢占当前进程的决策可能发生在一个新进程到达时，或者在一个中断发生后把一个被阻塞的进程置为就绪态时，或者基于周期性的时间中断。

瞎扯

前面那个计算CPU周转时间的题型其实讲的蛮清楚了

题7（2020年）

题面

描述虚拟分页内存管理技术的基本原理及其优点。

答案

内存被划分成许多大小相等的页框，进程被划分为许多大小与页框相等的页；进程的页在需要访问时，装入内存中不一定连续的某些页框中。
没有外部碎片，多道程序度更高，虚拟地址空间巨大。

题8（2018年）

题面

现代操作系统具有哪四项基本功能？并简单叙述每项功能的具体任务。

答案

处理器管理，存储管理，设备管理，文件管理。
一、处理器管理：进程控制，进程同步和互斥、死锁，进程通信，线程控制和管理，处理器调度
二、存储管理：内存分配与回收，地址转换与存储保护，主存共享，存储扩充
三、设备管理：设备分配和回收，设备的驱动调度，缓冲管理，虚拟设备
四、文件管理：文件的逻辑组织和物理组织，目录管理，文件共享和存取控制，文件存储空间管理

题9（2016年）

题面

简述DMA控制方式的技术特征。

答案

在内存和设备之间直接传送一个数据块，不需要CPU的干预。CPU 只在开始传送前发出命令，然后通过中断来得知传送过程是否结束。

题10（2016年）

题面

从调度的并发性、拥有资源、系统开销三个方面，对进程和线程进行比较。

答案

1）调度并发性：引入线程后，一个进程可包含多个线程，不仅进程之间可以并发执行，一个进程的多个线程之间也可并发，因此操作系统并发性更好。
2）拥有资源：进程拥有资源，线程不拥有资源，但它可访问其所属进程的资源。
3）系统开销：在创建、撤销和切换进程时，进程开销远远大于线程的开销。