操作系统复习

银行家算法：

假定系统中有四个进程P1,P2,P3,P4和三种类型的资源R1,R2,R3，每一种资源的数量分别为9、3、6，T0时刻的资源分配情况如表所示：

资源/进程

资源/进程	Max			Allocation			Need			Available
	R1	R2	R3	R1	R2	R3	R1	R2	R3	R1	R2	R3
P1	3	2	2	1	0	0	2	2	2	0	1	1
P2	6	1	3	6	1	2	0	0	1
P3	3	1	4	2	1	1	1	0	3
P4	4	2	2	0	0	2	4	2	0

分析T0时刻的资源分配情况，可得如表所示的信息。

T0时刻存在的安全序列：

资源/进程	Max			Allocation			Need			Work+Allocation			Finish
	R1	R2	R3	R1	R2	R3	R1	R2	R3	R1	R2	R3	true
P2	6	1	3	6	1	2	0	0	1	6	2	3	true
P1	3	2	2	1	0	0	2	2	2	7	2	3	true
P3	4	2	2	0	0	2	4	2	0	7	2	5	true
P4	3	1	4	2	1	1	1	0	3	9	3	6	true

Available：0 1 1

P2-Need：0 0 1（可以满足需求）

Available：0 1 0  P2完成

Available：6 2 3

P1-Need：2 2 2（可以满足需求）

Available：4 0 1  P1完成

Available：7 2 3

P3-Need：1 0 3（可以满足需求）

Available：6 2 0 P3完成

Available：9 3 4

P4-Need：4 2 0（可以满足需求）

Available：5 1 4  P4完成

Available：9 3 6 资源全部回收

从T0时刻的安全性分析可知，T0时刻存在着一个安全序列<P2,P1,P4,P3>,故T0时刻系统是安全的。

银行家算法：

资源/进程	Max			Allocation			Need			Available
	R1	R2	R3	R1	R2	R3	R1	R2	R3	R1	R2	R3
P1	3	2	2	1	0	0	2	2	2	0	1	1
P2	6	1	3	6	1	2	0	0	1
P3	3	1	4	2	1	1	1	0	3
P4	4	2	2	0	0	2	4	2	0

假设T0时刻，进程P1申请资源，其请求向量为Request1(0,0,1),系统按银行家算法进行检查：

判断线程申请的资源是否小于线程所需要的资源：Request1 (0,0,1) ≤ Need1(2,2,2)

判断线程申请的资源是否小于系统可分配的资源：Request1 (0,0,1) ≤ Available (0,1,1)

以上条件满足即可试探性修改，修改后如下所示

资源/进程	Max			Allocation			Need			Available
	R1	R2	R3	R1	R2	R3	R1	R2	R3	R1	R2	R3
P1	3	2	2	1	0	0	2	2	1	0	1	0
P2	6	1	3	6	1	2	0	0	1
P3	3	1	4	2	1	1	1	0	3
P4	4	2	2	0	0	2	4	2	0

系统的可用资源向量为Available（0,1,0），比较各进程的需求向量Need，系统不能满足任何进程的资源请求，系统进入不安全状态。所以P1请求的资源不能分配，因此只能让进程P1阻塞。

CPU调度算法

完成时间：根据调度算法原理确定；

周转时间 = 完成时间 - 到达时间；

带权周转时间 = 周转时间 / 服务时间；

平均周转时间 = 周转时间之和 / 进程数；

平均带权周转时间 = 带权周转时间之和 / 进程数；

假设系统中有5个进程，它们的到达时间和服务时间见下表

进程	到达时间	服务时间
A	0	3
B	2	6
C	4	4
D	6	5
E	8	2

先来先服务（FCFS）：

进程	到达时间	服务时间	完成时间	周转时间	带权周转时间	平均周转时间	平均带权周转时间
A	0	3	3	3	1	43/5=8.6	13.15/5=2.67
B	2	6	9	7	≈1.1
C	4	4	13	9	2.25
D	6	5	18	12	2.4
E	8	2	20	12	6

以上转自：(14条消息) 操作系统原理--调度算法例题_Pluto的博客-CSDN博客_操作系统调度算法例题

非抢占式短进程优先（SPF）：在就绪队列中选择服务时间最短的进程进行服务

进程	到达时间	服务时间	完成时间	周转时间	带权周转时间	平均周转时间	平均带权周转时间
A	0	3	3	3	1	43/5=8.6	13.15/5=2.67
B	2	6	9	7	≈1.1
C	4	4	13	9	2.25
D	6	5	18	12	2.4
E	8	2	20	12	6

抢占式短进程优先：后来的进程的服务时间比目前的正在运行进程所需的服务时间更短，则它等待，短服务时间的进程先服务，最后轮到长服务时间的进程。

高响应比优先（HRRN）

响应比 =（等待时间+要求服务时间）/ 要求服务时间

公式：R=1+w/t

进程	到达时间	服务时间（T）	等待时间（W）	相应比（R）
A	0	3	0	1
B	2	6	1	≈1.1
C	4	4	5	2.25
D	6	5	3	1.6
E	8	2	1	1.5

进程	到达时间	服务时间	相应比	完成时间	周转时间	带权周转时间	平均周转时间	平均带权周转时间
A	0	3	1	3	3	1
B	2	6	≈1.7	9	7	1.17
C	4	4	2.25	13	9	2.25
D	6	5
E	8	2

进程	到达时间	服务时间	相应比	完成时间	周转时间	带权周转时间	平均周转时间	平均带权周转时间
A	0	3	1	3	3	1	8	2.144
B	2	6	≈1.7	9	7	1.17
C	4	4	2.25	13	9	2.25
D	6	5	2.4	20	14	2.8
E	8	2	3.5	15	7	3.5

时间片轮转（RR，时间片=1）

进程	到达时间	服务时间	完成时间	周转时间	带权周转时间	平均周转时间	平均带权周转时间
A	0	3	4	4	1.33	10.8	2.71
B	2	6	18	16	2.67
C	4	4	17	13	3.25
D	6	5	20	14	2.8
E	8	2	15	7	3.4

最短剩余时间：

在同一时刻有多个线程就绪，找到剩余服务时间最短的线程服务。

非抢占式优先级调度算法：每次调度时选择当前已到达且优先级最高的进程。

进程	到达时间	服务时间	优先级
A	0	3	1
B	2	6	2
C	4	4	3
D	6	5	4
E	8	2	5

进程	到达时间	服务时间	完成时间	周转时间	带权周转时间	平均周转时间	平均带权周转时间
A	0	3	3	3	1	39/5=7.8	9.67/5=1.934
B	2	6	9	7	≈1.17
C	4	4	20	16	4
D	6	5	16	10	2
E	8	2	11	3	1.5

抢占式优先级调度算法：每次调度时选择当前已到达且优先级最高的进程。当前进程主动放弃处理机时发生调度。

进程	到达时间	服务时间	优先级
A	0	3	1
B	2	6	2
C	4	4	3
D	6	5	3
E	8	2	1

进程	到达时间	服务时间	完成时间	周转时间	带权周转时间
A	0	3	3	3	1
B	2	6	11	9	1.5
C	4	4	15	11	2.75
D	6	5	20	14	2.8
E	8	2	10	2	1

页面置换算法：

缺页率：p = 置换页数/总引用页数

最佳置换算法（OPT）（理想置换算法）不可能被实现的算法

先进先出置换算法（FIFO）

总是选择在主存中停留时间最长（即最老）的一页置换，即先进入内存的页，先退出内存。

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

选择在最近一段时间里最久没有使用过的页面予以置换

时钟页面置换算法（CLOCK）