用Future与CountDownLatch实现多线程执行多个异步任务，任务全部完成后返回结果

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;


public class TestFuture {
    public static void main(String[] args) {
        TestFuture testFuture = new TestFuture();
        // 初始为三个任务数
        int taskCount = 3;
        List> futures = new ArrayList<>(taskCount);
        // CountDownLatch作为递减计数器，一个线程完成了一个任务，计数器减一，减为0时表示任务全部完成
        CountDownLatch downLatch = new CountDownLatch(taskCount);

        ExecutorService executorService = new ThreadPoolExecutor
                (taskCount, 5, 5, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10));

        for (int i = 0; i < taskCount; i++) {
            // 开启三个异步任务
            Future future = executorService.submit(testFuture.executeTask(i, downLatch));
            futures.add(future);
        }

        System.out.println("do other things");

        try {
            // 在downLatch不为0时，主线程会在此阻塞
            downLatch.await();
            executorService.shutdown();
            // 通过future获取结果
            List result = testFuture.getFutureResult(futures);
            for (String s : result) {
                System.out.println(s);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public Callable executeTask(int i, CountDownLatch downLatch) {
        return () -> {
            Thread.sleep(i * 1000L);
            downLatch.countDown();
            return "Result " + Thread.currentThread().getName();
        };
    }

    public List getFutureResult(List> futures) {
        List result = new ArrayList<>(3);
        for (Future future : futures) {
            if (future.isDone() && !future.isCancelled()) {
                try {
                    result.add(future.get());
                } catch (InterruptedException | ExecutionException e) {
                    e.printStackTrace();
                }
            }
        }
        return result;
    }
}