Java实现单核CPU任务调度算法与优化技巧

1. 项目背景与核心挑战

最近在准备华为OD机考的同学们应该都注意到了C卷中出现的这道经典题目——单核CPU任务调度。这道题看似简单，实则暗藏玄机，非常考验对Java集合操作和时间复杂度的把控能力。我在实际机考和日常开发中多次遇到类似场景，今天就来拆解这道题的解题思路和优化技巧。

题目通常给出一个任务队列，每个任务包含到达时间和执行时长两个参数。我们需要模拟单核CPU按照特定规则处理这些任务的过程，并计算平均等待时间。关键在于理解任务调度的优先级规则：当CPU空闲时优先处理最先到达的任务；如果多个任务同时到达，则选择执行时间最短的任务（SJF短作业优先）。

2. 数据结构设计与算法选型

2.1 任务表示与输入处理

首先我们需要定义合适的数据结构来表示任务。这里我推荐使用记录类（Record）来封装任务属性：

java复制record Task(int arrival, int duration) implements Comparable<Task> {
    @Override
    public int compareTo(Task o) {
        return Integer.compare(this.arrival, o.arrival);
    }
}

输入处理阶段要注意边界条件检查。题目通常给出形如[[1,4],[2,3],[5,2]]的二维数组，我们需要将其转换为Task对象列表：

java复制List<Task> tasks = Arrays.stream(input)
    .map(arr -> new Task(arr[0], arr[1]))
    .collect(Collectors.toList());

2.2 核心调度算法实现

调度算法的核心在于维护两个关键数据结构：

1. 就绪队列：使用优先队列处理同时到达的任务
2. 时间线：记录当前CPU时间和任务执行情况

java复制PriorityQueue<Task> readyQueue = new PriorityQueue<>(
    (a,b) -> a.duration != b.duration 
        ? a.duration - b.duration 
        : a.arrival - b.arrival
);

int currentTime = 0;
int totalWait = 0;
int index = 0;

算法主循环需要处理三种情况：

1. CPU空闲且有任务到达
2. CPU正在执行任务
3. 所有任务处理完成

java复制while (index < tasks.size() || !readyQueue.isEmpty()) {
    // 将当前时间点前到达的任务加入就绪队列
    while (index < tasks.size() && tasks.get(index).arrival <= currentTime) {
        readyQueue.offer(tasks.get(index++));
    }
    
    if (!readyQueue.isEmpty()) {
        Task current = readyQueue.poll();
        totalWait += currentTime - current.arrival;
        currentTime += current.duration;
    } else {
        // CPU空闲时直接跳到下一个任务到达时间
        currentTime = tasks.get(index).arrival;
    }
}

3. 时间复杂度优化技巧

3.1 优先队列的选用分析

很多同学会疑惑为什么使用两个不同的优先队列：

• 初始排序队列：按arrival时间排序（O(nlogn)）
• 就绪队列：按duration排序（O(logn) per operation）

这种设计使得：

1. 初始排序只需一次O(nlogn)操作
2. 调度过程中每个任务最多经历一次入队和出队操作

总体时间复杂度控制在O(nlogn)，完全满足题目要求。

3.2 边界条件处理

实际编码时需要特别注意几个边界case：

1. 空输入处理
2. 任务到达时间无序的情况
3. 多个任务同时到达时的SJF选择
4. CPU空闲时的时间跳跃

这里分享一个验证边界条件的测试用例集：

java复制Object[][] testCases = {
    // 常规情况
    {new int[][]{{1,4},{2,3},{5,2}}, 3.0},
    // 同时到达任务
    {new int[][]{{1,4},{1,3},{1,2}}, 3.0},
    // 无序到达
    {new int[][]{{5,2},{1,4},{3,1}}, 3.666},
    // 单任务
    {new int[][]{{0,10}}, 0.0}
};

4. 完整实现与调试技巧

4.1 完整代码实现

结合上述分析，完整的解决方案如下：

java复制import java.util.*;

public class CPUScheduler {
    record Task(int arrival, int duration) implements Comparable<Task> {
        @Override
        public int compareTo(Task o) {
            return Integer.compare(this.arrival, o.arrival);
        }
    }

    public static double scheduleTasks(int[][] input) {
        if (input == null || input.length == 0) return 0;
        
        List<Task> tasks = Arrays.stream(input)
            .map(arr -> new Task(arr[0], arr[1]))
            .sorted()
            .collect(Collectors.toList());
            
        PriorityQueue<Task> readyQueue = new PriorityQueue<>(
            (a,b) -> a.duration != b.duration 
                ? a.duration - b.duration 
                : a.arrival - b.arrival
        );
        
        int currentTime = 0;
        int totalWait = 0;
        int index = 0;
        
        while (index < tasks.size() || !readyQueue.isEmpty()) {
            while (index < tasks.size() && tasks.get(index).arrival <= currentTime) {
                readyQueue.offer(tasks.get(index++));
            }
            
            if (!readyQueue.isEmpty()) {
                Task current = readyQueue.poll();
                totalWait += currentTime - current.arrival;
                currentTime += current.duration;
            } else if (index < tasks.size()) {
                currentTime = tasks.get(index).arrival;
            }
        }
        
        return (double) totalWait / input.length;
    }
}

4.2 调试与验证方法

在机考环境下调试这类算法题时，建议：

1. 先手动计算小规模测试用例的预期结果
2. 添加详细的日志输出关键变量状态
3. 使用断点调试观察队列变化

例如可以添加如下调试代码：

java复制System.out.println("Processing task: " + current + 
    " at time: " + currentTime + 
    " wait time: " + (currentTime - current.arrival));

5. 性能优化与变种思考

5.1 内存优化方案

对于大规模任务输入（虽然机考通常不会），我们可以优化内存使用：

1. 使用原始数组替代List
2. 复用数据结构而非重新创建
3. 考虑任务属性使用short而非int

优化后的数据结构：

java复制Task[] tasks = Arrays.stream(input)
    .map(arr -> new Task(arr[0], arr[1]))
    .sorted()
    .toArray(Task[]::new);

5.2 算法变种与扩展

这道题目有多个变种形式值得思考：

1. 多核CPU调度如何修改算法？
2. 如果考虑任务优先级（非SJF）如何处理？
3. 带抢占式的短作业优先如何实现？

以多核CPU为例，算法需要改为维护多个执行时间线，并合理分配任务到不同核心。核心修改点：

java复制// 使用数组记录各CPU状态
int[] cpuEndTimes = new int[k]; // k为CPU核心数

// 分配任务时选择最早空闲的CPU
int cpu = findEarliestCPU(cpuEndTimes);
totalWait += Math.max(cpuEndTimes[cpu] - task.arrival, 0);
cpuEndTimes[cpu] = Math.max(cpuEndTimes[cpu], task.arrival) + task.duration;

6. 机考实战经验分享

参加过多次OD机考后，我总结出这类题目的一些通关技巧：

1. 输入处理要健壮：题目可能给出空输入或非法数据，要提前判断
2. 变量命名要清晰：currentTime比简单的t更易读
3. 注释关键算法步骤：方便考官理解你的思路
4. 预留调试输出：虽然最后要注释掉，但调试时非常有用
5. 时间分配建议：
   • 5分钟理解题意
   • 10分钟设计数据结构
   • 20分钟编写核心算法
   • 5分钟处理边界条件
   • 10分钟测试验证

特别注意：机考环境可能没有IDE自动补全，要熟悉常用API的手写方式，比如PriorityQueue的构造函数写法。