java 8 新特性CompletableFuture使用

准备工作：定义一个线程池

        ExecutorService pool= Executors.newFixedThreadPool(3,(Runnable r)->{
            Thread t=new Thread(r);
            t.setDaemon(true);
            return t;
        });

一、执行方式
1、对于有返回值的

CompletableFuture future=CompletableFuture.supplyAsync(()->{
            return "主任务返回结果";
        },pool).handle((result,throwable)->{
            if(throwable!=null){
                return "处理异常结果";
            }
            System.out.println("结果回调");
            System.out.println(result);
            return "统一返回结果："+result;
        });
        String result=future.get();
        System.out.println(result);

2、对应没有返回值的

ExecutorService pool= Executors.newFixedThreadPool(3,(Runnable r)->{
            Thread t=new Thread(r);
            t.setDaemon(true);
            return t;
        });
        CompletableFuture future=CompletableFuture.runAsync(()->{
            System.out.println("业务1");
            System.out.println("业务2");
        },pool);
        future.join();

二、设置回调

CompletableFuture future=CompletableFuture.supplyAsync(()->{
            System.out.println("业务1");
            return "11111";
        },pool).whenComplete((v,throwable)->{
            System.out.println("回调结果");
            System.out.println(v);
        });
        future.join();

三、异步任务的串行：
即流水线方式，一个任务结束另一个任务开始执行
1、thenApplyAsync方式：第一个任务结束，第二个任务用第一个任务的结果作为参数，并开启第二个任务的执行，第二个任务返回新的结果。

CompletableFuture funtue=CompletableFuture.supplyAsync(()->"a",pool)
                .thenApplyAsync(v->{
                    System.out.println("主任务结果"+v);
                    return "b";
                },pool)
                .thenApplyAsync(v->{
                    System.out.println("次任务结果"+v);
                    return "c";
                },pool);
        System.out.println(funtue.get());

2、thenRunAsync：第一个任务结束，第二个任务开始，并且第二个任务无需参数（与上一个任务执行结果无关），并且第二个任务无返回值

CompletableFuture funtue=CompletableFuture.supplyAsync(()->"a",pool)
                .thenRunAsync(()->{
                    System.out.println("谢谢小星星");
                    System.out.println("异步执行");
                },pool);
        funtue.join();

3、thenAcceptAsync：第一个任务结束，第二个任务用第一个任务的结果作为参数，并开启第二个任务的执行，第二个任务无返回值。

CompletableFuture funtue=CompletableFuture.supplyAsync(()->"a",pool)
                        .thenAcceptAsync(v->{
                            System.out.println("上一步结果");
                            System.out.println(v);
                        },pool);
        funtue.join();

4、thenComposeAsync：与thenApplyAsync类似，不同的是第二个任务的返回结果是CompletableFuture类型的

        CompletableFuture funtue=CompletableFuture.supplyAsync(()->"a",pool)
                .thenComposeAsync(v->{
                    System.out.println("上一步计算结果："+v);
                    return CompletableFuture.supplyAsync(()->"b",pool);
                },pool);
        System.out.println(funtue.get());

四、异步任务的合并执行：

例如一共有三个任务，第三个任务需要再第一个任务和第二个任务都执行完成后才能执行第三个任务
1、thenCombineAsync：调用方为第一个任务的CompletionStage，第一个参数为第二个任务的CompletionStage。在第一个和第二个任务都执行完成后，开始执行第三个任务，第三个任务的参数分别为第一个、第二个任务的返回结果，并且第三个任务需要返回新的结果

CompletableFuture future1=CompletableFuture.supplyAsync(()->3,pool);
        CompletableFuture future2=CompletableFuture.supplyAsync(()->6,pool);
        CompletableFuture future3=future1.thenCombineAsync(future2,(m,v)->m*v,pool);
        System.out.println(future3.get());

2、runAfterBothAsync:：调用方为第一个任务的CompletionStage，第一个参数为第二个任务的CompletionStage。在第一个和第二个任务都执行完成后，开始执行第三个任务，第三个任务与第一个、第二个任务的返回结果无关，即没有参数，并且第三个任务无返回值。

CompletableFuture future1=CompletableFuture.runAsync(()-> System.out.println("步骤1"),pool);
        CompletableFuture future2=CompletableFuture.runAsync(()->System.out.println("步骤2"),pool);
        CompletableFuture future3=future1.runAfterBothAsync(future2,()->System.out.println("步骤3"),pool);
        future3.join();

3、thenAcceptBothAsync：调用方为第一个任务的CompletionStage，第一个参数为第二个任务的CompletionStage。在第一个和第二个任务都执行完成后，开始执行第三个任务，第三个任务的参数分别为第一个、第二个任务的返回结果，并且第三个任务无返回值。

CompletableFuture future1=CompletableFuture.supplyAsync(()->3,pool);
        CompletableFuture future2=CompletableFuture.supplyAsync(()->6,pool);
        CompletableFuture future3=future1.thenAcceptBothAsync(future2,(m,n)->{
            System.out.println(m);
            System.out.println(n);
        },pool);
        future3.join();

4、allOf：等待所有异步任务执行完成

CompletableFuture future1=CompletableFuture.supplyAsync(()->3,pool);
        CompletableFuture future2=CompletableFuture.supplyAsync(()->6,pool);
        CompletableFuture future3=CompletableFuture.supplyAsync(()->9,pool);
        CompletableFuture future4=CompletableFuture.allOf(future1,future2,future3);
        future4.join();
        System.out.println(future1.get());
        System.out.println(future2.get());
        System.out.println(future3.get());

五、异步任务的选择执行：
例如有三个任务，第三个任务需要在第一个任务和第二个任务中执行快的那一个执行完成后，才可以执行任务三
1、applyToEitherAsync：在任务一、任务二中，只要有一个任务先执行完成后，将执行快的那个任务的返回结果作为第三个任务的参数，然后才可执行任务三，并且任务三需要返回新的结果

CompletableFuture future1=CompletableFuture.supplyAsync(()->{
            try {
                Thread.sleep(9000);
                return 3;
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        },pool);
        CompletableFuture future2=CompletableFuture.supplyAsync(()->{
            try {
                Thread.sleep(6000);
                return 6;
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        },pool);
        CompletableFuture future3=future1.applyToEitherAsync(future2,v->v,pool);
        System.out.println(future3.get());

2、runAfterEitherAsync：在任务一、任务二中，只要有一个任务先执行完成后，再执行任务三，并且任务三无参数和返回值

CompletableFuture future1=CompletableFuture.runAsync(()->{
            try {
                Thread.sleep(3000);
                System.out.println("任务1");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        },pool);
        CompletableFuture future2=CompletableFuture.runAsync(()->{
            try {
                Thread.sleep(6000);
                System.out.println("任务2");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        },pool);
        CompletableFuture future3=future1.runAfterEitherAsync(future2,()-> System.out.println("任务3"),pool);
        System.out.println(future3.join());

3、acceptEitherAsync：在任务一、任务二中，只要有一个任务先执行完成后，将执行快的那一个任务的返回结果作为第三个任务的参数，然后才可执行任务三，并且任务三无需返回值

CompletableFuture future1=CompletableFuture.supplyAsync(()->{
            try {
                Thread.sleep(3000);
                return 3;
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        },pool);
        CompletableFuture future2=CompletableFuture.supplyAsync(()->{
            try {
                Thread.sleep(6000);
                return 6;
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        },pool);
        CompletableFuture future3=future1.acceptEitherAsync(future2,v-> System.out.println(v),pool);
        System.out.println(future3.join());