ExecutorService阻塞等待两个异步线程都执行完毕

本文介绍如何通过创建线程池并利用阻塞队列来处理执行时长不同的异步线程任务，确保所有任务完成后再继续执行后续操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

两个异步线程处理时长不同，先放入阻塞线程池内，需要等执行慢的那个线程任务执行完毕。

 //1.创建线程名称
    ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("thread-call-%d").build();
    //2.创建线程池
    /**
     * corePoolSize：   线程池中核心线程数的最大值
     * maximumPoolSize：线程池中能拥有最多线程数
     * keepAliveTime：  表示空闲线程的存活时间。
     * TimeUnitunit：   表示keepAliveTime的单位
     * workQueue：      用于缓存任务的阻塞队列(LinkedBlockingQueue<Runnable>：顾名思义是用链表实现的队列，可以是有界的，也可以是无界的，但在Executors中默认使用无界的)
     */
    ExecutorService executorService = new ThreadPoolExecutor(0,10,0L,TimeUnit.MILLISECONDS,new LinkedBlockingDeque<>(),threadFactory);

    List<Callable<Integer>> tasks = new ArrayList<Callable<Integer>>();

    Callable<Integer> task = new Callable<Integer>() {
        @Override
        public Integer call() throws Exception {
            int a = 0;
            for (int i = 0; i < 10; i++) {
                a = i;
                System.out.println(i);
            }
            return a;
        }
    };

    Callable<Integer> task2 = null;
    task2 = new Callable<Integer>() {
        @Override
        public Integer call() throws Exception {
            int a = 0;
            for (int i = 0; i < 100; i++) {
                a = i;
                System.out.println(i);
            }
            Thread.sleep(3000);
            return a;
        }
    };

    tasks.add(task);
    tasks.add(task2);
    
        try {
            //将两个执行任务都放入线程池内，阻塞
            List<Future<Integer>> futures = executorService.invokeAll(tasks);
           
            for (Future<Integer> future : futures) {
                //得到返回值
                future.get();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    tasks.clear();

}