操作系统复习知识点（第三章）

处理机调度

1.高级调度、中级调度、低级调度

• 高级调度：根据某种算法，把外存上处于后备队列中的那些作业调入内存。(作业调度)
• 中级调度：为了提高内存利用率和系统吞吐量，使那些暂时不能运行的进程不再占用内存资源，将它们调至外存等待，把进程状态改为就绪驻外存状态或挂起状态。（进程调度）
• 低级调度：保存处理机的现场信息，按某种算法先取进程，再把处理器分配给进程。

2.作业、作业步、作业流

• 作业：包含通常的程序和数据，还配有作业说明书，系统根据该说明书对程序的运行进行控制。批处理系统中是以作业为基本单位从外存调入内存的。
• 作业步：是指每个作业运行期间都必须经过若干个相对独立互相关联的顺序加工的步骤。
• 作业流：是指若干个作业进入系统后依次存放在外存上形成的输入作业流；在操作系统的控制下，逐个作业进程处理，于是形成了处理作业流。

3.JCB（作业控制块）

• 每当作业进入系统时，系统便为每个作业建立一个作业控制块JCB，根据作业类型将它插入到相应的后备队列中。
• 作业控制块（JCB）的内容
  • 作业号
  • 作业类别
  • 用户名及用户账号
  • 作业状态
  • 提交到系统的时间
  • 优先级别（或者响应比）
  • 作业所在的外存设置
  • 资源需求
  • 运行长度
  • 已经运行时间
  • 其他信息（收费标准，JCB队列指针）

4.在抢占调度方式中，抢占的原则是什么？

• 时间片原则（分时系统的调度算法：时间片轮转法）
• 优先权原则（实时系统的调度算法：最早截止时间优先即EDF）
• 短作业优先权原则（批处理系统的调度算法：短作业优先）

5.作业调度算法

• FCSF先来先服务调度算法

  • 作业等待时间得长短。比较有利于长作业（进程），而不利于短作业（进程）。

• SJF短作业优先调度算法

  • 优点：能有效的降低作业的平均等待事件，提高系统吞吐量。
  • 缺点：对长作业不利；该算法完全未考虑作业的紧迫程度，因而不能保证紧迫性作业（进程）会被及时处理；由于作业（进程）的长短含主观因素，不一定能真正做到短作业优先。

 周转时间 = 作业完成时刻 - 作业到达时刻

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

• 高响应比优先调度算法

• 高响应比优先调度算法主要用于作业调度，该算法是对FCFS调度算法和SJF调度算法的一种综合平衡，同时考虑每个作业的等待时间和估计的运行时间。在每次进行作业调度时，先计算后备作业队列中每个作业的响应比，从中选出响应比最高的作业投入运行。

作业	到达时间	服务时间
A	0	6
B	3	2
C	4	4
D	4	1

1.先执行A作业，其余再通过响应比判断执行哪个；

作业	到达时间	服务时间	开始时间	结束时间	周转时间	带权周转时间
A	0	6	0	6	6	1
B	3	2
C	4	4
D	4	1

 2.根据响应比，执行D作业；

• R（B） = 1 + （6 - 3）/ 2 = 2.5
• R（C） = 1 + （6 - 4）/ 4 = 1.5
• R（D）= 1 + （6 - 4） / 1 = 3

作业	到达时间	服务时间	开始时间	结束时间	周转时间	带权周转时间
A	0	6	0	6	6	1
B	3	2
C	4	4
D	4	1	6	7	3	3

3.根据响应比，执行B作业；

• R（B） = 1 + （7 - 3）/ 2 = 2
• R（C） = 1 + （7 - 4）/ 4 = 0.75

作业	到达时间	服务时间	开始时间	结束时间	周转时间	带权周转时间
A	0	6	0	6	6	1
B	3	2	7	10	7	3.5
C	4	4
D	4	1	6	7	3	3

4.执行最后C作业。

作业	到达时间	服务时间	开始时间	结束时间	周转时间	带权周转时间
A	0	6	0	6	6	1
B	3	2	7	10	7	3.5
C	4	4	10	14	10	2.5
D	4	1	6	7	3	3

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

等待时间 = 上一个作业调入完成时间 - 该作业到达的时间

• 当作业的等待时间相同时，则要求服务时间越短，其响应比越高，有利于短作业；
• 当要求服务时间相同时，作业的响应比由其等待时间决定，等待时间越长，其响应比越高，因而它实现的是先来先服务；
• 对于长作业，作业的响应比可以随等待时间的增加而提高，当其等待时间足够长时，其响应比便可升到很高，从而也可获得处理机，克服了饥饿状态，兼顾了长作业。

6.死锁

• 死锁的概念

  • 死锁是指多个进程因竞争资源而造成的一种僵局，若无外力作用，这些进程都将永远不能再向前推进。死锁一定是“循环等待对方手里的资源”导致的，因此如果有死锁现象，那至少有两个或两个以上的进程同时发生死锁。另外，发生死锁的进程一定处于阻塞态

• 死锁的必要条件

  • 互斥条件：只有对必须互斥使用的资源的争抢才会导致死锁（如哲学家的筷子、打印机设备）。像内存、扬声器这样可以同时让多个进程使用的资源是不会导致死锁的（因为进程不用阻塞等待这种资源）。
  • 不剥夺条件：进程所获得的资源在未使用完之前，不能由其他进程强制夺走，只能主动释放。
  • 请求和保持条件：进程已经保持了至少一个资源但又提出了新的资源请求，而该资源又被其他进程占有，此时请求进程被阻塞，但又对自己已有的资源保持不放。
  • 循环等待条件：存在一种进程资源的循环等待链，链中的每一个进程已获得的资源同时被下一个进程所请求。发生死锁时一定有循环等待，但是发生循环等待时不一定。

• 产生死锁的原因

  • 对临界资源的竞争：各进程对不可剥夺的资源的竞争可能引起死锁。
  • 进程推进顺序非法：请求和释放资源的顺序不当，同样会导致死锁。例如,并发执行的进程P1、P2两者分别申请并占有了资源R1、R2，之后进程P1又紧接着申请资源R2，而进程P2又申请资源R1，两者会因为申请的资源被对方占有而阻塞，从而发生了死锁。

• 解决死锁问题的方法

  • 预防死锁（最容易实现）
    • 摒弃“请求和保持”条件
    • 摒弃“不剥夺”条件
    • 摒弃“环路等待”条件
  • 避免死锁（银行家算法）
  • 检测和解除死锁

7.银行家算法

• 安全序列：是指一个进程序列{P1，…，Pn}是安全的，即对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。
• 安全状态：如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。安全状态一定是没有死锁发生。
• 不安全状态：如果分配了资源以后，系统找不出任何一个安全序列，就进入了不安全状态。这就意味着可能所有进程都无法顺利进行下去。如果系统处于不安全状态，不一定发生死锁，但发生死锁一定是在不安全状态

数据结构：

• 可利用资源向量Available：是个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目。如果Available[j]=K，则表示系统中现有Rj类资源K个。
• 最大需求矩阵Max：这是一个n×m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。如果Max[i,j]=K，则表示进程i需要Rj类资源的最大数目为K。
• 分配矩阵Allocation：这也是一个n×m的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。如果Allocation[i,j]=K，则表示进程i当前已分得Rj类资源的数目为K。
• 需求矩阵Need：这也是一个n×m的矩阵，用以表示每一个进程尚需的各类资源数。如果Need[i,j]=K，则表示进程i还需要Rj类资源K个，方能完成其任务。

下面是三者之间的关系:

Need[i,j]=Max[i,j]-Allocation[i,j]

(尚需资源数=最大资源需求数-已分配资源数)

银行家算法步骤:

请求向量Request(i)：是进程Pi的请求向量，如果Request(i)[j]=k，表示进程Pi需要K个R(j)类型的资源。当Pi发现资源请求后系统将进行下列步骤:

1. 如果Request(i)[j] <= Need[i,j],即请求量未超过尚需量，继续执行步骤2,否则认为出错，因为它所请求的资源数已超过它所宣布的最大值。
2. 如果Request(i)[j] <= Available[i,j]，即请求量未超过可分配资源量，继续执行步骤3，否则，表示尚无足够资源，Pi需等待。
3. 系统试探着把资源分配给进程Pi，并需要修改下面数据结构中的数值；                           

Available[j] = Available[j] - Request(i)[j];（可利用资源数减少）

Allocation[i,j] = Allocation[i,j] + Request(i)[j];（已分配资源数增加）

Need[i,j] = Need[i,j] - Request(i)[j];（尚需资源数减少）

      4.系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。若安全，才正式将资源分配给进程Pi，已完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。

安全性算法步骤：

（1）设置两个向量：

• 工作向量Work：表示系统可供进程继续运行所需的各类资源数目，它有m个元素，开始时，Work=Available;
• Finish:表示系统是否有足够的资源分配给进程，使之运行完成。开始时，Finish[i] = false；当有足够资源分配给进程时，再令Finish[i] = true。

（2）从进程集合中找到一个能满足下述条件的进程：

              1.Finish[i] = false

              2.Need[i,j] <= Work[j]（进程所需资源量未超过可分配资源量）;

              3.若都满足，执行步骤（3），否则执行步骤（4）

（3）当进程Pi获得资源后，可顺利执行至完成，并释放分配给它的资源，故应执行：

            Work[j] = Work[j] + Allocation[i,j]；

Finish[i] = true；

go to step （2）；

（4）所有进程的Finish[i] = true，表示系统处于安全状态；否则，系统处于不安全状态。

                           

举例：