在Java中指定任务顺序执行

Question

我搜过很多但都找不到解决方案。 我是这样使用Java线程池的：

ExecutorService c = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; ++i) {
  c.execute(new MyTask(i));
}

以这种方式，任务按顺序执行（如队列中所示）。但我需要更改“选择下一个任务”的策略。因此，我想为每个任务指定优先级（它不是线程优先级），并执行与这些优先级相对应的任务。因此，当执行程序完成另一个任务时，它会选择具有最高优先级的任务作为下一个任务。

这描述了常见的问题。也许有一种更简单的方法，不考虑优先级。它将选择最后添加的任务作为下一个要执行的任务，而不是最先添加的任务。粗略地说，FixedThreadPool使用FIFO策略。例如，我可以使用LIFO策略吗？

- Rustam Iuzmukhametov

Answer 1

你可以使用 PriorityBlockingQueue 来指定 ThreadPoolExecutor 中的队列。

public class PriorityExecutor extends ThreadPoolExecutor {

    public PriorityExecutor(int corePoolSize, int maximumPoolSize,
            long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }
    //Utitlity method to create thread pool easily
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new PriorityExecutor(nThreads, nThreads, 0L,
                TimeUnit.MILLISECONDS, new PriorityBlockingQueue<Runnable>());
    }
    //Submit with New comparable task 
    public Future<?> submit(Runnable task, int priority) {
        return super.submit(new ComparableFutureTask(task, null, priority));
    }
    //execute with New comparable task 
    public void execute(Runnable command, int priority) {
        super.execute(new ComparableFutureTask(command, null, priority));
    }
}

定义ComparableFutureTask按照优先级进行比较。

class ComparableFutureTask<T> extends FutureTask<T>
        implements
            Comparable<ComparableFutureTask<T>> {

    volatile int priority = 0;

    public ComparableFutureTask(Runnable runnable, T result, int priority) {
        super(runnable, result);
        this.priority = priority;
    }
    public ComparableFutureTask(Callable<T> callable, int priority) {
        super(callable);
        this.priority = priority;
    }
    @Override
    public int compareTo(ComparableFutureTask<T> o) {
        return Integer.valueOf(priority).compareTo(o.priority);
    }
  }

- Amit Deshpande

---

这行代码无法工作，因为newTaskFor会将ComparableFutureTask包装成一个不可比较的FutureTask。你还需要重写这两个newTaskFor方法。 - assylias

请参考此帖子中的简单示例。 - assylias

我的解决方案按优先级排序任务，但保留相同优先级级别的提交顺序：https://dev59.com/d3RA5IYBdhLWcg3w1BqW#42831172 - Daniel Hári

Answer 2

ThreadPoolExecutor的构造函数接受BlockingQueue。您可以将队列传递为PriorityBlockingQueue。它不会对排序做出任何保证，您需要传递自定义比较器来维护顺序。

static BlockingQueue<Task> queue=new PriorityBlockingQueue<Task>(MAXPOOL,new TaskComparator());

static ThreadPoolExecutor threadpool = new ThreadPoolExecutor(30, MAXPOOL, 
        MAXPOOL, TimeUnit.SECONDS, (PriorityBlockingQueue) queue, new mThreadFactory());



class TaskComparator implements Comparator<Task>{
  public int compare(Task t1, Task t2){
    //write you own logic to compare two task.
  }
}

- Subhrajyoti Majumder

---

除了equals返回boolean和compare返回int之外，这是一篇好文章。我认为你想使用compareTo。 - Tudor