5.1 ps

值得注意的是，两个任务必然是并行执行的！

关于CompletionStage<?>究竟是什么呢？

我们会发现，CompletableFuture 实现了CompletionStage，也就是说，我们需要在方法里面再传一个任务，与调用者一起组成两个任务，都完成后，执行后续操作

代码示例

public static void main(String[] args) throws Exception {
        runAfterBoth();
        runAfterBothAsync();
        runAfterBothAsyncWithExec();
        
        thenAcceptBoth();
        thenAcceptBothAsync();
        thenAcceptBothAsyncWithExec();
        
        CompletableFuture thenCombineFuture = thenCombine();
        thenCombineFuture = thenCombineAsync();
        thenCombineFuture = thenCombineAsyncWithExec();
        System.out.println(thenCombineFuture.get());
        Thread.sleep(50000);
 }

		/**
     * 异步执行，有返回值
     */
    static CompletableFuture supplyAsync() throws Exception {
        return CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            try {
                System.out.println("在此等待中……");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("运行结果：" + i);
            return i;
        });
    }

/**
 * 两个父任务执行完毕，触发action任务
 *
 * @return
 */
static void runAfterBoth() throws Exception {
    supplyAsync().runAfterBoth(supplyAsync(), () -> {
        System.out.println("runAfterBoth任务执行完成");
    });
}

/**
 * 两个父任务执行完毕，新开一个线程触发action任务
 *
 * @return
 */
static void runAfterBothAsync() throws Exception {
    supplyAsync().runAfterBothAsync(supplyAsync(), () -> {
        System.out.println("runAfterBoth任务执行完成");
    });
}

/**
 * 两个父任务执行完毕，线程池新开一个线程触发action任务
 *
 * @return
 */
static void runAfterBothAsyncWithExec() throws Exception {
    supplyAsync().runAfterBothAsync(supplyAsync(), () -> {
        System.out.println("runAfterBoth任务执行完成");
    }, executorService);
}

/**
     * 消费两个父任务执行结果，触发action任务，无返回值
     *
     * @return
     */
    static void thenAcceptBoth() throws Exception {
        supplyAsync().thenAcceptBoth(supplyAsync(), (firstResult, secondResult) -> {
            System.out.println("thenAcceptBoth-任务执行完成");
        });
    }

    /**
     * 消费两个父任务执行结果，新开一个线程触发action任务，无返回值
     *
     * @return
     */
    static void thenAcceptBothAsync() throws Exception {
        supplyAsync().thenAcceptBothAsync(supplyAsync(), (firstResult, secondResult) -> {
            System.out.println("thenAcceptBoth-任务执行完成");
        });
    }

    /**
     * 消费两个父任务执行结果，线程池新开一个线程触发action任务，无返回值
     *
     * @return
     */
    static void thenAcceptBothAsyncWithExec() throws Exception {
        supplyAsync().thenAcceptBothAsync(supplyAsync(), (firstResult, secondResult) -> {
            System.out.println("thenAcceptBoth-任务执行完成");
        }, executorService);
    }

		/**
     * 处理两个父任务结果，触发子任务并返回结果
     *
     * @return
     */
    static CompletableFuture thenCombine() throws Exception {
         return supplyAsync().thenCombine(supplyAsync(), (firstResult, secondResult) -> {
            System.out.println("thenAcceptBoth-任务执行完成");
            return "thenCombine";
        });
    }

    /**
     * 处理两个父任务结果，新开一个线程触发子任务并返回结果
     *
     * @return
     */
    static CompletableFuture thenCombineAsync() throws Exception {
        return supplyAsync().thenCombineAsync(supplyAsync(), (firstResult, secondResult) -> {
            System.out.println("thenAcceptBoth-任务执行完成");
            return "thenCombineAsync";
        });
    }

    /**
     * 处理两个父任务结果，线程池新开一个线程触发子任务并返回结果
     *
     * @return
     */
    static CompletableFuture thenCombineAsyncWithExec() throws Exception {
        return supplyAsync().thenCombineAsync(supplyAsync(), (firstResult, secondResult) -> {
            System.out.println("thenAcceptBoth-任务执行完成");
            return "thenCombineAsyncWithExec";
        }, executorService);
    }

6、两个任务组合（either）

CompletableFuture提供either组合模式--两个任务只要完成一个，触发改任务

与both有异曲同工之妙，照葫芦画瓢，这里不过多阐述

// 两个父任务结果只要返回一个，触发子任务，无返回结果
public CompletableFuture runAfterEither(CompletionStage<?> other,Runnable action)
// 两个父任务结果只要返回一个，新开一个线程触发子任务，无返回结果
public CompletableFuture runAfterEitherAsync(CompletionStage<?> other,Runnable action)
// 两个父任务结果只要返回一个，线程池新开一个线程触发子任务，无返回结果
public CompletableFuture runAfterEitherAsync(CompletionStage<?> other,Runnable action,Executor executor)

// 两个父任务结果只要返回一个，消费其结果，触发子任务，无返回结果
public CompletableFuture acceptEither(CompletionStage<? extends T> other, Consumer<? super T> action)
// 两个父任务结果只要返回一个，消费其结果，新开一个线程触发子任务，无返回结果
public CompletableFuture acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action)
// 两个父任务结果只要返回一个，消费其结果，线程池新开一个线程触发子任务，无返回结果
public CompletableFuture acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action,Executor executor)
  
// 两个父任务结果只要返回一个，触发子任务处理其结果，并返回
public  CompletableFuture applyToEither(CompletionStage<? extends T> other, Function<? super T, U> fn)
// 两个父任务结果只要返回一个，新开线程触发子任务处理其结果，并返回
public  CompletableFuture applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T, U> fn)
// 两个父任务结果只要返回一个，线程池新开线程触发子任务处理其结果，并返回
public  CompletableFuture applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T, U> fn,Executor executor)

// 执行完任何一个任务后，返回其结果，有返回值
public static CompletableFuture