【操作系统】进程调度（1）：FIFO（先进先出）算法 原理与实践_fifo调度算法

0 前言

本文基于书籍《Operating System：Three Easy Pieces》。

中译本：《操作系统导论》，中译本质量还可以，但是英文版后来的更新，中文版目前没有进行同步更新（写下此文的时间是2020年10月）

1 前提铺垫

1.1 进程的设定

我们知道，进行进程调度的前提是

• 硬件和OS的底层，能够支持上下文切换，这里我们假设已经实现
• 内存中要有就绪态的进程！

我们基于第二点，再做进一步的假设，以简化问题，对于已经进入或者即将进入内存的进程，我们它们假设：

1. 工作时间相同
2. 进程同时到达系统
3. 一旦开始，进程保持运行一直到其完成
4. 只使用CPU，不使用IO
5. 运行时间都是已知的

我先来解释一下这几点假设

• 第2点：意味着有好多个等着被调度进入CPU执行的进程，坐等操作系统“翻牌子”
• 第3点：意味着进程将会顺序执行，而不是我们所知道的快速切换式执行，先不要产生反对，这将简化一些原理和概念
• 第4点：意味着进程的指令，没有IO相关的指令，只有使用CPU的指令。
• 第1、5点：显然这是荒谬的假设，进程运行完成前，不可能预测未来知道它的运行时间，但是这有助于理解概念，我们先认可这样的假设！

1.2 调度指标：周转时间

周转时间 = 任务完成时间 - 任务到达时间

也就是任务到达系统的时间，与任务被执行完的时间之差。这是个性能指标，它反应了任务等待 + 执行的时间。

这里，任务到达系统是什么意思？进入就绪态吗? 暂时是不清楚，待解决。

周转时间为：T1 - T0

2 FIFO原理

FIFO（First In First Out）先进先出，也可以是FCFS（First Come First Serve 先来先服务）

2.1 算法

我们假设有3个进程A、B和C，首先强调，进程只能顺序执行，让我们充分体会一下先进先出算法的原理。

放宽任务同时到达的条件，假设A比B先到一点点，B比C先到一点点，这样，根据FIFO的原理，执行顺序应该是：

• A先执行
• A执行完，B再执行
• B执行完，C再执行

该算法的特点是，先到达的任务，先执行，就像食堂排队一样，先来的人应该先买饭，这看起来很公平，不是吗？

我们具体一点，举个例子，根据前面的假设，我们假定

• A、B和C的运行时间已知，且差不多
• 假设三个任务的执行时间都是10s

因为3个进程几乎同时到达，我们假定到达时间 = 0，这样一来，三个进程的周转时间为：

• A：10s
• B：20s
• C：30s

平均周转时间：（10 + 20 + 30）/3 = 10s

2.2 缺点：护航效应

我们现在将每个任务运行时间差不多的假设放宽，假设：

• A：100s
• B：1s
• C：1s

这样一来，每个进程的周转时间

• A：100s
• B：101s
• C：102s

平均周转时间（100 + 101 + 102）/3 = 101s，哦！这看起来很糟糕。

B和C使用的资源很少，但是却排在重量级的A后面，这就是护航效应，看来FIFO的算法，也并不是看起来那么公平。

这就像，你在超市排队结账，你只买了１包薯片，而你前面的人买了３个购物车的商品……我们需要更优化的算法！之后会提及。

接下来，我们使用模拟程序，来体验一下FIFO算法。

3 FIFO 实践

我们使用一开始提及的书中的模拟软件，来体验一下FIFO算法。

模拟程序链接，注意需要使用Linux / UNIX系统。

我们输入

./scheduler.py -p FIFO -j 5 -s 100 -m 30 -c
1

然后我们看见显示（你的和我的结果不一样，因为这是随机种子，数值是随机给出，详情需要参考README.md文档）

ARG policy FIFO
ARG jobs 5
ARG maxlen 30
ARG seed 100

Here is the job list, with the run time of each job: 
  Job 0 ( length = 5 )
  Job 1 ( length = 14 )
  Job 2 ( length = 24 )
  Job 3 ( length = 22 )
  Job 4 ( length = 22 )
1
2
3
4
5
6
7
8
9
10
11

我们看到，我们使用FIFO算法，生成了5个job，每个job都有对应的运行时间，并且有编号，这里编号其实就代表顺序了，因为是FIFO算法。

我们很容易得到一些性能指标，是的，这非常简单！自己算一算，然后参考一下答案，在刚才的命令后面加上-c就可以。

** Solutions **

Execution trace:
  [ time   0 ] Run job 0 for 5.00 secs ( DONE at 5.00 )
  [ time   5 ] Run job 1 for 14.00 secs ( DONE at 19.00 )
  [ time  19 ] Run job 2 for 24.00 secs ( DONE at 43.00 )
  [ time  43 ] Run job 3 for 22.00 secs ( DONE at 65.00 )
  [ time  65 ] Run job 4 for 22.00 secs ( DONE at 87.00 )

Final statistics:
  Job   0 -- Response: 0.00  Turnaround 5.00  Wait 0.00
  Job   1 -- Response: 5.00  Turnaround 19.00  Wait 5.00
  Job   2 -- Response: 19.00  Turnaround 43.00  Wait 19.00
  Job   3 -- Response: 43.00  Turnaround 65.00  Wait 43.00
  Job   4 -- Response: 65.00  Turnaround 87.00  Wait 65.00

  Average -- Response: 26.40  Turnaround 43.80  Wait 26.40

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

这里的参考指标有3个，分别是

• 周转时间：任务完成时间 - 任务到达时间
• 响应时间：任务第一次被执行时间 - 任务到达时间
• 等待时间：任务到达后，完成前，没有运行的时间之和

下面我们来体会一下1，1，100和100，1，1的差别，这里不再给出过程，直接给答案。

100，1，1

Average -- Response: 67.00  Turnaround 101.00  Wait 67.00
1

1，1，100

Average -- Response: 1.00  Turnaround 35.00  Wait 1.00
1

你可以充分体会到，FIFO真的是个有点糟糕的算法……看来先来先服务的方式也不太公平呀，再想一下，如果排在你前面办理银行业务的人，办理时间非常长，你是不是抓狂了？

4 重要思想

1. 先进先出，先来先服务的队列思想，这点算法与数据结构的队列有异曲同工之妙
2. 底层机制 + 上层策略思想：底层机制允许进行上下文切换（进程切换），上层策略采用了FIFO算法，从而实现了简单的进程调度。

先进先出的算法，非常容易理解，也非常简单，先来的任务就先执行，后来的任务需要等着之前的任务执行完，再执行，依次类推，这与你在食堂排队打饭没什么区别。

5 预告：进程调度（2a）：SJF（短任务优先） 算法 原理与实践

既然FIFO会造成护航效应的问题，我们就改善一下，让短的任务先来执行不就好了~~请看下一篇文章：进程调度（2a）：SJF（短任务优先） 算法 原理与实践

6 模拟软件资源链接

模拟软件：Linux下使用的python文件，需要阅读README.md知道软件如何使用，读者可以自行完成模拟，后续的进程调度章节都用的此软件。