期末速成操作系统原理有手就行！草履虫都能看懂！

操作系统原理

整理By Wolger

1.1.1 操作系统的定义_哔哩哔哩_bilibili

【拯救者】Ep_课程简介_哔哩哔哩_bilibili

两小时讲完操作系统总复习_哔哩哔哩_bilibili

以下内容大部分参考了以上视频，如果有时间一定要看！

注意，这是期末速成，做不到事无巨细，如果是考研的同学本篇仅作为参考

常见题型

一、信号量描述前趋图

首先要搞清楚啥是PV，PV是用来实现进程互斥的操作，而wait和signal是其具体的原语

P（wait）： 申请资源操作

V（signal）： 释放资源操作

S：信号量，用来记录资源数量

例如S=3代表3个可用的空闲资源

执行P：wait（s）操作后，将申请一个可用资源，此时S-1

执行V：signal（s）操作后，将释放一个可用资源，此时S+1

那么此类题型，一般给你一个前趋图，让你写出信号量的执行函数

此图大致可以理解为，执行完S1后，释放a、b资源，S2需要a资源，s3需要b资源，依次顺序执行

解题过程：

1. 首先，声明一堆变量，这些变量代表的是信号量
2. 定义进程函数，执行相关操作如s1()，执行完释放资源v(a)、v(b)，每个节点如果有前驱箭头，则需先申请资源
3. 所有进程函数定义好后，编写main函数
4. 对所有信号量进行初始化赋值为0，在cobegin与coend中并发执行所有进程函数

详情请见下图，看懂这代码，这类题型就差不多了

二、生产者消费者

基础题型

与上题类似，其实还是进程互斥的问题。

一般会有三个变量代表信号量所有的资源

1. 互斥信号量mutex：一般初始化为1，用来表示互斥的标志（互斥锁），同一时间只有一个线程可以有锁。当mutex为1时，大家都可以访问资源，当某个线程访问时，mutex会变为0，其他线程不允许访问
2. 空闲缓冲区empty：也就是生产者能够用的空间，只有当有空闲缓冲区够用，生产者才会生产
3. 非空缓冲区full：生产者生产出的资源就会放在这个空间，等着消费者来拿，只有当这个空间有东西，消费者才会消费

缓冲区是公用的，是公用的，是公用的，记住这个！所以empty和full他们是相对的

如果缓存区的大小是3，那么一开始空闲缓冲区就是3，非空闲的就是0

当1个缓冲区被使用了，那么空闲缓冲区就变为2，非空闲就是1

解题过程

1. 定义三个变量，mutex=1，empty=n（看题目给你多少空间），full=0
2. 编写生产者函数
   • 首先需要申请一个缓冲区空间用来生产p(empty)，同时也要给缓冲区上锁p(mutex)，让别人（消费者）无法访问
   • 执行相关操作，生产某个东西，放入某个东西之类的
   • 生产完成，释放锁v(mutex)，此时该缓冲区就有东西了所以非空缓冲区+1 v(full)
3. 编写消费者函数
   • 我要拿东西，肯定要申请下非空缓冲区p(full)，同时给缓冲区上锁p(mutex)，让别人（生产者）无法访问
   • 执行相关操作，拿东西，取东西，吃东西之类的
   • 消费完成，释放锁v(mutex)，此时该缓冲区就空了所以空闲缓冲区+1 v(empty)

多生产者消费者

题目描述：桌子上有一只盘子，最多可容纳两个水果，每次只能放入或者取出一个水果。爸爸专门向盘子中放苹果，妈妈专门向盘子中放橘子，儿子专门等待吃盘子中的橘子，女儿专门等吃盘子中的苹果。

注意缓存区是公用的这个概念

示例真题

三、页面置换算法

页面置换算法_哔哩哔哩_bilibili

操作系统——FIFO和LRU页面置换算法_fifo页面置换算法-CSDN博客

页面置换，就是把新的页面替换旧的页面

常考的一共三个算法

先进先出算法（FIFO）

思想： 把内存中驻留时间最久的页面淘汰，即淘汰最早进入内存的页面

题型： 采用FIFO算法，给你一个序列x,x,x,x,x,x,x,x,x,x，当物理块为 x 时，计算缺页次数和缺页率

解法： 转为如下表格，物理块有几个就几行

访问页面	7	0	1	2	0	3	0	4	2	3	0	3	2	1	2	0	1	7	0	1
物理块1
物理块2
物理块3
缺页否

过程（盯着看物理块）：

1. 前面m=3列，就直接按序列依次写进去

2. 后面的，如果不在物理块里面，看出现最长的数字，就把他替换掉（在纸上写的时候把他划掉，避免看错）

   例如第4个2，看物理块中7出现了最长，就把7变成2

3. 如果该页面比如第5个0本来就在物理块中，那这列就留空，即为不缺页

详情还请看上面提供的视频，比较清楚

访问页面	7	0	1	2	0	3	0	4	2	3	0	3	2	1	2	0	1	7	0	1
物理块1	7	7	7	2		2	2	4	4	4	0			0	0			7	7	7
物理块2		0	0	0		3	3	3	2	2	2			1	1			1	0	0
物理块3			1	1		1	0	0	0	3	3			3	2			2	2	1
缺页否	√	√	√	√		√	√	√	√	√	√			√	√			√	√	√

缺页数： 只要物理块有变动的都是缺页，总列数-空白数

缺页率： 缺页数/总列数

最近最久未使用算法（LRU）

思想： 选择在最近一段时间内最久不用的页面予以淘汰

过程（盯着访问页面看，第一行）

1. 前面m=3列，就直接按序列依次写进去
2. 后面的
   • 如果不在物理块里面，看访问页面（第一行）出现最早同时没被划掉的数，把他替换掉并用笔划掉
   • 如果在物理块里面，把访问页面最前面相同的数划掉，然后此列留空

遇到2时，将最前面、出现最久的7替换掉，并将他划掉

访问页面	7	0	1	2	0	3	0	4	2	3	0	3	2	1	2	0	1	7	0	1
物理块1	7	7	7	2
物理块2		0	0	0
物理块3			1	1
缺页否	√	√	√	√

遇到0时，在物理块里面，此列留空，但要把前面的0给划掉，因为使用了

访问页面	7	0	1	2	0	3	0	4	2	3	0	3	2	1	2	0	1	7	0	1
物理块1	7	7	7	2
物理块2		0	0	0
物理块3			1	1
缺页否	√	√	√	√

遇到3时，将最前面、出现最久的1替换掉，并将他划掉

访问页面	7	0	1	2	0	3	0	4	2	3	0	3	2	1	2	0	1	7	0	1
物理块1	7	7	7	2		2
物理块2		0	0	0		0
物理块3			1	1		3
缺页否	√	√	√	√		√

依次类推

访问页面	7	0	1	2	0	3	0	4	2	3	0	3	2	1	2	0	1	7	0	1
物理块1	7	7	7	2		2		4	4	4	0			1		1		1
物理块2		0	0	0		0		0	0	3	3			3		0		0
物理块3			1	1		3		3	2	2	2			2		2		7
缺页否	√	√	√	√		√		√	√	√	√			√		√		√

最佳置换算法（OPT）

思路： 替换以后永不访问，未来最长时间不被访问的页面，向后的选择

过程（盯着后面看）

1. 前面m=3列，就直接按序列依次写进去
2. 后面的
   • 如果不在物理块里面，看之后物理块哪个数最久没出现
   • 如果在物理块里面，此列留空

例如到第四个2了，看物理块哪个数最久没出现，7最久没出现，所以替换7，依次类推

访问页面	7	0	1	2	0	3	0	4	2	3	0	3	2	1	2	0	1	7	0	1
物理块1	7	7	7	2		2		2			2			2				7
物理块2		0	0	0		0		4			0			0				0
物理块3			1	1		3		3			3			1				1
缺页否	√	√	√	√		√		√			√			√				√

四、银行家算法

银行家算法1_哔哩哔哩_bilibili

操作系统——银行家算法（Banker’s Algorithm） - 王陸 - 博客园 (cnblogs.com)

操作系统-银行家算法_哔哩哔哩_bilibili

问题1：题目会给你一个表格，然后让你判断是否安全

Process	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 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. 先构建出以下表格（别管为什么，只写英文就行）

   进程/资源	work可提供的	Need需要的	Allocation分配	work+Allocation分配释放收回	finish

2. 把available抄到work第一行

3. 然后找题目的need全都小于等于work的填到表上面（能找到finish就是ture）

4. allocation照抄

5. 最后把work和Allocation两个加起来填到work+Allocation

   进程/资源	work可提供的	Need需要的	Allocation分配	work+Allocation分配释放收回	finish
   P0	1 6 2 2	0 0 1 2	0 0 3 2	1 6 8 4	true

6. 将work+Allocation作为下一行的work，重复该过程

   进程/资源	work可提供的	Need需要的	Allocation分配	work+Allocation分配释放收回	finish
   P0	1 6 2 2	0 0 1 2	0 0 3 2	1 6 8 4	true
   P3	1 6 5 4	0 6 5 2	0 3 3 2	1 9 8 6	true
   P1	1 9 8 6	1 7 5 0	1 0 0 0	2 9 8 6	true
   P2	2 9 8 6	2 3 5 6	1 3 5 4	3 12 13 10	true
   P4	3 12 13 10	0 6 5 6	0 0 1 4	3 12 14 14	true

如果finish全是true，那么他就是安全的，安全序列为{P0、P3、P1、P2、P4}

问题2

如果某进程P2提出请求Request（1，2，2，2）后，系统能否将资源分配给它？

解题过程：

1. 先看R是否小于Need，若不则失败

2. 先看Request是否小于Need，若不小于则失败

   Request(1，2，2，2) ≤ Need(2，3，5，6)

3. 再看R是否小于Available，若不小于则等待

   Request(1，2，2，2) ≤ Available(1，6，2，2)

4. 如果以上条件都满足则尝试分配，修改以下值

   Available = Available - Request
   
   Need = Need - Request
   
   Allocation = Allocation + Request
   

Process	Allocation	Need	Available
	A B C D	A B C D	A B C D
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

之后再使用第一题的安全检查，重新检查一遍，如果还是安全，那就是可以，否则不行

五、地址转换

首先你要知道，在页内存储中逻辑地址和物理地址的概念

逻辑地址 = 页号 + 页内地址

物理地址 = 块号 + 页内地址

可以看到他们其页内地址都是不变的，变的只有前面的页号和块号

所以，地址转换的做题思路就是：页号变块号，页内地址照抄

题型一：十进制地址转换

如题：已知某个分页系统，页面大小为1K(即1024字节)，某一个作业有4个页面，分别装入到主存的第3、4、6、8块中，求逻辑地址2100对应的物理地址。

有些题目会直接给你页表，但像这道题没有直接给你，其实他是一样的，如果觉得不清楚，自己画一个

页号	块号
0	3
1	4
2	6
3	8

十进制地址转换很简单，按我们的思路，先求出页号和页内地址，再把页号变块号即可

解题过程：

1. 求页号：逻辑地址 / 页面大小 (取整数)，所以本题页号为2
   $$2100/1024=2$$

2. 求业内地址：逻辑地址 % 页面大小 (取余数)，所以本题业内地址为52
   $$2100\%1024=52$$

3. 页号变块号：对应上方的页表，2对应的是6，所以块号是6

4. 计算物理地址：块号 x 页面大小 + 业内地址 （注意这里块号要乘回页面大小），所以本题物理地址为6196
   $$6\ast 1024+52=6196$$

题型二：十六进制地址转换

如题： 设某用户的编程空间共32个页面，每页为1KB，内存容量为16KB。假定用户程序的页表如下所示。请计算逻辑地址0A5CH所对应的物理地址。（要写出计算过程）

页号	块号
0	5
1	10
2	4
3	7

我们来依次解读题目给的东西是什么

32个页面：这里其实就是告诉你页号有多少位，在计算机中是用二进制存储的，所以32=2的5次方，那么页号就有5位

每页为1KB：这里是告诉你页内地址有几位，1KB=1024B=2的10次方，那么业内地址就有10位

内存容量16KB：这里是告诉你最终物理地址有几位，16KB=16*1024B=2的14次方，那么最终物理地址就有14位

知道上述内容，我们解题就很方便了

解题过程：

1. 将16进制逻辑地址变为2进制
   $$0A5CH=0000101001011100$$

2. 划分页内地址和页号

   先划分页内地址，由于业内地址我们已知10位，所以从后往前数10位就是页内地址

   再划分页号，从第10位开始再从后往前数5位，多余的1个0直接去掉
   $$0A5CH=\underline{00010}\underline{1001011100}$$

3. 页号变块号

   二进制页号00010转换为10进制是2，根据页表可得块号为4，再把块号转换为二进制（也要五位）
   $$4=00100B$$

4. 由于我们之前知道最终物理地址是14位的，但现在5+10等于15位，多了1位，所以把块号前面去掉1位0，再把业内地址抄回来

   其实这个物理地址的位数并不影响做题，因为前面都是0去不去无所谓
   $$物理地址=\underline{0100}\underline{1001011100}=125CH$$

六、磁盘调度算法

如题： 假设一个磁盘有100个柱面，编号为0~99，在完成了磁道25处的请求后，磁头当前正在磁道43处服务。磁盘请求的柱面按38、6、40、2、20、22、10的次序到达磁盘驱动器，寻道时每移动一个柱面需要10ms，计算以下算法的总寻道时间：
（1）先来先服务算法
（2）最短寻道时间优先算法
（3）电梯调度算法。

先来先服务（FCFS）

思路： 按顺序一个一个来，依次执行

即43→38→6→40→2→20→22→10

解题过程：

1. 列一个表

2. 根据算法依次写出下一个磁道数

3. 移动的磁道数就是两者差的绝对值

   下一个磁道号	移动的磁道数
   38	|43-38|=5
   6	|38-6|=32
   40	|6-40|=34
   2	|40-2|=38
   20	18
   22	2
   10	12

4. 根据移动的磁道数计算总寻道时间
   $$(5+32+34+38+18+2+12)\ast 10=1410ms$$

最短寻道时间优先（SSTF）

思路： 按最接近当前磁道的来

即43→40→38→22→20→10→6→2

值得注意的是，磁盘是一个圆，所以如果当前是98处，请求的柱面是95、1，那么按绝对值来最接近的磁道是1

解题过程：

1. 跟上面一样

   下一个磁道号	移动的磁道数
   40	3
   38	2
   22	16
   20	2
   10	10
   6	4
   2	4

SCAN扫描电梯算法（SCAN）

思路： 按方向找最近的，找完了那就反方向

以该题为例： 假定一磁盘有200个柱面,编号为0—199,在完成了磁道125处的请求后,当前正在磁道143处为一个请求服务。若请求队列的先后顺序为86,147,91,177,94,150,102,175,130，采用SCAN(扫描)算法和CSCAN(循环扫描)完成上述请求,写出磁头移动的顺序,并计算存取臂移动总量(单位为磁道数)。

题目以125->143为正方向

即143→147→150→175→177→130→102→94→91→86

解题过程：

1. 跟上面一样

   下一个磁道号	移动的磁道数
   147	4
   150	3
   175	25
   177	2
   130	47
   102	28
   94	8
   91	3
   86	5

循环扫描（CSCAN）

思路： 按方向找最近的，找完了那就从0开始按方向找

以该题为例： 假定一磁盘有200个柱面,编号为0—199,在完成了磁道125处的请求后,当前正在磁道143处为一个请求服务。若请求队列的先后顺序为86,147,91,177,94,150,102,175,130，采用SCAN(扫描)算法和CSCAN(循环扫描)完成上述请求,写出磁头移动的顺序,并计算存取臂移动总量(单位为磁道数)。

题目以125->143为正方向

即143→147→150→175→177→86→91→94→102→130

解题过程：

1. 跟上面一样

   下一个磁道号	移动的磁道数
   147	4
   150	3
   175	25
   177	2
   86	91
   91	5
   94	3
   102	8
   130	28

七、进程作业调度算法

如题： 假设一个系统有 4个进程，他们的到达时间和服务时间如下表所示，忽略 I/O 以及其他的开销时间，若分别按 先来先服务（ FCFS ） 、 短进程优先（ SPF ）、高响应比优先算法（HRRN） 调度算法进行 CPU 调度，请给出各进程的完成时间、周转时间、带权周转时间、平均周转时间和平均带权周转时间。

进程	到达时间	运行时间
P1	0	7
P2	2	4
P3	4	1
P4	5	4

首先你需要知道各个时间代表什么

1. 到达（提交）时间：题目给你的，该进程什么时候来的（还没运行呢）
2. 运行时间：题目给你的，该进程要运行多长时间
3. 开始时间：根据算法得的，该进程啥时候真正开始运行
4. 结束时间：开始时间 + 运行时间，该进程啥时候运行结束
5. 周转时间：结束时间 - 到达时间，该进程从到达到结束一共用的时间
6. 带权周转时间：周转时间 / 运行时间
7. 平均带权周转时间：所有进程带权周转时间总和 / 进程数

所以吧，你其实只要根据算法得开始时间就完事了，其他都是加加减减乘乘除除的事情

先来先服务（FCFS）

思路：谁先来的就先执行谁（非抢占式）

解题过程：

1. 别管算法，先列个表先，把题目告诉你的抄下来

   进程	到达时间	运行时间	开始时间	结束时间	周转时间	带权周转时间
   P1	0	7
   P2	2	4
   P3	4	1
   P4	5	4

2. 管管算法，按思路，谁先来谁就执行（谁到达时间最早先执行谁）

   即P1→P2→P3→P4，在表中填出开始时间、结束时间

   进程	到达时间	运行时间	开始时间	结束时间	周转时间	带权周转时间
   P1	0	7	0	7
   P2	2	4
   P3	4	1
   P4	5	4

   进程	到达时间	运行时间	开始时间	结束时间	周转时间	带权周转时间
   P1	0	7	0	7
   P2	2	4	7	11
   P3	4	1
   P4	5	4

   进程	到达时间	运行时间	开始时间	结束时间	周转时间	带权周转时间
   P1	0	7	0	7
   P2	2	4	7	11
   P3	4	1	11	12
   P4	5	4	12	16

3. 计算出周转时间、带权周转时间

   进程	到达时间	运行时间	开始时间	结束时间	周转时间	带权周转时间
   P1	0	7	0	7	7-0=7	7/7=1
   P2	2	4	7	11	11-2=9	9/4=2.25
   P3	4	1	11	12	12-4=8	8/1=8
   P4	5	4	12	16	16-5=11	11/4=2.75

短作业优先（SJF）

思路：先执行最先到达的，然后根据谁运行时间短先执行（非抢占式）

解题过程：

1. 别管算法，先列个表先，把题目告诉你的抄下来

2. 按思路，0时刻只有P1到了，先执行P1，然后谁运行时间短谁先执行（注意如果运行完发现某个进程还没到就先别运行他）

   即P1→P3→P2→P4，在表中填出开始时间、结束时间

3. 计算出周转时间、带权周转时间

   进程	到达时间	运行时间	开始时间	结束时间	周转时间	带权周转时间
   P1	0	7	0	7
   P2	2	4
   P3	4	1
   P4	5	4

   进程	到达时间	运行时间	开始时间	结束时间	周转时间	带权周转时间
   P1	0	7	0	7
   P2	2	4
   P3	4	1	7	8
   P4	5	4

   进程	到达时间	运行时间	开始时间	结束时间	周转时间	带权周转时间
   P1	0	7	0	7	7	1
   P2	2	4	8	12	10	2.5
   P3	4	1	7	8	4	4
   P4	5	4	12	16	11	2.75

高响应比优先算法（HRRN）

思路：计算响应比=（等待时间+执行时间）/执行时间，谁高谁先执行（等待时间=此时刻-到达时间）

解题过程：

1. 别管算法，先列个表先，把题目告诉你的抄下来

2. 按思路，0时刻只有P1到了，先执行P1，执行完在7时刻

   • 然后计算剩下进程的响应比

     P2：(5+4)/4=2.25，P3：(3+1)/1=4，P4：(2+4)/4=1.5

   所以接下来执行P3，P3执行完在8时刻

   • 计算响应比

     P2：(6+4)/4=2.5，P4：(3+4)/4=1.75

   所以接下来执行P2，最好执行P4

   即P1→P3→P2→P4

3. 计算出周转时间、带权周转时间

进程	到达时间	运行时间	开始时间	结束时间	周转时间	带权周转时间
P1	0	7	0	7	7	1
P2	2	4	8	12	10	2.5
P3	4	1	7	8	4	4
P4	5	4	12	16	11	2.75

知识点

相信我，你记不住的，建议直接刷你们老师发的作业题目

操作系统概述

操作系统是帮你掌控你的电脑的东西，用户和硬件的桥梁

定义：

• 管理软硬件
• 分配资源
• 提供接口
• 是基本系统软件

功能（其实就是控制硬件和读软件）：

• 控制处理器（就CPU）
• 控制存储器（内存）
• I/O设备（所有外设）
• 文件管理（看文件的）

OS的特征

1. 并发：多个个进程在同一时间间隔内执行。（并行是同一时刻执行多个程序）
2. 共享：将外设使用虚拟共享技术，使得两个进程都能调用，通过中间输入井，使得资源被多个进程调用（这样才能实现并发
   • 互斥共享（同一时刻只能有一个，这资源叫临界/独占资源）
   • 同时访问（宏观上的，实际是交替的）
3. 虚拟：例如cpu，实际只有一个但通过以下技术，可以让人感觉有多个cpu同时在用 ，物理上的变为逻辑上的
   • 空分复用技术：使用同一资源的不同部分（比如硬盘
   • 时分复用技术：在一个很短的时间片里循环调用资源，经典时间管理大师
4. 异步：各个进程不知道自己什么时候被调用

不同时期发展

1. 手工时期：就单个程序运行，没系统
2. 单道批处理：只有一个程序运行完才会运行下一个
3. 多道批处理：多个程序并发执行
4. 分时操作系统：时间片轮流服务，时间管理大师，人机交互但不能处理紧急任务（重点是用户,交互性强
5. 实时操作系统：严格时间内处理时间（必须给我完成！响应时间快！插队！ 可靠
6. 网络操作系统：云服务器呗
7. 分布式操作系统：机房，分布、并行

乱七八糟的概念

指令：

• 特权指令：权限很高的指令如IO指令、中断指令，只允许操作系统使用
• 非特权指令：不是很危险的指令，权限不高的指令

原语

由若干条指令执行

1. 最底层，最接近硬件
2. 不可再分，只能一气呵成
3. 运行时间短，用的多

提供的接口（系统调用）

让应用程序/用户能用调用指令，由操作系统执行

• 命令接口
  1. 联机：就是输一行就有结果（CMD
  2. 脱机：你得自己点运行
• 程序接口
  1. GUI界面

中断和异常

• 内中断（就是异常）：
  1. 自愿中断：某个软件要调用资源，要系统控制权，就要用指令中断
  2. 强迫中断：硬件中断（断电了）、软件异常（0/0）
• 外中断（来自外部）：外设要请求，人工干预（打印机）

CPU处理机状态

• 核心态（管态）：执行所有指令，访问外围设备
• 用户态（目态）：只能执行非特权指令，访问受限

从用户态到核心态是由硬件的中断完成的

体系结构

• 大内核：集权管理（全要管
• 微内核：放权管理（只管理核心功能

题目

【拯救者】Ep_操作系统概述-习题_哔哩哔哩_bilibili

进程管理

进程的基本概念

为啥要用进程？为了实现并发和共享

定义：

程序在数据集合上的一次运行活动，是系统资源分配和调度的基本单位

组成：

PCB：保存进程运行的数据，是进程存在的唯一标志

程序段：能被调度到CPU的代码

数据段：放数据的

状态：

• 运行态：进程正在占用CPU
• 就绪态：准备运行的状态，获得除了CPU的资源，想得到CPU！！
• 阻塞态：进程正在等待某一资源，不是CPU！！
• 创建状态：进程正在创建
• 结束状态：进程从系统中消失

程序和进程的区别：

1. 进程是动态的，程序是静态的。
2. 程序是一堆代码，进程是程序运行
3. 进程是暂时，程序是永久的
4. 进程包括，PCB，程序，数据
5. 一个程序可以多个进程（多开QQ

处理机调度

怎么调用进程，按照某个算法把CPU分配到某个进程

层次

• 高级调度：从后备队列选择作业调入内存，外存>内存，频率低
• 中级调度：从挂起队列选择进程调入内存，外存>内存，频率中
• 低级调度：从就绪队列选择进程调入CPU，内存>CPU，频率高

方式

• 非抢占式：好好排队，你着急但我不给你用，我要先自己执行完
• 抢占式：能插队，你着急先给你用

调度准则

系统吞吐量：总作业数量/总花费时间

CPU利用率：CPU工作时间 / (工作时间+等待时间)

等待时间：某个作业/进程等待的时间和

周转时间：就是全部时间，从提交到完成的时间

相应时间：从提交到相应的时间

平均周转时间：所有周转时间的合/作业数

带权周转时间：作业周转时间/实际允许时间

调度算法

先来先服务（FCFS）

按到达顺序来，先进先出

短作业优先（SJF）

优先处理短作业，平均等待时间和周转时间最少，会饥饿（长的等太久了）

多级反馈队列调度法

从优先级高的就绪队列中依次选择，找不到再从低优先队列找，兼顾长短作业，会饥饿

高响应比优先调度法

计算响应比（等待+运行时间）/ 运行时间

优先级调度法

优先级最高先执行

时间片轮转调度法

让每个进程执行一个时间片，若在时间片没执行完就换下一个，公平

进程同步

制约关系

• 同步制约关系：要一个一个来，先A再B
• 互斥制约关系：只有一个进程能使用资源

临界资源

一次仅允许一个进程使用的资源

临界区

在每个进程中访问临界资源的程序

临界区互斥

原则：

1. 空闲让进：空闲临界区只允许一个进程进入
2. 忙则等待：如果临界区已有进程，那其他进程就要等待
3. 有限等待：进程必须在有限临界区退出
4. 让权等待：如果进程不能进入临界区，那就要让出CPU

基本方法(实现机制)：

信号量，利用PV实现互斥，P是使用-1，V是放回+1

信号量是一个整形变量，如果信号量取值只能是0、1那么成了互斥量。0为临界区加锁，1为解锁

例如m=1 是互斥量，P(m)是使用资源m，m=0；V(m)是放回资源，m=1

PV是低级进程通信原语

生产者消费者问题

线程的内容

为了并发，提高资源利用率

线程是进程的具体功能，是CPU调度的基本单位

管程的内容

为什么要管程，因为每个进程都有PV会给系统管理造成麻烦，于是产生了新的进程管理工具—管程

组成（很少考）：

局部于管程的共享变量说明

对数据结构进行操作的一组过程

对局部于管程的数据设置初始值的语句，需为管程赋予名字

死锁：

在并发环境下，进程请求资源谁也不让谁，都不给对方资源，造成各进程阻塞，称为死锁

例如P1有A资源，但想要B资源；P2有B资源，想要A资源；谁也不让谁

四个必要条件

• 互斥条件：只有对互斥资源才会导致死锁
• 不剥夺条件：不能被强行剥夺
• 请求和保持条件：不给别人叫保持
• 循环等待条件：进程获取的资源被下一个进程请求（不懂）

解决方法

预防死锁❗：

破坏必要条件的一个或多个

• 破坏互斥：一般不行
• 破坏不剥夺：当我想要你必须给我
• 破坏请求和保持：一次性申请完资源，不然不给你创建
• 破坏循环等待：让请求资源的顺序一样

避免死锁

银行家算法❗❗❗：在资源申请时，判断是否会让系统不安全，如果不安全就不答应

死锁检测

如果系统既不预防，又不避免，系统应该提高两个算法

1. 死锁检测算法：检测有没有死锁（不会考
2. 死锁解除算法：死锁了，解除死锁的
   • 资源剥夺：把A的资源抢了给B
   • 撤销进程：把A和B进程的资源全拿了，重新分配
   • 进程回退：设置还原点，回退到死锁之前

例题：

2.1.5 线程以及有关进程的习题_哔哩哔哩_bilibili

2.2.2 有关调度的习题_哔哩哔哩_bilibili

2.4 关注死锁_哔哩哔哩_bilibili

内存管理

文件管理

考的很少，没时间可以不用看

IO外设管理

考的很少，没时间可以不用看