操作系统调度算法解析

先来先服务调度算法

先来先服务（First Come First Served,FCFS），是一种简单的调度算法，它既适用于作业调度，也适用于进程调度。先来先服务算法是按照作业或进程到达的先后次序来进行调度。当作业调度中采用该算法时，每次调度都是从后备队列中选择一个最先进入该队列中作业，将它调入内存，为其创建进程、分配相应的资源，将该作业的进程放入就绪队列。在进程调度中采用该算法时，每次调度是从就绪队列中选择一个最新进入该队列的进程，并给他分配处理机。

先来先服务调度算法

进程(作业)名	到达时间（开始时间）	运行时间	结束时间	周转时间
P1	0	9	9	20
P2	0.4	4	13	5
P3	1	1	14	1
P4	5.5	4	18	6
P5	7	2	20	2

先来先服务调度算法分析

时间/s
0	P1到达，P1执行（期间执行9s）
0.4	P2到达，P2未执行，P1执行中（剩余8.6s）
1	P3到达，P2未执行,P3未执行,P1(剩余7.6s)
5.5	P4到达,P2未执行,P3未执行,P1(剩余3.5s)
7	P5到达，P5未执行,P4未执行,P2未执行,P3未执行,P1(剩余2s)
9	P1 结束 ,P2开始运行(期间执行4s)
13	P2 结束 ,P3开始运行(期间执行1s)
14	P3 结束 ,P4开始运行(期间执行4s)
18	P4 结束 ,P5开始运行(期间执行2s)
20	P4 结束

需要提出的一点，这个调度算法的调度过程是先找作业或者进程中最先到来的那一个，也就是说，这个是看`到达时间`的，到达时间越早，则最先进行调度，值得注意的是，此调度算法是`服务`完一个作业或进程后，再`服务`下一个作业或者进程。

短作业（进程）优先调度算法

短作业优先调度算法（Shortest Job First,SJF）或短进程调度算法（Shortest Process First,SPF）是指对短作业或短进程优先调度的算法 。这里，作业或进程的长短是以作业或进程要求运行时间的长短来衡量的。

短作业（进程）优先调度算法

进程(作业)名	到达时间（开始时间）	运行时间	结束时间	周转时间
P1	0	9	20	20
P2	0.4	4	5.4	5
P3	1	1	2	1
P4	5.5	4	11.5	6
P5	7	2	9	2

短作业（进程）优先调度算法分析

时间/s
0	P1到达，P1执行
0.4	P2到达，P2执行，P1停（剩余8.6s）
1	P3到达，P2停（剩余3.4s）,P3执行
2	P3 结束 ，P2执行
5.4	P2 结束 ，P1执行
5.5	P4到达，P1停（剩余8.5s）,P4运行
7	P5到达，P5运行，P4停（剩余2.5s）
9	P5 结束 ，P4运行
11.5	P4 结束 ，P1运行
20	P1 结束

值得注意的时，短作业作业（进程）优先调度算法的确是按照`运行时间的长短`来衡量的。也就是谁的运行时间短，就先调度哪一个`作业`或`进程`。但是，这并不意味着是先把最先调度的`那一个作业`或`进程`运行完毕后调度其他的`作业`或`进程`，真正的调度过程是交叉进行的。总的顺序还是按照到达的时间开始从最先到达的作业或进程开始进行调度，例如在本例中，P1到达后，立即执行，在P1调度完成之前，P2开始到达，立即执行（此时，P1停止），依次类推。上述表-**短作业（进程）优先调度算法分析** 相信说的已经足够清楚。

优先级调度算法

在优先级调度算法中，优先级用来表示作业或进程所享有的调度优先权。该算法的关键是确定进程或作业的优先级。优先级分为两类：静态优先级和 动态优先级 。

静态优先级

静态方法根据作业或进程的静态特性，在作业或进程开始执行前就确定它们的优先级，一旦开始执行后就不能改变。下表的按优先级数高的为最优先

进程(作业)名	到达时间（开始时间）	运行时间	优先数（级）	结束时间	周转时间
P1	0	10	3	24	24
P2	0	6	5	6	6
P3	0	2	2	26	26
P4	0	4	1	30	30
P5	0	8	4	14	14

执行过程：

    P2          P5                 P1           P3     P4
|—————————|——————————————|———————————————————|———|——————————|————>
0         6              14                   24  26         30

在这个算法中，为了简单的计算 假设5个作业是同时提交的的，都在0时刻提交。整个过程和`先来先服务算法`很相似的，都是先运行完一个作业后，再进行另一个作业的调度。只是调度顺序衡量的标准换成了`优先数`。对于优先数的大小，不同题目中给出的标准不同，有的按最小小优先数优先，有的则按最大的优先，这里不做讨论。

时间片轮转法

时间片轮转法（Round-Robin,RR算法）主要用于分时系统中的进程调度。
轮转调度的实现原理为系统把所有就绪进程按先入先出的原则排成一个队列，新来的进程就绪队列末尾，每当执行进程调度时，就绪队列的队首进程总是先被调度程序选中，在CPU上运行一个时间片后，系统的计时器发出时钟中断，调度程序进行调度，停止该进程的运行，并把它放入就绪队列的末尾；随后，进行进程切换，把CPU分给就绪队列队首进程，同样让它运行一个时间片，如此往复。轮转法的原理图如下。

以下表来说，其中时间片长度为2ms。

进程(作业)名	到达时间	运行时间	开始时间	结束时间	周转时间
A	0	10	0	30	30
B	0	6	2	22	20
C	0	2	4	6	2
D	0	4	6	16	10
E	0	8	8	28	20

   A   B     C   D    E    A     B   D    E    A     B   E    A     E   A
|————|————|————|————|————|————|————|————|————|————|————|————|————|————|————|————>
0    2    4    6    8   10    12   14   16   18   20   22   24   26   28   30

在这个算法中，可以把时间片轮转法看作一个队列，在队列前面的先进行调度，但是和先来先服务算法不同是，各个进程是交叉进行的。而在先来先服务算法中则是 **在调度完成一整个作业(进程)** 后，再去调度其他的作业或者进程。从上面的时间轴可以看出，都在`一个时间片大小的时间里（这里是2ms）`进行调度，一直到一个进程调度完成，从上面的时间轴上还可以清楚的得出，每个进程的到达时间和开始时间也是不一样的。这一点和前面的几种算法也是稍微有区别。

说明

文章未完待续，后续算法持续更新。