如何避免使用递归调用的executorservice拥塞/停顿/死锁

Question

ExecutorService中的所有线程都在忙着等待滞留在executor服务队列中的任务的任务。

示例代码：

ExecutorService es=Executors.newFixedThreadPool(8);
        Set<Future<Set<String>>> outerSet=new HashSet<>();
        for(int i=0;i<8;i++){
            outerSet.add(es.submit(new Callable<Set<String>>() {

                @Override
                public Set<String> call() throws Exception {
                    Thread.sleep(10000); //to simulate work
                    Set<Future<String>> innerSet=new HashSet<>();
                    for(int j=0;j<8;j++) {
                        int k=j;
                        innerSet.add(es.submit(new Callable<String>() {
                            @Override
                            public String call() throws Exception {
                                return "number "+k+" in inner loop";
                            }

                        }));
                    }
                    Set<String> out=new HashSet<>();
                    while(!innerSet.isEmpty()) {            //we are stuck at this loop because all the
                        for(Future<String> f:innerSet) {    //callable in innerSet are stuckin the queue
                            if(f.isDone()) {                //of es and can't start since all the threads
                                out.add(f.get());           //in es are busy waiting for them to finish
                            }
                        }
                    }
                    return out;
                }
            }));
        }

除了为每层创建更多的线程池或者有一个大小不固定的线程池之外，还有什么方法可以避免这种情况吗？

一个实际的例子是，将一些调用项提交给ForkJoinPool.commonPool()，然后这些任务在其方法中使用也提交给CommonPoole的对象。

Answer 1

您应该使用forkjoinpool。它是为这种情况而制作的。

当线程等待其子任务完成时，您的解决方案会永久阻止它，而窃取forkjoinpool的工作可以在join()中执行工作。这使得它对于正在运行的小（通常是递归的）任务的数量可变的情况非常有效。对于常规线程池，您需要将其放大，以确保线程不会耗尽。

使用completablefuture，您需要自己处理更多的实际计划/日程安排，如果您决定更改内容，则调整将更加复杂。使用fjp时，您唯一需要优化的是池中的线程数量，而使用cf时，您还需要考虑then和thenasync。