CompletableFuture

声明： 本文这里只整理说明JDK8中的CompletableFuture， 暂不包含后续版本JDK新增的API方法。

---

方法简述：

方法	简述
runAsync	无返回值的异步执行
supplyAsync	有返回值的异步执行
whenComplete	(同一个异步线程)消费前面future的异步结果 注：无消费返回值、有future返回值。
whenCompleteAsync	(线程池分配的异步线程)消费前面future的异步结果 注：无消费返回值、有future返回值。
runAfterEither	this和other任意一个执行完毕时，(由执行异步任务最快的那个线程来)来消费前面future的异步结果 注：无消费返回值、无future返回值。
runAfterEitherAsync	this和other任意一个执行完毕时，(由线程池分配的异步线程来)来消费前面future的异步结果 注：无消费返回值、无future返回值。
runAfterBoth	this和other全部都执行完毕时，(由最后执行完异步任务的那个线程来)来消费前面future的异步结果 注：无消费返回值、无future返回值。
runAfterBothAsync	this和other全部都执行完毕时，(由线程池分配的异步线程来)来消费前面future的异步结果 注：无消费返回值、无future返回值。
acceptEither	this和other谁先执行完，就以谁的结果作为入参，(同时以其所在线程作为执行线程来)来进行消费 注：无消费返回值、无future返回值。
acceptEitherAsync	this和other谁先执行完，就以谁的结果作为入参，(同时以线程池分配的异步线程)来进行消费 注：无消费返回值、无future返回值。
applyToEither	this和other谁先执行完，就以谁的结果作为入参，(同时以其所在线程作为执行线程)来进行消费 注：有消费返回值、有future返回值。
applyToEitherAsync	this和other谁先执行完，就以谁的结果作为入参，(同时以线程池分配的异步线程)来进行消费 注：有消费返回值、有future返回值。
allOf	所有都完成, 才完成 注：有future返回值。
anyOf	任何一个完成, 就完成 注：有future返回值。
cancel	查看Future本身是否已取消
toString	输出当前对象及其完成状态
complete	主动将当前future标识为(正常)完成状态, 并以value作为当前future的完成(返回)值
completeExceptionally	主动将当前future标识为(异常)完成状态
completedFuture	构造一个处于已正常完成状态的CompletableFuture 注：有future返回值。
exceptionally	当future出现异常时, (才)会走exceptionally进行补偿 注：有补充返回值、有future返回值。
get	阻塞当前线程，直到获取到futuren的结果(或者直到等待超时)
getNow	立马获取futuren的值， 若此时futuren尚未完成， 那么以valueIfAbsent作为缺省值进行返回
join	阻塞获取future结果
getNumberOfDependents	获取正在等待future完成的CompletableFuture的预估数量
handle	当future(正常或异常)完成之后， （使用与执行future相同的那一个线程来）进行消费 注：有消费返回值、有future返回值。
handleAsync	当future(正常或异常)完成之后， （使用线程池分配的异步线程来）进行消费 注：有消费返回值、有future返回值。
isCompletedExceptionally	判断是否是异常完成
isDone	判断future是否已完成
obtrudeException	(无论这个future当前是否已经完成), 强制使furetu以指定异常完成
obtrudeValue	(无论这个future当前是否已经完成), 强制使furetu以指定返回值正常完成
thenAccept	当前一个future正常完成时， 会以此future的完成返回值的引用作为参数，(使用与执行future相同的线程)来进行消费 注：无消费返回值、无future返回值。
thenAcceptAsync	当前一个future正常完成时， 会以此future的完成返回值的引用作为参数，(使用线程池分配的异步线程)来进行消费 注：无消费返回值、无future返回值。
thenAcceptBoth	当两个future全部都正常完成时， 会以此future的完成返回值的引用作为参数，(使用与执行future相同的线程)来进行消费 注：无消费返回值、无future返回值。
thenAcceptBothAsync	当两个future全部都正常完成时， 会以此future的完成返回值的引用作为参数，(使用线程池分配的异步线程)来进行消费 注：无消费返回值、无future返回值。
thenApply	当future正常完成时， 以此future的完成返回值作为参数， (使用与执行future相同的线程)来进行消费 注：有消费返回值、有future返回值。
thenApplyAsync	当future正常完成时， 以此future的完成返回值作为参数， (使用线程池分配的异步线程)来进行消费 注：有消费返回值、有future返回值。
thenCombine	当两个future全部都正常完成时， 会以此future的完成返回值的引用作为参数，(使用与执行future相同的线程)来进行消费 注：有消费返回值、有future返回值。
thenCombineAsync	当两个future全部都正常完成时， 会以此future的完成返回值的引用作为参数，(使用线程池分配的异步线程)来进行消费 注：有消费返回值、有future返回值。
thenCompose	当future正常完成时， 以future的完成值为参数， (使用与执行future相同的线程)创建一个新的CompletableFuture 注：有消费返回值、有future返回值。 注：thenCompose其实就是一种thenApply的实现。
thenComposeAsync	当future正常完成时， 以future的完成值为参数， (使用线程池分配的异步线程)创建一个新的CompletableFuture 注：有消费返回值、有future返回值。 注：thenCompose其实就是一种thenApplyAsync的实现。
thenRun	当future正常完成时， (使用与执行future相同的线程)进行的消费 注：无消费返回值、无future返回值。
thenRunAsync	当future正常完成时， (使用线程池分配的异步线程)进行消费 注：无消费返回值、无future返回值。
toCompletableFuture	返回当前future对象自身
…	…

---

方法详细说明、方法验证及简单使用示例：

P.S.： 偷个懒，就不一一整理了，哈哈~

import com.aspire.demo.author.JustryDeng;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.lang.NonNull;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.concurrent.*;
import java.util.function.*;

/**
 * CompletableFuture学习
 *
 * 提示: ForkJoinPool.commonPool线程池即为ForkJoinPool线程池
 *
 * @author {@link JustryDeng}
 * @date 2020/6/6 17:13:24
 */
@SuppressWarnings("all")
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.NONE, classes = CompletableFutureDemo.class)
public class CompletableFutureDemo {
    
    /// ************************************************ 创建CompletableFuture(runAsync、supplyAsync)
    
    /**
     * public static CompletableFuture runAsync(Runnable runnable): (使用默认的线程池ForkJoinPool,)异步执行Runnable
     *
     * 输出:
     * ForkJoinPool.commonPool-worker-1	 runnable
     * main	 main
     */
    @Test
    public void runAsyncTest1() throws Exception {
        Runnable myRunnable = () -> {
            System.err.println(Thread.currentThread().getName() + "\t runnable");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };
        // runAsync(Runnable runnable)
        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(myRunnable);
        // 这里sleep 1秒， 是为了验证 runnable是会被立即执行的(而不是懒加载执行)。
        TimeUnit.SECONDS.sleep(1);
        System.err.println(Thread.currentThread().getName() + "\t main");
    }
    
    /**
     * public static CompletableFuture runAsync(Runnable runnable, Executor executor): 使用指定的线程池,异步执行Runnable
     *
     * 输出:
     * pool-1-thread-1	 runnable
     * main	 main
     */
    @Test
    public void runAsyncTest2() throws Exception {
        Executor myExecutor = Executors.newFixedThreadPool(3);
        Runnable myRunnable = () -> System.err.println(Thread.currentThread().getName() + "\t runnable");
        // runAsync(Runnable runnable, Executor executor)
        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(myRunnable, myExecutor);
        // 这里sleep 1秒， 是为了验证 runnable是会被立即执行的(而不是懒加载执行)。
        TimeUnit.SECONDS.sleep(1);
        System.err.println(Thread.currentThread().getName() + "\t main");
    }
    
    /**
     * public static  CompletableFuture supplyAsync(Supplier supplier): (使用默认的线程池ForkJoinPool,)异步执行Supplier实例,
     *                                                                            并返回结果U
     *
     * 输出:
     * ForkJoinPool.commonPool-worker-1	 supplier
     * main	 JustryDeng~
     */
    @Test
    public void supplyAsyncTest1() throws Exception {
        Supplier<String> supplier = () -> {
            System.out.println(Thread.currentThread().getName() + "\t supplier");
            return "JustryDeng~";
        };
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(supplier);
        // 阻塞main线程， 获取completableFuture异步结果
        String result = completableFuture.get();
        System.err.println(Thread.currentThread().getName() + "\t " + result);
    }
    
    /**
     * public static  CompletableFuture supplyAsync(Supplier supplier): 使用给定的线程池,异步执行Supplier实例,
     *                                                                            并返回结果U
     *
     * 输出:
     * pool-1-thread-1	 supplier
     * main	 JustryDeng~
     */
    @Test
    public void supplyAsyncTest2() throws Exception {
        Executor myExecutor = Executors.newFixedThreadPool(3);
        Supplier<String> mySupplier = () -> {
            System.out.println(Thread.currentThread().getName() + "\t supplier");
            return "JustryDeng~";
        };
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(mySupplier, myExecutor);
        // 阻塞main线程， 获取completableFuture异步结果
        String result = completableFuture.get();
        System.err.println(Thread.currentThread().getName() + "\t " + result);
    }
    
    
    /// ********************************************************************* whenComplete、whenCompleteAsync
    
    
    /**
     * public CompletableFuture whenComplete(BiConsumer action):
     * (同一个异步线程)无消费返回值的消费前面future的异步结果。
     * 注: 无消费返回值、有future返回值。
     * 注: 若异步执行CompletableFuture逻辑的线程是a, 那么在a计算完异步逻辑后，接着还是由该线程进行whenComplete逻辑。
     * 注: CompletableFuture实例的异步结果,会作为形参传递给whenComplete.
     *     换句话说，传递给whenComplete方法的参数，是CompletableFuture实例异步结果的引用，那么对于部分类型的变量来说，
     *     可以在whenComplete中修改该引用指向的堆中的数据，来达到篡改结果的目的。 如下面的StringBuilder示例。
     * 注: 若异步执行CompletableFuture逻辑时异常了， 那么该异常会被包装为CompletionException，并通过
     *     BiConsumer action中的Throwable使whenComplete方法可感知到；
     *     但是，这里仅仅是感知到(，需要的话可以做一些相应的处理)，但并不会抑制异常的抛出, 所以异常还是会按照自己原有的轨迹继续往外抛。
     *
     * 注: 当原线程执行到whenComplete时， 若future已经执行完成了，那么将会由原线程(这里为main线程)执行action的逻辑。
     *
     * 不抛异常时-输出:
     * ForkJoinPool.commonPool-worker-1	 supplier
     * ForkJoinPool.commonPool-worker-1	JustryDeng~
     * ForkJoinPool.commonPool-worker-1	JustryDeng~qwer~
     * ForkJoinPool.commonPool-worker-1	null
     * main	JustryDeng~qwer~
     *
     * 抛出异常时-输出:
     * ForkJoinPool.commonPool-worker-1	 supplier
     * ForkJoinPool.commonPool-worker-1	null
     * ForkJoinPool.commonPool-worker-1	java.util.concurrent.CompletionException: java.lang.UnsupportedOperationException: 异常了~
     * main	感知到了异步任务抛出的异常! java.lang.UnsupportedOperationException: 异常了~
     * main	null
     */
    @Test
    public void whenCompleteTest1() throws Exception {
        Supplier<StringBuilder> mySupplier = () -> {
            System.out.println(Thread.currentThread().getName() + "\t supplier");
            // 随机抛出异常, 测试BiConsumer中的Throwable
            if (ThreadLocalRandom.current().nextBoolean()) {
                throw new UnsupportedOperationException("异常了~");
            }
            return new StringBuilder("JustryDeng~");
        };
        
        BiConsumer<StringBuilder, Throwable> action = (StringBuilder x, Throwable y) -> {
            System.out.println(Thread.currentThread().getName() + "\t" + x);
            if (x != null) {
                x.append("qwer~");
                System.out.println(Thread.currentThread().getName() + "\t" + x);
            }
            System.out.println(Thread.currentThread().getName() + "\t" + y);
        };
        // whenComplete
        CompletableFuture<StringBuilder> completableFuture = CompletableFuture
                .supplyAsync(mySupplier)
                .whenComplete(action);
        // 获取结果supplyAsync返回的结果的引用
        StringBuilder result = null;
        try {
            result = completableFuture.get();
        } catch (Exception e) {
            System.err.println(Thread.currentThread().getName() + "\t感知到了异步任务抛出的异常! " + e.getMessage());
        }
        System.out.println(Thread.currentThread().getName() + "\t" + result);
    }
    
    /**
     * 测试： 当原线程执行到whenComplete时， 若future已经执行完成了，那么将会由原线程(这里为main线程)执行action的逻辑。
     *
     * 输出:
     *  main	JustryDeng~
     */
    @Test
    public void whenCompleteTest11() throws Exception {
        Supplier<String> mySupplier = () -> "JustryDeng~";
        CompletableFuture<String> futureA = CompletableFuture.supplyAsync(mySupplier);
        
        TimeUnit.SECONDS.sleep(1);
        
        BiConsumer<String, Throwable> action = (String x, Throwable y) -> {
            System.out.println(Thread.currentThread().getName() + "\t" + x);
        };
        CompletableFuture<String> futureB = futureA.whenComplete(action);
        TimeUnit.SECONDS.sleep(1);
    }
    
    /**
     * 测试： 当原线程执行到whenComplete时， 若future已经执行完成了，那么将会由原线程(这里为main线程)执行action的逻辑。
     *
     * 输出:
     *  main	JustryDeng
     */
    @Test
    public void whenCompleteTest12() throws Exception {
        BiConsumer<String, Throwable> action = (String x, Throwable y) -> {
            System.out.println(Thread.currentThread().getName() + "\t" + x);
        };
        CompletableFuture<String> future = CompletableFuture.completedFuture("JustryDeng").whenComplete(action);
        TimeUnit.SECONDS.sleep(1);
    }
    
    /**
     * public CompletableFuture whenCompleteAsync(BiConsumer action):
     * (由默认的线程池分配线程来)无消费返回值的消费前面future的异步结果。
     *
     * 注: 无消费返回值、有future返回值
     * 注: 若异步执行CompletableFuture逻辑的线程是a, 那么在a计算完异步逻辑后，接着由默认线程池ForkJoinPool分配一个线程来进行whenComplete逻辑。
     *     追注: 因为是由线程池分配的线程, (如果执行异步逻辑的线程在执行完异步逻辑后就空闲了,那么)分配的这个执行whenCompleteAsync逻辑线程有(与
     *           执行异步逻辑的线程)是同一线程的可能。
     * 注: 其余说明与{@link this#whenCompleteTest1}同。
     *
     * 提示: 由于没有并发抢占线程，所以本方法测试出来的效果其实是 supplyAsync与whenCompleteAsync用了同一个线程，
     *       不过为了让读者更容易理解，所以本人手动将输出结果里的whenCompleteAsync改为了ForkJoinPool.commonPool-worker-2。
     * 不抛异常时-(本次)输出:
     * ForkJoinPool.commonPool-worker-1	 supplier
     * ForkJoinPool.commonPool-worker-2	JustryDeng~
     * ForkJoinPool.commonPool-worker-2	JustryDeng~qwer~
     * ForkJoinPool.commonPool-worker-2	null
     * main	JustryDeng~qwer~
     *
     * 抛出异常时-(本次)输出:
     * ForkJoinPool.commonPool-worker-1	 supplier
     * ForkJoinPool.commonPool-worker-2	null
     * ForkJoinPool.commonPool-worker-2	java.util.concurrent.CompletionException: java.lang.UnsupportedOperationException: 异常了~
     * main	感知到了异步任务抛出的异常! java.lang.UnsupportedOperationException: 异常了~
     * main	null
     */
    @Test
    public void whenCompleteTest2() throws Exception {
        Supplier<StringBuilder> mySupplier = () -> {
            System.out.println(Thread.currentThread().getName() + "\t supplier");
            // 随机抛出异常, 测试BiConsumer中的Throwable
            if (ThreadLocalRandom.current().nextBoolean()) {
                throw new UnsupportedOperationException("异常了~");
            }
            return new StringBuilder("JustryDeng~");
        };
        
        BiConsumer<StringBuilder, Throwable> action = (StringBuilder x, Throwable y) -> {
            System.out.println(Thread.currentThread().getName() + "\t" + x);
            if (x != null) {
                x.append("qwer~");
                System.out.println(Thread.currentThread().getName() + "\t" + x);
            }
            System.out.println(Thread.currentThread().getName() + "\t" + y);
        };
        // whenComplete
        CompletableFuture<StringBuilder> completableFuture = CompletableFuture
                .supplyAsync(mySupplier)
                .whenCompleteAsync(action);
        // 获取结果supplyAsync返回的结果的引用
        StringBuilder result = null;
        try {
            result = completableFuture.get();
        } catch (Exception e) {
            System.err.println(Thread.currentThread().getName() + "\t感知到了异步任务抛出的异常! " + e.getMessage());
        }
        System.out.println(Thread.currentThread().getName() + "\t" + result);
    }
    
    /**
     * public CompletableFuture whenCompleteAsync(BiConsumer action):
     * (由指定的线程池分配线程来)无消费返回值的消费前面future的异步结果。
     * 注: 无消费返回值、有future返回值。
     * 注: 其余说明与{@link this#whenCompleteTest2}同。
     *
     * 不抛异常时-(本次)输出:
     * ForkJoinPool.commonPool-worker-1	 supplier
     * pool-1-thread-1	JustryDeng~
     * pool-1-thread-1	JustryDeng~qwer~
     * pool-1-thread-1	null
     * main	JustryDeng~qwer~
     *
     * 抛出异常时-(本次)输出:
     * ForkJoinPool.commonPool-worker-1	 supplier
     * pool-1-thread-1	null
     * pool-1-thread-1	java.util.concurrent.CompletionException: java.lang.UnsupportedOperationException: 异常了~
     * main	感知到了异步任务抛出的异常! java.lang.UnsupportedOperationException: 异常了~
     * main	null
     */
    @Test
    public void whenCompleteTest3() throws Exception {
        Executor myExecutor = Executors.newFixedThreadPool(3);
        Supplier<StringBuilder> mySupplier = () -> {
            System.out.println(Thread.currentThread().getName() + "\t supplier");
            // 随机抛出异常, 测试BiConsumer中的Throwable
            if (ThreadLocalRandom.current().nextBoolean()) {
                throw new UnsupportedOperationException("异常了~");
            }
            return new StringBuilder("JustryDeng~");
        };
        
        BiConsumer<StringBuilder, Throwable> action = (StringBuilder x, Throwable y) -> {
            System.out.println(Thread.currentThread().getName() + "\t" + x);
            if (x != null) {
                x.append("qwer~");
                System.out.println(Thread.currentThread().getName() + "\t" + x);
            }
            System.out.println(Thread.currentThread().getName() + "\t" + y);
        };
        // whenComplete
        CompletableFuture<StringBuilder> completableFuture = CompletableFuture
                .supplyAsync(mySupplier)
                .whenCompleteAsync(action, myExecutor);
        // 获取结果supplyAsync返回的结果的引用
        StringBuilder result = null;
        try {
            result = completableFuture.get();
        } catch (Exception e) {
            System.err.println(Thread.currentThread().getName() + "\t感知到了异步任务抛出的异常! " + e.getMessage());
        }
        System.out.println(Thread.currentThread().getName() + "\t" + result);
    }
    
    
    /// ********************************************************************* runAfterEither、runAfterEitherAsync
    
    /**
     * public CompletableFuture runAfterEither(CompletionStage other, Runnable action):
     * this和other任意一个执行完毕时，(由执行异步任务最快的那个线程来)执行action。
     * 注: 无消费返回值、无future返回值。
     * 注: 采用的是默认的线程池ForkJoinPool.commonPool。
     * 注: 哪个异步任务先执行完， 就用那个对应的线程来执行action。
     *     即: 假设执行this异步逻辑的线程是xyz, 执行other的异步逻辑的线程是abc, 若other先执行完， 那么由abc线程执行action。
     *     追注: 若执行到runAfterEither时, 两个异步任务全部都已经执行完成了， 那么将会由main线程来执行action的逻辑。
     *           所以说，总体来讲runAfterEither方法是异步的， 但是在某些特殊情况下，会智能的自动转换为同步。
     *
     * (当注释掉TimeUnit.SECONDS.sleep(4)时，)输出:
     * ForkJoinPool.commonPool-worker-1	 a
     * ForkJoinPool.commonPool-worker-2	 b
     * main	 main
     * ForkJoinPool.commonPool-worker-2	 action
     *
     * (当启用TimeUnit.SECONDS.sleep(4)时，)输出:
     * ForkJoinPool.commonPool-worker-1	 a
     * ForkJoinPool.commonPool-worker-2	 b
     * main	 action
     * main	 main
     */
    @Test
    public void runAfterEitherTest1() throws Exception {
        CompletableFuture<Void> a = CompletableFuture.runAsync(() -> {
            System.err.println(Thread.currentThread().getName() + "\t a");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
    
        CompletableFuture<Void> b = CompletableFuture.runAsync(() -> {
            System.err.println(Thread.currentThread().getName() + "\t b");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        // 测试当 执行到runAfterEither时， 若两个异步逻辑全部都已经执行完毕时， 那么使用main线程执行
        // TimeUnit.SECONDS.sleep(4);
        a.runAfterEither(b, () -> System.err.println(Thread.currentThread().getName() + "\t action"));
        System.err.println(Thread.currentThread().getName() + "\t main");
        TimeUnit.SECONDS.sleep(4);
    }
    
    /**
     * public CompletableFuture runAfterEitherAsync(CompletionStage other, Runnable action):
     * this和other任意一个执行完毕时，(由默认的线程池ForkJoinPool.commonPool分配线程来)执行action。
     * 注: 无消费返回值、无future返回值。
     * 注: 与{@link this#runAfterEitherTest1}不同的是， 即便执行到runAfterEitherAsync时, 两个异步任务全部都已经执行完成了，
     *     那么仍然会由默认的线程池ForkJoinPool.commonPool来分配线程执行action的逻辑。
     *     其它的与{@link this#runAfterEitherTest1}同。
     *
     * 输出:
     * ForkJoinPool.commonPool-worker-1	 a
     * ForkJoinPool.commonPool-worker-2	 b
     * ForkJoinPool.commonPool-worker-2	 c
     * main	 main
     * ForkJoinPool.commonPool-worker-3	 action
     */
    @Test
    public void runAfterEitherAsyncTest1() throws Exception {
        CompletableFuture<Void> a = CompletableFuture.runAsync(() -> {
            System.err.println(Thread.currentThread().getName() + "\t a");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
    
        CompletableFuture<Void> b = CompletableFuture.runAsync(() -> {
            System.err.println(Thread.currentThread().getName() + "\t b");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        
        // ---------------------- 这一块儿的逻辑，是为了让c占用任务b释放出来的线程， 进而使我们能直观的看到runAfterEitherAsync用的线程时其它的线程
        TimeUnit.SECONDS.sleep(1);
        CompletableFuture<Void> c = CompletableFuture.runAsync(() -> {
            System.err.println(Thread.currentThread().getName() + "\t c");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        // ----------------------
        a.runAfterEitherAsync(b, () -> System.err.println(Thread.currentThread().getName() + "\t action"));
        System.err.println(Thread.currentThread().getName() + "\t main");
        TimeUnit.SECONDS.sleep(4);
    }
    
    /**
     * public CompletableFuture runAfterEitherAsync(CompletionStage other,
     *                                                        Runnable action,
     *                                                        Executor executor):
     * this和other任意一个执行完毕时，(由指定的线程池executor分配线程来)执行action。
     *
     * 注: 无消费返回值、无future返回值。
     * 注: 与{@link this#runAfterEitherTest1}不同的是， 即便执行到runAfterEitherAsync时, 两个异步任务全部都已经执行完成了，
     *     那么仍然会由指定的线程池来分配线程执行action的逻辑。
     *     其它的与{@link this#runAfterEitherTest1}同。
     *
     * 输出:
     * ForkJoinPool.commonPool-worker-1	 a
     * ForkJoinPool.commonPool-worker-1	 b
     * main	 main
     * pool-1-thread-1	 action
     */
    @Test
    public void runAfterEitherAsyncTest2() throws Exception {
        CompletableFuture<Void> a = CompletableFuture.runAsync(() ->
            System.err.println(Thread.currentThread().getName() + "\t a")
        );
        CompletableFuture<Void> b = CompletableFuture.runAsync(() ->
                System.err.println(Thread.currentThread().getName() + "\t b")
        );
        Executor myExecutor = Executors.newFixedThreadPool(3);
        a.runAfterEitherAsync(b, () -> System.err.println(Thread.currentThread().getName() + "\t action"), myExecutor);
        System.err.println(Thread.currentThread().getName() + "\t main");
        TimeUnit.SECONDS.sleep(4);
    }
    
    /// ********************************************************************* runAfterBoth、runAfterBothAsync
    
    /**
     * public CompletableFuture runAfterBoth(CompletionStage other,
     *                                                 Runnable action):
     * this和other全部都执行完毕时，(由最后执行完异步任务的那个线程来)执行action。
     *
     * 注: 无消费返回值、无future返回值。
     * 注: 采用的是默认的线程池ForkJoinPool.commonPool。
     * 注: 哪个异步任务最后执行完异步逻辑， 就用那个对应的线程来执行action。
     *     即: 假设执行this异步逻辑的线程是xyz, 执行other的异步逻辑的线程是abc, 若other后执行完， 那么由abc线程执行action。
     *     追注: 若执行到runAfterBoth时, 两个异步任务全部都已经执行完成了， 那么将会由main线程来执行action的逻辑。
     *           所以说，总体来讲runAfterBoth方法是异步的， 但是在某些特殊情况下，会智能的自动转换为同步。
     *
     * (当注释掉TimeUnit.SECONDS.sleep(4)时，)输出:
     * ForkJoinPool.commonPool-worker-1	 a
     * ForkJoinPool.commonPool-worker-2	 b
     * main	 main
     * ForkJoinPool.commonPool-worker-2	 action
     *
     * (当启用TimeUnit.SECONDS.sleep(4)时，)输出:
     * ForkJoinPool.commonPool-worker-1	 a
     * ForkJoinPool.commonPool-worker-2	 b
     * main	 action
     * main	 main
     */
    @Test
    public void runAfterBothTest1() throws Exception {
        CompletableFuture<Void> a = CompletableFuture.runAsync(() -> {
            System.err.println(Thread.currentThread().getName() + "\t a");
            try {
                TimeUnit.SECONDS.sleep(1);
                // 用于测试: 由最后执行完异步任务的那个线程执行action
                // TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        
        CompletableFuture<Void> b = CompletableFuture.runAsync(() -> {
            System.err.println(Thread.currentThread().getName() + "\t b");
            try {
                TimeUnit.SECONDS.sleep(2);
                // 用于测试: 由最后执行完异步任务的那个线程执行action
                // TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        // 测试当 执行到runAfterBoth时， 若两个异步逻辑全部都已经执行完毕时， 那么使用main线程执行
        // TimeUnit.SECONDS.sleep(4);
        a.runAfterBoth(b, () -> System.err.println(Thread.currentThread().getName() + "\t action"));
        System.err.println(Thread.currentThread().getName() + "\t main");
        TimeUnit.SECONDS.sleep(4);
    }
    
    /**
     * public CompletableFuture runAfterBothAsync(CompletionStage other,
     *                                                      Runnable action):
     * this和other全部都执行完毕时，(由默认的线程池ForkJoinPool.commonPool分配线程来)执行action。
     *
     * 注: 无消费返回值、无future返回值。
     * 注: 与{@link this#runAfterBothTest1}不同的是， 即便执行到runAfterBothAsync时, 两个异步任务全部都已经执行完成了，
     *     那么仍然会由默认的线程池ForkJoinPool.commonPool来分配线程执行action的逻辑。
     *     其它的与{@link this#runAfterBothTest1}同。
     *
     * 输出:
     * ForkJoinPool.commonPool-worker-1	 a
     * ForkJoinPool.commonPool-worker-2	 b
     * main	 main
     * ForkJoinPool.commonPool-worker-2	 action
     */
    @Test
    public void runAfterBothAsyncTest1() throws Exception {
        CompletableFuture<Void> a = CompletableFuture.runAsync(() -> {
            System.err.println(Thread.currentThread().getName() + "\t a");
        });
        
        CompletableFuture<Void> b = CompletableFuture.runAsync(() -> {
            System.err.println(Thread.currentThread().getName() + "\t b");
        });
    
        TimeUnit.SECONDS.sleep(4);
        a.runAfterBothAsync(b, () -> System.err.println(Thread.currentThread().getName() + "\t action"));
        System.err.println(Thread.currentThread().getName() + "\t main");
        TimeUnit.SECONDS.sleep(4);
    }
    
    /**
     * public CompletableFuture runAfterBothAsync(CompletionStage other,
     *                                                      Runnable action,
     *                                                      Executor executor):
     * this和other全部都执行完毕时，(由指定的线程池executor分配线程来)执行action。
     *
     * 注: 无消费返回值、无future返回值。
     * 注: 与{@link this#runAfterBothTest1}不同的是， 即便执行到runAfterBothAsync时, 两个异步任务全部都已经执行完成了，
     *     那么仍然会由指定的线程池executor来分配线程执行action的逻辑。
     *     其它的与{@link this#runAfterBothTest1}同。
     *
     * 输出:
     * ForkJoinPool.commonPool-worker-1	 a
     * ForkJoinPool.commonPool-worker-1	 b
     * main	 main
     * pool-1-thread-1	 action
     */
    @Test
    public void runAfterBothAsyncTest2() throws Exception {
        CompletableFuture<Void> a = CompletableFuture.runAsync(() ->
                System.err.println(Thread.currentThread().getName() + "\t a")
        );
        CompletableFuture<Void> b = CompletableFuture.runAsync(() ->
                System.err.println(Thread.currentThread().getName() + "\t b")
        );
        Executor myExecutor = Executors.newFixedThreadPool(3);
        a.runAfterBothAsync(b, () -> System.err.println(Thread.currentThread().getName() + "\t action"), myExecutor);
        System.err.println(Thread.currentThread().getName() + "\t main");
        TimeUnit.SECONDS.sleep(4);
    }
    
    
    /// ********************************************************************* acceptEither、acceptEitherAsync
    /**
     * public CompletableFuture acceptEither(
     *         CompletionStage other, Consumer action):
     * this和other谁先执行完，就以谁的结果作为入参，(同时以其所在线程作为执行线程)执行action。
     *
     * 注: 无消费返回值、无future返回值。
     * 注: 假设执行this异步逻辑的线程是xyz，执行结果是foo；执行other的异步逻辑的线程是abc，执行结果是zoo. 若other先执行完，
     *     那么以zoo作为入参，由abc线程执行action。
     *     追注: 若原线程执行到acceptEither时, 两个异步任务全部都已经执行完成了， 那么将会由原线程(这里为main线程)来执行action的逻辑。
     *           此时，假设调用是这么调用的xxx.acceptEither(yyy, function)，那么会选择异步逻辑xxx的返回结果作为action的入参。
     *           所以说，总体来讲acceptEither方法是异步的， 但是在某些特殊情况下，会智能的自动转换为同步。
     *
     *
     * (当注释掉TimeUnit.SECONDS.sleep(4)时，)输出:
     * ForkJoinPool.commonPool-worker-1	 a
     * ForkJoinPool.commonPool-worker-2	 b
     * main	 main
     * ForkJoinPool.commonPool-worker-2	 function	b
     *
     * (当启用TimeUnit.SECONDS.sleep(4)时，)输出:
     * ForkJoinPool.commonPool-worker-1	 a
     * ForkJoinPool.commonPool-worker-2	 b
     * main	 function	b
     * main	 main
     */
    @Test
    public void acceptEitherTest1() throws Exception {
        CompletableFuture<String> a = CompletableFuture.supplyAsync(() -> {
            System.err.println(Thread.currentThread().getName() + "\t a");
            try {
                TimeUnit.SECONDS.sleep(2);
                // 用于测试a比b快
                //TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "a";
        });
    
        CompletableFuture<String> b = CompletableFuture.supplyAsync(() -> {
            System.err.println(Thread.currentThread().getName() + "\t b");
            try {
                TimeUnit.SECONDS.sleep(1);
                // 用于测试a比b快
                //TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "b";
        });
        Consumer<String> consumer = x -> System.err.println(Thread.currentThread().getName() + "\t function\t" + x);
        // TimeUnit.SECONDS.sleep(4);
        a.acceptEither(b, consumer);
        System.err.println(Thread.currentThread().getName() + "\t main");
        TimeUnit.SECONDS.sleep(4);
    }
    
    /**
     * 测试: 若先完成的这个属于异常完成， 那么是不会走consumer的逻辑的， 一场会继续往外传递
     *
     * 输出:
     * ForkJoinPool.commonPool-worker-1	 a
     * ForkJoinPool.commonPool-worker-2	 b
     */
    @Test
    public void acceptEitherTest11() throws Exception {
        CompletableFuture<String> a = CompletableFuture.supplyAsync(() -> {
            System.err.println(Thread.currentThread().getName() + "\t a");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            int b = 1 / 0;
            return "a";
        });
        
        CompletableFuture<String> b = CompletableFuture.supplyAsync(() -> {
            System.err.println(Thread.currentThread().getName() + "\t b");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "b";
        });
        Consumer<String> consumer = x -> System.err.println(Thread.currentThread().getName() + "\t function\t" + x);
        a.acceptEither(b, consumer);
        TimeUnit.SECONDS.sleep(4);
    }
    
    /**
     * public CompletableFuture acceptEitherAsync(
     *         CompletionStage other, Consumer action):
     * this和other谁先执行完，就以谁的结果作为入参，(同时以默认的线程池ForkJoinPool.commonPool分配的线程，来)执行action。
     *
     * 注: 无消费返回值、无future返回值。
     * 注: 假设执行this异步逻辑的线程是xyz，执行结果是foo；执行other的异步逻辑的线程是abc，执行结果是zoo. 若other先执行完，
     *     那么以zoo作为入参，由abc线程执行action。
     *     追注: 若执行到acceptEitherAsync时, 即便两个异步任务全部都已经执行完成了， 那么仍然还是会由默认的
     *           线程池ForkJoinPool.commonPool分配线程来执行action的逻辑。此时，假设调用是这么调用的
     *           xxx.acceptEitherAsync(yyy, function)，那么会选择异步逻辑xxx的返回结果作为fn的入参。
     *
     *
     * (当注释掉TimeUnit.SECONDS.sleep(4)时，)输出:
     * ForkJoinPool.commonPool-worker-1	 a
     * ForkJoinPool.commonPool-worker-2	 b
     * main	 main
     * ForkJoinPool.commonPool-worker-2	 function	b
     *
     * (当启用TimeUnit.SECONDS.sleep(4)时，)输出:
     * ForkJoinPool.commonPool-worker-1	 a
     * ForkJoinPool.commonPool-worker-2	 b
     * main	 main
     * ForkJoinPool.commonPool-worker-1	 function	b
     */
    @Test
    public void acceptEitherAsyncTest1() throws Exception {
        CompletableFuture<String> a = CompletableFuture.supplyAsync(() -> {
            System.err.println(Thread.currentThread().getName() + "\t a");
            try {
                TimeUnit.SECONDS.sleep(2);
                // 用于测试a比b快
                //TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "a";
        });
        
        CompletableFuture<String> b = CompletableFuture.supplyAsync(() -> {
            System.err.println(Thread.currentThread().getName() + "\t b");
            try {
                TimeUnit.SECONDS.sleep(1);
                // 用于测试a比b快
                //TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "b";
        });
        Consumer<String> consumer = x -> System.err.println(Thread.currentThread().getName() + "\t function\t" + x);
        // TimeUnit.SECONDS.sleep(4);
        b.acceptEitherAsync(a, consumer);
        System.err.println(Thread.currentThread().getName() + "\t main");
        TimeUnit.SECONDS.sleep(4);
    }
    
    /**
     * public CompletableFuture acceptEitherAsync(
     *         CompletionStage other, Consumer action, Executor executor):
     * this和other谁先执行完，就以谁的结果作为入参，(同时以指定的线程池executor分配的线程，来)执行action。
     *
     * 注: 无消费返回值、无future返回值。
     * 注: 假设执行this异步逻辑的线程是xyz，执行结果是foo；执行other的异步逻辑的线程是abc，执行结果是zoo. 若other先执行完，
     *     那么以zoo作为入参，由abc线程执行action。
     *     追注: 若执行到acceptEitherAsync时, 即便两个异步任务全部都已经执行完成了， 那么仍然还是会由指定的
     *           线程池分配线程来执行fn的逻辑。此时，假设调用是这么调用的
     *           xxx.applyToEitherAsync(yyy, function)，那么会选择异步逻辑xxx的返回结果作为fn的入参。
     *
     *
     * (当注释掉TimeUnit.SECONDS.sleep(4)时，)输出:
     * ForkJoinPool.commonPool-worker-1	 a
     * ForkJoinPool.commonPool-worker-2	 b
     * main	 main
     * pool-1-thread-1	 function	b
     *
     * (当启用TimeUnit.SECONDS.sleep(4)时，)输出:
     * ForkJoinPool.commonPool-worker-1	 a
     * ForkJoinPool.commonPool-worker-2	 b
     * main	 main
     * pool-1-thread-1	 function	b
     */
    @Test
    public void acceptEitherAsyncTest2() throws Exception {
        Executor myExecutor = Executors.newFixedThreadPool(3);
        CompletableFuture<String> a = CompletableFuture.supplyAsync(() -> {
            System.err.println(Thread.currentThread().getName() + "\t a");
            try {
                TimeUnit.SECONDS.sleep(2);
                // 用于测试a比b快
                //TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "a";
        });
        
        CompletableFuture<String> b = CompletableFuture.supplyAsync(() -> {
            System.err.println(Thread.currentThread().getName() + "\t b");
            try {
                TimeUnit.SECONDS.sleep(1);
                // 用于测试a比b快
                //TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "b";
        });
        Consumer<String> consumer = x -> System.err.println(Thread.currentThread().getName() + "\t function\t" + x);
        // TimeUnit.SECONDS.sleep(4);
        b.acceptEitherAsync(a, consumer, myExecutor);
        System.err.println(Thread.currentThread().getName() + "\t main");
        TimeUnit.SECONDS.sleep(4);
    }
    
    /// ********************************************************************* applyToEither、applyToEitherAsync(注: 与acceptEither、acceptEitherAsync不同的是， Function有返回结果)
    
    /**
     * public  CompletableFuture applyToEither(CompletionStage other, Function fn):
     * this和other谁先执行完，就以谁的结果作为入参，(同时以其所在线程作为执行线程)执行fn。
     *
     * 注: 有消费返回值、有future返回值。
     * 注: 假设执行this异步逻辑的线程是xyz，执行结果是foo；执行other的异步逻辑的线程是abc，执行结果是zoo. 若other先执行完，
     *     那么以zoo作为入参，由abc线程执行fn。
     *     追注: 若原线程执行到applyToEither时, 两个异步任务全部都已经执行完成了， 那么将会由原线程(这里为main线程)来执行fn的逻辑。
     *           此时，假设调用是这么调用的xxx.applyToEither(yyy, function)，那么会选择异步逻辑xxx的返回结果作为fn的入参。
     *           所以说，总体来讲applyToEither方法是异步的， 但是在某些特殊情况下，会智能的自动转换为同步。
     *
     *
     * (当注释掉TimeUnit.SECONDS.sleep(4)时，)输出:
     * ForkJoinPool.commonPool-worker-1	 a
     * ForkJoinPool.commonPool-worker-2	 b
     * main	 main
     * ForkJoinPool.commonPool-worker-2	 function	b
     *
     * (当启用TimeUnit.SECONDS.sleep(4)时，)输出:
     * ForkJoinPool.commonPool-worker-1	 a
     * ForkJoinPool.commonPool-worker-2	 b
     * main	 function	a
     * main	 main
     */
    @Test
    public void applyToEitherTest1() throws Exception {
        CompletableFuture<String> a = CompletableFuture.supplyAsync(() -> {
            System.err.println(Thread.currentThread().getName() + "\t a");
            try {
                TimeUnit.SECONDS.sleep(2);
                // 用于测试a比b快
                //TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "a";
        });
        
        CompletableFuture<String> b = CompletableFuture.supplyAsync(() -> {
            System.err.println(Thread.currentThread().getName() + "\t b");
            try {
                TimeUnit.SECONDS.sleep(1);
                // 用于测试a比b快
                //TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "b";
        });
        Function<String, String> function = x -> {
            System.err.println(Thread.currentThread().getName() + "\t function\t" + x);
            return x + ThreadLocalRandom.current().nextInt(1000);
        };
         TimeUnit.SECONDS.sleep(4);
        CompletableFuture<String> result = a.applyToEither(b, function);
        System.err.println(Thread.currentThread().getName() + "\t main");
        TimeUnit.SECONDS.sleep(4);
    }
    
    /**
     * public  CompletableFuture applyToEitherAsync(CompletionStage other, Function fn):
     * this和other谁先执行完，就以谁的结果作为入参，(同时以默认的线程池ForkJoinPool.commonPool分配的线程，来)执行fn。
     *
     * 注: 有消费返回值、有future返回值。
     * 注: 假设执行this异步逻辑的线程是xyz，执行结果是foo；执行other的异步逻辑的线程是abc，执行结果是zoo. 若other先执行完，
     *     那么以zoo作为入参，由abc线程执行fn。
     *     追注: 若执行到applyToEitherAsync时, 即便两个异步任务全部都已经执行完成了， 那么仍然还是会由默认的
     *           线程池ForkJoinPool.commonPool分配线程来执行fn的逻辑。此时，假设调用是这么调用的
     *           xxx.applyToEitherAsync(yyy, function)，那么会选择异步逻辑xxx的返回结果作为fn的入参。
     *
     *
     * (当注释掉TimeUnit.SECONDS.sleep(4)时，)输出:
     * ForkJoinPool.commonPool-worker-1	 a
     * ForkJoinPool.commonPool-worker-2	 b
     * main	 main
     * ForkJoinPool.commonPool-worker-2	 function	b
     *
     * (当启用TimeUnit.SECONDS.sleep(4)时，)输出:
     * ForkJoinPool.commonPool-worker-1	 a
     * ForkJoinPool.commonPool-worker-2	 b
     * main	 main
     * ForkJoinPool.commonPool-worker-1	 function	b
     */
    @Test
    public void applyToEitherAsyncTest1() throws Exception {
        CompletableFuture<String> a = CompletableFuture.supplyAsync(() -> {
            System.err.println(Thread.currentThread().getName() + "\t a");
            try {
                TimeUnit.SECONDS.sleep(2);
                // 用于测试a比b快
                //TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "a";
        });
        
        CompletableFuture<String> b = CompletableFuture.supplyAsync(() -> {
            System.err.println(Thread.currentThread().getName() + "\t b");
            try {
                TimeUnit.SECONDS.sleep(1);
                // 用于测试a比b快
                //TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "b";
        });
        Function<String, String> function = x -> {
            System.err.println(Thread.currentThread().getName() + "\t function\t" + x);
            return x + ThreadLocalRandom.current().nextInt(1000);
        };
        // TimeUnit.SECONDS.sleep(4);
        CompletableFuture<String> result = b.applyToEitherAsync(a, function);
        System.err.println(Thread.currentThread().getName() + "\t main");
        TimeUnit.SECONDS.sleep(4);
    }
    
    /**
     * public  CompletableFuture applyToEitherAsync(
     *         CompletionStage other, Function fn, Executor executor):
     * this和other谁先执行完，就以谁的结果作为入参，(同时以指定的线程池executor分配的线程，来)执行fn。
     *
     * 注: 有消费返回值、有future返回值。
     * 注: 假设执行this异步逻辑的线程是xyz，执行结果是foo；执行other的异步逻辑的线程是abc，执行结果是zoo. 若other先执行完，
     *     那么以zoo作为入参，由abc线程执行fn。
     *     追注: 若执行到applyToEitherAsync时, 即便两个异步任务全部都已经执行完成了， 那么仍然还是会由指定的
     *           线程池分配线程来执行fn的逻辑。此时，假设调用是这么调用的
     *           xxx.applyToEitherAsync(yyy, function)，那么会选择异步逻辑xxx的返回结果作为fn的入参。
     *
     *
     * (当注释掉TimeUnit.SECONDS.sleep(4)时，)输出:
     * ForkJoinPool.commonPool-worker-1	 a
     * ForkJoinPool.commonPool-worker-2	 b
     * main	 main
     * pool-1-thread-1	 function	b
     *
     * (当启用TimeUnit.SECONDS.sleep(4)时，)输出:
     * ForkJoinPool.commonPool-worker-1	 a
     * ForkJoinPool.commonPool-worker-2	 b
     * main	 main
     * pool-1-thread-1	 function	b
     */
    @Test
    public void applyToEitherAsyncTest2() throws Exception {
        Executor myExecutor = Executors.newFixedThreadPool(3);
        CompletableFuture<String> a = CompletableFuture.supplyAsync(() -> {
            System.err.println(Thread.currentThread().getName() + "\t a");
            try {
                TimeUnit.SECONDS.sleep(2);
                // 用于测试a比b快
                //TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "a";
        });
        
        CompletableFuture<String> b = CompletableFuture.supplyAsync(() -> {
            System.err.println(Thread.currentThread().getName() + "\t b");
            try {
                TimeUnit.SECONDS.sleep(1);
                // 用于测试a比b快
                //TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "b";
        });
        Function<String, String> function = x -> {
            System.err.println(Thread.currentThread().getName() + "\t function\t" + x);
            return x + ThreadLocalRandom.current().nextInt(1000);
        };
         TimeUnit.SECONDS.sleep(4);
        CompletableFuture<String> result = b.applyToEitherAsync(a, function, myExecutor);
        System.err.println(Thread.currentThread().getName() + "\t main");
        TimeUnit.SECONDS.sleep(4);
    }
    
    
    
    
    /// ********************************************************************* allOf​、anyOf​
    
    /**
     * public static CompletableFuture allOf(CompletableFuture... cfs):
     * 所有的cfs都完成了, this才完成。
     *
     * 注:只要有一个future异常完成， 那么allOf返回的future完成后的完成状态就属于异常完成。
     *    即: 只有所有的future全部都正常完成， allOf返回的future完成后的完成状态才是正常完成。
     * 注: 任何一个cfs正常执行完成 或者 有异常出现导致完成， 都属于完成。 追注: 取消也属于异常完成。
     *
     * 输出:
     * ......
     * ......
     * ForkJoinPool.commonPool-worker-1	 a完成了
     * ......
     * ......
     * ForkJoinPool.commonPool-worker-2	 b完成了
     * ......
     * c完成了
     */
    @Test
    public void allOfTest1() throws Exception {
        CompletableFuture<Void> a = CompletableFuture.runAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.err.println(Thread.currentThread().getName() + "\t a完成了");
            // 测试异常也算完成
            // int da = 1 /0;
        });
        
        CompletableFuture<Void> b = CompletableFuture.runAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 测试异常也算完成
            // int da = 1 /0;
            System.err.println(Thread.currentThread().getName() + "\t b完成了");
        });
        CompletableFuture<Void> c = CompletableFuture.allOf(a, b);
        
        while (!c.isDone()) {
            TimeUnit.MILLISECONDS.sleep(400);
            System.err.println("......");
        }
        System.err.println("c完成了");
    }
    
    /**
     * 验证: 只要有一个future异常完成， 那么allOf返回的future完成后的完成状态就属于异常完成。
     *      即: 只有所有的future全部都正常完成， allOf返回的future完成后的完成状态才是正常完成。
     *
     *
     * (注释A、B处)输出:
     * ForkJoinPool.commonPool-worker-1	 b完成了
     * a的完成状态	java.util.concurrent.CompletableFuture@70f02c32[Completed normally]
     * b的完成状态	java.util.concurrent.CompletableFuture@62010f5c[Completed normally]
     * c的完成状态	java.util.concurrent.CompletableFuture@51fadaff[Completed normally]
     *
     * (打开A处, 注释B处)输出:
     * a的完成状态	java.util.concurrent.CompletableFuture@70f02c32[Completed exceptionally]
     * b的完成状态	java.util.concurrent.CompletableFuture@62010f5c[Completed normally]
     * c的完成状态	java.util.concurrent.CompletableFuture@51fadaff[Completed exceptionally]
     *
     * (打开B处, 注释A处)输出:
     * a的完成状态	java.util.concurrent.CompletableFuture@70f02c32[Completed normally]
     * b的完成状态	java.util.concurrent.CompletableFuture@62010f5c[Completed exceptionally]
     * c的完成状态	java.util.concurrent.CompletableFuture@51fadaff[Completed exceptionally]
     *
     *
     * (打开A、B处)输出:
     * ForkJoinPool.commonPool-worker-1	 b完成了
     * a的完成状态	java.util.concurrent.CompletableFuture@70f02c32[Completed exceptionally]
     * b的完成状态	java.util.concurrent.CompletableFuture@62010f5c[Completed exceptionally]
     * c的完成状态	java.util.concurrent.CompletableFuture@51fadaff[Completed exceptionally]
     */
    @Test
    public void allOfTest2() throws Exception {
        CompletableFuture<Void> a = CompletableFuture.runAsync(() -> {
              int da = 1 /0; // A处
        });
        
        CompletableFuture<Void> b = CompletableFuture.runAsync(() -> {
             int da = 1 /0; // B处
        });
        CompletableFuture<Void> c = CompletableFuture.allOf(a, b);
    
        try {
            c.join();
        } catch (Exception e) {
            // ignore
        }
    
        System.err.println("a的完成状态\t" + a.toString());
        System.err.println("b的完成状态\t" + b.toString());
        System.err.println("c的完成状态\t" + c.toString());
    }
    
    /**
     * public static CompletableFuture