CompletableFuture异步编排

CompletableFuture是JDK8新引入的异步编排方式，并可结合线程池来使用

• 首先声明一个线程池

private static ExecutorService executors = Executors.newFixedThreadPool(10);

• 有返回结果的异步调用 supplyAsync

        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("异步任务执行");
            int a = 10/0; //制造异常
            return 10;
        }, executors)
                .whenCompleteAsync((res,exception)->{
                    //当异步任务执行完成以后
                    System.out.println("上一步的返回值是" + res);
                    System.out.println("异常是" + exception);
                },executors)
                .exceptionally((e)->{
                    //当异步任务发生异常时回调这个方法,这个方法的好处是可以重新定义返回值
                    System.out.println("异步任务发生了异常");
                    return -1;
                });
        System.out.println("异步任务的执行结果是" + future.get());
        System.out.println("主线程结束");

• 无返回结果的异步调用 runAsync

        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("异步调用执行");
        }, executors);
        System.out.println("异步任务的执行结果是" + future.get());

• 多任务组合,不能获取上一步返回值，最后一步不能返回 runAfterBothAsync

        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("异步任务1执行了");
            return 1;
        }, executors);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("异步任务2执行了");
            return 2;
        }, executors);
        future1.runAfterBothAsync(future2,()->{
            System.out.println("任务3执行.....，必须等任务1和任务2完成以后执行，无法获取返回值");
        },executors);

• 多任务组合,能获取上一步返回值，但最后一步不能返回 thenAcceptBothAsync

        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("异步任务1执行了");
            return 1;
        }, executors);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("异步任务2执行了");
            return 2;
        }, executors);
        future1.thenAcceptBothAsync(future2,(res1,res2)->{
            System.out.println("任务3执行.....，必须等任务1和任务2完成以后执行，" +
                    "上一步的返回值是" + res1 + "-->" + res2);
        },executors);

• 多任务组合,能获取上一步返回值，且最后一步能返回thenCombineAsync

        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("异步任务1执行了");
            return 1;
        }, executors);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("异步任务2执行了");
            return 2;
        }, executors);
        CompletableFuture<Integer> future3 = future1.thenCombineAsync(future2, (res1, res2) -> {
            System.out.println("任务3执行.....，必须等任务1和任务2完成以后执行，" +
                    "上一步的返回值是" + res1 + "-->" + res2);
            return res1 + res2;
        }, executors);
        System.out.println("最后一个任务的返回值为" + future3.get());

• 单任务：runAfterEitherAsync，两任务完成其1就执行，无返回值

        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("异步任务1执行了");
            return 1;
        }, executors);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("异步任务2执行了");
            return 2;
        }, executors);
        future1.runAfterEitherAsync(future2,()->{
            System.out.println("runAfterEitherAsync:两个异步任务执行完其中1个就执行");
        },executors);

• 单任务：acceptEitherAsync，两任务完成其1就执行，无返回值，但能获取到上一步返回值

        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("异步任务1执行了");
            return 1;
        }, executors);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("异步任务2执行了");
            return 2;
        }, executors);
        future1.acceptEitherAsync(future2,(res)->{
            //res就是先做完的任务的返回值
            System.out.println("runAfterEitherAsync:两个异步任务执行完其中1个就执行，返回值为" +
                    res);
        },executors);

• 单任务：applyToEitherAsync，两任务完成其1就执行，有返回值，且能获取到上一步返回值

        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("异步任务1执行了");
            return 1;
        }, executors);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("异步任务2执行了");
            return 2;
        }, executors);
        CompletableFuture<Integer> future3 = future1.applyToEitherAsync(future2, (res) -> {
            //res就是先做完的任务的返回值
            System.out.println("runAfterEitherAsync:两个异步任务执行完其中1个就执行，返回值为" +
                    res);
            return res * 2;
        }, executors);
        System.out.println("任务3的返回结果是" + future3.get());

• 多任务阻塞：allOf 所有任务都做完才算最终完成,是一个阻塞方法

        CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
            System.out.println("异步任务1执行了");
        }, executors);
        CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> {
            System.out.println("异步任务2执行了");
        }, executors);
        CompletableFuture.allOf(future1,future2).get(); //阻塞等待，一定要调用get方法

• 多任务阻塞：anyOf 其中一个任务都做完算最终完成

CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
            System.out.println("异步任务1执行了");
        }, executors);
        CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> {
            System.out.println("异步任务2执行了");
        }, executors);
        CompletableFuture<Void> future3 = CompletableFuture.runAsync(() -> {
            System.out.println("异步任务3执行了");
        }, executors);
        CompletableFuture.anyOf(future1,future2,future3).get(); //三个任务完成其一就执行完成