我应该使用Java中的哪个ThreadPool？

Question

有大量的任务。 每个任务都属于一个组。 要求是每组任务都应像在单个线程中执行的那样串行执行，并且在多核（或多cpu）环境中应使吞吐量最大化。 注意：还有大量与任务数量成正比的组。

天真的解决方案是使用ThreadPoolExecutor并进行同步（或锁定）。 但是，线程会相互阻塞，并且吞吐量不会最大化。

有更好的主意吗？ 还是存在满足要求的第三方库？

Answer 1

一种简单的方法是将所有组任务“串联”为一个超级任务，从而使子任务串行运行。 但这可能会导致其他组中的延迟，除非其他一些组完全完成并在线程池中留出一些空间，否则其他组将不会开始。

作为替代方案，请考虑将小组的任务链接在一起。 以下代码对此进行了说明：

public class MultiSerialExecutor {
    private final ExecutorService executor;

    public MultiSerialExecutor(int maxNumThreads) {
        executor = Executors.newFixedThreadPool(maxNumThreads);
    }

    public void addTaskSequence(List<Runnable> tasks) {
        executor.execute(new TaskChain(tasks));
    }

    private void shutdown() {
        executor.shutdown();
    }

    private class TaskChain implements Runnable {
        private List<Runnable> seq;
        private int ind;

        public TaskChain(List<Runnable> seq) {
            this.seq = seq;
        }

        @Override
        public void run() {
            seq.get(ind++).run(); //NOTE: No special error handling
            if (ind < seq.size())
                executor.execute(this);
        }       
    }

优点是无需使用额外的资源（线程/队列），并且任务的粒度比幼稚的方法要好。 缺点是应事先知道所有小组的任务 。

- 编辑 -

为了使该解决方案通用且完整，您可能需要决定错误处理（即即使发生错误，链是否仍继续），并且实现ExecutorService并将所有调用委托给底层执行程序也是一个好主意。

Answer 2

我建议使用任务队列：

• 对于每组任务，您已经创建了一个队列，并将该组中的所有任务插入其中。
• 现在，您的所有队列都可以并行执行，而一个队列中的任务则可以串行执行。

谷歌快速搜索表明，Java api本身没有任务/线程队列。 但是，有许多关于编码的教程。 如果您知道一些，每个人都可以列出好的教程/实现：

Answer 3

我大多同意Dave的回答，但是如果您需要在所有“组”之间分配CPU时间，即所有任务组都应并行进行，那么您可能会发现这种构造很有用（将删除用作“锁”。我的情况，虽然我想它倾向于使用更多的内存）：

class TaskAllocator {
    private final ConcurrentLinkedQueue<Queue<Runnable>> entireWork
         = childQueuePerTaskGroup();

    public Queue<Runnable> lockTaskGroup(){
        return entireWork.poll();
    }

    public void release(Queue<Runnable> taskGroup){
        entireWork.offer(taskGroup);
    }
 }

和

 class DoWork implmements Runnable {
     private final TaskAllocator allocator;

     public DoWork(TaskAllocator allocator){
         this.allocator = allocator;
     }

     pubic void run(){
        for(;;){
            Queue<Runnable> taskGroup = allocator.lockTaskGroup();
            if(task==null){
                //No more work
                return;
            }
            Runnable work = taskGroup.poll();
            if(work == null){
                //This group is done
                continue;
            }

            //Do work, but never forget to release the group to 
            // the allocator.
            try {
                work.run();
            } finally {
                allocator.release(taskGroup);
            }
        }//for
     }
 }

然后，您可以使用最佳线程数来运行DoWork任务。 这是一种循环负载平衡。

通过使用它而不是TaskAllocator中的简单队列，您甚至可以做一些更复杂的TaskAllocator （任务组剩余的任务更多，往往会被执行）

ConcurrentSkipListSet<MyQueue<Runnable>> sophisticatedQueue = 
    new ConcurrentSkipListSet(new SophisticatedComparator());

SophisticatedComparator在哪里

class SophisticatedComparator implements Comparator<MyQueue<Runnable>> {
    public int compare(MyQueue<Runnable> o1, MyQueue<Runnable> o2){
        int diff = o2.size() - o1.size();
        if(diff==0){
             //This is crucial. You must assign unique ids to your 
             //Subqueue and break the equality if they happen to have same size.
             //Otherwise your queues will disappear...
             return o1.id - o2.id;
        }
        return diff;
    }
 }

Answer 4

Actor也是针对此指定类型问题的另一种解决方案。 Scala有演员，还有AKKA提供的Java。

Answer 5

我有类似的您一个问题，我用了一个ExecutorCompletionService与一个作品Executor对任务的完全集合。 这是自Java7以来的java.util.concurrent API的摘录：

假设您有一组针对某个问题的求解器，每个求解器都返回某种Result类型的值，并希望同时运行它们，并处理每个返回非空值的结果，在某种方法中使用use（Result r）。 您可以这样写：

void solve(Executor e, Collection<Callable<Result>> solvers)
        throws InterruptedException, ExecutionException {
    CompletionService<Result> ecs = new ExecutorCompletionService<Result>(e);
    for (Callable<Result> s : solvers)
        ecs.submit(s);
    int n = solvers.size();
    for (int i = 0; i < n; ++i) {
        Result r = ecs.take().get();
        if (r != null)
            use(r);
    }
}

因此，在您的方案中，每个任务将是一个Callable<Result> ，并且任务将被分组在Collection<Callable<Result>> 。

参考： http : //docs.oracle.com/javase/7/docs/api/java/util/concurrent/ExecutorCompletionService.html