📌  相关文章
📜  抢占式优先级 CPU 调度算法

📅  最后修改于: 2022-05-13 01:57:01.195000             🧑  作者: Mango

抢占式优先级 CPU 调度算法

先决条件 - https://www.geeksforgeeks.org/cpu-scheduling-in-operating-systems/

介绍：

这是一种基于进程优先级来调度进程的先发制人方法。在该算法中，调度程序根据优先级调度任务工作。应该首先执行更高优先级的进程。当我们有 2 个优先级相同的进程时，我们会选择基于 FCFS（先到先服务）的进程。当它到达最终流程时，我们将根据优先级执行剩余的流程。

注意：数量越少，优先级越高

例如： 1是高优先级， 10 - 低优先级

程序：

  • Step-1：选择到达时间为0的第一个进程，我们需要选择该进程，因为该进程仅在时间t = 0时执行。
  • 步骤 2：检查下一个可用进程的优先级。

在这里，我们需要检查 3 个条件。

(i) 如果优先级(current_process) > 优先级(prior_process)则执行当前进程。

(ii) 如果优先级(current_process) > 优先级(prior_process)则执行优先进程。

(iii) 如果优先级(current_process) > 优先级(prior_process)则执行最先到达的进程，即到达时间

应该是第一。

  • 步骤 3：重复步骤 2 ，直到到达最终过程。
  • Step-4：当它到达最终进程时，选择具有最高优先级的进程并执行它。重复相同的步骤，直到所有进程完成执行。

注意：一个进程在其突发时间变为 0 时完成。

示例 1：考虑以下五个进程P1、P2、P3、P4和P5的到达时间、优先级和突发时间的表格。

ProcessArrival Time PriorityBurst Time
 P1   0 ms33 ms
 P2 1 ms24 ms
 P3 2 ms4   6 ms
 P4 3 ms6   4 ms
 P5 5 ms10   2 ms

工作：（对于输入1）：

Step-1：在到达时间t = 0时，进程P1执行 1ms，因为它的到达时间是从 0ms 到 1ms，因为它是就绪队列中的第一个进程。 P1 的剩余突发时间 (BT) = 3-1 = 2 ms。

Step-2：在时间t = 1时，进程P2的优先级高于P1 ，因此我们需要执行进程 P2 1ms。
P2 的剩余 BT = 4-1 = 3 ms。

Step-3：在时间t = 2时，进程P2的优先级高于P3 ，因此 P2 将再次执行 1 ms。
P2 的剩余 BT = 3-1 = 2 ms。

Step-4：在时间t = 3时，进程P2的优先级高于P4 ，因此 P2 现在将执行 2 ms，因为 P4 的到达时间是从 3 ms 到 5 ms。 P2 的剩余 BT = 2-2 = 0 ms。

-> 这里进程 P2 的执行完成，因为 P2 的突发时间为 0。
-> 这里进程的到达时间现在是 5，所以它已经到达所有进程。

Step-5：现在我们需要调度最高优先级的进程，这里我们将P1作为最高优先级，所以P1被完全执行，P1的剩余BT = 2-2 = 0 ms。

Step-6:同样地，对所有剩余进程基于优先级重复Step-5 ，直到所有进程完成它们的执行。

甘特图：

现在我们需要通过甘特图计算每个过程的完成时间（CT）和首到时间（FAT）。

CT -> P1-7 毫秒、P2-5 毫秒、P3-13 毫秒、P4-17 毫秒、P5-19 毫秒。
FAT -> P1-0 毫秒、P2-1 毫秒、P3-7 毫秒、P4-13 毫秒、P5-17 毫秒。

计算完以上字段后，最终的表格看起来像

这里， H – 较高优先级 L – 最低优先级

输出 ：

示例 2：

考虑以下七个进程 P1、P2、P3、P4、P5、P6 和 P7 的到达时间、优先级和突发时间的表格

ProcessArrival TimePriority  Burst Time
P1      0 ms3 8 ms
P2   1 ms4 2 ms
P3  3 ms4       4 ms
P4  4 ms5 1 ms
P5  5 ms2 6 ms
P6  6 ms6     5 ms
P7       10 ms1 1 ms

工作：（输入2）

步骤 1：在时间t = 0时，进程 P1 在就绪队列中可用，执行 P1 1 ms。
P1 的剩余 BT = 8-1 = 7 ms。

Step-2：在时间t = 1时，P1 的优先级大于 P2，所以我们执行 P1 2 ms，因为 P2 的到达时间是从 1 ms 到 3 ms。 P1 的剩余 BT = 7-2 = 5 ms。

Step-3：在时间t = 3时，P1 的优先级大于 P3，所以我们执行 P1 1 ms。
P1 的剩余 BT = 5-1 = 4 ms。

Step-4：在时间t = 4时，P1 的优先级大于 P4，所以我们执行 P1 1 ms。
P1 的剩余 BT = 4-1 = 3 ms。

Step-5：在时间t = 5时，P5 的优先级大于 P1，所以我们执行 P5 1 ms。
P5 的剩余 BT = 6-1 = 5 ms。

Step-6：在时间t = 6时，P5 的优先级大于 P6，所以我们执行 P5 4 ms。
P5 的剩余 BT = 5-4 = 1 ms。

Step-7：在时间t = 7时，P7 的优先级大于 P5，所以我们执行 P7 1 ms。
P7 的剩余 BT = 1-1 = 0 ms。
-> 在这里，进程 P7 完成了它的执行。

第8步：现在我们采用具有最高优先级的进程。在这里我们发现 P5 具有最高优先级并完全执行 P5 并且 P5 的剩余 BT = 1-1 = 0 ms。

Step-9：类似地根据优先级对所有剩余进程重复Step-8 ，直到所有进程完成它们的执行。

甘特图：

现在我们需要通过甘特图计算每个过程的完成时间（CT）和首到时间（FAT）。

CT -> P1-15 毫秒、P2-17 毫秒、P3-21 毫秒、P4-22 毫秒、P5-12 毫秒、P6-27 毫秒、P7-11 毫秒。

FAT -> P1-0 毫秒、P2-15 毫秒、P3-17 毫秒、P4-21 毫秒、P5-5 毫秒、P6-22 毫秒、P7-10 毫秒。

计算完以上字段后，最终的表格看起来像

这里， H – 较高优先级，L – 最低优先级

输出：

抢先优先级调度算法的缺点：

饥饿问题： 这是一个进程必须等待更长的时间才能被调度到 CPU 中的问题。这种情况称为饥饿问题。

示例：在示例 2 中，我们可以看到进程 P1 的优先级为 3，并且我们已经抢占了进程 P1 并将 CPU 分配给了 P5。这里我们只有 7 个进程。

现在，假设我们有许多优先级高于 P1 的进程，那么 P1 需要等待更长的时间才能让其他进程被 CPU 抢占和调度。这种情况称为饥饿问题。

解决方案：这个饥饿问题的解决方案是老化。

老化： 这可以通过将优先级数减少特定进程的特定数量来完成，该特定进程在特定间隔之后等待更长的时间段。

例子：每3个单位时间后，所有处于等待状态的进程，这些进程的优先级会降低2，所以，如果有一个进程P1的优先级为5，等待3个单位时间后它的优先级将从 5 降低到 3，因此如果有任何进程 P2 的优先级为 4，则该进程 P2 将等待并且 P1 将被调度和执行。

本文提供了这个调度过程的实现。