关于 Executor 参数说明：

• 没有指定Executor的方法，直接使用默认的 ForkJoinPool.commPool() 作为它的线程池执行异步代码。
• 如果指定线程池，则使用我们定义的或者特别指定的线程池执行异步代码。

代码演示 runAsync ：

public class CompletableFutureTest01 {public static void main(String[] args) throws ExecutionException, InterruptedException {// Void 表示没有返回值CompletableFuture completableFuture = CompletableFuture.runAsync(() -> {System.out.println("异步任务开始执行。。。。");});System.out.println(completableFuture.get());}
}

runAsync + 线程池：

public class CompletableFutureTest01 {public static void main(String[] args) throws ExecutionException, InterruptedException {// 创建线程池ExecutorService threadPool = Executors.newFixedThreadPool(3);// Void 表示没有返回值CompletableFuture completableFuture = CompletableFuture.runAsync(() -> {System.out.println(Thread.currentThread().getName() + "异步任务开始执行。。。。");},threadPool);System.out.println(completableFuture.get());}
}

supplyAsync ：

        CompletableFuture uCompletableFuture = CompletableFuture.supplyAsync(() -> {System.out.println(Thread.currentThread().getName() + "异步任务开始执行。。。。");return  " hello, supplyAsync";});System.out.println(uCompletableFuture.get());

supplyAsync+ 线程池；

    ExecutorService threadPool = Executors.newFixedThreadPool(3);CompletableFuture uCompletableFuture = CompletableFuture.supplyAsync(() -> {System.out.println(Thread.currentThread().getName() + "异步任务开始执行。。。。");return  " hello, supplyAsync";},threadPool);System.out.println(uCompletableFuture.get());}

CompletableFuture 减少阻塞和轮询

在上面的演示中，CompletableFuture 不仅可以完成 Future 的功能，并且能够通过 whenComplete来减少阻塞和轮询（自动回调）

whenComplete() 方法演示：

public CompletableFuture whenComplete(BiConsumer action)

参数是一个消费类型参数，其中有俩个参数：v 和 e。

v 表示 异步任务返回的值，就是计算结果

e 表示 异步任务出现的异常信息

public class CompletableFutureTest02 {public static void main(String[] args) throws ExecutionException, InterruptedException {CompletableFuture.supplyAsync(() -> {System.out.println(Thread.currentThread().getName() + " 异步任务正在计算.....");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}int result = new Random().nextInt();return  result;}).whenComplete((v,e)-> { // 回调函数if (e == null) {System.out.println("计算后的结果为: " + v);}}).exceptionally((e) -> { // 打印异常信息System.out.println(e.getCause() + "\t" + e.getMessage());return null;});System.out.println(Thread.currentThread().getName() + " 正在执行其他任务.....");}
}

注意事项

由于我们使用的是默认的 ForkJoinPool 线程池， 该线程池就像一个守护线程，主线程结束，该线程池就会关闭，因此主线程结束太快，获取不到异步任务的返回值。针对此情况，俩种解决方案：

• 使用自定义的线程池
• 在 main 方法末尾，使用 sleep

使用自定义线程池：

public class CompletableFutureTest02 {public static void main(String[] args) throws ExecutionException, InterruptedException {// 创建线程池ExecutorService threadPool = Executors.newFixedThreadPool(3);CompletableFuture.supplyAsync(() -> {System.out.println(Thread.currentThread().getName() + " 异步任务正在计算.....");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}int result = new Random().nextInt();return  result;},threadPool).whenComplete((v,e)-> { // 回调函数if (e == null) {System.out.println("计算后的结果为: " + v);}}).exceptionally((e) -> { // 打印异常信息System.out.println(e.getCause() + "\t" + e.getMessage());return null;});System.out.println(Thread.currentThread().getName() + " 正在执行其他任务.....");// 睡眠一会，避免由于main线程执行太快，获取不到异步任务的计算结果// try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}threadPool.shutdown();}
}

演示异常发生的情况：

public class CompletableFutureTest02 {public static void main(String[] args) throws ExecutionException, InterruptedException {// 创建线程池ExecutorService threadPool = Executors.newFixedThreadPool(3);CompletableFuture.supplyAsync(() -> {System.out.println(Thread.currentThread().getName() + " 异步任务正在计算.....");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}// 异常int i = 10/0 ;int result = new Random().nextInt();return  result;},threadPool).whenComplete((v,e)-> { // 回调函数if (e == null) {System.out.println("计算后的结果为: " + v);}}).exceptionally((e) -> { // 打印异常信息System.out.println("异常信息: " + e.getCause() + "\t" + e.getMessage());return null;});System.out.println(Thread.currentThread().getName() + " 正在执行其他任务.....");// 睡眠一会，避免由于main线程执行太快，获取不到异步任务的计算结果// try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}threadPool.shutdown();}

输出结果：

总结

• 异步任务结束时，会自动回调某个对象的方法 whenComplete；
• 主线程设置好毁掉后，不再关心异步任务的执行，异步任务之间可以顺序执行
• 异步任务出错时，会自动回调某个对象的方法。 exceptionally

CompletableFuture 案例

讲解案例之前，需要的知识点：

• jdk8新特性：Lambda、Stream、函数式接口编程…
  • 在我另一篇博客中有讲解：https://blog.csdn.net/aetawt/article/details/127949647
• 链式编程
• join 和 get 的区别
  • get 会抛出 ExecutionException, InterruptedException 异常, join 不会抛出异常。

链式编程：将多个方法用链子 “串起来”

public class ChainTest {public static void main(String[] args) {// 普通写法Student student = new Student();student.setAge(1);student.setId(1);student.setName("aa");// 链式编程student.setName("aa").setAge(1).setId(2);}
}@Data
@Accessors(chain = true) // 开启链式编程
class Student {private String name;private int age;private int id;
}

电商网站比价需求分析

1需求说明

1.1同一款产品，同时搜索出同款产品在各大电商平台的售价；
1.2同一款产品，同时搜索出本产品在同一个电商平台下，各个入驻卖家售价是多少

2输出返回

出来结果希望是同款产品的在不同地方的价格清单列表， 返回一个List
《mysql》in jd price is 88.05
《mysql》in dang dang price is 86.11
《mysql》in tao bao price is 90.43

3解决方案

比对同一个商品在各个平台上的价格，要求获得一个清单列表

1 stepbystep ， 按部就班， 查完京东查淘宝， 查完淘宝查天猫…
2 all in ，万箭齐发，一口气多线程异步任务同时查询。。。

第一种方案

/**** Author: YZG* Date: 2022/11/20 16:06* Description: */
public class NetMallCase {// 平台集合static List list = Arrays.asList(new NetMall("jd"),new NetMall("dangdang"),new NetMall("taobao"));/*** step to step* @description 在不同平台中搜索商品的价格* @date 2022/11/20 16:16* @param list 平台集合* @param productName 商品名字* @return java.lang.String* 返回格式：* 《mysql》in jd price is 88.05* 《mysql》in dang dang price is 86.11* 《mysql》in tao bao price is 90.43*/public static List getPrice(List list, String productName) {// % 占位符，相当于 jdbc里面的 ？return list.stream().map(netMall -> String.format(productName + " in %s is %.2f",netMall.getNetName(),netMall.calcPrice(productName))).collect(Collectors.toList());}public static void main(String[] args) {long begin = System.currentTimeMillis();List mysqlList = getPrice(list, "mysql");for (String s : mysqlList) {System.out.println(s);}long end = System.currentTimeMillis();System.out.println("程序耗时: " + (end - begin) + "毫秒");}
}// 平台类
@Data
class NetMall {private String netName;public NetMall(String netName) {this.netName = netName;}// 根据商品名搜索价格public Double calcPrice(String productName) {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}return new Random().nextDouble() * 2 + productName.charAt(0);}
}

输出结果：

mysql in jd is 109.22
mysql in dangdang is 109.67
mysql in taobao is 110.81程序耗时: 3085毫秒

第二种方案

使用 异步任务

public class NetMallCase {// 平台集合static List list = Arrays.asList(new NetMall("jd"),new NetMall("dangdang"),new NetMall("taobao"));/*** step to step* @description 在不同平台中搜索商品的价格* @date 2022/11/20 16:16* @param list 平台集合* @param productName 商品名字* @return* 返回格式：* 《mysql》in jd price is 88.05* 《mysql》in dang dang price is 86.11* 《mysql》in tao bao price is 90.43*/public static List getPrice(List list, String productName) {// % 占位符，相当于 jdbc里面的 ？return list.stream().map(netMall -> String.format(productName + " in %s is %.2f",netMall.getNetName(),netMall.calcPrice(productName))).collect(Collectors.toList());}// 异步任务处理public static List getPriceByCompletableFuture(List list, String productName) {// map 映射：会将异步任务的处理应用到 流中的每一个元素上return list.stream().map(netMall -> CompletableFuture.supplyAsync(() -> {return String.format(productName + " in %s is %.2f",netMall.getNetName(),netMall.calcPrice(productName));})) //Stream>.collect(Collectors.toList()) //List>.stream() //Stream>.map(CompletableFuture::join) //Stream.collect(Collectors.toList()); // List}public static void main(String[] args) {long begin = System.currentTimeMillis();List mysqlList = getPrice(list, "mysql");for (String s : mysqlList) {System.out.println(s);}long end = System.currentTimeMillis();System.out.println("程序耗时: " + (end - begin) + "毫秒");System.out.println("---------------异步任务处理-------------");long begin1 = System.currentTimeMillis();List mysqlList1 = getPriceByCompletableFuture(list, "mysql");for (String s : mysqlList1) {System.out.println(s);}long end1 = System.currentTimeMillis();System.out.println("程序耗时: " + (end1 - begin1) + "毫秒");}
}// 平台类
@Data
class NetMall {private String netName;public NetMall(String netName) {this.netName = netName;}// 根据商品名搜索价格public Double calcPrice(String productName) {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}return new Random().nextDouble() * 2 + productName.charAt(0);}
}

输出结果：

mysql in jd is 109.93
mysql in dangdang is 109.78
mysql in taobao is 109.48
程序耗时: 3109毫秒
---------------异步任务处理-------------
mysql in jd is 110.42
mysql in dangdang is 109.43
mysql in taobao is 110.04
程序耗时: 1012毫秒Process finished with exit code 0

CompletableFuture 常用的方法

获得结果和触发计算

获取结果

• public T get() 不见不散，容易阻塞
• public T get(long timeout,TimeUnit unit) 过时不候，超过时间会爆异常
• public T join() 类似于get()，区别在于是否需要抛出异常
• public T getNow(T valueIfAbsent)
  • 获取计算结果时，如果异步任务没有完成计算，返回指定的 valueIfAbsent。

主动触发计算

• public boolean complete(T value) 是否立即打断异步任务的计算
  • true：打断异步任务的计算，并将 value 作为返回值
  • false： 没有打断异步任务计算，将计算结果返回

public class CompletableFutureAPITest {public static void main(String[] args) throws Exception {CompletableFuture completableFuture = CompletableFuture.supplyAsync(() -> {try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}return "abc";});// System.out.println(completableFuture.get());// 超过 1s 没有获取到计算结果，就会抛出异常: TimeoutException// System.out.println(completableFuture.get(1, TimeUnit.SECONDS));// 和 get() 方法一样，唯一区别就是该方法不需要抛异常// System.out.println(completableFuture.join());// 如果获取时没有计算完成，将返回指定的值// System.out.println(completableFuture.getNow("new Value") );// complete 返回 boolean类型，是否打断了 异步任务的计算。// true：打断了计算，并将指定的值作为返回结果返回// false ：没有打断计算，返回计算好的结果// 等待 3s 计算需要 2s，没有打断，返回 abctry {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(completableFuture.complete("newValue") + "\t" + completableFuture.join());}
}

对计算结果进行处理

• thenApply 计算结果存在在依赖关系，使得线程串行化。
  • 出现异常不会继续往下执行。
• handle 计算结果存在在依赖关系，使得线程串行化。
  • 出现异常，也会继续执行。根据异常参数进行调整

俩个方法的区别就是对异常的处理不同

thenApply 演示：

/**** Author: YZG* Date: 2022/11/20 17:17* Description: */
public class CompletableFutureAPI2Test {public static void main(String[] args) throws Exception {CompletableFuture.supplyAsync(() -> {System.out.println("第一步");return 1;}).thenApply(f -> {System.out.println("第二步");// 出现异常// 由于出现异常，不会继续执行第三步int i = 10/0;return f + 2;}).thenApply(f -> {System.out.println("第三步");return f + 3;}).whenComplete((v, e) -> {System.out.println("最终的计算结果: " + v);}).exceptionally(e -> {System.out.println(e.getCause() + "\t" + e.getMessage());return null;});}
}

输出结果：

handle 方法演示：

/**** Author: YZG* Date: 2022/11/20 17:17* Description: */
public class CompletableFutureAPI2Test {public static void main(String[] args) throws Exception {// handle方法演示CompletableFuture.supplyAsync(() -> {System.out.println("第一步");return 1;}).handle((f, e) -> {System.out.println("第二步");// 出现异常// 即使出现异常，也会继续执行第三步int i = 10 / 0;return f + 2;}).handle((f, e) -> {System.out.println("第三步");return f + 3;}).whenComplete((f, e) -> {System.out.println("最终的计算结果: " + f);}).exceptionally(e -> {System.out.println(e.getCause() + "\t" + e.getMessage());return null;});}
}

输出结果：

第一步
第二步
第三步
最终的计算结果: null
java.lang.NullPointerException	java.lang.NullPointerExceptionProcess finished with exit code 0

对计算结果进行消费

• thenAccept 接收任务的处理结果，并消费处理，无返回结果|消费型函数式接口，之前的是Function

演示：

public class CompletableFutureAPI3Test {public static void main(String[] args) throws Exception {CompletableFuture.supplyAsync(() -> {System.out.println("第一步");return 1;}).thenApply(f -> {System.out.println("第二步");return f + 2;}).thenApply(f -> {System.out.println("第三步");return f + 3;}).thenAccept(System.out::println); }
}

多个任务之间的顺序执行：

• thenRun(Runnable runnable)

  • 任务A执行完执行B，并且B不需要A的结果，没有返回值

• thenAccept(Consumer action)

  • 任务A执行完执行B，B需要A的结果，但是任务B无返回值

• thenApply(Function fn)

  • 任务A执行完执行B，B需要A的结果，同时任务B有返回值

// 多个任务间的执行顺序
System.out.println(CompletableFuture.supplyAsync(() -> 1).thenRun(() -> {}).join()); 
// null
System.out.println(CompletableFuture.supplyAsync(() -> 1).thenApply(f -> f + 2).join()); // 3
System.out.println(CompletableFuture.supplyAsync(() -> 1).thenAccept(f -> {}).join()); 
// null

CompletableFuture 对线程池的选择

以上的几个方法：thenApply、thenRun、thenAccept 都有另外一个版本，就是后面加 Async 这俩种有什么区别呢？

以 thenRun 和 thenRunAsync 为例：

1. 没有传入自定义线程池，都用默认线程池ForkJoinPool
2. 传入了一个自定义线程池如果你执行第一个任务的时候，传入了一个自定义线程池
   • 调用thenRun方法执行第二个任务的时候，则第二个任务和第一个任务是用同一个线程池
   • 调用thenRunAsync执行第二个任务的时候，则第一个任务使用的是你自己传入的线程池，第二个任务使用的是ForkJoin线程池
3. 也有可能处理太快，系统优化切换原则，直接使用main线程处理（把sleep去掉）

**代码演示 1 **：

public class CompletableFutureThreadPoolTest {public static void main(String[] args) throws Exception {CompletableFuture.supplyAsync(() -> {try {Thread.sleep(30);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " 任务1");return 1;}).thenRun(() -> {try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " 任务2");}).thenRun(() -> {try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " 任务3");}).thenRun(() -> {try {Thread.sleep(30);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " 任务4");});// 避免主线程结束太快而导致 关闭 ForkJoinPooltry {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}}
}

输出结果：

ForkJoinPool.commonPool-worker-1 任务1
ForkJoinPool.commonPool-worker-1 任务2
ForkJoinPool.commonPool-worker-1 任务3
ForkJoinPool.commonPool-worker-1 任务4

代码演示 2.1 ：

public class CompletableFutureThreadPoolTest {public static void main(String[] args) throws Exception {// 创建线程池ExecutorService threadPool = Executors.newFixedThreadPool(5);try {CompletableFuture.supplyAsync(() -> {try {Thread.sleep(30);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " 任务1");return 1;},threadPool).thenRun(() -> {try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " 任务2");}).thenRun(() -> {try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " 任务3");}).thenRun(() -> {try {Thread.sleep(30);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " 任务4");});} finally {threadPool.shutdown();}// 避免主线程结束太快而导致 关闭 ForkJoinPool// try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}}
}

输出结果：

pool-1-thread-1 任务1
pool-1-thread-1 任务2
pool-1-thread-1 任务3
pool-1-thread-1 任务4

代码演示 2.2 ：

public class CompletableFutureThreadPoolTest {public static void main(String[] args) throws Exception {// 创建线程池ExecutorService threadPool = Executors.newFixedThreadPool(5);try {CompletableFuture.supplyAsync(() -> {try {Thread.sleep(30);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " 任务1");return 1;},threadPool).thenRunAsync(() -> {try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " 任务2");}).thenRun(() -> {try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " 任务3");}).thenRun(() -> {try {Thread.sleep(30);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " 任务4");});} finally {threadPool.shutdown();}// 避免主线程结束太快而导致 关闭 ForkJoinPooltry {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}}

输出结果：

pool-1-thread-1 任务1
ForkJoinPool.commonPool-worker-1 任务2
ForkJoinPool.commonPool-worker-1 任务3
ForkJoinPool.commonPool-worker-1 任务4

代码演示 3 ：

public class CompletableFutureThreadPoolTest {public static void main(String[] args) throws Exception {// 创建线程池ExecutorService threadPool = Executors.newFixedThreadPool(5);try {CompletableFuture.supplyAsync(() -> {// try {Thread.sleep(30);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " 任务1");return 1;},threadPool).thenRunAsync(() -> {// try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " 任务2");}).thenRun(() -> {// try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " 任务3");}).thenRun(() -> {// try {Thread.sleep(30);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " 任务4");});} finally {threadPool.shutdown();}// 避免主线程结束太快而导致 关闭 ForkJoinPooltry {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}}
}

输出结果：

pool-1-thread-1 任务1
ForkJoinPool.commonPool-worker-1 任务2
main 任务3
main 任务4

对计算速度进行选用

• public CompletableFuture applyToEither方法，快的那个掌权

public class CompletableFutureAPI4Test {public static void main(String[] args) throws Exception {CompletableFuture playerA = CompletableFuture.supplyAsync(() -> {System.out.println("Player A come in");try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}return "Player A";});CompletableFuture playerB =  CompletableFuture.supplyAsync(() -> {System.out.println("Player B come in");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}return "Player B";});// 哪个异步任务先完成，就先返回哪个异步任务的计算结果CompletableFuture future = playerA.applyToEither(playerB, f -> {return f + " is win";});System.out.println(Thread.currentThread().getName() + "   " +future.join());}
}

Player A come in
Player B come in
main   Player B is win

public class CompletableFutureAPI5Test {public static void main(String[] args) throws Exception {CompletableFuture futureA = CompletableFuture.supplyAsync(() -> {System.out.println(Thread.currentThread().getName() + " 开始计算...");try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}return 10;});CompletableFuture futureB =  CompletableFuture.supplyAsync(() -> {System.out.println(Thread.currentThread().getName() + " 开始计算...");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}return 20;});// 对俩个异步任务的计算结果进行合并CompletableFuture future = futureA.thenCombine(futureB, Integer::sum);System.out.println(Thread.currentThread().getName() + " 开始进行合并，结果为: " + future.join());}
}

public class CompletableFutureAPI5Test {public static void main(String[] args) throws Exception {// 合并版CompletableFuture integerCompletableFuture = CompletableFuture.supplyAsync(() -> {System.out.println(Thread.currentThread().getName() + " 开始计算...");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}return 10;}).thenCombine(CompletableFuture.supplyAsync(() -> {System.out.println(Thread.currentThread().getName() + " 开始计算...");try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}return 20;}), (x, y) -> {System.out.println(Thread.currentThread().getName() + " 第一次开始合并...");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}return x + y;}).thenCombine(CompletableFuture.supplyAsync(() -> {return 30;}), (x, y) -> {System.out.println(Thread.currentThread().getName() + " 第二次开始合并...");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}return x + y;});System.out.println(Thread.currentThread().getName() + " 合并结果: " + integerCompletableFuture.join());}
}

ForkJoinPool.commonPool-worker-1 开始计算...
ForkJoinPool.commonPool-worker-2 开始计算...
ForkJoinPool.commonPool-worker-2 第一次开始合并...
ForkJoinPool.commonPool-worker-2 第二次开始合并...
main 合并结果: 60Process finished with exit code 0