CompletableFuture的使用

CompletableFuture解决的问题:

总的来说，就是

1. 解决future模式的缺点。主要是
   a. 为了解决Future虽然可以实现异步获取线程的执行结果，但是future没有提供通知机制，调用方无法得知future什么时候执行完的问题。 b.要么使用阻塞， 在future.get()的地方等待future返回结果，这时会变成同步操作。如果使用isDone()方法进行循环判断，就会消耗cpu资源。
2. CompletableFuture能够将回调放到与任务不同的线程中执行（其实这句话，我也不是很理解），也能将回调作为继续执行的同步函数（但是我觉的这句是关键），在于任务相同的线程中执行。他避免了传统回调的最大问题，就是能够将控制流分离到不同的事件处理器中。

CompletableFuture的静态工厂方法

1. runAsync()方法的使用，—》使用了ForkJoinPool.commonPool() 作为线程池，并进行异步执行

 CompletableFuture future = CompletableFuture.runAsync(()->{
            System.out.println("hello world");
        });


        try {
            future.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        System.out.println("completableFuture end!");

2. runAsync()方法的使用，—》使用了ForkJoinPool.commonPool() 作为线程池，并进行异步执行

    CompletableFuture future = CompletableFuture.supplyAsync(new Supplier() {
            @Override
            public String get() {
                return "Hello";
            }
        });

        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("completableFuture end!");

supplyAsync 和 runAsync 的区别是supplyAsyncy有返回值，而runAsync没有返回值。

3. complete的使用

        CompletableFuture future = CompletableFuture.supplyAsync(()->"Hello")；
//        多次重复调会失效
        future.complete("World");
        future.complete("World2");
        future.complete("World3");
        future.complete("World4");
        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("completableFuture end!");

如果future已经执行完毕能够返回结果，此时再调complete(T t)则会无效

  CompletableFuture future = CompletableFuture.supplyAsync(()->"Hello");
        //如果future已经执行完毕能够返回结果，此时再调complete(T t)则会无效
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("completableFuture end!");

4. thenApply 是将CompletableFuture 转换成CompletableFuture,也就是类型转换

CompletableFuture future = CompletableFuture.supplyAsync(()->"Hello").thenApply(s->s+" world").thenApply(String::toUpperCase);
  try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("completableFuture end!");

5. thenCompose 组合多个CompletableFuture，将前一个结果作为下一个计算的参数，他们之间存在着先后顺序。还是串行

        CompletableFuture future = CompletableFuture.supplyAsync(()->"Hello").thenCompose(s->CompletableFuture.supplyAsync(()->s + " world"));
//thenCompose 可以用于组合多个CompletableFuture，将前一个结果作为下一个计算的参数，它们之间存在着先后顺序

        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

theApply 强调的是类型转换，而thenCompose强调的是执行顺序，就是前一个计算结果作为下一个计算的参数。

6. thenCombine 是将两个或多个CompletableFuture的结果进行汇总。

        CompletableFuture future1 = CompletableFuture.supplyAsync(()->"100");
        CompletableFuture future2 = CompletableFuture.supplyAsync(()->10);
        CompletableFuture future = future1.thenCombine(future2,(s,i)->Double.parseDouble(s+i));
//        使用thenCombine是将future1 和future2的结果汇总，这一点跟thenCompose()不同。其中future1和future2是并行执行的。
        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("completableFuture end!");

7. thenAcceptBoth 是当两个CompletableFuture都正常完成后，执行提供的action,用它来组合另一个CompletableFuture的结果。

   CompletableFuture future1 = CompletableFuture.supplyAsync(()->"100");
        CompletableFuture future2 = CompletableFuture.supplyAsync(()->70);
        CompletableFuture future = future1.thenAcceptBoth(future2,(s,i)->{
            System.out.println(s+i);
        });

8. 当CompletableFuture完成计算结果后，我们需要对结果进行一些处理。 whenComplete 对结果的异常进行处理。

      CompletableFuture.supplyAsync(()->"Hello").thenApply(s->s+" world").thenApply(s->s+"\nThis is CompletableFuture demo").thenApply(String::toLowerCase).whenComplete((result,throwable)-> System.out.println(result));

9. handle 当CompletableFuture完成计算结果或者抛出异常的时候，执行提供的fn;

       CompletableFuture future = CompletableFuture.supplyAsync(()->"100").thenApply(s->s+"10").handle((s,t)->s!=null? Double.parseDouble(s):0);
       try {
           System.out.println(future.get());
       } catch (InterruptedException e) {
           e.printStackTrace();
       } catch (ExecutionException e) {
           e.printStackTrace();
       }
       System.out.println("completableFuture end!");

10. handle :当CompletableFuture完成计算结果或者抛出异常的时候，执行提供的方法。相当于whenComplete()+转换

       CompletableFuture future = CompletableFuture.supplyAsync(()->"100").thenApply(s->s+"10").handle(new BiFunction() {
            @Override
            public Double apply(String s, Throwable throwable) {
                return s!=null?Double.parseDouble(s):0;
            }
        });
        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
// 使用lamda表达式的写法：
        CompletableFuture future = CompletableFuture.supplyAsync(()->"100").thenApply(s->s+"10").handle((s,t)->s!=null?Double.parseDouble(s):0);

11. 纯消费（执行Action）thenAccept,只会对计算结果进行消费而不会返回任何结果的方法。

       CompletableFuture.supplyAsync(()->"Hello")
                 .thenApply(s->s+" world")
                 .thenApply(s->s+"\nThis is CompletableFuture demo")
                 .thenApply(String::toLowerCase).thenAccept(new Consumer(){
             @Override
             public void accept(Object o) {
                 System.out.println(o);
             }
         });