Priority Scheduling & Starvation

// Priority scheduling with aging to prevent starvation
// Lower number = higher priority (convention)

class Process {
    int id, basePriority, effectivePriority, waitingTime;
    Process(int id, int priority) {
        this.id = id;
        this.basePriority = priority;
        this.effectivePriority = priority;
        this.waitingTime = 0;
    }
}

List<Process> readyQueue = new ArrayList<>();
readyQueue.add(new Process(1, 1));   // high priority
readyQueue.add(new Process(2, 10));  // low priority — risk of starvation
readyQueue.add(new Process(3, 5));   // medium priority

int AGING_INTERVAL = 3;   // boost priority every 3 time units
int agingBoost = 1;       // increase effective priority by 1 per interval

// Simulate aging: every tick, boost waiting processes' effective priority
for (int tick = 0; tick < 15; tick++) {
    for (Process p : readyQueue) {
        p.waitingTime++;
        if (p.waitingTime % AGING_INTERVAL == 0) {
            p.effectivePriority = Math.max(1,
                p.effectivePriority - agingBoost);  // lower number = higher priority
            System.out.printf("Tick %2d: P%d priority boosted to %d%n",
                tick, p.id, p.effectivePriority);
        }
    }
}
// Eventually, low-priority P2 (base=10) ages up to compete with high-priority tasks

// Java Thread priorities — advisory only, OS-dependent
Thread high = new Thread(() -> System.out.println("High priority task"));
high.setPriority(Thread.MAX_PRIORITY);   // 10

Thread low = new Thread(() -> System.out.println("Low priority task"));
low.setPriority(Thread.MIN_PRIORITY);    // 1

// WARNING: On Linux with default JVM settings, these priorities are often ignored
// Use explicit prioritization with PriorityBlockingQueue for reliable behavior

// Priority-aware task queue — reliably prioritized
PriorityBlockingQueue<Runnable> priorityQueue = new PriorityBlockingQueue<>(
    10, Comparator.comparingInt(r -> ((PrioritizedTask) r).priority)
);

record PrioritizedTask(int priority, Runnable work) implements Runnable, Comparable<PrioritizedTask> {
    public void run() { work.run(); }
    public int compareTo(PrioritizedTask other) {
        return Integer.compare(this.priority, other.priority); // lower = higher priority
    }
}

priorityQueue.add(new PrioritizedTask(5, () -> System.out.println("Medium task")));
priorityQueue.add(new PrioritizedTask(1, () -> System.out.println("Critical task")));
priorityQueue.add(new PrioritizedTask(9, () -> System.out.println("Low task")));

// Drain in priority order
while (!priorityQueue.isEmpty()) priorityQueue.poll().run();
// Output: Critical → Medium → Low