初探 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());

 

转载于:https://my.oschina.net/u/3370769/blog/3070033