Используйте PriorityBlockingQueue с компаратором в ScheduledThreadPoolExecutor

Если я понял ваш вопрос, вы хотите периодически выполнять некоторые задачи, но с определенным приоритетом. Если не изобретать свой собственный ExecutorService, я предлагаю сделать шаг назад и взглянуть на свой дизайн. Вы можете отделить планирование от приоритезации и выполнения задачи:

1. Поскольку ThreadPoolExecutor принимает индивидуальный BlockingQueue, вы можете легко реализовать свою собственную приоритезацию. Затем просто периодически отправляйте задачи из других частей кода.
2. Если вы настаиваете на использовании ScheduledThreadPoolExecutor, тогда вы получите расписание, но вам придется самостоятельно установить приоритеты. Вы можете проявить большой творческий подход, но одним из вариантов может быть задача оркестровки, которая берет задачи из настраиваемого BlockingQueue и отправляет их в пул.

Я искал другие возможные решения и пришел к следующему результату:

Поскольку ThreadPoolExecutor управляет пулом из нескольких Threads (т. Е. Если вы устанавливаете два или более потоков в методе Executors.newFixedThreadPool(int nThreads)), и если вы действительно хотите смешать с ним BlockingQueue на основе приоритета, я бы посоветовал сделать следующее:

• Создайте собственный ThreadPoolExecutor класс, аналогичный приведенному выше, используя PriorityBlockingQueue с настраиваемым компаратором.
• Создайте свой собственный Task класс (или FutureTask расширение, в зависимости от того, что вы считаете лучшим для вас)
• Эти классы задач предназначены для одноразовых задач, то есть они выполняются только один раз.

Для задач цикла, которые должны периодически выполняться в фоновом режиме, я придумал для этой цели простой класс:

public abstract class AbstractThread extends Thread {

    protected Runnable runnable;

    protected AbstractThread(String name, Runnable runnable) {
        super(runnable, name);

        this.runnable = runnable;
    }

    /**
     * This method provides a way to perform some action before the thread is actually starting.
     */
    protected abstract void beforeExecution();

    /**
     * This method provides a way to perform some action after the thread finished.
     */
    protected abstract void afterExecution();

    @Override
    public void run() {
        try {
            doRun();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * Run the given runnable here.
     * 
     * @throws InterruptedException 
     */
    protected abstract void doRun() throws InterruptedException;

}

В то время как простые одноразовые потоки просто запускают runnable один раз:

@Override
protected void doRun() {
    beforeExecution();

    runnable.run();

    afterExecution();
}

Периодические задачи в потоке будут делать что-то вроде:

@Override
protected void doRun() throws InterruptedException {
    beforeExecution();

    while(!isInterrupted()) {
        runnable.run();
        Thread.sleep(millis);
    }

    afterExecution();
}

Если вы хотите поддерживать периодические задачи, которые запускаются время от времени, вы можете либо передать параметр задержки экземпляру Thread, либо просто написать что-то вроде Thread.sleep(delay) в своем исполняемом файле.

Это не настоящий код, это просто предложение, поскольку я сейчас пытаюсь с ним работать.

Я написал простое, чистое, рабочее решение для ThreadPoolExecutor с PriorityBlockingQueue.

public class PriorityQueueThreadPoolExecutor {
    private static final int DEFAULT_INITIAL_PRIORITY_QUEUE_CAPACITY = 100;
    private static final long THREAD_TIMEOUT_IN_SECS = 60L;
    public static final int DEFAULT_PRIORITY = 0;

    private static final AtomicInteger InstanceCounter = new AtomicInteger(0);

    private final ThreadPoolExecutor internalExecutor;

    public PriorityQueueThreadPoolExecutor(int threadPoolSize, String threadNamePrefix) {
        internalExecutor = new ThreadPoolExecutor(threadPoolSize, threadPoolSize, THREAD_TIMEOUT_IN_SECS,
                TimeUnit.SECONDS, createPriorityQueue(), createThreadFactory(threadNamePrefix));
        internalExecutor.allowCoreThreadTimeOut(true);
    }

    public void submit(Runnable runnable, int priority) {
        internalExecutor.execute(new RunnableWithPriority(runnable, priority));
    }

    public void submit(Runnable runnable) {
        submit(runnable, DEFAULT_PRIORITY);
    }

    public ThreadPoolExecutor getInternalThreadPoolExecutor() {
        return internalExecutor;
    }

    private static BlockingQueue<Runnable> createPriorityQueue() {
        return new PriorityBlockingQueue<>(DEFAULT_INITIAL_PRIORITY_QUEUE_CAPACITY,
                new ComparatorForPriorityRunnable());
    }

    private static ThreadFactory createThreadFactory(String threadNamePrefix) {
        return new ThreadFactoryBuilder().setThreadFactory(Executors.defaultThreadFactory())
                .setNameFormat(threadNamePrefix + "-%d").setDaemon(true).build();
    }

    private static class RunnableWithPriority implements Runnable {
        final int creationOrder;
        final int priority;
        final Runnable runnable;

        public RunnableWithPriority(Runnable runnable, int priority) {
            this.runnable = runnable;
            this.priority = priority;
            this.creationOrder = InstanceCounter.incrementAndGet();
        }

        @Override
        public void run() {
            runnable.run();
        }
    }

    private static class ComparatorForPriorityRunnable implements Comparator<Runnable> {
        @Override
        public int compare(Runnable r1, Runnable r2) {
            RunnableWithPriority pr1 = (RunnableWithPriority) r1;
            RunnableWithPriority pr2 = (RunnableWithPriority) r2;
            // higher value means higher priority
            int priorityResult = pr2.priority - pr1.priority;
            return priorityResult != 0 ? priorityResult : (pr1.creationOrder - pr2.creationOrder);
        }
    }
}