AgingScheduling.java

packagecom.thealgorithms.scheduling;

importjava.util.LinkedList;
importjava.util.Queue;

/**
 * AgingScheduling is an algorithm designed to prevent starvation
 * by gradually increasing the priority of waiting tasks.
 * The longer a process waits, the higher its priority becomes.
 *
 * Use Case: Useful in systems with mixed workloads to avoid
 * lower-priority tasks being starved by higher-priority tasks.
 *
 * @author Hardvan
 */
publicfinalclassAgingScheduling {

staticclassTask {
Stringname;
intwaitTime;
intpriority;

Task(Stringname, intpriority) {
this.name = name;
this.priority = priority;
this.waitTime = 0;
 }
 }

privatefinalQueue<Task> taskQueue;

publicAgingScheduling() {
taskQueue = newLinkedList<>();
 }

/**
 * Adds a task to the scheduler with a given priority.
 *
 * @param name name of the task
 * @param priority priority of the task
 */
publicvoidaddTask(Stringname, intpriority) {
taskQueue.offer(newTask(name, priority));
 }

/**
 * Schedules the next task based on the priority and wait time.
 * The priority of a task increases with the time it spends waiting.
 *
 * @return name of the next task to be executed
 */
publicStringscheduleNext() {
if (taskQueue.isEmpty()) {
returnnull;
 }
TasknextTask = taskQueue.poll();
nextTask.waitTime++;
nextTask.priority += nextTask.waitTime;
taskQueue.offer(nextTask);
returnnextTask.name;
 }
}