ExecutorService怎样不用shutdown，awaitTermination实现主线程等待所有子线程完成再继续执行

Question

ExecutorService es = Executors.newFixedThreadPool(THREADPOOLSIZE+1);

        while(true){
            long startTime2 = System.currentTimeMillis();
            numIids = getIds(batchId, LIMITSIZE);
            if (numIids == null || numIids.isEmpty()) {
                break;
            }
            int i = 0;
            int batchSize = numIids.size() / THREADPOOLSIZE;
            if (numIids.size() > THREADPOOLSIZE) {
                for (i = 0; i < THREADPOOLSIZE; i++) {
                    List<Long> subList = numIids.subList(i * batchSize, ((i + 1) * batchSize));
                    es.submit(() -> {
                        try {
                            compute(batchId, subList);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    });
                }
            }
            if (i * batchSize < numIids.size()) {
                List<Long> subList = numIids.subList(i * batchSize, numIids.size());
                es.submit(() -> {
                    try {
                        compute(batchId, subList);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                });
            }
            我想在这里实现等待上面所有子线程完成所有任务，然后向下执行（不关闭线程池中的线程，让这些线程重复使用）
        }
        es.shutdown();
        awaitTerminationQuietly(es);
        }

Answer 1

可以使用 java.util.concurrent.CountDownLatch 这个类

Answer 2

看看invokeAll这个方法

Answer 3

我项目里面是这么做的，可以达到你要求：

/**
 * 
 * <p>
 * 线程池调度子类实现<br />
 * 主要是重写awaitTermination方法，达到不让线程池shutdown目的
 * </p>
 * @author jialing.yao  2015年9月5日
 */
public class MyThreadPoolExecutor extends ThreadPoolExecutor{
    private static Logger log = LoggerFactory.getLogger(MyThreadPoolExecutor.class);
    private ReentrantLock pauseLock = new ReentrantLock();
    private Condition unpaused = pauseLock.newCondition();
    
    public MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,handler);
    }
    
    /**
     * 重写，覆盖并弃用父类的awaitTermination方法 </br>
     * 所以，这里传的两个参数将无效，可以随便传
     */
    @Override
    public boolean awaitTermination(long timeout, TimeUnit unit){
        //阻塞，不让主程序死掉，到时候这里传异常信号量，出现异常则推送信号数据到这里while(flag)
        while(true){
            pauseLock.lock();
            try {
                unpaused.await();
            }catch (InterruptedException e) {
                log.error("",e);
            }finally {
                pauseLock.unlock();
            }
        }
    }

}