初探 CompletableFuture Java8新的异步编程方式

1. 序言

       因为项目中想获取多个异步线程的状态，并判断其是否都执行完成，若执行完成后则作后续操做，经同事提醒java8 中CompletableFuture这个能够完美解决项目问题，故借此机会学习了下，记录下涉及到的知识点，以便后期回顾。

1. CompletableFuture

        2.1 Async结尾的方法都是能够异步执行的，若是指定了线程池，会在指定的线程池中执行，若是没有指定，默认会ForkJoinPool.commonPool()中执行。

     runAsync方法：它以Runnabel函数式接口类型为参数，因此CompletableFuture的计算结果为空。

    supplyAsync方法以Supplier<U>函数式接口类型为参数，CompletableFuture的计算结果类型为U。

方法	描述
static CompletableFuture<Void> runAsync(Runnable runnable)	返回一个新的CompletableFuture，它在运行给定操做后由运行在 ForkJoinPool.commonPool()中的任务 异步完成
static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor)	返回一个新的CompletableFuture，它在运行给定操做后在给定的线程池中运行的任务异步完成异步完成
static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)	返回一个新的CompletableFuture，它经过在 ForkJoinPool.commonPool()中运行的任务与经过调用给定的供应商得到的值 异步完成
static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)	返回一个新的CompletableFuture，由给定执行器中运行的任务异步完成，并经过调用给定的供应商得到的值

//1. 返回一个新的CompletableFuture，它在运行给定操做后由运行在 ForkJoinPool.commonPool()中的任务 异步完成。
        CompletableFuture<Void> completableFuture1 = CompletableFuture.runAsync(()-> {
            System.out.println(" completableFuture1 is not nothing");
        });
        //2. 返回一个新的CompletableFuture，它在运行给定操做后在给定的线程池中运行的任务异步完成异步完成。
        CompletableFuture<Void> completableFuture2 = CompletableFuture.runAsync(()-> {
            System.out.println(" completableFuture2 is not nothing");
        },Executors.newSingleThreadExecutor());

       //3. 返回一个新的CompletableFuture，它经过在 ForkJoinPool.commonPool()中运行的任务与经过调用给定的供应商得到的值 异步完成。
        CompletableFuture<Object> completableFuture3 = CompletableFuture.supplyAsync(()-> {
                    return "hello completableFuture3";
                });
       //4. 返回一个新的CompletableFuture，由给定执行器中运行的任务异步完成，并经过调用给定的供应商得到的值。
        CompletableFuture<Object> completableFuture4 = CompletableFuture.supplyAsync(()-> {
            return "hello completableFuture4";
        },Executors.newSingleThreadExecutor());

        System.out.println(completableFuture3.get());
        System.out.println(completableFuture4.get());

   2.2 allOf 、 anyOf

方法	描述
static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs)	返回一个新的CompletableFuture，当全部给定的CompletableFutures完成时，完成。   执行完全部提交任务后进行后面的操做,无返回值
static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs)	返回一个新的CompletableFuture，当任何一个给定的CompletableFutures完成时，完成相同的结果。用于有返回值的,当任一执行完当即返回结果

CompletableFuture<Object> completableFuture5 = CompletableFuture.supplyAsync(()-> {
            return "hello completableFuture5";
        });
        CompletableFuture<Object> completableFuture6 = CompletableFuture.supplyAsync(()-> {
            return "hello completableFuture6";
        },Executors.newSingleThreadExecutor());

        // allOf 若后面没有加join(),那么void1和void2将异步执行,这里不会阻塞,也就拿不到执行结果
        CompletableFuture.allOf(completableFuture5,completableFuture6)
                .thenRun(()->{
                    System.out.println("hello allof");
                }).join();

        List<CompletableFuture> completableFutureList = new ArrayList<>();
        completableFutureList.add(completableFuture5);
        completableFutureList.add(completableFuture6);
         // 方式一
        // completableFuture5 和 completableFuture6都执行完成后，输出对应的结果
        CompletableFuture<Void> res = CompletableFuture.allOf(completableFutureList.toArray(new CompletableFuture[completableFutureList.size()]));

        CompletableFuture<List<Object>> result = res.thenApply(v ->{
             return  completableFutureList.stream()
                    .map(CompletableFuture::join)
                    .collect(Collectors.toList());
                }
        );
         System.out.println(result.get());
        // 方式二
        List<Object> result2 = Stream.of(completableFutureList.toArray(new CompletableFuture[completableFutureList.size()]))
                .map(CompletableFuture::join)
                .collect(Collectors.toList());
        System.out.println(result2);

        // completableFuture5 和 completableFuture6 随机的，只要某个执行完成就会结束并返回结果。
        CompletableFuture<Object> anyof = CompletableFuture.anyOf(completableFutureList.toArray(new CompletableFuture[completableFutureList.size()]));
        System.out.println(anyof.get());

2.3 CompletableFuture 异常处理

CompletableFuture在运行时若是遇到异常，能够使用get()并抛出异常进行处理，但这并非一个最好的方法。CompletableFuture自己也提供了几种方式来处理异常

方法	描述
exceptionally(Function<Throwable,? extends T> fn)	只有当CompletableFuture抛出异常的时候，才会触发这个exceptionally的计算，调用function计算值。

CompletableFuture<String> completableFuture7 = CompletableFuture.supplyAsync(()-> {
            int m = 1/0;
            return "hello completableFuture7";
        }).exceptionally(ex->{
            return ex.getMessage();
        });
        System.out.println(completableFuture7.get());