CompletableFuture的使用

总的来说，就是

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

CompletableFuture的静态工厂方法

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

 CompletableFuture<Void> 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!");

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14

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

    CompletableFuture<String> future = CompletableFuture.supplyAsync(new Supplier<String>() {
            @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!");

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15

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

    complete的使用

        CompletableFuture<String> 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!");

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14

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

  CompletableFuture<String> 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!");

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16

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

CompletableFuture<String> 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!");

    1
    2
    3
    4
    5
    6
    7
    8
    9

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

        CompletableFuture<String> 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();
        }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10

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

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

        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(()->"100");
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(()->10);
        CompletableFuture<Double> 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!");

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12

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

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

    1
    2
    3
    4
    5

    当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));

    1

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

       CompletableFuture<Double> 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!");

    1
    2
    3
    4
    5
    6
    7
    8
    9

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

       CompletableFuture<Double> future = CompletableFuture.supplyAsync(()->"100").thenApply(s->s+"10").handle(new BiFunction<String, Throwable, Double>() {
            @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<Double> future = CompletableFuture.supplyAsync(()->"100").thenApply(s->s+"10").handle((s,t)->s!=null?Double.parseDouble(s):0);

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15

    纯消费（执行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);
             }
         });