CompletableFuture 六大类 14种 代码模板

CompletableFuture 异步框架，有很多种使用场景，总结了几种代码模板：

        // 一 ，平常的任务
        // 1、 异步执行任务， 不提供返回值
        CompletableFuture cf_ra = CompletableFuture.runAsync(()->{
            // your code
        });

        // 2、 异步执行任务， 提供返回值
        CompletableFuture cf_saa = CompletableFuture.supplyAsync(()->{
            // your code
            return 1; // result
        });


        // 二 单任务处理后 回调
        // 3、 任务执行完之后，回调 指定的任务，不接收上一任务结果，不提供返回值
        CompletableFuture<Long> cf_tr = CompletableFuture.supplyAsync(()->1L);
        cf_tr.thenRun(()->{
            // just code
        });

        // 4、 任务执行完之后，回调，接收任务处理结果，不提供返回值
        CompletableFuture<Long> cf_taccept = CompletableFuture.supplyAsync(()->1L);
        cf_taccept.thenAccept(t->{
            // t 上一个任务的执行结果
            // your code
        });

        // 5、 任务执行完之后，回调，接收任务处理结果，提供返回值
        CompletableFuture<Long> cf_ta = CompletableFuture.supplyAsync(()->1L);
        cf_ta.thenApply(t->{
            // t 上一个任务的执行结果
            // your code
            return 1;// result
        });


        // 三 单任务处理后 回调，兼容异常信息
        // 6、 任务执行完之后， 回调，接收任务处理结果 和 任务处理异常,不提供返回值
        CompletableFuture cf_wc = CompletableFuture.supplyAsync(()->1);
        cf_wc.whenComplete((t1,t2)-> {
            // t1 上一个任务执行结果
            // t2 上一个任务执行异常信息
            // your code
        });


        // 7、 任务执行完之后， 回调，接收任务处理结果 和 任务处理异常,提供返回值
        CompletableFuture<Long> cf_h = CompletableFuture.supplyAsync(()->1L);
        cf_h.handle((t1,t2)->{
            // t1 上一个任务执行结果
            // t2 上一个任务执行异常信息
            // your code
            return 1;// result
        });


        // 四 任务串行化
        // 8、 两个任务顺序执行，A执行完后，执行B
        CompletableFuture cf_tcc1 = CompletableFuture.runAsync(()->{});
        CompletableFuture cf_tcc2 = CompletableFuture.runAsync(()->{});
        CompletableFuture cf_tcc3 = cf_tcc1.thenCompose(t->cf_tcc2);

        // 五 双任务处理后，回调
        // 9、 A任务和B任务 都处理结束后，回调，接收 任务A的结果 和 任务B的结果 , 提供返回值
        CompletableFuture<Long> cf_tc1 = CompletableFuture.supplyAsync(()->1L);
        CompletableFuture<Long> cf_tc2 = CompletableFuture.supplyAsync(()->2L);
        CompletableFuture<Long> cf_tc = cf_tc1.thenCombine(cf_tc2,(t1,t2)->{
            // t1 任务 cf_tc1 的处理结果
            // t2 任务 cf_tc2 的处理结果
            // your code
            return t1 + t2; // result
        });

        // 10、 A任务和B任务 都处理结束后，回调，接收 任务A的结果 和 任务B的结果 , 不提供返回值
        CompletableFuture<Long> cf_tab1 = CompletableFuture.supplyAsync(()->1L);
        CompletableFuture<Long> cf_tab2 = CompletableFuture.supplyAsync(()->2L);
        CompletableFuture<Void> cf_tab = cf_tab1.thenAcceptBoth(cf_tab2,(t1,t2)->{
            // t1 任务 cf_tab1 的处理结果
            // t2 任务 cf_tab2 的处理结果
            // your code
        });

        ///11、A任务和B任务 都处理结束后，回调，不接收 处理结果，不提供返回值
        CompletableFuture<Long> cf_rab1 = CompletableFuture.supplyAsync(()->1L);
        CompletableFuture<Long> cf_rab2 = CompletableFuture.supplyAsync(()->2L);
        CompletableFuture<Void> cf_rab = cf_rab1.runAfterBoth(cf_rab2,()->{
            // your code
        });

        // 六 双任务 有一个任务结束后 回调
        // 12、 A任务和B任务 有一个任务处理结束后，回调，接收处理结果，提供返回值
        CompletableFuture<Long> cf_ate1 = CompletableFuture.supplyAsync(()->1L);
        CompletableFuture<Long> cf_ate2 = CompletableFuture.supplyAsync(()->2L);
        CompletableFuture<Long> cf_ate = cf_ate1.applyToEither(cf_ate2,t->{
            // t , cf_ate1 和 cf_ate2 的两个任务，哪个任务 最先有结果，t 就是 哪个任务的处理结果
            // your code
            return t;
        });

        // 13、 A任务和B任务 有一个任务处理结束后，回调，接收处理结果，不提供返回值
        CompletableFuture<Long> cf_ae1 = CompletableFuture.supplyAsync(()->1L);
        CompletableFuture<Long> cf_ae2 = CompletableFuture.supplyAsync(()->2L);
        CompletableFuture<Void> cf_ae = cf_ae1.acceptEither(cf_ae2,t->{
            // t , cf_ae1 和 cf_ae2 的两个任务，哪个任务 最先有结果，t 就是 哪个任务的处理结果
            // your code
        });

        ///14、A任务和B任务 有一个任务处理结束后，回调，不接收 处理结果，不提供返回值
        CompletableFuture<Long> cf_rae1 = CompletableFuture.supplyAsync(()->1L);
        CompletableFuture<Long> cf_rae2 = CompletableFuture.supplyAsync(()->2L);
        CompletableFuture<Void> cf_rae = cf_rae1.runAfterEither(cf_rae2,()->{
            // your code
        });