Java8 CompletableFuture

Java8之前，如果想让mian线程的一组异步任务执行完毕后再继续往下执行，需要依靠CountDownLatch和Future来完成，代码显得啰嗦不够简洁，需要引入CountDownLatch来控制线程相互等待对方的任务完成，才能继续往下执行。

        final CountDownLatch countDownLatch = new CountDownLatch(3);
        final SecureRandom random = new SecureRandom();
        Future<String> stringFuture1 = executorService.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                Thread.sleep(random.nextInt(10) * 1000);
                countDownLatch.countDown();
                return "stringFuture1";
            }
        });
        Future<String> stringFuture2 = executorService.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                Thread.sleep(random.nextInt(10) * 1000);
                countDownLatch.countDown();
                return "stringFuture2";
            }
        });
        Future<String> stringFuture3 = executorService.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                Thread.sleep(random.nextInt(10) * 1000);
                countDownLatch.countDown();
                return "stringFuture3";
            }
        });
        countDownLatch.await();
        System.out.println("beforeJava8所有任务都执行完毕.");
        System.out.println(stringFuture1.get());
        System.out.println(stringFuture2.get());
        System.out.println(stringFuture3.get());
        executorService.shutdown();

Java8之后，如果想让mian线程的一组异步任务执行完毕后再继续往下执行，则相对简单了，代码也更为简洁。

        final SecureRandom random = new SecureRandom();
        CompletableFuture<String> completableFuture1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(random.nextInt(10) * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "completableFuture1";
        }, executorService);
        CompletableFuture<String> completableFuture2 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(random.nextInt(10) * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "completableFuture2";
        }, executorService);
        CompletableFuture<String> completableFuture3 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(random.nextInt(10) * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "completableFuture3";
        }, executorService);
        CompletableFuture.allOf(completableFuture1, completableFuture2, completableFuture3).get();
        System.out.println("afterJava8所有任务都执行完毕.");
        System.out.println(completableFuture1.get());
        System.out.println(completableFuture2.get());
        System.out.println(completableFuture3.get());
        executorService.shutdown();

Java8引入的CompletableFuture相较于Future，更为强大，功能丰富，支持回调、组合。