引言
在计算机系统的运行中，操作系统就像是一位幕后的总指挥，协调着各种资源的分配和任务的执行。而任务调度算法则是这位总指挥手中的关键策略，它决定了如何将 CPU 时间合理地分配给各个任务，从而影响着整个系统的性能和效率。无论是我们日常使用的手机、电脑，还是支撑大型业务的服务器，任务调度算法都在默默地发挥着重要作用。本文将详细介绍常见的任务调度算法，通过 Java 代码示例帮助大家更好地理解其实现原理，并探讨它们在不同场景下的应用。
任务调度算法基础概念
什么是任务调度
简单来说，任务调度就是操作系统根据一定的规则，在多个等待执行的任务之间分配 CPU 时间的过程。想象一下，操作系统就像一个繁忙的机场，各个任务就像是等待起飞的航班，而调度算法则决定了哪架航班先起飞、飞行多久，以及何时轮到下一架航班。
调度的目标
- 公平性：确保每个任务都能获得合理的 CPU 时间，避免某些任务长时间得不到执行而处于“饥饿”状态。
- 效率：提高系统的整体吞吐量，即在单位时间内完成更多的任务。同时，尽量减少任务的响应时间（从任务提交到首次执行的时间间隔）和周转时间（从任务提交到任务完成的总时间）。
- 资源利用率：合理利用 CPU、内存等系统资源，避免资源闲置浪费。例如，当 CPU 空闲时，及时调度任务执行，提高 CPU 的利用率。
调度时机
- 进程主动放弃 CPU：当进程执行 I/O 操作（如读取文件、网络通信等）时，由于 I/O 操作速度较慢，进程会主动释放 CPU，让其他进程有机会执行。此时，操作系统会调度其他就绪进程。
- 时间片用完：在一些调度算法中，为每个进程分配固定的时间片。当进程的时间片用完后，操作系统会暂停当前进程，将 CPU 分配给其他进程。
- 新进程到达：当有新的进程进入系统的就绪队列时，操作系统会根据调度算法决定是否立即调度该新进程执行。
- 进程终止：当一个进程执行完毕或因异常终止时，操作系统会回收其占用的资源，并从就绪队列中选择下一个进程执行。
常见任务调度算法及 Java 代码示例
先来先服务（FCFS, First - Come, First - Served）
原理
按照任务进入就绪队列的先后顺序进行调度，先进入队列的任务先获得 CPU 资源，直到任务完成或主动放弃 CPU。
示例代码
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
class Process {
int pid;
int arrivalTime;
int burstTime;
int waitingTime;
int turnaroundTime;
public Process(int pid, int arrivalTime, int burstTime) {
this.pid = pid;
this.arrivalTime = arrivalTime;
this.burstTime = burstTime;
this.waitingTime = 0;
this.turnaroundTime = 0;
}
}
public class FCFS {
public static void fcfsScheduling(List<Process> processes) {
// 按到达时间排序
Collections.sort(processes, Comparator.comparingInt(p -> p.arrivalTime));
int currentTime = 0;
int totalWaitingTime = 0;
int totalTurnaroundTime = 0;
for (Process process : processes) {
if (currentTime < process.arrivalTime) {
currentTime = process.arrivalTime;
}
process.waitingTime = currentTime - process.arrivalTime;
process.turnaroundTime = process.waitingTime + process.burstTime;
totalWaitingTime += process.waitingTime;
totalTurnaroundTime += process.turnaroundTime;
currentTime += process.burstTime;
}
double avgWaitingTime = (double) totalWaitingTime / processes.size();
double avgTurnaroundTime = (double) totalTurnaroundTime / processes.size();
System.out.println("平均等待时间: " + avgWaitingTime);
System.out.println("平均周转时间: " + avgTurnaroundTime);
}
public static void main(String[] args) {
List<Process> processes = new ArrayList<>();
processes.add(new Process(1, 0, 3));
processes.add(new Process(2, 1, 1));
processes.add(new Process(3, 2, 2));
fcfsScheduling(processes);
}
}
优缺点
- 优点：算法简单，易于实现，遵循公平原则，对每个任务一视同仁。
- 缺点：对于长任务有利，可能导致短任务等待时间过长，降低系统整体效率。
短作业优先（SJF, Shortest Job First）
原理
从就绪队列中选择预计执行时间最短的任务进行调度，目的是最小化平均周转时间。
示例代码
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
class SJFProcess {
int pid;
int arrivalTime;
int burstTime;
int waitingTime;
int turnaroundTime;
boolean completed;
public SJFProcess(int pid, int arrivalTime, int burstTime) {
this.pid = pid;
this.arrivalTime = arrivalTime;
this.burstTime = burstTime;
this.waitingTime = 0;
this.turnaroundTime = 0;
this.completed = false;
}
}
public class SJF {
public static void sjfScheduling(List<SJFProcess> processes) {
int currentTime = 0;
int completedProcesses = 0;
int totalWaitingTime = 0;
int totalTurnaroundTime = 0;
while (completedProcesses < processes.size()) {
List<SJFProcess> readyProcesses = new ArrayList<>();
for (SJFProcess process : processes) {
if (!process.completed && process.arrivalTime <= currentTime) {
readyProcesses.add(process);
}
}
if (readyProcesses.isEmpty()) {
currentTime++;
continue;
}
SJFProcess shortestJob = readyProcesses.stream()
.min(Comparator.comparingInt(p -> p.burstTime))
.get();
shortestJob.waitingTime = currentTime - shortestJob.arrivalTime;
shortestJob.turnaroundTime = shortestJob.waitingTime + shortestJob.burstTime;
totalWaitingTime += shortestJob.waitingTime;
totalTurnaroundTime += shortestJob.turnaroundTime;
currentTime += shortestJob.burstTime;
shortestJob.completed = true;
completedProcesses++;
}
double avgWaitingTime = (double) totalWaitingTime / processes.size();
double avgTurnaroundTime = (double) totalTurnaroundTime / processes.size();
System.out.println("平均等待时间: " + avgWaitingTime);
System.out.println("平均周转时间: " + avgTurnaroundTime);
}
public static void main(String[] args) {
List<SJFProcess> processes = new ArrayList<>();
processes.add(new SJFProcess(1, 0, 3));
processes.add(new SJFProcess(2, 1, 1));
processes.add(new SJFProcess(3, 2, 2));
sjfScheduling(processes);
}
}
优缺点
- 优点：能有效减少平均周转时间，提高系统吞吐量，让短任务尽快完成。
- 缺点：需要预先知道每个任务的执行时间，实际中难以做到。如果不断有短任务进入，长任务可能会长期得不到执行，产生饥饿现象。
优先级调度算法
原理
为每个任务分配一个优先级，调度时选择优先级最高的任务执行。优先级可以根据任务类型、紧急程度等因素确定。
示例代码
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
class PriorityProcess {
int pid;
int arrivalTime;
int burstTime;
int priority;
int waitingTime;
int turnaroundTime;
boolean completed;
public PriorityProcess(int pid, int arrivalTime, int burstTime, int priority) {
this.pid = pid;
this.arrivalTime = arrivalTime;
this.burstTime = burstTime;
this.priority = priority;
this.waitingTime = 0;
this.turnaroundTime = 0;
this.completed = false;
}
}
public class PriorityScheduling {
public static void priorityScheduling(List<PriorityProcess> processes) {
int currentTime = 0;
int completedProcesses = 0;
int totalWaitingTime = 0;
int totalTurnaroundTime = 0;
while (completedProcesses < processes.size()) {
List<PriorityProcess> readyProcesses = new ArrayList<>();
for (PriorityProcess process : processes) {
if (!process.completed && process.arrivalTime <= currentTime) {
readyProcesses.add(process);
}
}
if (readyProcesses.isEmpty()) {
currentTime++;
continue;
}
PriorityProcess highestPriorityJob = readyProcesses.stream()
.min(Comparator.comparingInt(p -> p.priority))
.get();
highestPriorityJob.waitingTime = currentTime - highestPriorityJob.arrivalTime;
highestPriorityJob.turnaroundTime = highestPriorityJob.waitingTime + highestPriorityJob.burstTime;
totalWaitingTime += highestPriorityJob.waitingTime;
totalTurnaroundTime += highestPriorityJob.turnaroundTime;
currentTime += highestPriorityJob.burstTime;
highestPriorityJob.completed = true;
completedProcesses++;
}
double avgWaitingTime = (double) totalWaitingTime / processes.size();
double avgTurnaroundTime = (double) totalTurnaroundTime / processes.size();
System.out.println("平均等待时间: " + avgWaitingTime);
System.out.println("平均周转时间: " + avgTurnaroundTime);
}
public static void main(String[] args) {
List<PriorityProcess> processes = new ArrayList<>();
processes.add(new PriorityProcess(1, 0, 3, 2));
processes.add(new PriorityProcess(2, 1, 1, 3));
processes.add(new PriorityProcess(3, 2, 2, 1));
priorityScheduling(processes);
}
}
优缺点
- 优点：可依据任务的重要性与紧急程度，合理分配 CPU 资源，确保关键任务能及时得到处理。
- 缺点：若优先级设置不合理，可能导致低优先级任务长期无法执行，产生饥饿问题。此外，如何科学合理地设置任务优先级也是一大挑战。
时间片轮转调度算法（Round - Robin）
原理
把 CPU 时间划分成固定长度的时间片，每个任务轮流获得一个时间片来执行。当时间片用完后，即使任务尚未完成，也会被暂停，放入就绪队列末尾，等待下一轮调度。
示例代码
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
class RRProcess {
int pid;
int arrivalTime;
int burstTime;
int remainingTime;
int waitingTime;
int turnaroundTime;
public RRProcess(int pid, int arrivalTime, int burstTime) {
this.pid = pid;
this.arrivalTime = arrivalTime;
this.burstTime = burstTime;
this.remainingTime = burstTime;
this.waitingTime = 0;
this.turnaroundTime = 0;
}
}
public class RoundRobin {
public static void roundRobinScheduling(List<RRProcess> processes, int timeSlice) {
int currentTime = 0;
int completedProcesses = 0;
int totalWaitingTime = 0;
int totalTurnaroundTime = 0;
Queue<RRProcess> readyQueue = new LinkedList<>();
int index = 0;
while (completedProcesses < processes.size()) {
// 将到达的进程加入就绪队列
while (index < processes.size() && processes.get(index).arrivalTime <= currentTime) {
readyQueue.add(processes.get(index));
index++;
}
if (readyQueue.isEmpty()) {
currentTime++;
continue;
}
RRProcess currentProcess = readyQueue.poll();
if (currentProcess.remainingTime <= timeSlice) {
currentTime += currentProcess.remainingTime;
currentProcess.remainingTime = 0;
completedProcesses++;
currentProcess.turnaroundTime = currentTime - currentProcess.arrivalTime;
currentProcess.waitingTime = currentProcess.turnaroundTime - currentProcess.burstTime;
} else {
currentTime += timeSlice;
currentProcess.remainingTime -= timeSlice;
// 将未完成的进程重新加入队列末尾
while (index < processes.size() && processes.get(index).arrivalTime <= currentTime) {
readyQueue.add(processes.get(index));
index++;
}
readyQueue.add(currentProcess);
}
totalWaitingTime += currentProcess.waitingTime;
totalTurnaroundTime += currentProcess.turnaroundTime;
}
double avgWaitingTime = (double) totalWaitingTime / processes.size();
double avgTurnaroundTime = (double) totalTurnaroundTime / processes.size();
System.out.println("平均等待时间: " + avgWaitingTime);
System.out.println("平均周转时间: " + avgTurnaroundTime);
}
public static void main(String[] args) {
List<RRProcess> processes = new ArrayList<>();
processes.add(new RRProcess(1, 0, 5));
processes.add(new RRProcess(2, 1, 3));
processes.add(new RRProcess(3, 2, 8));
processes.add(new RRProcess(4, 3, 6));
int timeSlice = 2;
roundRobinScheduling(processes, timeSlice);
}
}
优缺点
- 优点：能保证每个任务都有机会在一定时间内获得 CPU 资源，响应时间较好，适合交互式系统，让用户的操作能及时得到处理。
- 缺点：时间片的设置很关键，如果设置过长，会退化为先来先服务算法，影响短任务的响应；如果设置过短，会导致频繁的上下文切换，增加系统开销。
多级反馈队列调度算法（Multilevel Feedback Queue）
原理
设置多个不同优先级的就绪队列，每个队列有不同的时间片。新任务首先进入最高优先级队列，按时间片轮转方式执行。若在一个时间片内未完成，就移到下一级队列。低优先级队列的任务只有在高优先级队列都为空时才会被调度。
示例代码
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
class MLFQProcess {
int pid;
int arrivalTime;
int burstTime;
int remainingTime;
int waitingTime;
int turnaroundTime;
int currentQueue;
public MLFQProcess(int pid, int arrivalTime, int burstTime) {
this.pid = pid;
this.arrivalTime = arrivalTime;
this.burstTime = burstTime;
this.remainingTime = burstTime;
this.waitingTime = 0;
this.turnaroundTime = 0;
this.currentQueue = 0;
}
}
public class MultilevelFeedbackQueue {
public static void mlfqScheduling(List<MLFQProcess> processes, int[] timeSlices) {
int numQueues = timeSlices.length;
List<Queue<MLFQProcess>> queues = new ArrayList<>();
for (int i = 0; i < numQueues; i++) {
queues.add(new LinkedList<>());
}
int currentTime = 0;
int completedProcesses = 0;
int totalWaitingTime = 0;
int totalTurnaroundTime = 0;
int index = 0;
while (completedProcesses < processes.size()) {
// 将到达的进程加入最高优先级队列
while (index < processes.size() && processes.get(index).arrivalTime <= currentTime) {
queues.get(0).add(processes.get(index));
index++;
}
boolean processExecuted = false;
for (int i = 0; i < numQueues; i++) {
Queue<MLFQProcess> queue = queues.get(i);
if (!queue.isEmpty()) {
MLFQProcess currentProcess = queue.poll();
int timeSlice = timeSlices[i];
if (currentProcess.remainingTime <= timeSlice) {
currentTime += currentProcess.remainingTime;
currentProcess.remainingTime = 0;
completedProcesses++;
currentProcess.turnaroundTime = currentTime - currentProcess.arrivalTime;
currentProcess.waitingTime = currentProcess.turnaroundTime - currentProcess.burstTime;
} else {
currentTime += timeSlice;
currentProcess.remainingTime -= timeSlice;
if (i < numQueues - 1) {
currentProcess.currentQueue++;
queues.get(i + 1).add(currentProcess);
} else {
queues.get(i).add(currentProcess);
}
}
totalWaitingTime += currentProcess.waitingTime;
totalTurnaroundTime += currentProcess.turnaroundTime;
processExecuted = true;
break;
}
if (!processExecuted) {
currentTime++;
}
}
double avgWaitingTime = (double) totalWaitingTime / processes.size();
double avgTurnaroundTime = (double) totalTurnaroundTime / processes.size();
System.out.println("平均等待时间: " + avgWaitingTime);
System.out.println("平均周转时间: " + avgTurnaroundTime);
}
public static void main(String[] args) {
List<MLFQProcess> processes = new ArrayList<>();
processes.add(new MLFQProcess(1, 0, 5));
processes.add(new MLFQProcess(2, 1, 3));
processes.add(new MLFQProcess(3, 2, 8));
processes.add(new MLFQProcess(4, 3, 6));
int[] timeSlices = {1, 2, 4};
mlfqScheduling(processes, timeSlices);
}
}
### 优缺点
- **优点**：综合了多种调度算法的优点，既能让短任务快速完成，又能兼顾长任务，避免饥饿现象，在不同类型任务混合的场景下表现良好。
- **缺点**：算法复杂度较高，需要合理设置队列数量、优先级和时间片大小等参数，否则难以达到最优性能。
## 调度算法的选择与实际应用
### 不同场景下的算法选择
- **批处理系统**：批处理系统通常处理大量无需用户实时交互的任务，更关注系统的吞吐量和资源利用率。在这种场景下，短作业优先算法（SJF）是一个不错的选择，因为它能减少平均周转时间，提高单位时间内完成的任务数量。
- **交互式系统**：如桌面操作系统，用户希望操作能快速得到响应，对响应时间要求较高。时间片轮转调度算法或多级反馈队列调度算法更适合这类场景，它们能保证每个任务都能及时获得 CPU 资源，提供良好的用户体验。
- **实时系统**：像航空航天控制系统、工业自动化控制系统等实时系统，对任务的实时性要求极高，任何延迟都可能导致严重后果。优先级调度算法在这种场景下至关重要，它能确保关键任务具有较高的优先级，及时得到执行。
### 实际操作系统中的应用
- **Linux 操作系统**：采用基于 CFS（Completely Fair Scheduler）的调度算法。CFS 是一种公平调度算法，它通过维护一个红黑树来管理就绪队列，根据进程的虚拟运行时间来决定调度顺序。这种算法旨在尽量保证每个进程都能公平地使用 CPU 资源，同时也会考虑进程的优先级等因素，以适应不同类型的任务。
- **Windows 操作系统**：使用了一种混合调度算法，结合了优先级调度和时间片轮转调度。Windows 为不同类型的任务分配不同的优先级，例如系统关键任务具有较高优先级。对于相同优先级的任务，则采用时间片轮转方式进行调度，以确保每个任务都有机会执行。
## 总结
操作系统的任务调度算法是一个复杂且关键的领域，不同的调度算法各有优劣，适用于不同的应用场景。在实际设计和实现操作系统时，需要综合考虑系统的目标、任务类型以及用户需求等因素，选择合适的调度算法或对现有算法进行优化。随着计算机技术的不断发展，如多核处理器的普及，任务调度算法也在持续演进，以更好地适应新的硬件环境和应用需求。
扫一扫
8004
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
