java - 在 ScheduledThreadPoolExecutor 中使用带有比较器的 PriorityBlockingQueue

Question

首先:我已经阅读了以下两个问题及其可能的解决方案:

• ScheduledThreadPoolExecutors and custom queue
• Java Executors: how can I set task priority?

我遇到的难题是我想使用自定义 BlockingQueue或者更确切地说是一个不同但特定的队列，即 PriorityBlockingQueue自定义 Comparator它按优先级对队列进行排序。

ThreadPoolExecutor在其构造函数中支持自定义队列，但它不实现 ScheduledExecutorService 中的方法界面。所以我去找了子类 ScheduledThreadPoolExecutor , 但它不支持自定义队列并使用 DelayedWorkQueue反而。

问题:

• 我无法从 ScheduledThreadPoolExecutor 扩展因为为我自己的类创建构造函数不会做任何事情，因为 ScheduledThreadPoolExecutor 的构造函数不接受自定义队列作为参数。
• 我无法复制 ThreadPoolExecutor 的内容类和 ScheduledThreadPoolExecutor 的实现因为它使用了很多用没有修饰符声明的方法(例如canRunInCurrentState(boolean periodic)和这个调用调用的所有方法)这不允许我访问该方法，因为即使它是ThreadPoolExecutor , 它不在同一个包中。

我目前的实现是这样的:

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import com.croemheld.tasks.PriorityTaskComparator;

public class ScheduledPriorityThreadPoolExecutor extends ThreadPoolExecutor implements ScheduledExecutorService {

    private static final int INITIAL_QUEUE_SIZE = 10;

    public ScheduledPriorityThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,
            TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, 
            new PriorityBlockingQueue<Runnable>(INITIAL_QUEUE_SIZE, new PriorityTaskComparator()));
    }

    public ScheduledPriorityThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,
            TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, 
            new PriorityBlockingQueue<Runnable>(INITIAL_QUEUE_SIZE, new PriorityTaskComparator()), handler);
    }

    public ScheduledPriorityThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,
            TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, 
            new PriorityBlockingQueue<Runnable>(INITIAL_QUEUE_SIZE, new PriorityTaskComparator()), threadFactory);
    }

    public ScheduledPriorityThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,
            TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory,
            RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, 
            new PriorityBlockingQueue<Runnable>(INITIAL_QUEUE_SIZE, new PriorityTaskComparator()), threadFactory, handler);
    }

    @Override
    public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) {
        // TODO Auto-generated method stub
        return null;
    }

}

如您所见，构造函数问题已解决，但仍保留来自 ScheduledExecutorService 的调度方法的实现。 .

所以我问你，有没有什么办法可以传递 Comparator到队列或一个简单而不是太详尽的方法来创建一个自己的执行器类，它实现了ScheduledExecutorService中的方法。并提供来自 ThreadPoolExecutor 的方法类以及使用 PriorityBlockingQueue ？

Answer 1

如果我理解你的问题，你想定期执行一些任务，但要根据一些自定义优先级。如果没有发明您自己的 ExecutorService，我建议退后一步，看看您的设计。您可能希望将调度与优先级排序和任务执行分开:

1. 由于 ThreadPoolExecutor 接受自定义 BlockingQueue，您可以轻松实现自己的优先级排序。然后只需定期从代码中的其他地方提交任务。
2. 如果您坚持使用 ScheduledThreadPoolExecutor，那么您可以进行调度，但您必须自己实现优先级排序。您可以非常有创意地使用它，但一种选择可能是让编排任务从自定义 BlockingQueue 中挑选任务并提交到池中。