如何实现支持带Comparator的PriorityBlockingQueue的ScheduledThreadPoolExecutor？

你的核心痛点很明确：JDK自带的ScheduledThreadPoolExecutor虽然支持定时/周期性任务，但硬绑定了DelayedWorkQueue；而ThreadPoolExecutor支持自定义队列，却没有定时任务能力，且继承ScheduledThreadPoolExecutor会因为包私有方法（比如canRunInCurrentState）无法完整实现逻辑。

下面给出两种可行方案，优先推荐第一种（无需大量重复造轮子）：

方案一：改造ScheduledThreadPoolExecutor的任务排序逻辑（最简便） #

其实ScheduledThreadPoolExecutor的DelayedWorkQueue是基于任务的compareTo方法排序的，我们只需要自定义任务的排序规则，让它同时考虑延迟时间和自定义优先级，就能在不替换队列的前提下实现需求。

步骤1：定义优先级任务接口 #

先定义一个接口，让需要优先级的任务实现它：

public interface Prioritized {
    // 返回优先级值，值越小优先级越高（可根据需求调整规则）
    int getPriority();
}

步骤2：自定义带优先级的ScheduledThreadPoolExecutor #

我们重写ScheduledThreadPoolExecutor的任务创建方法，生成支持优先级排序的任务实例：

import java.util.concurrent.Callable;
import java.util.concurrent.RunnableScheduledFuture;
import java.util.concurrent.ScheduledFutureTask;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class PriorityScheduledThreadPoolExecutor extends ScheduledThreadPoolExecutor {

    public PriorityScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize);
    }

    // 重写任务创建逻辑，为带优先级的任务生成自定义任务对象
    @Override
    protected <V> RunnableScheduledFuture<V> newTaskFor(Runnable runnable, V value) {
        if (runnable instanceof Prioritized) {
            return new PriorityScheduledFutureTask<>(runnable, value, ((Prioritized) runnable).getPriority());
        }
        return super.newTaskFor(runnable, value);
    }

    @Override
    protected <V> RunnableScheduledFuture<V> newTaskFor(Callable<V> callable) {
        if (callable instanceof Prioritized) {
            return new PriorityScheduledFutureTask<>(callable, ((Prioritized) callable).getPriority());
        }
        return super.newTaskFor(callable);
    }

    // 自定义带优先级的任务实现，重写排序逻辑
    private static class PriorityScheduledFutureTask<V> extends ScheduledFutureTask<V> {
        private final int priority;

        public PriorityScheduledFutureTask(Runnable runnable, V result, int priority) {
            super(runnable, result, 0, TimeUnit.NANOSECONDS);
            this.priority = priority;
        }

        public PriorityScheduledFutureTask(Callable<V> callable, int priority) {
            super(callable, 0, TimeUnit.NANOSECONDS);
            this.priority = priority;
        }

        // 先按延迟时间排序，延迟相同则按优先级排序
        @Override
        public int compareTo(java.util.concurrent.Delayed other) {
            int delayCompare = super.compareTo(other);
            if (delayCompare != 0) {
                return delayCompare;
            }
            // 延迟相同，优先级高的任务优先执行（这里遵循值越小优先级越高的规则）
            if (other instanceof PriorityScheduledFutureTask) {
                PriorityScheduledFutureTask<?> that = (PriorityScheduledFutureTask<?>) other;
                return Integer.compare(this.priority, that.priority);
            }
            return 0;
        }
    }
}

步骤3：使用示例 #

创建带优先级的定时任务并测试：

public class PriorityTask implements Runnable, Prioritized {
    private final int priority;
    private final String name;

    public PriorityTask(int priority, String name) {
        this.priority = priority;
        this.name = name;
    }

    @Override
    public int getPriority() {
        return priority;
    }

    @Override
    public void run() {
        System.out.printf("Executing task: %s | Priority: %d%n", name, priority);
    }
}

// 测试代码
public class ExecutorTest {
    public static void main(String[] args) {
        PriorityScheduledThreadPoolExecutor executor = new PriorityScheduledThreadPoolExecutor(2);

        // 提交三个延迟相同但优先级不同的任务
        executor.schedule(new PriorityTask(3, "Task C"), 1, TimeUnit.SECONDS);
        executor.schedule(new PriorityTask(1, "Task A"), 1, TimeUnit.SECONDS);
        executor.schedule(new PriorityTask(2, "Task B"), 1, TimeUnit.SECONDS);

        executor.shutdown();
    }
}

输出会按优先级从高到低执行：Task A → Task B → Task C。

方案二：基于ThreadPoolExecutor + PriorityBlockingQueue实现定时能力（复杂但完全自定义队列） #

如果你一定要使用PriorityBlockingQueue，需要自己实现定时任务的触发逻辑：

1. 自定义DelayedPrioritizedTask类，同时实现Delayed和Prioritized接口，保存任务的触发时间和优先级。
2. 让PriorityBlockingQueue先按触发时间排序（到期任务优先），触发时间相同则按优先级排序。
3. 额外启动一个调度线程，持续扫描队列，将到达触发时间的任务提交给ThreadPoolExecutor执行。
4. 实现ScheduledExecutorService的四个方法，把任务包装成DelayedPrioritizedTask放入队列。

但这种方案需要自己处理线程安全、任务取消、周期性任务重复调度等问题，工作量大且容易踩坑，不如方案一简洁可靠。

总结：优先选择方案一，它复用了JDKScheduledThreadPoolExecutor的成熟定时逻辑，仅修改任务排序规则，就能完美兼顾定时任务和自定义优先级需求，避免了大量重复造轮子和包私有方法的访问问题。

内容的提问来源于stack exchange，提问作者CRoemheld