操作系统的任务调度算法-CSDN博客

本文链接：https://blog.csdn.net/2301_80320652/article/details/145576843

本篇博客涵盖：

任务调度的核心概念
五大经典调度算法（含 Java 实现）
性能分析与适用场景
现代操作系统中的实际应用

1. 任务调度的核心概念

1.1 什么是任务调度？

任务调度（Task Scheduling）是指 操作系统按照一定的规则分配 CPU 资源，决定哪个进程先执行、执行多长时间，以及何时切换任务。

在多任务系统中，多个进程同时竞争 CPU，合理的调度算法可以提高系统吞吐量、减少响应时间，并优化用户体验。

1.2 调度的三大类别

操作系统中的调度机制可以分为以下三类：

调度类型	作用	触发时机
长期调度（Long-Term Scheduling）	选择哪些任务可以进入内存，控制系统的负载	任务进入系统
短期调度（Short-Term Scheduling）	决定哪个进程获得 CPU 执行	CPU 空闲时
中期调度（Medium-Term Scheduling）	负责挂起或恢复进程，优化内存使用	内存不足或进程等待 IO

其中，短期调度最为关键，它直接影响系统性能，因此本文主要探讨 短期任务调度算法。

2. 五大经典任务调度算法

2.1 先来先服务（FCFS, First Come First Serve）

📌 原理： 按照进程到达的顺序进行调度，先到先执行。
📌 特点：
✅ 简单易实现，所有进程公平竞争 CPU。
❌ 可能导致“拖尾效应”（Convoy Effect），即长进程会影响短进程的执行。

示例：

进程	到达时间	执行时间
P1	0	6
P2	1	4
P3	2	2

执行顺序：

时间线: 0 ---- P1(6) ---- 6 ---- P2(4) ---- 10 ---- P3(2) ---- 12

Java 实现

import java.util.*;

class Process {
    int arrivalTime, burstTime;

    public Process(int arrivalTime, int burstTime) {
        this.arrivalTime = arrivalTime;
        this.burstTime = burstTime;
    }
}

public class FCFS_Scheduling {
    public static void main(String[] args) {
        List<Process> processes = Arrays.asList(
            new Process(0, 6),
            new Process(1, 4),
            new Process(2, 2)
        );

        processes.sort(Comparator.comparingInt(p -> p.arrivalTime)); // 按到达时间排序

        int time = 0;
        for (Process p : processes) {
            int waitTime = Math.max(0, time - p.arrivalTime);
            System.out.println("进程到达: " + p.arrivalTime + ", 执行时间: " + p.burstTime + ", 等待时间: " + waitTime);
            time += p.burstTime;
        }
    }
}

2.2 短作业优先（SJF, Shortest Job First）

📌 原理： 优先调度执行时间最短的进程，减少平均等待时间。
📌 特点：
✅ 等待时间最短，吞吐量高。
❌ 可能导致饥饿问题（短作业不断到达，长作业可能一直得不到执行）。

Java 实现

public class SJF_Scheduling {
    public static void main(String[] args) {
        List<Process> processes = Arrays.asList(
            new Process(0, 6),
            new Process(1, 4),
            new Process(2, 2)
        );

        processes.sort(Comparator.comparingInt(p -> p.burstTime)); // 按执行时间排序

        int time = 0;
        for (Process p : processes) {
            int waitTime = Math.max(0, time - p.arrivalTime);
            System.out.println("进程到达: " + p.arrivalTime + ", 执行时间: " + p.burstTime + ", 等待时间: " + waitTime);
            time += p.burstTime;
        }
    }
}

2.3 轮转调度（RR, Round Robin）

📌 原理： 每个进程按照 时间片 轮流执行，超时后切换到下一个进程。
📌 特点：
✅ 适用于交互式系统，防止进程饿死。
❌ 时间片选择过短会增加 CPU 上下文切换的开销。

Java 实现

import java.util.LinkedList;
import java.util.Queue;

public class RR_Scheduling {
    public static void main(String[] args) {
        Queue<Process> queue = new LinkedList<>();
        queue.add(new Process(0, 5));
        queue.add(new Process(1, 3));
        queue.add(new Process(2, 2));

        int timeSlice = 2, time = 0;
        while (!queue.isEmpty()) {
            Process p = queue.poll();
            int executionTime = Math.min(timeSlice, p.burstTime);
            System.out.println("进程 " + p.arrivalTime + " 运行 " + executionTime + " 时间");
            time += executionTime;
            if (p.burstTime > timeSlice) {
                queue.add(new Process(p.arrivalTime, p.burstTime - timeSlice)); // 重新加入队列
            }
        }
    }
}

3. 现代操作系统任务调度的优化

现代操作系统如 Linux、Windows、macOS 采用更高级的任务调度机制：

Linux CFS（Completely Fair Scheduler）：基于红黑树的公平调度算法，使 CPU 资源更加公平地分配。
Windows NT 任务调度：优先级+抢占式调度，保证前台应用的流畅性。
Android O（8.0+）调度：优化了 Background Execution Limits，限制后台进程的 CPU 占用，提升前台任务响应速度。

4. 总结

调度算法	适用场景	优点	缺点
FCFS	批处理	简单	可能导致长时间等待
SJF	任务时间已知	最短平均等待时间	可能饿死长任务
RR	交互式系统	公平	时间片选择关键