北京seo网站推广,网站建设和成本,阿里巴巴logo图片,学校网站的建设论文文章目录 一.简介二.并行加载1.为何需要并行加载2.并行加载的实现方式 三.CompletableFuture使用与原理1.背景和定义2.常用方法3.CompletableFuture的使用3.CompletableFuture原理4.实践总结 一.简介
CompletableFuture由Java 8提供#xff0c;是实现异步化的工具类#xff… 文章目录 一.简介二.并行加载1.为何需要并行加载2.并行加载的实现方式 三.CompletableFuture使用与原理1.背景和定义2.常用方法3.CompletableFuture的使用3.CompletableFuture原理4.实践总结 一.简介
CompletableFuture由Java 8提供是实现异步化的工具类上手难度较低且功能强大支持通过函数式编程的方式对各类操作进行组合编排
随着订单量的持续上升美团外卖各系统服务面临的压力也越来越大。作为外卖链路的核心环节商家端提供了商家接单、配送等一系列核心功能业务对系统吞吐量的要求也越来越高。而商家端API服务是流量入口所有商家端流量都会由其调度、聚合对外面向商家提供功能接口对内调度各个下游服务获取数据进行聚合具有鲜明的I/O密集型I/O Bound特点。在当前日订单规模已达千万级的情况下使用同步加载方式的弊端逐渐显现因此我们开始考虑将同步加载改为并行加载的可行性。
二.并行加载
1.为何需要并行加载
外卖商家端API服务是典型的I/O密集型I/O Bound服务。除此之外美团外卖商家端交易业务还有两个比较大的特点 服务端必须一次返回订单卡片所有内容根据商家端和服务端的“增量同步协议注1”服务端必须一次性返回订单的所有信息包含订单主信息、商品、结算、配送、用户信息、骑手信息、餐损、退款、客服赔付参照下面订单卡片截图等需要从下游三十多个服务中获取数据。在特定条件下如第一次登录和长时间没登录的情况下客户端会分页拉取多个订单这样发起的远程调用会更多。 商家端和服务端交互频繁商家对订单状态变化敏感多种推拉机制保证每次变更能够触达商家导致App和服务端的交互频繁每次变更需要拉取订单最新的全部内容。
在外卖交易链路如此大的流量下为了保证商家的用户体验保证接口的高性能并行从下游获取数据就成为必然。
2.并行加载的实现方式
并行从下游获取数据从IO模型上来讲分为同步模型和异步模型。
同步模型
从各个服务获取数据最常见的是同步调用如下图所示 在同步调用的场景下接口耗时长、性能差接口响应时长T T1T2T3……Tn这时为了缩短接口的响应时间一般会使用线程池的方式并行获取数据商家端订单卡片的组装正是使用了这种方式。 这种方式由于以下两个原因导致资源利用率比较低 CPU资源大量浪费在阻塞等待上导致CPU资源利用率低。在Java 8之前一般会通过回调的方式来减少阻塞但是大量使用回调又引发臭名昭著的回调地狱问题导致代码可读性和可维护性大大降低。 为了增加并发度会引入更多额外的线程池随着CPU调度线程数的增加会导致更严重的资源争用宝贵的CPU资源被损耗在上下文切换上而且线程本身也会占用系统资源且不能无限增加。
同步模型下会导致硬件资源无法充分利用系统吞吐量容易达到瓶颈。
NIO异步模型
我们主要通过以下两种方式来减少线程池的调度开销和阻塞时间
通过RPC NIO异步调用的方式可以降低线程数从而降低调度上下文切换开销通过引入CompletableFuture下文简称CF对业务流程进行编排降低依赖之间的阻塞。本文主要讲述CompletableFuture的使用和原理。
为什么会选择CompletableFuture
我们首先对业界广泛流行的解决方案做了横向调研主要包括Future、CompletableFuture注2、RxJava、Reactor。它们的特性对比如下
可组合可以将多个依赖操作通过不同的方式进行编排例如CompletableFuture提供thenCompose、thenCombine等各种then开头的方法这些方法就是对“可组合”特性的支持。操作融合将数据流中使用的多个操作符以某种方式结合起来进而降低开销时间、内存。延迟执行操作不会立即执行当收到明确指示时操作才会触发。例如Reactor只有当有订阅者订阅时才会触发操作。回压某些异步阶段的处理速度跟不上直接失败会导致大量数据的丢失对业务来说是不能接受的这时需要反馈上游生产者降低调用量。
RxJava与Reactor显然更加强大它们提供了更多的函数调用方式支持更多特性但同时也带来了更大的学习成本。而我们本次整合最需要的特性就是“异步”、“可组合”综合考虑后我们选择了学习成本相对较低的CompletableFuture。
三.CompletableFuture使用与原理
1.背景和定义
CompletableFuture是由Java 8引入的在Java8之前我们一般通过Future实现异步。 Future用于表示异步计算的结果只能通过阻塞或者轮询的方式获取结果而且不支持设置回调方法Java 8之前若要设置回调一般会使用guava的ListenableFuture回调的引入又会导致臭名昭著的回调地狱下面的例子会通过ListenableFuture的使用来具体进行展示。 CompletableFuture对Future进行了扩展可以通过设置回调的方式处理计算结果同时也支持组合操作支持进一步的编排同时一定程度解决了回调地狱的问题。
下面将举例来说明我们通过ListenableFuture、CompletableFuture来实现异步的差异。假设有三个操作step1、step2、step3存在依赖关系其中step3的执行依赖step1和step2的结果。
Future(ListenableFuture)的实现回调地狱如下 public static void main(String[] args) {//创建线程池ExecutorService executor Executors.newFixedThreadPool(5);//转换为支持异步回调的ListeningExecutorServiceListeningExecutorService guavaExecutor MoreExecutors.listeningDecorator(executor);//提交两个异步任务ListenableFutureString future1 guavaExecutor.submit(() - {//step 1System.out.println(执行step 1);return step1 result;});ListenableFutureString future2 guavaExecutor.submit(() - {//step 2System.out.println(执行step 2);return step2 result;});//使用 Futures.allAsList(future1, future2) 方法将 future1 和 future2 这两个异步任务组合起来形成一个新的 ListenableFuture 对象 future1And2表示它们都执行完毕后返回一个结果列表。ListenableFutureListString future1And2 Futures.allAsList(future1, future2);//使用 Futures.addCallback(future1And2, new FutureCallbackListString()) 方法为 future1And2 注册一个回调函数当 future1And2 执行成功后自动调用该回调函数执行 step 3 的操作。Futures.addCallback(future1And2, new FutureCallbackListString() {Overridepublic void onSuccess(ListString result) {System.out.println(result);//在回调函数中使用 guavaExecutor.submit() 方法提交一个新的异步任务 future3执行 step 3 的操作并返回其执行结果。ListenableFutureString future3 guavaExecutor.submit(() - {System.out.println(执行step 3);return step3 result;});//使用 Futures.addCallback(future3, new FutureCallbackString()) 方法为 future3 注册一个回调函数当 future3 执行成功后自动调用该回调函数在该回调函数中输出 step3 result。Futures.addCallback(future3, new FutureCallbackString() {Overridepublic void onSuccess(String result) {System.out.println(result);}Overridepublic void onFailure(Throwable t) {}}, guavaExecutor);}Overridepublic void onFailure(Throwable t) {}}, guavaExecutor);}CompletableFuture的实现如下 public static void main(String[] args) {ExecutorService executor Executors.newFixedThreadPool(5);//CompletableFuture.supplyAsync()方法创建了两个异步任务cf1和cf2//cf1任务使用了线程池executor来执行它会打印一行输出并返回一个字符串。cf2任务没有指定线程池所以会使用默认的ForkJoinPool来执行它也会打印一行输出并返回一个字符串CompletableFutureString cf1 CompletableFuture.supplyAsync(() - {System.out.println(执行step 1);return step1 result;}, executor);CompletableFutureString cf2 CompletableFuture.supplyAsync(() - {System.out.println(执行step 2);return step2 result;});//使用cf1的thenCombine()方法将cf1和cf2合并为一个新的CompletableFuture并指定一个BiFunction作为合并函数这个函数会将cf1和cf2的结果合并为一个字符串并再打印一行输出。在这个合并操作完成后继续使用CompletableFuture.thenAccept()方法来消费结果打印出最终结果。cf1.thenCombine(cf2, (result1, result2) - {System.out.println(result1 , result2);System.out.println(执行step 3);return step3 result;}).thenAccept(result3 - System.out.println(result3));}CompletableFuture实现了两个接口如上图所示Future、CompletionStage。Future表示异步计算的结果CompletionStage用于表示异步执行过程中的一个步骤Stage这个步骤可能是由另外一个CompletionStage触发的随着当前步骤的完成也可能会触发其他一系列CompletionStage的执行。从而我们可以根据实际业务对这些步骤进行多样化的编排组合CompletionStage接口正是定义了这样的能力我们可以通过其提供的thenAppy、thenCompose等函数式编程方法来组合编排这些步骤。
2.常用方法 supplyAsync supplyAsync是创建带有返回值的异步任务。它有如下两个方法一个是使用默认线程池ForkJoinPool.commonPool()的方法一个是带有自定义线程池的重载方法
//supplyAsync 默认线程池public static void main(String[] args) throws ExecutionException, InterruptedException {CompletableFutureString cf CompletableFuture.supplyAsync(() - {System.out.println(hello test supplyAsync 默认线程池);return result;});//等待子任务执行完成System.out.println(结果-》cf.get());}//supplyAsync 自定义线程池public static void main(String[] args) throws ExecutionException, InterruptedException {//自定义线程池ExecutorService executor Executors.newFixedThreadPool(5);CompletableFutureString cf CompletableFuture.supplyAsync(() - {System.out.println(hello test supplyAsync 自定义线程池);return result;}, executor);//等待子任务执行完成System.out.println(结果-》cf.get());}runAsync runAsync是创建没有返回值的异步任务。它有如下两个方法一个是使用默认线程池ForkJoinPool.commonPool()的方法一个是带有自定义线程池的重载方法 //runAsync 默认线程池public static void main(String[] args) throws ExecutionException, InterruptedException {CompletableFutureVoid cf CompletableFuture.runAsync(() - {System.out.println(do something.... runAsync 默认线程池);});//等待任务执行完成System.out.println(结果- cf.get());}//runAsync 自定义线程池public static void main(String[] args) throws ExecutionException, InterruptedException {ExecutorService executorService Executors.newSingleThreadExecutor();CompletableFutureVoid cf CompletableFuture.runAsync(() - {System.out.println(do something...runAsync 自定义线程池);}, executorService);//等待任务执行完成System.out.println(结果- cf.get());}获取任务结果的方法
// 如果完成则返回结果否则就抛出具体的异常
public T get() throws InterruptedException, ExecutionException // 最大时间等待返回结果否则就抛出具体异常
public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException// 完成时返回结果值否则抛出unchecked异常。为了更好地符合通用函数形式的使用如果完成此 CompletableFuture所涉及的计算引发异常则此方法将引发unchecked异常并将底层异常作为其原因
// 调用 join() 方法时它会阻塞当前线程直到关联的 CompletableFuture 完成并返回结果。如果任务已经完成join() 方法会立即返回结果如果任务尚未完成它会一直等待直到任务完成。与之相反get() 方法也会等待任务完成并返回结果但它会抛出 InterruptedException 和 ExecutionException 异常而 join() 方法则不会抛出任何受检异常。
//这使得 join() 方法更适合在 Lambda 表达式或流式操作中使用因为它不需要显式处理异常或声明 throws 子句。
public T join()// 如果完成则返回结果值或抛出任何遇到的异常否则返回给定的 valueIfAbsent。
//获取异步任务的结果如果任务已经完成则返回结果如果任务尚未完成则返回一个默认值 valueIfAbsent。这个方法不会等待任务的完成而是立即返回结果或默认值。
public T getNow(T valueIfAbsent)// 如果任务没有完成返回的值设置为给定值
public boolean complete(T value)// 如果任务没有完成就抛出给定异常
public boolean completeExceptionally(Throwable ex)
get() //get()方法设置超时时间public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {//自定义线程池ExecutorService executor Executors.newFixedThreadPool(5);CompletableFutureString cf CompletableFuture.supplyAsync(() - {System.out.println(hello test get()方法设置超时时间);try {Thread.sleep(20000);} catch (InterruptedException e) {e.printStackTrace();}return result;}, executor);//等待子任务执行完成System.out.println(结果-》cf.get(10, TimeUnit.SECONDS));}join() //join()方法public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {//自定义线程池ExecutorService executor Executors.newFixedThreadPool(5);CompletableFutureString cf CompletableFuture.supplyAsync(() - {System.out.println(hello test join());try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}return result;}, executor);System.out.println(cf.join());}getNow() //getNow()方法public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {//自定义线程池ExecutorService executor Executors.newFixedThreadPool(5);CompletableFutureString cf CompletableFuture.supplyAsync(() - {System.out.println(hello test getNow());try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}return result;}, executor);System.out.println(cf.getNow(完不成啦。。。。。));}//getNow()方法public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {//自定义线程池ExecutorService executor Executors.newFixedThreadPool(5);CompletableFutureString cf CompletableFuture.supplyAsync(() - {System.out.println(hello test getNow());return result;}, executor);Thread.sleep(100);System.out.println(cf.getNow(完不成啦。。。。。));}complete() public static void main(String[] args) {CompletableFutureString future new CompletableFuture();// 在另一个线程中手动完成 CompletableFuturenew Thread(() - {try {Thread.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}future.complete(Hello, World!);}).start();// 等待 CompletableFuture 完成并获取结果System.out.println(future.join());}thenApply()和thenApplyAsync() thenApply 表示某个任务执行完成后执行的动作即回调方法会将该任务的执行结果即方法返回值作为入参传递到回调方法中带有返回值。 public static void main(String[] args) throws ExecutionException, InterruptedException {ExecutorService executor Executors.newFixedThreadPool(5);CompletableFutureInteger cf1 CompletableFuture.supplyAsync(() - {System.out.println(Thread.currentThread().getName() cf1 do something....);return 1;});CompletableFutureInteger cf2 cf1.thenApplyAsync((result) - {System.out.println(Thread.currentThread().getName() cf2 do something....);result 2;try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}return result;});//等待任务1执行完成System.out.println(cf1结果- cf1.get());//等待任务2执行完成System.out.println(cf2结果- cf2.get());}既然调用thenApplyAsync()不应该是在不同的线程去执行吗 那输出的线程名称为什么都是ForkJoinPool.commonPool-worker-1呢 使用自定义线程池
public static void main(String[] args) throws ExecutionException, InterruptedException {ExecutorService executor Executors.newFixedThreadPool(5);CompletableFutureInteger cf1 CompletableFuture.supplyAsync(() - {System.out.println(Thread.currentThread().getName() cf1 do something....);return 1;},executor);CompletableFutureInteger cf2 cf1.thenApplyAsync((result) - {System.out.println(Thread.currentThread().getName() cf2 do something....);result 2;try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}return result;},executor);//等待任务1执行完成System.out.println(cf1结果- cf1.get());//等待任务2执行完成System.out.println(cf2结果- cf2.get());}thenAccept和thenAcceptAsync thenAccept() public static void main(String[] args) throws ExecutionException, InterruptedException {CompletableFutureInteger cf1 CompletableFuture.supplyAsync(() - {System.out.println(Thread.currentThread().getName() cf1 do something....);return 1;});CompletableFutureVoid cf2 cf1.thenAccept((result) - {System.out.println(Thread.currentThread().getName() cf1 返回resultresult cf2 do something....);});//等待任务1执行完成System.out.println(cf1结果- cf1.get());//等待任务2执行完成System.out.println(cf2结果- cf2.get());}thenAcceptAsync()
public static void main(String[] args) throws ExecutionException, InterruptedException {CompletableFutureInteger cf1 CompletableFuture.supplyAsync(() - {System.out.println(Thread.currentThread().getName() cf1 do something....);return 1;});CompletableFutureVoid cf2 cf1.thenAcceptAsync((result) - {System.out.println(Thread.currentThread().getName() cf1 返回resultresult cf2 do something....);});//等待任务1执行完成System.out.println(cf1结果- cf1.get());//等待任务2执行完成System.out.println(cf2结果- cf2.get());
}调用thenAcceptAsync()方法了为什么线程名称都为ForkJoinPool.commonPool-worker-1
thenRun和thenRunAsync thenRun()
public static void main(String[] args) throws ExecutionException, InterruptedException {CompletableFutureInteger cf1 CompletableFuture.supplyAsync(() - {System.out.println(Thread.currentThread().getName() cf1 do something....);return 1;});CompletableFutureVoid cf2 cf1.thenRun(() - {System.out.println(Thread.currentThread().getName() cf2 do something....);});//等待任务1执行完成System.out.println(cf1结果- cf1.get());//等待任务2执行完成System.out.println(cf2结果- cf2.get());}thenRunAsync() public static void main(String[] args) throws ExecutionException, InterruptedException {ExecutorService executor Executors.newFixedThreadPool(5);CompletableFutureInteger cf1 CompletableFuture.supplyAsync(() - {System.out.println(Thread.currentThread().getName() cf1 do something....);return 1;},executor);CompletableFutureVoid cf2 cf1.thenRunAsync(() - {System.out.println(Thread.currentThread().getName() cf2 do something....);},executor);//等待任务1执行完成System.out.println(cf1结果- cf1.get());//等待任务2执行完成System.out.println(cf2结果- cf2.get());}whenComplete和whenCompleteAsync
whenComplete() public static void main(String[] args) throws ExecutionException, InterruptedException {ExecutorService executor Executors.newFixedThreadPool(5);CompletableFutureInteger cf1 CompletableFuture.supplyAsync(() - {System.out.println(Thread.currentThread().getName() cf1 do something....);int a 1/0;return 1;},executor);CompletableFutureInteger cf2 cf1.whenComplete((result, e) - {try {Thread.sleep(1000);} catch (InterruptedException ex) {ex.printStackTrace();}System.out.println(上个任务结果 result);System.out.println(上个任务抛出异常 e);System.out.println(Thread.currentThread().getName() cf2 do something....);});// //等待任务1执行完成System.out.println(cf1结果- cf1.get());
// //等待任务2执行完成System.out.println(cf2结果- cf2.get());}whenCompleteAsync() public static void main(String[] args) throws ExecutionException, InterruptedException {ExecutorService executor Executors.newFixedThreadPool(5);CompletableFutureInteger cf1 CompletableFuture.supplyAsync(() - {System.out.println(Thread.currentThread().getName() cf1 do something....);int a 1/0;return 1;},executor);CompletableFutureInteger cf2 cf1.whenCompleteAsync((result, e) - {try {Thread.sleep(1000);} catch (InterruptedException ex) {ex.printStackTrace();}System.out.println(上个任务结果 result);System.out.println(上个任务抛出异常 e);System.out.println(Thread.currentThread().getName() cf2 do something....);},executor);// //等待任务1执行完成System.out.println(cf1结果- cf1.get());
// //等待任务2执行完成System.out.println(cf2结果- cf2.get());}handle和handleAsync 跟whenComplete基本一致区别在于handle的回调方法有返回值。
public static void main(String[] args) throws ExecutionException, InterruptedException {CompletableFutureInteger cf1 CompletableFuture.supplyAsync(() - {System.out.println(Thread.currentThread().getName() cf1 do something....);// int a 1/0;return 1;});CompletableFutureInteger cf2 cf1.handle((result, e) - {System.out.println(Thread.currentThread().getName() cf2 do something....);System.out.println(上个任务结果 result);System.out.println(上个任务抛出异常 e);return result2;});//等待任务2执行完成System.out.println(cf2结果- cf2.get());
}thenCombine、thenAcceptBoth 和runAfterBoth
这三个方法都是将两个CompletableFuture组合起来处理只有两个任务都正常完成时才进行下阶段任务。
区别thenCombine会将两个任务的执行结果作为所提供函数的参数且该方法有返回值thenAcceptBoth同样将两个任务的执行结果作为方法入参但是无返回值runAfterBoth没有入参也没有返回值。注意两个任务中只要有一个执行异常则将该异常信息作为指定任务的执行结果。
thenCombine public static void main(String[] args) throws ExecutionException, InterruptedException {ExecutorService executor Executors.newFixedThreadPool(5);CompletableFutureInteger cf1 CompletableFuture.supplyAsync(() - {System.out.println(Thread.currentThread().getName() cf1 do something....);return 1;},executor);CompletableFutureInteger cf2 CompletableFuture.supplyAsync(() - {System.out.println(Thread.currentThread().getName() cf2 do something....);try {Thread.sleep(10000);} catch (InterruptedException e) {e.printStackTrace();}return 2;},executor);CompletableFutureInteger cf3 cf1.thenCombine(cf2, (a, b) - {System.out.println(Thread.currentThread().getName() cf3 do something....);return a b;});System.out.println(cf1结果- cf1.get());System.out.println(cf2结果- cf2.get());System.out.println(cf3结果- cf3.get());}thenAcceptBoth() public static void main(String[] args) throws ExecutionException, InterruptedException {ExecutorService executor Executors.newFixedThreadPool(5);CompletableFutureInteger cf1 CompletableFuture.supplyAsync(() - {System.out.println(Thread.currentThread().getName() cf1 do something....);return 1;},executor);CompletableFutureInteger cf2 CompletableFuture.supplyAsync(() - {System.out.println(Thread.currentThread().getName() cf2 do something....);try {Thread.sleep(10000);} catch (InterruptedException e) {e.printStackTrace();}return 2;},executor);CompletableFutureVoid cf3 cf1.thenAcceptBoth(cf2, (a, b) - {System.out.println(Thread.currentThread().getName() cf3 do something....);System.out.println(a b);});System.out.println(cf1结果- cf1.get());System.out.println(cf2结果- cf2.get());System.out.println(cf3结果- cf3.get());}public static void main(String[] args) throws ExecutionException, InterruptedException {ExecutorService executor Executors.newFixedThreadPool(5);CompletableFutureInteger cf1 CompletableFuture.supplyAsync(() - {System.out.println(Thread.currentThread().getName() cf1 do something....);//int i 1/0;return 1;},executor);CompletableFutureInteger cf2 CompletableFuture.supplyAsync(() - {System.out.println(Thread.currentThread().getName() cf2 do something....);
// try {
// Thread.sleep(10000);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }return 2;},executor);CompletableFutureVoid cf3 cf1.runAfterBoth(cf2, () - {System.out.println(Thread.currentThread().getName() cf3 do something....);});System.out.println(Thread.currentThread().getName() cf1结果- cf1.get());System.out.println(Thread.currentThread().getName() cf2结果- cf2.get());System.out.println(Thread.currentThread().getName() cf3结果- cf3.get());}applyToEither、acceptEither和runAfterEither 这三个方法和上面一样也是将两个CompletableFuture组合起来处理当有一个任务正常完成时就会进行下阶段任务。 区别applyToEither会将已经完成任务的执行结果作为所提供函数的参数且该方法有返回值acceptEither同样将已经完成任务的执行结果作为方法入参但是无返回值runAfterEither没有入参也没有返回值。
applyToEither() public static void main(String[] args) throws ExecutionException, InterruptedException {ExecutorService executor Executors.newFixedThreadPool(5);CompletableFutureString cf1 CompletableFuture.supplyAsync(() - {try {System.out.println(Thread.currentThread().getName() cf1 do something....);Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}return cf1 任务完成;},executor);CompletableFutureString cf2 CompletableFuture.supplyAsync(() - {try {Thread.sleep(10000);System.out.println(Thread.currentThread().getName() cf2 do something....);} catch (InterruptedException e) {e.printStackTrace();}return cf2 任务完成;},executor);CompletableFutureString cf3 cf1.applyToEither(cf2, (result) - {System.out.println(Thread.currentThread().getName() cf3 do something....);System.out.println(接收到 result);return cf3 任务完成;});System.out.println(Thread.currentThread().getName() cf1结果- cf1.get());System.out.println(Thread.currentThread().getName() cf2结果- cf2.get());System.out.println(Thread.currentThread().getName() cf3结果- cf3.get());}acceptEither() public static void main(String[] args) throws ExecutionException, InterruptedException {ExecutorService executor Executors.newFixedThreadPool(5);CompletableFutureString cf1 CompletableFuture.supplyAsync(() - {try {System.out.println(Thread.currentThread().getName() cf1 do something....);Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}return cf1 任务完成;},executor);CompletableFutureString cf2 CompletableFuture.supplyAsync(() - {try {Thread.sleep(10000);System.out.println(Thread.currentThread().getName() cf2 do something....);} catch (InterruptedException e) {e.printStackTrace();}return cf2 任务完成;},executor);CompletableFutureVoid cf3 cf1.acceptEither(cf2, (result) - {System.out.println(接收到 result);System.out.println(Thread.currentThread().getName() cf3 do something....);});System.out.println(Thread.currentThread().getName() cf3结果- cf3.get());}runAfterEither()
public static void main(String[] args) throws ExecutionException, InterruptedException {ExecutorService executor Executors.newFixedThreadPool(5);CompletableFutureString cf1 CompletableFuture.supplyAsync(() - {try {System.out.println(Thread.currentThread().getName() cf1 do something....);Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(cf1 任务完成);return cf1 任务完成;},executor);CompletableFutureString cf2 CompletableFuture.supplyAsync(() - {try {Thread.sleep(10000);System.out.println(Thread.currentThread().getName() cf2 do something....);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(cf2 任务完成);return cf2 任务完成;},executor);CompletableFutureVoid cf3 cf1.runAfterEither(cf2, () - {System.out.println(Thread.currentThread().getName() cf3 do something....);System.out.println(cf3 任务完成);});System.out.println(cf3结果- cf3.get());}allOf / anyOf allOfCompletableFuture是多个任务都执行完成后才会执行只有有一个任务执行异常则返回的CompletableFuture执行get方法时会抛出异常如果都是正常执行则get返回null。 anyOf CompletableFuture是多个任务只要有一个任务执行完成则返回的CompletableFuture执行get方法时会抛出异常如果都是正常执行则get返回执行完成任务的结果。
allOf() public static void main(String[] args) throws ExecutionException, InterruptedException {ExecutorService executor Executors.newFixedThreadPool(5);CompletableFutureString cf1 CompletableFuture.supplyAsync(() - {try {System.out.println(Thread.currentThread().getName() cf1 do something....);Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(cf1 任务完成);return cf1 任务完成;},executor);CompletableFutureString cf2 CompletableFuture.supplyAsync(() - {try {System.out.println(Thread.currentThread().getName() cf2 do something....);int a 1/0;Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(cf2 任务完成);return cf2 任务完成;},executor);CompletableFutureString cf3 CompletableFuture.supplyAsync(() - {try {Thread.sleep(30000);System.out.println(Thread.currentThread().getName() cf3 do something....);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(cf3 任务完成);return cf3 任务完成;},executor);CompletableFutureVoid cfAll CompletableFuture.allOf(cf1, cf2, cf3);System.out.println(Thread.currentThread().getName() cf1结果- cf1.get());System.out.println(Thread.currentThread().getName() cf2结果- cf2.get());System.out.println(Thread.currentThread().getName() cf3结果- cf3.get());System.out.println(cfAll结果- cfAll.get());}anyOf() public static void main(String[] args) throws ExecutionException, InterruptedException {ExecutorService executor Executors.newFixedThreadPool(5);CompletableFutureString cf1 CompletableFuture.supplyAsync(() - {System.out.println(Thread.currentThread().getName() cf1 do something....);return cf1 任务完成;},executor);CompletableFutureString cf2 CompletableFuture.supplyAsync(() - {try {System.out.println(Thread.currentThread().getName() cf2 do something....);Thread.sleep(50000);} catch (InterruptedException e) {e.printStackTrace();}return cf2 任务完成;},executor);CompletableFutureString cf3 CompletableFuture.supplyAsync(() - {try {System.out.println(Thread.currentThread().getName() cf3 do something....);Thread.sleep(30000);} catch (InterruptedException e) {e.printStackTrace();}return cf3 任务完成;},executor);CompletableFutureObject cfAll CompletableFuture.anyOf(cf1, cf2, cf3);System.out.println(Thread.currentThread().getName() cf1结果- cf1.get());System.out.println(Thread.currentThread().getName() cf2结果- cf2.get());System.out.println(Thread.currentThread().getName() cf3结果- cf3.get());System.out.println(cfAll结果- cfAll.get());}3.CompletableFuture的使用
下面我们通过一个例子来讲解CompletableFuture如何使用使用CompletableFuture也是构建依赖树的过程。一个CompletableFuture的完成会触发另外一系列依赖它的CompletableFuture的执行 如上图所示这里描绘的是一个业务接口的流程其中包括CF1\CF2\CF3\CF4\CF5共5个步骤并描绘了这些步骤之间的依赖关系每个步骤可以是一次RPC调用、一次数据库操作或者是一次本地方法调用等在使用CompletableFuture进行异步化编程时图中的每个步骤都会产生一个CompletableFuture对象最终结果也会用一个CompletableFuture来进行表示。 根据CompletableFuture依赖数量可以分为以下几类零依赖、一元依赖、二元依赖和多元依赖。
零依赖CompletableFuture的创建 我们先看下如何不依赖其他CompletableFuture来创建新的CompletableFuture 如上图红色链路所示接口接收到请求后首先发起两个异步调用CF1、CF2主要有三种方式
ExecutorService executor Executors.newFixedThreadPool(5);
//1、使用runAsync或supplyAsync发起异步调用
CompletableFutureString cf1 CompletableFuture.supplyAsync(() - {return result1;
}, executor);//2、CompletableFuture.completedFuture()直接创建一个已完成状态的CompletableFuture
CompletableFutureString cf2 CompletableFuture.completedFuture(result2);//3、先初始化一个未完成的CompletableFuture然后通过complete()、completeExceptionally()完成该CompletableFuture
CompletableFutureString cf new CompletableFuture();
cf.complete(success);第三种方式的一个典型使用场景就是将回调方法转为CompletableFuture然后再依赖CompletableFure的能力进行调用编排示例如下:
FunctionalInterface
public interface ThriftAsyncCall {void invoke() throws TException;
}/*** 该方法为美团内部rpc注册监听的封装可以作为其他实现的参照* OctoThriftCallback 为thrift回调方法* ThriftAsyncCall 为自定义函数用来表示一次thrift调用定义如上*/public static T CompletableFutureT toCompletableFuture(final OctoThriftCallback?,T callback , ThriftAsyncCall thriftCall) {//新建一个未完成的CompletableFutureCompletableFutureT resultFuture new CompletableFuture();//监听回调的完成并且与CompletableFuture同步状态callback.addObserver(new OctoObserverT() {Overridepublic void onSuccess(T t) {resultFuture.complete(t);}Overridepublic void onFailure(Throwable throwable) {resultFuture.completeExceptionally(throwable);}});if (thriftCall ! null) {try {thriftCall.invoke();} catch (TException e) {resultFuture.completeExceptionally(e);}}return resultFuture;}一元依赖依赖一个CF 如上图红色链路所示CF3CF5分别依赖于CF1和CF2这种对于单个CompletableFuture的依赖可以通过thenApply、thenAccept、thenCompose等方法来实现代码如下所示
CompletableFutureString cf3 cf1.thenApply(result1 - {//result1为CF1的结果//......return result3;
});
CompletableFutureString cf5 cf2.thenApply(result2 - {//result2为CF2的结果//......return result5;
});二元依赖依赖两个CF 如上图红色链路所示CF4同时依赖于两个CF1和CF2这种二元依赖可以通过thenCombine等回调来实现如下代码所示
CompletableFutureString cf4 cf1.thenCombine(cf2, (result1, result2) - {//result1和result2分别为cf1和cf2的结果return result4;
});多元依赖依赖多个CF 如上图红色链路所示整个流程的结束依赖于三个步骤CF3、CF4、CF5这种多元依赖可以通过allOf或anyOf方法来实现区别是当需要多个依赖全部完成时使用allOf当多个依赖中的任意一个完成即可时使用anyOf如下代码所示
CompletableFutureVoid cf6 CompletableFuture.allOf(cf3, cf4, cf5);
CompletableFutureString result cf6.thenApply(v - {//这里的join并不会阻塞因为传给thenApply的函数是在CF3、CF4、CF5全部完成时才会执行 。result3 cf3.join();result4 cf4.join();result5 cf5.join();//根据result3、result4、result5组装最终result;return result;
});3.CompletableFuture原理
CompletableFuture中包含两个字段result和stack。result用于存储当前CF的结果stackCompletion表示当前CF完成后需要触发的依赖动作Dependency Actions去触发依赖它的CF的计算依赖动作可以有多个表示有多个依赖它的CF以栈Treiber stack的形式存储stack表示栈顶元素。 这种方式类似“观察者模式”依赖动作Dependency Action都封装在一个单独Completion子类中。下面是Completion类关系结构图。CompletableFuture中的每个方法都对应了图中的一个Completion的子类Completion本身是观察者的基类。
UniCompletion继承了Completion是一元依赖的基类例如thenApply的实现类UniApply就继承自UniCompletion。BiCompletion继承了UniCompletion是二元依赖的基类同时也是多元依赖的基类。例如thenCombine的实现类BiRelay就继承自BiCompletion。
CompletableFuture的设计思想 按照类似“观察者模式”的设计思想原理分析可以从“观察者”和“被观察者”两个方面着手。由于回调种类多但结构差异不大所以这里单以一元依赖中的thenApply为例不再枚举全部回调类型。如下图所示 被观察者
每个CompletableFuture都可以被看作一个被观察者其内部有一个Completion类型的链表成员变量stack用来存储注册到其中的所有观察者。当被观察者执行完成后会弹栈stack属性依次通知注册到其中的观察者。上面例子中步骤fn2就是作为观察者被封装在UniApply中。
被观察者CF中的result属性用来存储返回结果数据。这里可能是一次RPC调用的返回值也可能是任意对象在上面的例子中对应步骤fn1的执行结果。
观察者
CompletableFuture支持很多回调方法例如thenAccept、thenApply、exceptionally等这些方法接收一个函数类型的参数f生成一个Completion类型的对象即观察者并将入参函数f赋值给Completion的成员变量fn然后检查当前CF是否已处于完成状态即result ! null如果已完成直接触发fn否则将观察者Completion加入到CF的观察者链stack中再次尝试触发如果被观察者未执行完则其执行完毕之后通知触发。
1.观察者中的dep属性指向其对应的CompletableFuture在上面的例子中dep指向CF2。 2.观察者中的src属性指向其依赖的CompletableFuture在上面的例子中src指向CF1。 3.观察者Completion中的fn属性用来存储具体的等待被回调的函数。这里需要注意的是不同的回调方法thenAccept、thenApply、exceptionally等接收的函数类型也不同即fn的类型有很多种在上面的例子中fn指向fn2。
整体流程
一元依赖
这里仍然以thenApply为例来说明一元依赖的流程 1.将观察者Completion注册到CF1此时CF1将Completion压栈。 2.当CF1的操作运行完成时会将结果赋值给CF1中的result属性。 3.依次弹栈通知观察者尝试运行。 初步流程设计如上图所示这里有几个关于注册与通知的并发问题大家可以思考下 Q1在观察者注册之前如果CF已经执行完成并且已经发出通知那么这时观察者由于错过了通知是不是将永远不会被触发呢 A1不会。在注册时检查依赖的CF是否已经完成。如果未完成即result null则将观察者入栈如果已完成result ! null则直接触发观察者操作。 Q2在”入栈“前会有”result null“的判断这两个操作为非原子操作CompletableFufure的实现也没有对两个操作进行加锁完成时间在这两个操作之间观察者仍然得不到通知是不是仍然无法触发 A3CompletableFuture的实现是这样解决该问题的观察者在执行之前会先通过CAS操作设置一个状态位将status由0改为1。如果观察者已经执行过了那么CAS操作将会失败取消执行。 通过对以上3个问题的分析可以看出CompletableFuture在处理并行问题时全程无加锁操作极大地提高了程序的执行效率。我们将并行问题考虑纳入之后可以得到完善的整体流程图如下所示 CompletableFuture支持的回调方法十分丰富但是正如上一章节的整体流程图所述他们的整体流程是一致的。所有回调复用同一套流程架构不同的回调监听通过策略模式实现差异化。
二元依赖 我们以thenCombine为例来说明二元依赖 thenCombine操作表示依赖两个CompletableFuture。其观察者实现类为BiApply如上图所示BiApply通过src和snd两个属性关联被依赖的两个CFfn属性的类型为BiFunction。与单个依赖不同的是在依赖的CF未完成的情况下thenCombine会尝试将BiApply压入这两个被依赖的CF的栈中每个被依赖的CF完成时都会尝试触发观察者BiApplyBiApply会检查两个依赖是否都完成如果完成则开始执行。这里为了解决重复触发的问题同样用的是上一章节提到的CAS操作执行时会先通过CAS设置状态位避免重复触发。
多元依赖 依赖多个CompletableFuture的回调方法包括allOf、anyOf区别在于allOf观察者实现类为BiRelay需要所有被依赖的CF完成后才会执行回调而anyOf观察者实现类为OrRelay任意一个被依赖的CF完成后就会触发。二者的实现方式都是将多个被依赖的CF构建成一棵平衡二叉树执行结果层层通知直到根节点触发回调监听。
4.实践总结
本章节为CompletableFuture实现原理的科普旨在尝试不粘贴源码而通过结构图、流程图以及搭配文字描述把CompletableFuture的实现原理讲述清楚。把晦涩的源码翻译为“整体流程”章节的流程图并且将并发处理的逻辑融入便于大家理解。
在商家端API异步化的过程中我们遇到了一些问题这些问题有的会比较隐蔽下面把这些问题的处理经验整理出来。希望能帮助到更多的同学大家可以少踩一些坑。
线程阻塞问题
代码执行在哪个线程上
要合理治理线程资源最基本的前提条件就是要在写代码时清楚地知道每一行代码都将执行在哪个线程上。下面我们看一下CompletableFuture的执行线程情况。 CompletableFuture实现了CompletionStage接口通过丰富的回调方法支持各种组合操作每种组合场景都有同步和异步两种方法。
同步方法即不带Async后缀的方法有两种情况。
如果注册时被依赖的操作已经执行完成则直接由当前线程执行。如果注册时被依赖的操作还未执行完则由回调线程执行。
异步方法即带Async后缀的方法可以选择是否传递线程池参数Executor运行在指定线程池中当不传递Executor时会使用ForkJoinPool中的共用线程池CommonPoolCommonPool的大小是CPU核数-1如果是IO密集的应用线程数可能成为瓶颈。
ExecutorService threadPool1 new ThreadPoolExecutor(10, 10, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue(100));
CompletableFutureString future1 CompletableFuture.supplyAsync(() - {System.out.println(supplyAsync 执行线程 Thread.currentThread().getName());//业务操作return ;
}, threadPool1);
//此时如果future1中的业务操作已经执行完毕并返回则该thenApply直接由当前main线程执行否则将会由执行以上业务操作的threadPool1中的线程执行。
future1.thenApply(value - {System.out.println(thenApply 执行线程 Thread.currentThread().getName());return value 1;
});
//使用ForkJoinPool中的共用线程池CommonPool
future1.thenApplyAsync(value - {
//do somethingreturn value 1;
});
//使用指定线程池
future1.thenApplyAsync(value - {
//do somethingreturn value 1;
}, threadPool1);线程池须知
异步回调要传线程池
前面提到异步回调方法可以选择是否传递线程池参数Executor这里我们建议强制传线程池且根据实际情况做线程池隔离。 当不传递线程池时会使用ForkJoinPool中的公共线程池CommonPool这里所有调用将共用该线程池核心线程数处理器数量-1单核核心线程数为1所有异步回调都会共用该CommonPool核心与非核心业务都竞争同一个池中的线程很容易成为系统瓶颈。手动传递线程池参数可以更方便的调节参数并且可以给不同的业务分配不同的线程池以求资源隔离减少不同业务之间的相互干扰。
线程池循环引用会导致死锁
public Object doGet() {ExecutorService threadPool1 new ThreadPoolExecutor(10, 10, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue(100));CompletableFuture cf1 CompletableFuture.supplyAsync(() - {//do sthreturn CompletableFuture.supplyAsync(() - {System.out.println(child);return child;}, threadPool1).join();//子任务}, threadPool1);return cf1.join();
}如上代码块所示doGet方法第三行通过supplyAsync向threadPool1请求线程并且内部子任务又向threadPool1请求线程。threadPool1大小为10当同一时刻有10个请求到达则threadPool1被打满子任务请求线程时进入阻塞队列排队但是父任务的完成又依赖于子任务这时由于子任务得不到线程父任务无法完成。主线程执行cf1.join()进入阻塞状态并且永远无法恢复。 为了修复该问题需要将父任务与子任务做线程池隔离两个任务请求不同的线程池避免循环依赖导致的阻塞。
异步RPC调用注意不要阻塞IO线程池
服务异步化后很多步骤都会依赖于异步RPC调用的结果这时需要特别注意一点如果是使用基于NIO比如Netty的异步RPC则返回结果是由IO线程负责设置的即回调方法由IO线程触发CompletableFuture同步回调如thenApply、thenAccept等无Async后缀的方法如果依赖的异步RPC调用的返回结果那么这些同步回调将运行在IO线程上而整个服务只有一个IO线程池这时需要保证同步回调中不能有阻塞等耗时过长的逻辑否则在这些逻辑执行完成前IO线程将一直被占用影响整个服务的响应。
EG:
public class ServiceExample {private RemoteRpcService rpcService;public void process() {CompletableFutureString future rpcService.getDataAsync();future.thenApply(data - {// 在这里进行数据处理可能包含一些耗时操作String processedData processData(data);return processedData;}).thenAccept(processedData - {// 在这里进行处理后的数据的后续操作doSomething(processedData);});}private String processData(String data) {// 进行数据处理可能是一些耗时操作return Processed data;}private void doSomething(String processedData) {// 处理后续操作System.out.println(Processed data: processedData);}
}在上面的代码中process()方法调用了rpcService.getDataAsync()来获取远程RPC服务的数据然后使用thenApply()和thenAccept()方法对数据进行处理和后续操作。
然而如果processData()方法中包含了一个耗时长的操作例如执行一个复杂的计算或者访问一个慢速的外部资源那么这个同步回调将会在IO线程上执行阻塞IO线程的执行。这将导致整个服务的响应性能下降因为IO线程无法及时处理其他请求。为了解决这个问题可以将耗时长的操作放到单独的线程池中执行以释放IO线程。
异常处理
由于异步执行的任务在其他线程上执行而异常信息存储在线程栈中因此当前线程除非阻塞等待返回结果否则无法通过try\catch捕获异常。CompletableFuture提供了异常捕获回调exceptionally相当于同步调用中的try\catch。使用方法如下所示
Autowired
private WmOrderAdditionInfoThriftService wmOrderAdditionInfoThriftService;//内部接口
public CompletableFutureInteger getCancelTypeAsync(long orderId) {CompletableFutureWmOrderOpRemarkResult remarkResultFuture wmOrderAdditionInfoThriftService.findOrderCancelledRemarkByOrderIdAsync(orderId);//业务方法内部会发起异步rpc调用return remarkResultFuture.exceptionally(err - {//通过exceptionally 捕获异常打印日志并返回默认值log.error(WmOrderRemarkService.getCancelTypeAsync Exception orderId{}, orderId, err);return 0;});
}有一点需要注意CompletableFuture在回调方法中对异常进行了包装。大部分异常会封装成CompletionException后抛出真正的异常存储在cause属性中因此如果调用链中经过了回调方法处理那么就需要用Throwable.getCause()方法提取真正的异常。但是有些情况下会直接返回真正的异常最好使用工具类提取异常如下代码所示
Autowired
private WmOrderAdditionInfoThriftService wmOrderAdditionInfoThriftService;//内部接口
public CompletableFutureInteger getCancelTypeAsync(long orderId) {CompletableFutureWmOrderOpRemarkResult remarkResultFuture wmOrderAdditionInfoThriftService.findOrderCancelledRemarkByOrderIdAsync(orderId);//业务方法内部会发起异步rpc调用return remarkResultFuture.thenApply(result - {//这里增加了一个回调方法thenApply如果发生异常thenApply内部会通过new CompletionException(throwable) 对异常进行包装//这里是一些业务操作}).exceptionally(err - {//通过exceptionally 捕获异常这里的err已经被thenApply包装过因此需要通过Throwable.getCause()提取异常log.error(WmOrderRemarkService.getCancelTypeAsync Exception orderId{}, orderId, ExceptionUtils.extractRealException(err));return 0;});
}上面代码中用到了一个自定义的工具类ExceptionUtils用于CompletableFuture的异常提取在使用CompletableFuture做异步编程时可以直接使用该工具类处理异常。实现代码如下
public class ExceptionUtils {public static Throwable extractRealException(Throwable throwable) {//这里判断异常类型是否为CompletionException、ExecutionException如果是则进行提取否则直接返回。if (throwable instanceof CompletionException || throwable instanceof ExecutionException) {if (throwable.getCause() ! null) {return throwable.getCause();}}return throwable;}
}参考链接 https://mp.weixin.qq.com/s/NXaP1xPL7_At9e-MVad4cQ https://tech.meituan.com/2022/05/12/principles-and-practices-of-completablefuture.html
