Многопоточная версия TaskScheduler, которая гарантирует, что задача с более высоким приоритетом никогда не запускается после задачи с более низким приоритетом в java

Question

Мне нужно написать многопоточную версию TaskSchedular

TaskScheduler {
   TaskScheduler(List<Task> tasks)
    .... 
}


   interface Task {
      int getPriority()
      void execute()
    }

так что это гарантирует, что задача с более высоким приоритетом никогда не запускается после более низкого приоритета

Вот мой пример однопоточной версии. Мне нужно создать этот многопоточный.

public class SingleThreadedTaskScheduler {

    private ExecutorService executorService = Executors.newFixedThreadPool(1);

    private PriorityQueue<Task> taskQueue;
    private static final PriorityComparator PRIORITY_COMPARATOR = new PriorityComparator();


    public SingleThreadedTaskScheduler(List<Task> tasks){
        this.taskQueue = new PriorityQueue<Task>(tasks.size(), PRIORITY_COMPARATOR);
        this.taskQueue.addAll(tasks);
    }

    public void executeAllByPriority(){
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                for (Task task : taskQueue) {
                    task.execute();
                }
            }
        });

    }


    public void executeAllByPriorityWithUnInterruptableFirst(){
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                PriorityQueue<Task> interruptedQueue = new PriorityQueue<Task>(taskQueue.size(),PRIORITY_COMPARATOR);
                for (Task task : taskQueue) {
                    if (task instanceof Interruptible && ((Interruptible) task).isInterrupted() ){
                        interruptedQueue.add(task);
                    } else {
                        task.execute();
                    }
                }

                for (Task task : interruptedQueue ){
                    task.execute();
                }
            }
        });

    }

    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        executorService.shutdown();
    }

}

Небольшой код очень поможет.

Answer 1

Не берите в голову, я нашел решение самостоятельно. Я использую пул потоков размером 10. И использую AtomicInteger, чтобы увидеть, действительно ли поток с более высокой степенью приоритета не получает цикл ЦП после потока с более низким приоритетом.

Пожалуйста, добавьте свой отзыв, если что-то вы видите неправильно.

public class MultiThreadedTaskScheduler  {

      AtomicInteger priorityCounter = new AtomicInteger(-1);
private ExecutorService executorService = Executors.newFixedThreadPool(10);

private PriorityQueue<Task> taskQueue;
private static final PriorityComparator PRIORITY_COMPARATOR = new PriorityComparator();


        public MultiThreadedTaskScheduler(List<Task> tasks){
            this.taskQueue = new PriorityQueue<Task>(tasks.size(), PRIORITY_COMPARATOR);
            this.taskQueue.addAll(tasks);
        }

        public void executeAllByPriority(){
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    for (Task task : taskQueue) {
                        executeMethod(task);
                    }
                }
            });

        }

    private void executeMethod(Task task) {
        if (task.getPriority()  > priorityCounter.get() ){
            task.execute();
            priorityCounter.getAndSet(task.getPriority());
        }

    }



        public void executeAllByPriorityWithUnInterruptableFirst(){
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    PriorityQueue<Task> interruptedQueue = new PriorityQueue<Task>(taskQueue.size(),PRIORITY_COMPARATOR);
                    for (Task task : taskQueue) {
                        if (task instanceof Interruptible && ((Interruptible) task).isInterrupted() ){
                            interruptedQueue.add(task);
                        } else {
                            executeMethod(task);
                        }
                    }

                    for (Task task : interruptedQueue ){
                        executeMethod(task);
                    }
                }
            });

        }

        @Override
        protected void finalize() throws Throwable {
            super.finalize();
            executorService.shutdown();
        }

}

Answer 2

Я немного запутался с вашим вопросом. Вы хотите выполнить задачу с более низким приоритетом в первую очередь?

Я думаю, что если вы спрашиваете, как использовать TaskScheduler для проверки задачи с более высоким приоритетом, чем для более низкого приоритета и BY-Pass FIFO по умолчанию, тогда вам нужно использовать PriorityBlockingQueue с объектом, который реализовал интерфейс java.util.Comparator. С помощью собственного компаратора вы также можете определить свой собственный приоритет.