CompletableFuture常见用法，CompletableFuture使用示例，CompletableFuture等待所有异步任务返回

CompletableFuture常见用法，CompletableFuture使用示例，CompletableFuture等待所有异步任务返回，包括常见的用法，结合自定义线程池使用。结合实际业务Demo代码运行效果如下，可直接运行查看效果，具体请参考如下代码

1.创建CompletableFuture对象

方法名  功能描述
completedFuture(U value)    返回一个已经计算好的CompletableFuture
runAsync(Runnable runnable) 使用ForkJoinPool.commonPool()作为线程池执行任务，没有返回值
runAsync(Runnable runnable, Executor executor)  使用指定的线程池执行任务，没有返回值
supplyAsync(Supplier supplier)   使用ForkJoinPool.commonPool()作为线程池执行任务，有返回值
supplyAsync(Supplier supplier, Executor executor)    使用指定的线程池执行任务，有返回值

各种使用示例如下(可直接复制运行):

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 1.创建CompletableFuture对象
        //  方法名  功能描述
        //  completedFuture(U value)    返回一个已经计算好的CompletableFuture
        //  runAsync(Runnable runnable) 使用ForkJoinPool.commonPool()作为线程池执行任务，没有返回值
        //  runAsync(Runnable runnable, Executor executor)  使用指定的线程池执行任务，没有返回值
        //  supplyAsync(Supplier supplier)   使用ForkJoinPool.commonPool()作为线程池执行任务，有返回值
        //  supplyAsync(Supplier supplier, Executor executor)    使用指定的线程池执行任务，有返回值

        CompletableFuture intFuture = CompletableFuture.completedFuture(100);
        // 100
        System.out.println(intFuture.get());

        CompletableFuture voidFuture = CompletableFuture.runAsync(() -> System.out.println("hello"));
        // null
        System.out.println(voidFuture.get());

        CompletableFuture stringFuture = CompletableFuture.supplyAsync(() -> "hello");
        // hello
        System.out.println("stringFuture="+stringFuture.get());


        // 2.计算结果完成时.可以执行的方法
        // 方法名
        // whenComplete(BiConsumer action)
        // whenCompleteAsync(BiConsumer action)
        // whenCompleteAsync(BiConsumer action, Executor executor)

        CompletableFuture future = CompletableFuture.supplyAsync(() -> {
            return "hello";
        }).whenComplete((v, e) -> {
            // hello
            System.out.println(v);
        });
        // hello
        System.out.println(future.get());

        // 3.转换，消费，执行
        // 方法名      功能描述
        // thenApply    获取上一个任务的返回，并返回当前任务的值
        // thenAccept   获取上一个任务的返回，单纯消费，没有返回值
        // thenRun      上一个任务执行完成后，开始执行thenRun中的任务
        CompletableFuture.supplyAsync(() -> {
            return "hello ";
        }).thenAccept(str -> {
            // hello world
            System.out.println(str + "world");
        }).thenRun(() -> {
            // task finish
            System.out.println("task finish");
        });

        // 4.组合（两个任务都完成）
        // 方法名  描述
        // thenCombine  组合两个future，获取两个future的返回结果，并返回当前任务的返回值
        // thenAcceptBoth   组合两个future，获取两个future任务的返回结果，然后处理任务，没有返回值
        // runAfterBoth 组合两个future，不需要获取future的结果，只需两个future处理完任务后，处理该任务
        CompletableFuture futureA = CompletableFuture.supplyAsync(() -> {
            return "欢迎关注 ";
        }).thenApply(t -> {
            return t + "微信公众号 ";
        }).thenCombine(CompletableFuture.completedFuture("Java"), (t, u) -> {
            return t + u;
        }).whenComplete((t, e) -> {
            // 欢迎关注 微信公众号 Java
            System.out.println(t);
        });

        // 5.组合（只需要一个任务完成）
        // 方法名  描述
        // applyToEither    两个任务有一个执行完成，获取它的返回值，处理任务并返回当前任务的返回值
        // acceptEither 两个任务有一个执行完成，获取它的返回值，处理任务，没有返回值
        // runAfterEither   两个任务有一个执行完成，不需要获取future的结果，处理任务，也没有返回值
        CompletableFuture future1 = CompletableFuture.supplyAsync(() -> {
            return "欢迎关注微信公众号";
        });
        CompletableFuture future2 = CompletableFuture.supplyAsync(() -> {
            return "Java";
        });
        CompletableFuture future3 = future1.applyToEither(future2, str -> str);

        // 欢迎关注微信公众号 Java 随机输出
        System.out.println(future3.get());


        //  6.多任务组合
        //  方法名 描述
        //  allOf   当所有的CompletableFuture完成后执行计算
        //  anyOf   任意一个CompletableFuture完成后执行计算
        //  allOf的使用
        CompletableFuture future1A = CompletableFuture.supplyAsync(() -> {
            sleepRandom();
            return "欢迎关注";
        });
        CompletableFuture future2A = CompletableFuture.supplyAsync(() -> {
            sleepRandom();
            return "微信公众号";
        });
        CompletableFuture future3A = CompletableFuture.supplyAsync(() -> {
            sleepRandom();
            return "Java识堂";
        });

        // 欢迎关注 微信公众号 Java
        CompletableFuture.allOf(future1A, future2A, future3A)
                .thenApply(v -> {
                            List