当前位置： 首页 > news >正文

贪心算法应用：最早截止时间优先(EDF)问题详解

news 2025/9/15 8:41:57

在这里插入图片描述

Java中的贪心算法应用：最早截止时间优先(EDF)问题详解

贪心算法是一种在每一步选择中都采取在当前状态下最好或最优（即最有利）的选择，从而希望导致结果是全局最好或最优的算法。最早截止时间优先(Earliest Deadline First, EDF)是一种经典的贪心调度算法，广泛应用于实时系统、任务调度等领域。

1. EDF算法基本概念

1.1 EDF算法定义

最早截止时间优先(EDF)是一种动态优先级调度算法，其中任务的优先级根据其截止时间动态分配。在任何时刻，具有最早截止时间的任务获得最高优先级。

1.2 EDF算法特点

  • 动态优先级：任务的优先级不是固定的，而是随着时间变化
  • 可抢占：高优先级任务可以抢占低优先级任务的执行
  • 最优性：对于单处理器上的可调度任务集，EDF是最优的

1.3 EDF算法适用场景

  • 实时系统任务调度
  • 作业调度
  • 项目管理中的任务安排
  • 任何需要基于时间约束进行决策的场景

2. EDF算法原理与实现

2.1 算法基本原理

EDF算法的核心思想是：总是选择当前剩余任务中截止时间最早的任务执行。这种策略可以最大限度地减少错过截止时间的任务数量。

2.2 算法步骤

  1. 将所有任务按照截止时间排序
  2. 选择截止时间最早的任务执行
  3. 执行该任务直到完成或被更高优先级任务抢占
  4. 重复步骤2-3直到所有任务完成或无法满足截止时间

2.3 Java实现EDF算法

下面是一个完整的Java实现示例：

import java.util.*;class Task {int id;int duration;    // 执行所需时间int deadline;    // 截止时间int remaining;   // 剩余执行时间public Task(int id, int duration, int deadline) {this.id = id;this.duration = duration;this.deadline = deadline;this.remaining = duration;}@Overridepublic String toString() {return "Task " + id + " (Duration: " + duration + ", Deadline: " + deadline + ")";}
}public class EDFScheduler {public static void schedule(List<Task> tasks) {// 按截止时间排序tasks.sort(Comparator.comparingInt(t -> t.deadline));int currentTime = 0;System.out.println("EDF Scheduling Started:");while (!tasks.isEmpty()) {// 选择截止时间最早的任务Task currentTask = tasks.get(0);// 执行任务System.out.println("Time " + currentTime + ": Executing " + currentTask);currentTask.remaining--;// 检查任务是否完成if (currentTask.remaining == 0) {System.out.println("Time " + (currentTime + 1) + ": Task " + currentTask.id + " completed.");tasks.remove(currentTask);}currentTime++;// 检查是否有任务错过截止时间for (Task task : tasks) {if (currentTime > task.deadline) {System.out.println("Time " + currentTime + ": Task " + task.id + " missed deadline!");tasks.remove(task);break;}}// 重新排序，因为截止时间可能变化（对于周期性任务）tasks.sort(Comparator.comparingInt(t -> t.deadline));}System.out.println("All tasks completed or missed deadline.");}public static void main(String[] args) {List<Task> tasks = new ArrayList<>();tasks.add(new Task(1, 3, 5));  // 任务1需要3单位时间，截止时间5tasks.add(new Task(2, 2, 4));  // 任务2需要2单位时间，截止时间4tasks.add(new Task(3, 1, 7));  // 任务3需要1单位时间，截止时间7schedule(tasks);}
}

3. EDF算法的变体与扩展

3.1 可抢占EDF

在基本EDF基础上，允许高优先级任务抢占低优先级任务的执行：

public class PreemptiveEDF {public static void schedule(List<Task> tasks) {PriorityQueue<Task> queue = new PriorityQueue<>(Comparator.comparingInt(t -> t.deadline));queue.addAll(tasks);int currentTime = 0;Task currentTask = null;System.out.println("Preemptive EDF Scheduling Started:");while (!queue.isEmpty() || currentTask != null) {// 检查是否有新任务到达（对于动态任务）// 这里简化为所有任务一开始就可用// 选择截止时间最早的任务if (!queue.isEmpty() && (currentTask == null || queue.peek().deadline < currentTask.deadline)) {if (currentTask != null) {System.out.println("Time " + currentTime + ": Preempting " + currentTask);queue.add(currentTask);}currentTask = queue.poll();System.out.println("Time " + currentTime + ": Starting " + currentTask);}if (currentTask != null) {// 执行任务currentTask.remaining--;System.out.println("Time " + currentTime + ": Executing " + currentTask);// 检查任务是否完成if (currentTask.remaining == 0) {System.out.println("Time " + currentTime + ": Task " + currentTask.id + " completed.");currentTask = null;}} else {System.out.println("Time " + currentTime + ": Idle");}currentTime++;// 检查是否有任务错过截止时间Iterator<Task> iterator = queue.iterator();while (iterator.hasNext()) {Task task = iterator.next();if (currentTime > task.deadline) {System.out.println("Time " + currentTime + ": Task " + task.id + " missed deadline!");iterator.remove();}}}System.out.println("All tasks completed or missed deadline.");}
}

3.2 周期性EDF

对于周期性任务，需要扩展任务模型并调整调度策略：

class PeriodicTask extends Task {int period;      // 周期int nextRelease; // 下次释放时间public PeriodicTask(int id, int duration, int deadline, int period) {super(id, duration, deadline);this.period = period;this.nextRelease = 0;}@Overridepublic String toString() {return super.toString() + ", Period: " + period;}
}public class PeriodicEDF {public static void schedule(List<PeriodicTask> tasks, int simulationTime) {PriorityQueue<PeriodicTask> queue = new PriorityQueue<>(Comparator.comparingInt(t -> t.deadline));int currentTime = 0;System.out.println("Periodic EDF Scheduling Started:");while (currentTime < simulationTime) {// 检查是否有新任务实例到达for (PeriodicTask task : tasks) {if (currentTime >= task.nextRelease) {PeriodicTask newInstance = new PeriodicTask(task.id, task.duration, currentTime + task.deadline, task.period);queue.add(newInstance);task.nextRelease += task.period;System.out.println("Time " + currentTime + ": New instance of Task " + task.id + " arrived.");}}// 选择截止时间最早的任务PeriodicTask currentTask = queue.poll();if (currentTask != null) {// 执行任务System.out.println("Time " + currentTime + ": Executing " + currentTask);currentTask.remaining--;// 检查任务是否完成if (currentTask.remaining == 0) {System.out.println("Time " + currentTime + ": Task " + currentTask.id + " completed.");} else {queue.add(currentTask);}} else {System.out.println("Time " + currentTime + ": Idle");}currentTime++;// 检查是否有任务错过截止时间Iterator<PeriodicTask> iterator = queue.iterator();while (iterator.hasNext()) {PeriodicTask task = iterator.next();if (currentTime > task.deadline) {System.out.println("Time " + currentTime + ": Task " + task.id + " missed deadline!");iterator.remove();}}}}
}

4. EDF算法的正确性与性能分析

4.1 可调度性分析

EDF算法的可调度性可以通过以下条件判断：

对于n个周期性任务，如果满足：
[ \sum_{i=1}^{n} \frac{C_i}{T_i} \leq 1 ]
其中：

  • ( C_i ) 是任务i的执行时间
  • ( T_i ) 是任务i的周期

则任务集是可调度的。

4.2 时间复杂度分析

  • 排序阶段：O(n log n)，n为任务数量
  • 调度阶段：每次选择任务O(log n)（使用优先队列）
  • 总体复杂度为O(n log n + m log n)，其中m为调度步骤数

4.3 优缺点分析

优点：

  • 对于单处理器是最优的
  • 可以实现100%的处理器利用率
  • 适用于动态任务集

缺点：

  • 在过载情况下性能下降明显
  • 实现比固定优先级算法复杂
  • 对于多处理器系统不是最优的

5. EDF算法的实际应用案例

5.1 实时操作系统调度

// 简化的实时任务调度器
public class RealTimeScheduler {private PriorityQueue<RealTimeTask> readyQueue;public RealTimeScheduler() {readyQueue = new PriorityQueue<>(Comparator.comparingInt(RealTimeTask::getAbsoluteDeadline));}public void addTask(RealTimeTask task) {readyQueue.add(task);}public void schedule() {while (!readyQueue.isEmpty()) {RealTimeTask task = readyQueue.poll();execute(task);if (task.isPeriodic()) {task.updateForNextPeriod();readyQueue.add(task);}}}private void execute(RealTimeTask task) {// 实际执行任务的代码System.out.println("Executing task with deadline: " + task.getAbsoluteDeadline());// ...}
}class RealTimeTask {private int executionTime;private int deadline;private int period;private boolean isPeriodic;// ... 其他方法和构造函数public int getAbsoluteDeadline() {return deadline;}public void updateForNextPeriod() {if (isPeriodic) {deadline += period;}}public boolean isPeriodic() {return isPeriodic;}
}

5.2 项目管理中的任务安排

public class ProjectScheduler {static class ProjectTask {String name;int duration; // in daysLocalDate deadline;// other task attributes// constructor, getters, etc.}public static List<ProjectTask> scheduleTasks(List<ProjectTask> tasks) {tasks.sort(Comparator.comparing(ProjectTask::getDeadline));LocalDate currentDate = LocalDate.now();List<ProjectTask> schedule = new ArrayList<>();for (ProjectTask task : tasks) {LocalDate startDate = currentDate;LocalDate endDate = startDate.plusDays(task.duration);if (endDate.isAfter(task.deadline)) {System.out.println("Warning: Task '" + task.name + "' will miss deadline!");}schedule.add(task);currentDate = endDate;}return schedule;}
}

6. EDF算法的测试与验证

6.1 单元测试示例

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;class EDFSchedulerTest {@Testvoid testBasicEDFScheduling() {List<Task> tasks = new ArrayList<>();tasks.add(new Task(1, 2, 3));tasks.add(new Task(2, 1, 2));tasks.add(new Task(3, 3, 5));EDFScheduler.schedule(tasks);// 应该看到任务按2,1,3的顺序执行}@Testvoid testPreemptiveEDF() {List<Task> tasks = new ArrayList<>();tasks.add(new Task(1, 3, 5));tasks.add(new Task(2, 2, 3));  // 这个任务应该抢占任务1PreemptiveEDF.schedule(tasks);// 任务2应该在时间0开始，任务1在时间2开始}@Testvoid testPeriodicEDF() {List<PeriodicTask> tasks = new ArrayList<>();tasks.add(new PeriodicTask(1, 1, 3, 4));tasks.add(new PeriodicTask(2, 2, 5, 6));PeriodicEDF.schedule(tasks, 10);// 应该看到任务1在时间0,4,8释放// 任务2在时间0,6释放}
}

6.2 性能测试

public class EDFPerformanceTest {public static void main(String[] args) {int[] taskCounts = {10, 100, 1000, 10000};for (int n : taskCounts) {List<Task> tasks = generateRandomTasks(n);long startTime = System.nanoTime();EDFScheduler.schedule(tasks);long endTime = System.nanoTime();System.out.printf("EDF with %d tasks: %d ms%n", n, (endTime - startTime) / 1_000_000);}}private static List<Task> generateRandomTasks(int n) {List<Task> tasks = new ArrayList<>();Random random = new Random();for (int i = 0; i < n; i++) {int duration = random.nextInt(10) + 1;int deadline = random.nextInt(100) + duration;tasks.add(new Task(i, duration, deadline));}return tasks;}
}

7. EDF算法与其他调度算法比较

7.1 EDF vs 固定优先级调度(RM)

特性EDF固定优先级(RM)
优先级分配动态，基于截止时间静态，基于周期
处理器利用率最高100%最高约69%
实现复杂度较高较低
过载表现不可预测可预测
适用场景动态任务集静态任务集

7.2 EDF vs 最短作业优先(SJF)

特性EDFSJF
决策依据截止时间执行时间
目标最小化错过截止时间的任务数最小化平均等待时间
适用场景实时系统批处理系统
抢占性通常可抢占通常不可抢占

8. EDF算法的优化与进阶

8.1 过载管理策略

当系统过载时，基本的EDF算法性能会下降，可以引入以下策略：

public class EDWithOverloadManagement {public static void schedule(List<Task> tasks) {// 1. 首先检查可调度性double utilization = tasks.stream().mapToDouble(t -> (double)t.duration / t.deadline).sum();if (utilization > 1.0) {System.out.println("System overloaded! Applying management strategies...");// 策略1：丢弃最不重要的任务（基于价值）tasks.sort(Comparator.comparingDouble(Task::getValue).reversed());while (utilization > 1.0 && !tasks.isEmpty()) {Task removed = tasks.remove(tasks.size() - 1);utilization -= (double)removed.duration / removed.deadline;System.out.println("Discarded task: " + removed);}// 策略2：均匀缩短所有任务执行时间if (utilization > 1.0) {double factor = 1.0 / utilization;for (Task t : tasks) {t.duration = (int)(t.duration * factor);}System.out.println("Uniformly scaled down task durations");}}// 正常EDF调度EDFScheduler.schedule(tasks);}
}

8.2 能量感知EDF

在移动设备等需要考虑能耗的场景，可以扩展EDF算法：

public class EnergyAwareEDF {static class EnergyAwareTask extends Task {double powerConsumption;public EnergyAwareTask(int id, int duration, int deadline, double power) {super(id, duration, deadline);this.powerConsumption = power;}}public static void schedule(List<EnergyAwareTask> tasks, double powerBudget) {tasks.sort((t1, t2) -> {// 先按截止时间排序，截止时间相同时选择能耗低的任务if (t1.deadline != t2.deadline) {return Integer.compare(t1.deadline, t2.deadline);}return Double.compare(t1.powerConsumption, t2.powerConsumption);});double totalEnergy = 0;int currentTime = 0;while (!tasks.isEmpty()) {EnergyAwareTask task = tasks.get(0);double taskEnergy = task.powerConsumption * task.remaining;if (totalEnergy + taskEnergy > powerBudget) {System.out.println("Power budget exceeded at time " + currentTime);break;}// 执行任务System.out.println("Time " + currentTime + ": Executing " + task);task.remaining--;totalEnergy += task.powerConsumption;if (task.remaining == 0) {tasks.remove(0);}currentTime++;}}
}

9. EDF算法在实际项目中的最佳实践

9.1 任务建模建议

  1. 明确时间约束：确保每个任务有明确的执行时间和截止时间
  2. 区分关键性：为关键任务设置更早的截止时间
  3. 考虑资源需求：扩展任务模型包含资源需求

9.2 实现建议

  1. 使用高效数据结构：优先队列是EDF的核心
  2. 考虑线程安全：对于多线程环境
  3. 添加监控机制：跟踪任务执行情况

9.3 性能调优技巧

  1. 批量处理：对于大量小任务，考虑批量处理
  2. 懒排序：只在必要时重新排序
  3. 近似EDF：对于大型系统，考虑近似算法

10. 总结

最早截止时间优先(EDF)算法是一种强大而灵活的贪心调度算法，特别适合有时间约束的场景。通过动态调整任务优先级，EDF能够实现高效的资源利用率和良好的实时性。Java提供了丰富的集合框架和并发工具，非常适合实现各种EDF变体。在实际应用中，需要根据具体需求选择合适的EDF实现，并考虑过载管理、能耗优化等扩展功能。

理解EDF算法不仅有助于解决调度问题，也是学习贪心算法思想和实时系统设计的重要案例。通过本指南的详细讲解和代码示例，您应该能够在Java项目中有效地实现和应用EDF算法。


文章转载自：

http://qR1F7pP2.krqhw.cn
http://kJDLnm7Q.krqhw.cn
http://4r2yScP4.krqhw.cn
http://sDRTDi5E.krqhw.cn
http://5NkaPzvI.krqhw.cn
http://vYpj8j7V.krqhw.cn
http://UD2dUj43.krqhw.cn
http://AKbtMo6W.krqhw.cn
http://VutlRGoL.krqhw.cn
http://XVrIlEkq.krqhw.cn
http://UjjRIy14.krqhw.cn
http://5tD8VrOR.krqhw.cn
http://NBejdCwi.krqhw.cn
http://T8KMak3m.krqhw.cn
http://9PMVmou2.krqhw.cn
http://tfc5YDjn.krqhw.cn
http://wqWi78Wo.krqhw.cn
http://yFVyoFi6.krqhw.cn
http://QGvYf4Dv.krqhw.cn
http://UvX0VZtr.krqhw.cn
http://UBp9jI73.krqhw.cn
http://CaaoMH30.krqhw.cn
http://iDvv8iML.krqhw.cn
http://R0VUKjbN.krqhw.cn
http://jHSUqXDd.krqhw.cn
http://tlwMUqY8.krqhw.cn
http://mcKmj984.krqhw.cn
http://sGwQGoB3.krqhw.cn
http://66G07d5u.krqhw.cn
http://mpb04Cy7.krqhw.cn
http://www.dtcms.com/a/383552.html

相关文章：

  • 每天五分钟深度学习：神经网络的权重参数如何初始化
  • BisenetV1/2网络以及模型推理转换
  • Codeforces Round 1050 (Div. 4)补题
  • 【Java后端】Spring Boot 多模块项目实战：从零搭建父工程与子模块
  • c++命名空间详解
  • 第15课：知识图谱与语义理解
  • HarmonyOS图形处理：Canvas绘制与动画开发实战
  • ffmpeg 有什么用处？
  • 如何重置Gitlab的root用户密码
  • LeetCode算法日记 - Day 41: 数据流的中位数、图像渲染
  • 计算机网络（二）物理层数据链路层
  • 零基础从头教学Linux（Day 33）
  • collections模块
  • 【前端】【高德地图WebJs】【知识体系搭建】图层知识点——＞热力图，瓦片图层，自定义图层
  • 关系模型的数据结构
  • Spring Boot 与前端文件上传跨域问题：Multipart、CORS 与网关配置
  • MySQL的事务特性和高可用架构
  • AI重构车载测试：从人工到智能的跨越
  • 前端梳理体系从常问问题去完善-基础篇（html,css,js,ts）
  • 文件查找 find
  • LeetCode 2110.股票平滑下跌阶段的数目
  • 解锁仓储智能调度、运输路径优化、数据实时追踪，全功能降本提效的智慧物流开源了
  • FPGA学习篇——Verilog学习MUX的实现
  • hadoop单机伪分布环境配置
  • Vue3 响应式失效 debug：Proxy 陷阱导致数据更新异常的深度排查
  • el-table的隔行变色不影响row-class-name的背景色
  • 【深度学习新浪潮】游戏中的agents技术研发进展一览
  • Condor 安装
  • 类和对象 (中)
  • [数据结构——lesson10.2堆的应用以及TopK问题]