调度算法 - 时间片轮转调度算法

囧九

已于 2024-10-17 10:52:56 修改

阅读量3.2k

点赞数 34

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

于 2024-10-17 10:52:26 首次发布

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

版权

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

9 篇文章

订阅专栏

操作系统的调度算法是操作系统核心模块之一，决定了如何有效地利用CPU资源，让多个进程共享系统资源。今天我们要深入探讨的调度算法之一是 时间片轮转调度算法（Round Robin Scheduling），这是一种非常经典且广泛使用的时间共享系统调度方式。

1. 时间片轮转调度算法的定义

时间片轮转调度算法是一种基于时间片的抢占式调度算法。它将 CPU 的时间分割为一个个固定长度的时间片（Time Slice），然后将这些时间片按顺序分配给每个进程。每个进程在它的时间片内执行任务，如果在时间片结束前完成任务，那么它会释放 CPU 供其他进程使用；如果未完成任务，则进程会被置于就绪队列的末尾，等待下一轮时间片。

时间片轮转调度的基本特点包括：

每个进程都有一个固定的时间片。
如果进程在时间片内没有完成，则会被挂起并移到队列的尾部。
该算法是抢占式的，可以提高系统响应时间。

2. 时间片轮转调度的流程

时间片轮转调度的工作原理可以分为以下步骤：

初始化就绪队列，将所有需要调度的进程加入队列。
调度器从队列中按顺序选择进程，并将其分配给CPU进行执行。
如果进程在其时间片内完成了执行，则从队列中移除。
如果进程未能在时间片内完成，则将其放回队列的末尾，等待下一轮调度。

时间片的大小对调度效率影响很大：

如果时间片太短，会频繁地进行上下文切换，增加系统的开销，降低CPU效率。
如果时间片太长，轮询的效果会更接近于先来先服务（FCFS），使系统响应性变差。

3. 举例分析

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

进程	到达时间 (ms)	执行时间 (ms)
P1	0	6
P2	2	4
P3	4	8

时间片大小设为 3ms。

调度过程：

时间 (ms)	执行进程	执行时长 (ms)	剩余执行时间 (ms)
0	P1	3	P1: 3
3	P2	3	P2: 1
6	P3	3	P3: 5
9	P1	3	P1: 0 (完成)
12	P2	1	P2: 0 (完成)
13	P3	3	P3: 2
16	P3	2	P3: 0 (完成)

第一轮：
- 时间 0ms：P1 执行 3ms，剩余 3ms。
- 时间 3ms：P2 到达并开始执行，执行 3ms，剩余 1ms。
- 时间 6ms：P3 到达并开始执行，执行 3ms，剩余 5ms。
第二轮：
- 时间 9ms：P1 执行 3ms，剩余 0ms，执行完成。
- 时间 12ms：P2 执行 1ms，剩余 0ms，执行完成。
- 时间 13ms：P3 执行 3ms，剩余 2ms。
第三轮：
- 时间 16ms：P3 执行 2ms，剩余 0ms，执行完成。

从上面的例子可以看出，时间片轮转调度让每个进程都能够公平地获得CPU时间，减少了单个进程长期独占CPU的问题，从而提高了系统的响应性。

4. 时间片轮转调度的优缺点

优点：

时间片轮转算法简单易实现。
适合多任务操作系统和需要较快响应时间的场景。
每个进程都能公平地得到CPU时间，避免某些进程长时间等待。

缺点：

如果时间片过小，频繁的上下文切换会导致大量的开销。
如果时间片过大，会使得系统响应性降低。
不适合实时任务调度，因为它不能保证特定任务在特定时间内完成。

5. 实现代码示例

我们可以用 C 语言来模拟时间片轮转调度的过程。以下是一个简单的代码示例，模拟了进程调度的过程：

#include <stdio.h>

#define MAX_PROCESSES 10

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

void round_robin_scheduling(Process processes[], int n, int time_slice) {
    int time = 0;
    int completed = 0;
    int i;
    while (completed < n) {
        for (i = 0; i < n; i++) {
            if (processes[i].remaining_time > 0 && processes[i].arrival_time <= time) {
                int execution_time = (processes[i].remaining_time < time_slice) ? processes[i].remaining_time : time_slice;
                time += execution_time;
                processes[i].remaining_time -= execution_time;
                printf("At time %dms: Executed Process %c for %dms\n", time, processes[i].pid, execution_time);

                if (processes[i].remaining_time == 0) {
                    completed++;
                    printf("Process %c completed\n", processes[i].pid);
                }
            }
        }
    }
}

int main() {
    Process processes[MAX_PROCESSES] = {
        {'P1', 0, 6, 6},
        {'P2', 2, 4, 4},
        {'P3', 4, 8, 8}
    };
    int n = 3;
    int time_slice = 3;
    round_robin_scheduling(processes, n, time_slice);
    return 0;
}

代码解释：

定义了一个结构体 Process，用于存储进程的ID、到达时间、执行时间以及剩余的执行时间。
函数 round_robin_scheduling 实现了时间片轮转调度的逻辑。它遍历所有进程，并根据到达时间和剩余执行时间来调度。
每当一个进程完成时，输出信息显示进程完成的时间。

输出结果：

At time 3ms: Executed Process P1 for 3ms
At time 6ms: Executed Process P2 for 3ms
At time 9ms: Executed Process P3 for 3ms
At time 12ms: Executed Process P1 for 3ms
Process P1 completed
At time 13ms: Executed Process P2 for 1ms
Process P2 completed
At time 16ms: Executed Process P3 for 3ms
At time 18ms: Executed Process P3 for 2ms
Process P3 completed