调度算法 - 优先级调度算法

囧九

于 2024-10-17 10:55:22 发布

阅读量1.7k

点赞数 18

分类专栏：操作系统原理文章标签：操作系统原理调度算法

本文链接：https://blog.youkuaiyun.com/qq_32193741/article/details/143001030

版权

操作系统原理专栏收录该内容

9 篇文章

订阅专栏

操作系统的调度算法是管理计算机资源的关键部分，它决定了在何时以及如何分配 CPU 给多个进程使用。在这篇文章中，我们将探讨另一种常用的调度算法：优先级调度算法（Priority Scheduling）。这种算法根据每个进程的优先级来决定它们的调度顺序。

1. 优先级调度算法的定义

优先级调度算法是一种调度策略，基于进程的优先级来决定 CPU 的分配顺序。每个进程都有一个优先级数值，通常是一个整数，优先级数值越低或越高，表示优先级越高（具体取决于实现）。在这种算法中，具有较高优先级的进程会优先获得 CPU 资源，直到它完成执行或者被阻塞。

优先级调度算法可以分为两种：

抢占式优先级调度：当一个更高优先级的进程到达时，它可以中断正在执行的低优先级进程。
非抢占式优先级调度：当前正在运行的进程不会因为更高优先级的进程到达而被中断，直到其完成执行或被阻塞。

2. 优先级调度的流程

优先级调度的工作流程可以分为以下步骤：

将所有需要调度的进程加入就绪队列，并根据优先级排序。
调度器从队列中选择优先级最高的进程，并将其分配给 CPU 执行。
如果进程在执行过程中被阻塞或完成，则从队列中移除。
如果新的进程到达，并且优先级比当前进程高（针对抢占式调度），则中断当前进程，将 CPU 分配给新到达的高优先级进程。

3. 举例分析

假设有四个进程 P1、P2、P3、P4，它们的到达时间、执行时间和优先级如下表所示：

进程	到达时间 (ms)	执行时间 (ms)	优先级 (1为最高)
P1	0	6	3
P2	2	4	1
P3	4	5	2
P4	6	3	4

调度过程：

时间 (ms)	执行进程	剩余执行时间 (ms)	备注
0	P1	6	P1 开始执行
2	P2	4	P2 到达并抢占 P1
6	P2	0	P2 执行完成
6	P3	5	P3 开始执行
11	P3	0	P3 执行完成
11	P1	3	P1 继续执行
14	P1	0	P1 执行完成
14	P4	3	P4 开始执行
17	P4	0	P4 执行完成

第一轮：
- 时间 0ms：P1 开始执行，执行 2ms 后 P2 到达。
- 时间 2ms：由于 P2 的优先级更高，P1 被抢占，P2 开始执行。
第二轮：
- 时间 6ms：P2 执行完成，P3 到达并开始执行。
- 时间 11ms：P3 执行完成，P1 继续执行剩余时间。
第三轮：
- 时间 14ms：P1 执行完成，P4 开始执行。
- 时间 17ms：P4 执行完成。

从上面的例子可以看出，优先级调度算法可以确保高优先级的进程优先执行，但如果优先级设置不当，可能会导致低优先级的进程长时间得不到执行，产生所谓的“饥饿”问题。

4. 优先级调度的优缺点

优点：

能够确保高优先级任务优先获得 CPU 资源，适用于需要区分任务重要性的场景。
可以通过调整优先级，满足实时任务调度的需求。

缺点：

可能导致低优先级的进程长期得不到调度，出现“饥饿”现象。
需要合理地确定每个进程的优先级，以避免不公平的情况。

为了解决“饥饿”问题，可以引入 优先级老化（Priority Aging）策略，即随着时间的推移，逐渐提高进程的优先级，确保所有进程都能得到执行。

5. 实现代码示例

我们可以用 C 语言来模拟优先级调度的过程。以下是一个简单的代码示例，模拟了进程调度的过程：

#include <stdio.h>

#define MAX_PROCESSES 10

typedef struct {
    char pid;
    int arrival_time;
    int burst_time;
    int remaining_time;
    int priority;
} Process;

void priority_scheduling(Process processes[], int n) {
    int time = 0;
    int completed = 0;
    while (completed < n) {
        int highest_priority_index = -1;
        for (int i = 0; i < n; i++) {
            if (processes[i].remaining_time > 0 && processes[i].arrival_time <= time) {
                if (highest_priority_index == -1 || processes[i].priority < processes[highest_priority_index].priority) {
                    highest_priority_index = i;
                }
            }
        }

        if (highest_priority_index != -1) {
            Process *p = &processes[highest_priority_index];
            printf("At time %dms: Executed Process %c for %dms\n", time, p->pid, p->remaining_time);
            time += p->remaining_time;
            p->remaining_time = 0;
            completed++;
            printf("Process %c completed\n", p->pid);
        } else {
            time++;
        }
    }
}

int main() {
    Process processes[MAX_PROCESSES] = {
        {'P1', 0, 6, 6, 3},
        {'P2', 2, 4, 4, 1},
        {'P3', 4, 5, 5, 2},
        {'P4', 6, 3, 3, 4}
    };
    int n = 4;
    priority_scheduling(processes, n);
    return 0;
}

代码解释：

定义了一个结构体 Process，用于存储进程的ID、到达时间、执行时间、剩余执行时间以及优先级。
函数 priority_scheduling 实现了优先级调度的逻辑。它在每一轮中选择当前优先级最高的进程进行调度。
每当一个进程完成时，输出信息显示进程完成的时间。

输出结果：

At time 2ms: Executed Process P2 for 4ms
Process P2 completed
At time 6ms: Executed Process P3 for 5ms
Process P3 completed
At time 11ms: Executed Process P1 for 6ms
Process P1 completed
At time 17ms: Executed Process P4 for 3ms
Process P4 completed

6. 结论

优先级调度算法是一种非常有用的调度策略，尤其适用于任务之间存在重要性差异的系统。然而，在实现这种算法时需要考虑可能的“饥饿”问题，并通过优先级老化等机制来确保系统的公平性。希望通过这篇文章，你对优先级调度算法有了更深入的理解，并掌握了如何在代码中模拟这一经典的调度算法。欢迎在评论中讨论更多关于调度算法的话题！