下面的示例代码是在验证上面的说法：在上面的四个静态方法中

• 如果是没有指定 Executor 的方法，会使用 ForkJoinPool.commonPool() 作为它的线程池执行异步代码；
• 如果是指定了线程池的方法，则使用指定的线程池运行

@Slf4j(topic = "c.CompletableFutureDemo_1")
public class CompletableFutureDemo_1 {public static void main(String[] args) throws ExecutionException, InterruptedException {method_1();}// ... ...
}

• 调用 method_1() 方法（未指定线程池）

private static void method_1() throws InterruptedException, ExecutionException {CompletableFuture voidCF = CompletableFuture.runAsync(() -> {log.info("{}", Thread.currentThread().getName());// 线程暂停 1 秒try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }});log.info("{}", voidCF.get());
}

• 调用 method_2() 方法（指定线程池）

private static void method_2() throws InterruptedException, ExecutionException {ExecutorService threadPool = Executors.newFixedThreadPool(3);CompletableFuture voidCF = CompletableFuture.runAsync(() -> {log.info("{}", Thread.currentThread().getName());// 线程暂停 1 秒try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace();}}, threadPool);log.info("{}", voidCF.get());threadPool.shutdown();
}

• 调用 method_3() 方法（未指定线程池）

private static void method_3() throws InterruptedException, ExecutionException {CompletableFuture rCF = CompletableFuture.supplyAsync(() -> {log.info("{}", Thread.currentThread().getName());// 线程暂停 1 秒try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}return "Hello SupplyAsync";});log.info("{}", rCF.get());
}

• 调用 method_4() 方法（指定线程池）

private static void method_4() throws InterruptedException, ExecutionException {ExecutorService threadPool = Executors.newFixedThreadPool(3);CompletableFuture rCF = CompletableFuture.supplyAsync(() -> {log.info("{}", Thread.currentThread().getName());// 线程暂停 1 秒try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}return "Hello SupplyAsync";}, threadPool);log.info("{}", rCF.get());threadPool.shutdown();
}

• 调用 method_1() 方法（未指定线程池）控制台输出

10:48:14.519 [ForkJoinPool.commonPool-worker-1] INFO c.CompletableFutureDemo_1 - ForkJoinPool.commonPool-worker-1
10:48:15.535 [main] INFO c.CompletableFutureDemo_1 - null

• 调用 method_2() 方法（指定线程池）控制台输出

10:51:03.789 [pool-1-thread-1] INFO c.CompletableFutureDemo_1 - pool-1-thread-1
10:51:04.813 [main] INFO c.CompletableFutureDemo_1 - null

• 调用 method_3() 方法（未指定线程池）控制台输出

11:04:24.533 [ForkJoinPool.commonPool-worker-1] INFO c.CompletableFutureDemo_1 - ForkJoinPool.commonPool-worker-1
11:04:25.555 [main] INFO c.CompletableFutureDemo_1 - Hello SupplyAsync

• 调用 method_4() 方法（指定线程池）控制台输出

11:05:23.226 [pool-1-thread-1] INFO c.CompletableFutureDemo_1 - pool-1-thread-1
11:05:24.244 [main] INFO c.CompletableFutureDemo_1 - Hello SupplyAsync

2.3.通用异步编程

从 Java 8 开始引入了 CompletableFuture，它是 Future 的扩展功能增强版，可以减少 Future 中的阻塞和轮询问题。

它可以传入回调对象，当异步任务完成或发生异常的时候，自动调用回调对象的回调方法。

@Slf4j(topic = "c.CompletaleFutureDemo_2")
public class CompletableFutureDemo_2 {public static void main(String[] args) throws ExecutionException, InterruptedException {test_1();}// ... ...
}

熟悉的配方，熟悉的味道

private static void test_1() throws InterruptedException, ExecutionException {CompletableFuture rCF = CompletableFuture.supplyAsync(() -> {log.info("---【{} Come In】---", Thread.currentThread().getName());int result = ThreadLocalRandom.current().nextInt(10);try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}log.info("---【1 秒后出结果：{}】---", result);return result;});log.info("---【{} 线程先去忙其他任务了】---", Thread.currentThread().getName());log.info("---【result：{}】---", rCF.get());
}

Future 可以做到的事情，CompletableFuture 都可以做到。

11:30:11.460 [main] INFO c.CompletaleFutureDemo_2 - ---【main 线程先去忙其他任务了】---
11:30:11.460 [ForkJoinPool.commonPool-worker-1] INFO c.CompletaleFutureDemo_2 - ---【ForkJoinPool.commonPool-worker-1 Come In】---
11:30:12.487 [ForkJoinPool.commonPool-worker-1] INFO c.CompletaleFutureDemo_2 - ---【1 秒后出结果：9】---
11:30:12.487 [main] INFO c.CompletaleFutureDemo_2 - ---【result：9】---

CompletableFuture 可以传入回调对象，当异步任务完成或发生异常的时候，自动调用回调对象的回调方法。

private static void test_2() throws InterruptedException, ExecutionException {ExecutorService threadPool = Executors.newFixedThreadPool(3);try {CompletableFuture.supplyAsync(() -> {log.info("【{} Come In】", Thread.currentThread().getName());int result = ThreadLocalRandom.current().nextInt(10);try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }log.info("【1 秒后出结果：{}】", result);if (result > 5) { int i = 10 / 0; }return result;}, threadPool).whenComplete((result, exception) -> {log.info("[进入 whenComplete 方法]");if (exception == null) { log.info("【计算完成，更新系统。Update result：{}】", result); }log.info("[退出 whenComplete 方法]");}).exceptionally(exception -> {// exception.printStackTrace();System.out.println("【异常情况 Cause：" + exception.getCause() + "】");log.info("【异常情况 Message：{}】", exception.getMessage());return null;});} catch (Exception e) {// e.printStackTrace();} finally {threadPool.shutdown();}// 【注意】//  在这个程序里，CompletableFuture 默认使用的 [ForkJoinPool] 就是守护线程，[main] 就是用户线程//  如果主线程立刻结束的话，CompletableFuture 默认使用的线程池会立刻关闭// （守护线程要守护的对象不存在了，程序就应该结束）// 	我们一般推荐 [自定义线程池 + CompletableFuture] 配合使用log.info("【{} 线程先去忙其他任务了】", Thread.currentThread().getName());
}

控制台输出（没有出现异常的情况，走 whenComplete() 方法）

12:28:54.135 [main] INFO c.CompletaleFutureDemo_2 - 【main 线程先去忙其他任务了】
12:28:54.135 [pool-1-thread-1] INFO c.CompletaleFutureDemo_2 - 【pool-1-thread-1 Come In】
12:28:55.151 [pool-1-thread-1] INFO c.CompletaleFutureDemo_2 - 【1 秒后出结果：5】
12:28:55.151 [pool-1-thread-1] INFO c.CompletaleFutureDemo_2 - [进入 whenComplete 方法]
12:28:55.151 [pool-1-thread-1] INFO c.CompletaleFutureDemo_2 - 【计算完成，更新系统。Update result：5】
12:28:55.151 [pool-1-thread-1] INFO c.CompletaleFutureDemo_2 - [退出 whenComplete 方法]

控制台输出（出现了异常的情况，依然会进入 whenComplete() 方法，之后会走 exceptionally() 方法）

注意：就算是出现了异常，也还是会进入 whenComplete() 方法，故我们还需要在 whenComplete() 加判断处理

12:29:58.062 [pool-1-thread-1] INFO c.CompletaleFutureDemo_2 - 【pool-1-thread-1 Come In】
12:29:58.062 [main] INFO c.CompletaleFutureDemo_2 - 【main 线程先去忙其他任务了】
12:29:59.079 [pool-1-thread-1] INFO c.CompletaleFutureDemo_2 - 【1 秒后出结果：8】
12:29:59.079 [pool-1-thread-1] INFO c.CompletaleFutureDemo_2 - [进入 whenComplete 方法]
12:29:59.079 [pool-1-thread-1] INFO c.CompletaleFutureDemo_2 - [退出 whenComplete 方法]
【异常情况 Cause：java.lang.ArithmeticException: / by zero】
12:29:59.080 [pool-1-thread-1] INFO c.CompletaleFutureDemo_2 - 【异常情况 Message：java.lang.ArithmeticException: / by zero】

2.4.函数式接口简单复习

• Runnable 接口无参数，无返回值

@FunctionalInterface
public interface Runnable {public abstract void run();
}

• Function 接收一个参数，且有返回值

@FunctionalInterface
public interface Function {R apply(T t);
}

• Consumer 接收一个参数，没有返回值
• BiConsumer 接收两个参数，没有返回值（Bi 是英文单词的词根，代表两个的意思）

@FunctionalInterface
public interface Consumer {void accept(T t);
}

@FunctionalInterface
public interface BiConsumer {accept(T t, U u);
}

• Supplier 接口没有参数，有一个返回值

@FunctionalInterface
public interface Supplier {T get();
}

2.5.案例：电商比价

案例说明：电商比价需求

模拟如下情况：

• 需求：
  • 同一款产品，同时搜索出同款产品在各大电商的售价
  • 同一款产品,同时搜索出本产品在某一个电商平台下,各个入驻门店的售价是多少
• 输出：
  • 输出的结果，希望是同款产品的在不同地方的价格清单列表，返回的是一个 List
    《MySQL》 in jd price is 88.05
《MySQL》 pdd price is 86.11
《MySQL》 in taobao price is 90.43
• 解决方案：比对同一个商品在各个平台上的价格，要求活动一个清单列表
  • step by step，按部就班，查完京东查淘宝，查完淘宝查天猫 … …
  • all in，多线程异步任务同时查询

NetMall.java

public class NetMall {private String netMallName;public String getNetMallName() {return netMallName;}public NetMall(String netMallName) {this.netMallName = netMallName;}public Double calcPrice(String productName) {try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }return ThreadLocalRandom.current().nextDouble() * 2 + productName.charAt(0);}
}

CompletableFutureMallDemo.java

@Slf4j(topic = "c.CompletableFutureMallDemo")
public class CompletableFutureMallDemo {static List list = Arrays.asList(new NetMall("jd"),new NetMall("dangdang"),new NetMall("taobao"));/*** Step By Step** @param list* @param productName* @return*/public static List getPrice_1(List list, String productName) {// 输出格式：MySQL in taobao price is 90.43List collectList = list.stream().map(netMall -> String.format(productName + " in %s  price is %.2f",netMall.getNetMallName(),netMall.calcPrice(productName))).collect(Collectors.toList());return collectList;}/*** All In** @param list* @param productName* @return*/public static List getPrice_2(List list, String productName) {// 其实可以一步链式到位的，但这里为了便于理解，还是中间截断了一下，设了俩变量List> futureList = list.stream().map(netMall -> CompletableFuture.supplyAsync(() -> String.format(productName + " in %s price is %.2f",netMall.getNetMallName(),netMall.calcPrice(productName)))).collect(Collectors.toList());List collectList = futureList.stream().map(s -> s.join()).collect(Collectors.toList());return collectList;}public static void main(String[] args) {long startTime_1 = System.currentTimeMillis();List lists_1 = getPrice_1(list, "MySQL");for (String element : lists_1) {System.out.println(element);}long endTime_1 = System.currentTimeMillis();log.info("【costTime_1：{} 毫秒】", (endTime_1 - startTime_1));System.out.println("---------------------------------------------");long startTime_2 = System.currentTimeMillis();List lists_2 = getPrice_2(list, "MySQL");for (String element: lists_2){System.out.println(element);}long endTime_2 = System.currentTimeMillis();log.info("【costTime_2：{} 毫秒】", (endTime_2 - startTime_2));}
}

控制台输出

MySQL in jd  price is 77.53
MySQL in dangdang  price is 77.19
MySQL in taobao  price is 77.53
17:27:21.710 [main] INFO c.CompletableFutureMallDemo - 【costTime_1：3068 毫秒】
---------------------------------------------
MySQL in jd price is 78.91
MySQL in dangdang price is 77.80
MySQL in taobao price is 77.56
17:27:22.735 [main] INFO c.CompletableFutureMallDemo - 【costTime_2：1014 毫秒】

2.6.常用方法

2.6.1.获得结果和触发计算

获取结果

• public T get()：一旦调用 get() 方法求结果，在 futureTask 没有计算完成的情况下，容易导致线程阻塞
• public T get(long timeout, TimeUnit unit)：超过了设置的时间，则不再等候，会发生阻塞
• public T join()：和 get() 方法的区别不大，只是其在编译期也不会报错，而 get() 方法必须抛异常
• public T getNow(T valueIfAbsent)：在没有计算完成的情况下，会返回一个替代的结果
  特点是立即获取结果不阻塞：计算完成，则返回计算完成后的结果；计算没有完成，则会返回设定的 ValueIfAbsent 值

主动触发计算

• public boolean complete(T value)：判断是否是 get() 方法发生打断操作，并立即返回括号里面的值
  显然这个方法也是立即获取结果不阻塞
  计算完成，get() 方法没有发生打断操作，返回 false ，返回计算完成后的结果；
  计算没有完成，get() 方法发生打断操作，返回 true ，返回设定的 value 值

@Slf4j(topic = "c.CompletableFutureAPIDemo")
public class CompletableFutureAPIDemo {// public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {public static void main(String[] args) {CompletableFuture cf = CompletableFuture.supplyAsync(() -> {log.info("【进入 CompletableFuture.supplyAsync()】");try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}return "ABC";});// log.info("【{}】", cf.get());// log.info("【{}】", cf.get(2L, TimeUnit.SECONDS));// log.info("【{}】", cf.join());try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}// log.info("【{}】", cf.getNow("xxx"));log.info("[{}]\t[{}]", cf.complete("completeValue"), cf.join());}
}

控制台输出结果

19:43:53.219 [ForkJoinPool.commonPool-worker-1] INFO c.CompletableFutureAPIDemo - 【进入 CompletableFuture.supplyAsync()】
19:43:56.223 [main] INFO c.CompletableFutureAPIDemo - [false]	[ABC]

2.6.2.对计算结果进行处理

• public CompletableFuture thenApply(Function fn)
  计算结果存在依赖关系，这两个线程串行化
  由于存在依赖关系（当前步骤出错，则不走下一步），当前步骤有异常会叫停。
• public CompletableFuture handle(BiFunction fn)
  计算结果存在依赖关系，这两个线程串行化
  这个方法和上面方法的区别就是，纵然异常出现了，它也可以继续往下一步走，可以根据带的异常参数进一步处理

@Slf4j(topic = "c.CompletableFutureAPIDemo_2")
public class CompletableFutureAPIDemo_2 {public static void main(String[] args) throws InterruptedException {ExecutorService threadPool = Executors.newFixedThreadPool(10);// test_1_1(threadPool);// test_2(threadPool);}
}

private static void test_1_1(ExecutorService threadPool) {CompletableFuture.supplyAsync(() -> {try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {}log.info("【111】");return 1;}, threadPool).thenApply(f -> {int i = 1 / 0; //故意设置异常log.info("【222】");return f + 2;}).thenApply(f -> {log.info("【333】");return f + 3;}).whenComplete((v, e) -> {log.info("---[进入 whenComplete() 方法]---");if (e == null) log.info("【计算结果：{}】", v);log.info("---[即将退出 whenComplete() 方法]---");}).exceptionally(e -> {// e.printStackTrace();log.info("【{}】", e.getMessage());return null;});log.info("-----【（{}）线程去忙其它事情了】-----", Thread.currentThread().getName());threadPool.shutdown();
}

private static void test_2(ExecutorService threadPool) {CompletableFuture.supplyAsync(() -> {try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {}log.info("【111】");return 1;}, threadPool).handle((f, e) -> {int i = 1 / 0;// 此处故意设置异常log.info("【222】");return f + 2;}).handle((f, e) -> {log.info("【333】");return f + 3;}).whenComplete((v, e) -> {log.info("---[进入 whenComplete() 方法]---");if (e == null) log.info("【计算结果：{}】", v);log.info("---[即将退出 whenComplete() 方法]---");}).exceptionally(e -> {// e.printStackTrace();log.info("【{}】", e.getMessage());return null;});log.info("-----【（{}）线程去忙其它事情了】-----", Thread.currentThread().getName());threadPool.shutdown();
}

20:31:23.578 [main] INFO c.CompletableFutureAPIDemo_2 - -----【（main）线程去忙其它事情了】-----
20:31:24.581 [pool-1-thread-1] INFO c.CompletableFutureAPIDemo_2 - 【111】
20:31:24.581 [pool-1-thread-1] INFO c.CompletableFutureAPIDemo_2 - 【222】
20:31:24.581 [pool-1-thread-1] INFO c.CompletableFutureAPIDemo_2 - 【333】
20:31:24.581 [pool-1-thread-1] INFO c.CompletableFutureAPIDemo_2 - ---[进入 whenComplete() 方法]---
20:31:24.581 [pool-1-thread-1] INFO c.CompletableFutureAPIDemo_2 - 【计算结果：6】
20:31:24.581 [pool-1-thread-1] INFO c.CompletableFutureAPIDemo_2 - ---[即将退出 whenComplete() 方法]---

20:30:53.304 [main] INFO c.CompletableFutureAPIDemo_2 - -----【（main）线程去忙其它事情了】-----
20:30:54.302 [pool-1-thread-1] INFO c.CompletableFutureAPIDemo_2 - 【111】
20:30:54.302 [pool-1-thread-1] INFO c.CompletableFutureAPIDemo_2 - ---[进入 whenComplete() 方法]---
20:30:54.302 [pool-1-thread-1] INFO c.CompletableFutureAPIDemo_2 - ---[即将退出 whenComplete() 方法]---
20:30:54.302 [pool-1-thread-1] INFO c.CompletableFutureAPIDemo_2 - 【java.lang.ArithmeticException: / by zero】

20:31:48.706 [main] INFO c.CompletableFutureAPIDemo_2 - -----【（main）线程去忙其它事情了】-----
20:31:49.711 [pool-1-thread-1] INFO c.CompletableFutureAPIDemo_2 - 【111】
20:31:49.711 [pool-1-thread-1] INFO c.CompletableFutureAPIDemo_2 - 【333】
20:31:49.711 [pool-1-thread-1] INFO c.CompletableFutureAPIDemo_2 - ---[进入 whenComplete() 方法]---
20:31:49.711 [pool-1-thread-1] INFO c.CompletableFutureAPIDemo_2 - ---[即将退出 whenComplete() 方法]---
20:31:49.711 [pool-1-thread-1] INFO c.CompletableFutureAPIDemo_2 - 【java.lang.NullPointerException】

public  CompletableFuture thenApplyAsync(Function fn, Executor executor) {return uniApplyStage(screenExecutor(executor), fn);
}

private static void test_1_2(ExecutorService threadPool) {CompletableFuture.supplyAsync(() -> {try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }log.info("【111】");return 1;}, threadPool).thenApplyAsync(f -> {log.info("【222】");return f + 2;}, threadPool).thenApplyAsync(f -> {log.info("【333】");return f + 3;}).whenComplete((v, e) -> {log.info("---[进入 whenComplete() 方法]---");if (e == null) log.info("【计算结果：{}】", v);log.info("---[即将退出 whenComplete() 方法]---");}).exceptionally(e -> {// e.printStackTrace();log.info("【{}】", e.getMessage());return null;});log.info("-----【（{}）线程去忙其它事情了】-----", Thread.currentThread().getName());try { TimeUnit.SECONDS.sleep(6); } catch (InterruptedException e) { e.printStackTrace(); }threadPool.shutdown();
}

21:35:21.902 [main] INFO c.CompletableFutureAPIDemo_2 - -----【（main）线程去忙其它事情了】-----
21:35:22.902 [pool-1-thread-1] INFO c.CompletableFutureAPIDemo_2 - 【111】
21:35:22.902 [pool-1-thread-2] INFO c.CompletableFutureAPIDemo_2 - 【222】
21:35:22.903 [ForkJoinPool.commonPool-worker-1] INFO c.CompletableFutureAPIDemo_2 - 【333】
21:35:22.903 [ForkJoinPool.commonPool-worker-1] INFO c.CompletableFutureAPIDemo_2 - ---[进入 whenComplete() 方法]---
21:35:22.903 [ForkJoinPool.commonPool-worker-1] INFO c.CompletableFutureAPIDemo_2 - 【计算结果：6】
21:35:22.903 [ForkJoinPool.commonPool-worker-1] INFO c.CompletableFutureAPIDemo_2 - ---[即将退出 whenComplete() 方法]---

java.util.concurrent.CompletionException: java.util.concurrent.RejectedExecutionException: Task java.util.concurrent.CompletableFuture$UniApply@514e386b rejected from java.util.concurrent.ThreadPoolExecutor@5f89dc32[Shutting down, pool size = 1, active threads = 1, queued tasks = 0, completed tasks = 0]
... ...

public class CompletableFutureAPIDemo_3 {public static void main(String[] args) {CompletableFuture.supplyAsync(() -> {return "整一个值 A";}).thenApply(f -> { return f + "\t再整一个值 C"; }).thenAccept(f -> System.out.println("thenAccept：" + f)).thenRun(() -> {System.out.println("thenRun()：无输入值，亦无返回值");});System.out.println("===========================================");System.out.println(CompletableFuture.supplyAsync(() -> "Result").thenRun(() -> {}).join());}
}

thenAccept：整一个值 A	再整一个值 C
thenRun()：无输入值，亦无返回值
===========================================
null

10:00:07.860 [main] INFO c.TestA - 【main 线程正在摸鱼中...】
10:00:07.893 [ForkJoinPool.commonPool-worker-1] INFO c.TestA - 一号任务：ForkJoinPool.commonPool-worker-1
10:00:07.925 [ForkJoinPool.commonPool-worker-1] INFO c.TestA - 二号任务：ForkJoinPool.commonPool-worker-1
10:00:07.956 [ForkJoinPool.commonPool-worker-1] INFO c.TestA - 三号任务：ForkJoinPool.commonPool-worker-1
10:00:07.988 [ForkJoinPool.commonPool-worker-1] INFO c.TestA - 四号任务：ForkJoinPool.commonPool-worker-1
10:00:07.988 [main] INFO c.TestA - 【cf.get：null】

10:02:00.847 [main] INFO c.TestA - 【main 线程正在摸鱼中...】
10:02:00.868 [pool-1-thread-1] INFO c.TestA - 一号任务：pool-1-thread-1
10:02:00.898 [pool-1-thread-1] INFO c.TestA - 二号任务：pool-1-thread-1
10:02:00.930 [pool-1-thread-1] INFO c.TestA - 三号任务：pool-1-thread-1
10:02:00.960 [pool-1-thread-1] INFO c.TestA - 四号任务：pool-1-thread-1
10:02:00.960 [main] INFO c.TestA - 【cf.get：null】

10:07:34.691 [main] INFO c.TestA - 【main 线程正在摸鱼中...】
10:07:34.713 [pool-1-thread-1] INFO c.TestA - 一号任务：pool-1-thread-1
10:07:34.744 [ForkJoinPool.commonPool-worker-1] INFO c.TestA - 二号任务：ForkJoinPool.commonPool-worker-1
10:07:34.776 [ForkJoinPool.commonPool-worker-1] INFO c.TestA - 三号任务：ForkJoinPool.commonPool-worker-1
10:07:34.808 [ForkJoinPool.commonPool-worker-1] INFO c.TestA - 四号任务：ForkJoinPool.commonPool-worker-1
10:07:34.808 [main] INFO c.TestA - 【cf.get：null】

10:12:27.048 [main] INFO c.TestA - 【main 线程正在摸鱼中...】
10:12:27.068 [pool-1-thread-1] INFO c.TestA - 一号任务：pool-1-thread-1
10:12:27.100 [pool-1-thread-2] INFO c.TestA - 二号任务：pool-1-thread-2
10:12:27.130 [pool-1-thread-3] INFO c.TestA - 三号任务：pool-1-thread-3
10:12:27.161 [pool-1-thread-4] INFO c.TestA - 四号任务：pool-1-thread-4
10:12:27.161 [main] INFO c.TestA - 【cf.get：null】

10:15:02.708 [main] INFO c.TestA - 【main 线程正在摸鱼中...】
10:15:02.741 [pool-1-thread-1] INFO c.TestA - 一号任务：pool-1-thread-1
10:15:02.772 [ForkJoinPool.commonPool-worker-1] INFO c.TestA - 二号任务：ForkJoinPool.commonPool-worker-1
10:15:02.804 [pool-1-thread-2] INFO c.TestA - 三号任务：pool-1-thread-2
10:15:02.835 [ForkJoinPool.commonPool-worker-1] INFO c.TestA - 四号任务：ForkJoinPool.commonPool-worker-1
10:15:02.835 [main] INFO c.TestA - 【cf.get：null】

【一号任务：pool-1-thread-1】
【二号任务：main】
【三号任务：main】
【四号任务：main】
10:38:02.131 [main] INFO c.TestA - 【main 线程正在摸鱼中...】
10:38:02.143 [main] INFO c.TestA - 【cf.get：null】

public CompletableFuture thenRunAsync(Runnable action) {return uniRunStage(asyncPool, action);
}

public CompletableFuture thenRunAsync(Runnable action, Executor executor) {return uniRunStage(screenExecutor(executor), action);
}

private static final boolean useCommonPool =(ForkJoinPool.getCommonPoolParallelism() > 1);

private static final Executor asyncPool = useCommonPool ?ForkJoinPool.commonPool() : new ThreadPerTaskExecutor();

static Executor screenExecutor(Executor e) {if (!useCommonPool && e == ForkJoinPool.commonPool())return asyncPool;if (e == null) throw new NullPointerException();return e;
}

@Slf4j(topic = "c.CompletableFutureAPIDemo_4")
public class CompletableFutureAPIDemo_4 {public static void main(String[] args) {CompletableFuture cfA = CompletableFuture.supplyAsync(() -> {log.info("【A come in】");try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }return "[This is cfA]";});CompletableFuture cfB = CompletableFuture.supplyAsync(() -> {log.info("【B come in】");try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }return "[This is cfB]";});CompletableFuture result = cfA.applyToEither(cfB, f -> { return "【" + f + " is Winer" + "】"; });log.info(result.join());}
}

11:19:01.620 [ForkJoinPool.commonPool-worker-1] INFO c.CompletableFutureAPIDemo_4 - 【A come in】
11:19:01.620 [ForkJoinPool.commonPool-worker-2] INFO c.CompletableFutureAPIDemo_4 - 【B come in】
11:19:02.634 [main] INFO c.CompletableFutureAPIDemo_4 - 【[This is cfB] is Winer】

@Slf4j(topic = "c.CompletableFutureAPIDemo_5")
public class CompletableFutureAPIDemo_5 {public static void main(String[] args) {CompletableFuture cf_1 = CompletableFuture.supplyAsync(() -> {log.info("【[cf_1] | 开始启动】");try { TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) { e.printStackTrace(); }return 10;});CompletableFuture cf_2 = CompletableFuture.supplyAsync(() -> {log.info("【[cf_2] | 开始启动】");try { TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) { e.printStackTrace(); }return 20;});CompletableFuture combineResult = cf_1.thenCombine(cf_2, (x, y) -> {log.info("【俩结果开始合并】");return x + y;});log.info("【CombineResult：{}】", combineResult.join());}
}

11:39:27.550 [ForkJoinPool.commonPool-worker-2] INFO c.CompletableFutureAPIDemo_5 - 【[cf_2] | 开始启动】
11:39:27.550 [ForkJoinPool.commonPool-worker-1] INFO c.CompletableFutureAPIDemo_5 - 【[cf_1] | 开始启动】
11:39:29.571 [ForkJoinPool.commonPool-worker-2] INFO c.CompletableFutureAPIDemo_5 - 【俩结果开始合并】
11:39:29.571 [main] INFO c.CompletableFutureAPIDemo_5 - 【CombineResult：30】

@Slf4j(topic = "c.CompletableFutureAPIDemo_5Plus")
public class CompletableFutureAPIDemo_5Plus {public static void main(String[] args) {CompletableFuture combineResult = CompletableFuture.supplyAsync(() -> {log.info("【come in 1】");return 10;}).thenCombine(CompletableFuture.supplyAsync(() -> {log.info("【come in 2】");return 20;}), (x, y) -> {log.info("【come in 3】");return x + y;}).thenCombine(CompletableFuture.supplyAsync(() -> {log.info("【come in 4】");return 30;}), (a, b) -> {log.info("【come in 5】");return a + b;});log.info("【[{}]线程在摸鱼】", Thread.currentThread().getName());log.info("【CombineResult：{}】", combineResult.join());}
}

11:50:02.395 [ForkJoinPool.commonPool-worker-3] INFO c.CompletableFutureAPIDemo_5Plus - 【come in 4】
11:50:02.395 [ForkJoinPool.commonPool-worker-2] INFO c.CompletableFutureAPIDemo_5Plus - 【come in 2】
11:50:02.396 [main] INFO c.CompletableFutureAPIDemo_5Plus - 【[main]线程在摸鱼】
11:50:02.395 [ForkJoinPool.commonPool-worker-1] INFO c.CompletableFutureAPIDemo_5Plus - 【come in 1】
11:50:02.406 [ForkJoinPool.commonPool-worker-1] INFO c.CompletableFutureAPIDemo_5Plus - 【come in 3】
11:50:02.406 [ForkJoinPool.commonPool-worker-1] INFO c.CompletableFutureAPIDemo_5Plus - 【come in 5】
11:50:02.406 [main] INFO c.CompletableFutureAPIDemo_5Plus - 【CombineResult：60】