Algorithm Design & Real-Time System Optimization Questions

import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;
import java.time.Instant;

public class AgingPriorityQueue<T> {
    public static class Request<T> {
        final T payload;
        final int basePriority; // higher means more important
        final long enqueuedAtMillis;

        public Request(T payload, int basePriority) {
            this.payload = payload;
            this.basePriority = basePriority;
            this.enqueuedAtMillis = System.currentTimeMillis();
        }
    }

    private final PriorityBlockingQueue<Request<T>> queue;
    private final double agingRatePerSec; // how much priority increases per second
    private final int scanLimit; // how many items to scan on poll to choose best
    private final ReentrantLock scanLock = new ReentrantLock();

    public AgingPriorityQueue(double agingRatePerSec, int scanLimit) {
        // comparator is a fallback by basePriority (highest first)
        this.queue = new PriorityBlockingQueue<>(11, Comparator.comparingInt((Request<T> r) -> -r.basePriority));
        this.agingRatePerSec = agingRatePerSec;
        this.scanLimit = Math.max(1, scanLimit);
    }

    public void put(Request<T> req) {
        queue.put(req);
    }

    public boolean offer(Request<T> req, long timeout, TimeUnit unit) throws InterruptedException {
        return queue.offer(req, timeout, unit);
    }

    // Poll that applies aging by scanning top scanLimit candidates
    public Request<T> poll(long timeout, TimeUnit unit) throws InterruptedException {
        long deadline = System.nanoTime() + unit.toNanos(timeout);
        // Try fast-path: peek and return if queue small
        Request<T> head = queue.poll();
        if (head == null) {
            long remain = deadline - System.nanoTime();
            if (remain <= 0) return null;
            return queue.poll(remain, TimeUnit.NANOSECONDS);
        }

        // We have at least one item; collect up to scanLimit-1 more
        List<Request<T>> candidates = new ArrayList<>();
        candidates.add(head);
        queue.drainTo(candidates, scanLimit - 1); // already have one in list

        // If no more candidates and others exist, we might be fine to return head.
        // Compute effective priority and pick best
        Request<T> best = null;
        double bestScore = Double.NEGATIVE_INFINITY;
        long now = System.currentTimeMillis();

        for (Request<T> r : candidates) {
            double ageSec = Math.max(0, (now - r.enqueuedAtMillis) / 1000.0);
            double score = r.basePriority + agingRatePerSec * ageSec;
            if (score > bestScore) {
                bestScore = score;
                best = r;
            }
        }

        // Reinsert others
        for (Request<T> r : candidates) {
            if (r != best) queue.put(r);
        }

        return best;
    }

    public int size() { return queue.size(); }
}