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

我对你的问题有点困惑。您想先执行优先级较低的任务吗？

我认为如果你问如何使用TaskScheduler确保优先级较高的任务而不是优先级较低的优先级和BY-Pass默认的FIFO，那么你需要使用PriorityBlockingQueue和一个实现了java.util.Comparator接口的对象。使用您自己的比较器，您还可以定义自己的优先级。

Answer 2

没关系，我自己想出了解决方案。我正在使用10的线程池大小。并使用AtomicInteger实际查看更高优先级线程后更高的prority线程是否没有获得CPU周期。

如果您看到不正确的内容，请添加您的反馈。

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();
        }

}

TaskScheduler的多线程版本，它保证优先级较高的任务永远不会在java中的低优先级任务后开始执行

2 个答案: