CompletableFuture实现多线程异步任务编排实战

最新推荐文章于 2024-04-26 14:57:20 发布
最新推荐文章于 2024-04-26 14:57:20 发布
阅读量506 收藏 3
点赞数 1
文章标签： mybatis java spring boot 开发语言 后端
原文链接：https://mp.weixin.qq.com/s?__biz=MzUxOTc4NjEyMw==&mid=2247553536&idx=2&sn=36a6d32235980d59234c7fe1ff860bde&chksm=f9f609e4ce8180f2a00516db42b40eab1c3d16640c0e6a63237fac7ad778f30e30cd949ce1da&scene=126&sessionid=0
版权

点击上方“Java基基”，选择“设为星标”

做积极的人，而不是积极废人！

每天 14:00 更新文章，每天掉亿点点头发...

源码精品专栏

 

来源：juejin.cn/post/

7140244126679138312

问题背景

问题：当查询接口较复杂时候，数据的获取都需要[远程调用 ]，必然需要花费更多的时间。假如查询文章详情页面，需要如下标注的时间才能完成，比如如下场景：

1. 查询文章详情 0.5s
2. 查询文章博主个人信息 0.5s
3. 查询文章评论 1s
4. 查询博主相关文章分类 1s
5. 相关推荐文章 1s
上面的描述只是举个例子不要在意这里的查询描述，看实际情况使用，有些相关的查询我们可以拆分接口实现，上面的描述只是为了举例子。

那么，用户需要4s后才能统计的数据。很显然是不能接受的。如果有多个线程同时完成这4步操作，也许只需要1s左右即可完成响应。

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序，支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址：https://github.com/YunaiV/ruoyi-vue-pro

  • 视频教程：https://doc.iocoder.cn/video/

CompletableFuture介绍

在Java 8中, 新增加了一个包含50个方法左右的类: CompletableFuture，提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合CompletableFuture的方法。CompletableFuture类实现了Future接口，所以你还是可以像以前一样通过get方法阻塞或者轮询的方式获得结果，但是这种方式不推荐使用。CompletableFuture和FutureTask同属于Future接口的实现类，都可以获取线程的执行结果。

4cc62b7c3c113a254a4370502f050a0e.jpegCompletableFuture介绍

基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 实现的后台管理系统 + 用户小程序，支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址：https://github.com/YunaiV/yudao-cloud

  • 视频教程：https://doc.iocoder.cn/video/

具体场景

我们先从单个任务开始

runAsync：无返回值

/**
 * runAsync无返回值
 */
CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
    System.out.println("当前线程" + Thread.currentThread().getId());
    int i = 10 / 2;
    System.out.println("运行结果：" + i);
}, executor);

supplyAsync：有返回值

「whenComplete：能感知异常，能感知结果，但没办法给返回值 exceptionally：能感知异常，不能感知结果，能给返回值。相当于，如果出现异常就返回这个值」

/**
 * supplyAsync有返回值
 * whenComplete能感知异常，能感知结果，但没办法给返回值
 * exceptionally能感知异常，不能感知结果，能给返回值。相当于，如果出现异常就返回这个值
 */
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("当前线程" + Thread.currentThread().getId());
    int i = 10 / 0;
    System.out.println("运行结果：" + i);
    return i;
}, executor).whenComplete((res,excption)->{
    //whenComplete虽然能得到异常信息，但是没办法修改返回值
    System.out.println("异步任务成功完成...结果是："+res+";异常是："+excption);
}).exceptionally(throwable -> {
    //exceptionally能感知异常，而且能返回一个默认值，相当于，如果出现异常就返回这个值
    return 10;
});

supplyAsync：有返回值

「handle能拿到返回结果，也能得到异常信息，也能修改返回值」

/**
* supplyAsync有返回值
* handle能拿到返回结果，也能得到异常信息，也能修改返回值
*/
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("当前线程" + Thread.currentThread().getId());
    int i = 10 / 4;
    System.out.println("运行结果：" + i);
    return i;
}, executor).handle((res,excption)->{
    if(excption!=null){
        return 0;
    }else {
        return res * 2;
    }
});

两个任务编排

两任务组合（「线程串行化」 ） 可以是两任务的串行化，就是一个任务执行完了再执行下一个 也可以是多个任务的串行化，就是按照顺序一个个的执行

thenRunAsync：不能接收上一次的执行结果，也没返回值

/**
 * thenRunXXX 不能接收上一次的执行结果，也没返回值
 * .thenRunAsync(() -> {
 *      System.out.println("任务2启动了...");
 * }, executor);
 */
CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("当前线程" + Thread.currentThread().getId());
    int i = 10 / 4;
    System.out.println("运行结果：" + i);
    return i;
}, executor).thenRunAsync(() -> {
    System.out.println("任务2启动了...");
}, executor);

thenAcceptAsync：能接收上一次的执行结果，但没返回值

/**
 * thenAcceptXXX 能接收上一次的执行结果，但没返回值
 * .thenAcceptAsync(res->{
 *      System.out.println("任务2启动了..."+res);
 *  },executor);
 */
CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("当前线程" + Thread.currentThread().getId());
    int i = 10 / 4;
    System.out.println("运行结果：" + i);
    return i;
}, executor).thenAcceptAsync(res -> {
    System.out.println("任务2启动了..." + res);
}, executor);

thenApplyAsync：能接收上一次的执行结果，又可以有返回值

/**
 * thenApplyXXX 能接收上一次的执行结果，又可以有返回值
 * .thenApplyAsync(res -> {
 *      System.out.println("任务2启动了..." + res);
 *      return "hello " + res;
 *  }, executor);
 */
CompletableFuture<String> future = CompletableFuture.supplyAsync(() ->         {
    System.out.println("当前线程" + Thread.currentThread().getId());
    int i = 10 / 4;
    System.out.println("运行结果：" + i);
    return i;
}, executor).thenApplyAsync(res -> {
    System.out.println("任务2启动了..." + res);
    return "hello " + res;
}, executor);

三任务编排

先准备两个任务

CompletableFuture<Object> future01 =CompletableFuture.supplyAsync(() -> {
    System.out.println("任务1线程" + Thread.currentThread().getId());
    int i = 10 / 4;
    System.out.println("任务1结束：");
    return i;
}, executor);
CompletableFuture<Object> future02 = CompletableFuture.supplyAsync(() -> {
    System.out.println("任务2线程" + Thread.currentThread().getId());
    try {
        Thread.sleep(3000);
        System.out.println("任务2结束：");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "hello";
}, executor);

三任务组合，前两个任务都完成，才执行任务3

「runAfterBothAsync」 ：「任务01 任务02都完成了，再开始执行任务3，不感知任务1、2的结果的，也没返回值」

CompletableFuture<Void> future = future01.runAfterBothAsync(future02, () -> {
    System.out.println("任务3开始");
}, executor);

「thenAcceptBothAsync：任务01 任务02都完成了，再开始执行任务3，能感知到任务1、2的结果，但没返回值」

CompletableFuture<Void> future = future01.thenAcceptBothAsync(future02, (f1, f2) -> {
            System.out.println("任务3开始...得到之前的结果：f1:" + f1 + ", f2:" + f2);
        }, executor);

「thenCombineAsync」 ：「任务01 任务02都完成了，再开始执行任务3，能感知到任务1、2的结果，而且自己可以带返回值」

CompletableFuture<String> future = future01.thenCombineAsync(future02, (f1, f2) -> {
            return f1+":"+f2+"：哈哈";
        }, executor);

三任务组合，前两个任务只要有一个完成，就执行任务3

「runAfterEitherAsync」 ：「两个任务只要有一个完成，就执行任务3，不感知结果，自己没返回值」

CompletableFuture<Void> future = future01.runAfterEitherAsync(future02, () -> {
            System.out.println("任务3开始...");
        }, executor);

「acceptEitherAsync：两个任务只要有一个完成，就执行任务3，感知结果，自己没返回值」

CompletableFuture<Void> future = future01.acceptEitherAsync(future02, (res) -> {
        System.out.println("任务3开始...之前的结果" + res);
    }, executor);

「applyToEitherAsync：两个任务只要有一个完成，就执行任务3，感知结果，自己有返回值」

CompletableFuture<String> future = future01.applyToEitherAsync(future02, (res) -> {
        System.out.println("任务3开始...之前的结果" + res);
        return "任务3的结果...";
    }, executor);

多任务的编排

/**
 * 多任务组合
 */
CompletableFuture<String> futureImg = CompletableFuture.supplyAsync(() -> {
    System.out.println("查询商品图片信息");
    return "hello.jpg";
},executor);

CompletableFuture<String> futureAttr = CompletableFuture.supplyAsync(() -> {
    System.out.println("查询商品属性信息");
    return "黑色+256G";
},executor);

CompletableFuture<String> futureDesc = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(3000);
        System.out.println("查询商品介绍信息");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "华为...";
},executor);

allOf：所有任务都执行完

/**
 * allOf 所有任务都执行完
 */
CompletableFuture<Void> allOf = CompletableFuture.allOf(futureImg, futureAttr, futureDesc);
allOf.get();//等待所有结果完成

anyOf：其中有一个任务执行完就可以

/**
 * anyOf 其中有一个任务执行完就可以
 */
CompletableFuture<Object> anyOf = CompletableFuture.anyOf(futureImg, futureAttr, futureDesc);
anyOf.get();

一个实际的例子

public SkuItemVo item(Long skuId) {
    SkuItemVo skuItemVo = new SkuItemVo();

    //1、sku详细信息 sku_info
    SkuInfoEntity skuInfo = getById(skuId);
    skuItemVo.setInfo(skuInfo);

    //2、sku 图片信息 sku_img
    List<SkuImagesEntity> images = skuImagesService.getImagesBySkuId(skuId);
    skuItemVo.setImages(images);

    //3、spu 销售属性组合
    List<SkuItemSaleAttrVo> saleAttr = skuSaleAttrValueService.getSaleAttrBySpuId(skuInfo.getSpuId());
    skuItemVo.setSaleAttr(saleAttr);

    //4、spu 的介绍
    SpuInfoDescEntity spuInfoDesc = spuInfoDescService.getById(skuInfo.getSpuId());
    skuItemVo.setDesc(spuInfoDesc);

    //5、spu 规格参数信息
    List<SpuItemAttrGroupVo> groupAttrs = attrGroupService.getAttrGroupWithAttrsBySpuId(skuInfo.getSpuId(),skuInfo.getCatalogId());
    skuItemVo.setGroupAttrs(groupAttrs);

    return skuItemVo;
}

使用CompletableFuture异步编排后

private SkuItemVo item(Long skuId) {
    SkuItemVo skuItemVo = new SkuItemVo();

    /**
     * 3、4、5需要依赖1的运行结果，需要返回skuInfo后从中获取spuId和catalogId
     * 而2不需要依赖1的运行结果
     */

    //1、sku详细信息 sku_info
    CompletableFuture<SkuInfoEntity> infoFuture = CompletableFuture.supplyAsync(() -> {
            SkuInfoEntity skuInfo = getById(skuId);
            skuItemVo.setInfo(skuInfo);
            return skuInfo;
    }, executor);

    //2、sku 图片信息 sku_img  2不需要等待上边1的执行结果
    CompletableFuture<Void> imageFuture = CompletableFuture.runAsync(() -> {
            List<SkuImagesEntity> images = skuImagesService.getImagesBySkuId(skuId);
            skuItemVo.setImages(images);
    }, executor);

    //下边的3、4、5都需要上边1的执行结果
    //所以下边的3、4、5都是基于上边1的执行结果 infoFuture 开始的
    //都是以infoFuture.thenAcceptAsync(skuInfo -> {})开始的
    CompletableFuture<Void> saleAttrFuture = infoFuture.thenAcceptAsync(skuInfo -> {
            //3、spu 销售属性组合  3
            List<SkuItemSaleAttrVo> saleAttr = skuSaleAttrValueService.getSaleAttrBySpuId(skuInfo.getSpuId());
            skuItemVo.setSaleAttr(saleAttr);
            System.out.println(saleAttr);
    }, executor);

    CompletableFuture<Void> descFuture = infoFuture.thenAcceptAsync(skuInfo -> {
            //4、spu 的介绍
            SpuInfoDescEntity spuInfoDesc = spuInfoDescService.getById(skuInfo.getSpuId());
            skuItemVo.setDesc(spuInfoDesc);
    }, executor);

    CompletableFuture<Void> attrGroupFuture = infoFuture.thenAcceptAsync(skuInfo -> {
            //5、spu 规格参数信息
            List<SpuItemAttrGroupVo> groupAttrs = attrGroupService.getAttrGroupWithAttrsBySpuId(skuInfo.getSpuId(),skuInfo.getCatalogId());
            System.out.println(groupAttrs);
            skuItemVo.setGroupAttrs(groupAttrs);
    }, executor);

    //等待所有任务完成
    try {
            CompletableFuture.allOf(saleAttrFuture,descFuture,attrGroupFuture,imageFuture).get() ;
    } catch (InterruptedException e) {
            log.error("查询商品详情异步编排错误: ");
            log.error(e.getMessage() );
    } catch (ExecutionException e) {
            log.error(e.getMessage() );
    }
    return skuItemVo;
}

欢迎加入我的知识星球，一起探讨架构，交流源码。加入方式，长按下方二维码噢：

59f3fe52ed47fbcb22ed3c1ed7cfac8d.png

已在知识星球更新源码解析如下：

eeee5c76c78c2b2bb9dc1f4adc7bec2e.jpeg

a34d76b460b14e2955cd2760c686aa4b.jpeg

9f2f60d308bf5c265806bb39e405efbe.jpeg

433752d1c5b748bd150547164083e06e.jpeg

最近更新《芋道 SpringBoot 2.X 入门》系列，已经 101 余篇，覆盖了 MyBatis、Redis、MongoDB、ES、分库分表、读写分离、SpringMVC、Webflux、权限、WebSocket、Dubbo、RabbitMQ、RocketMQ、Kafka、性能测试等等内容。

提供近 3W 行代码的 SpringBoot 示例，以及超 6W 行代码的电商微服务项目。

获取方式：点“在看”，关注公众号并回复 666 领取，更多内容陆续奉上。

文章有帮助的话，在看，转发吧。
谢谢支持哟 (*^__^*）
Java基基
关注
Java创建多线程异步执行实现代码解析
08-18
Java多线程异步执行实现代码解析 Java语言中提供了多种方式来实现多线程异步执行，包括实现Runnable接口和继承Thread类两种方式。下面将对这两种方式进行详细的介绍和解析。 实现Runnable接口 实现Runnable接口是...
多线程之异步编排实例详解
Hola
12-11 1841
在 Java 8 中, 新增加了一个包含 50 个方法左右的类: CompletableFuture，提供了非常强大的 Future 的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合 CompletableFuture 的方法。虽然`Future`以及相关使用方法提供了异步执行任务的能力，但是对于结果的获取却是很不方便，只能通过阻塞或者轮询的方式得到任务的结果。Future 是 Java 5 添加的类，用来描述一个异步计算的结果。
多线程-异步编排
HGW的博客
06-24 3853
多线程-异步编排
CompletableFuture异步编程事务及多数据源配置详解(含gitee源码)
卓越之识论道，平常之识论事，狭隘之识论人
08-02 3391
CompletableFuture异步编程事务及多数据源配置详解(含gitee源码)
多线程异步编排
qq_45643467的博客
09-07 302
JUC的工具类也会提供一些实例化线程池的方法，但是我们项目中并没有使用，因为都会有潜在的OOM风险，所以我们是对这些参数做了定制，具体是这样的(核心线程数)：cpu+1 这个参数要根据具体的服务器配置来定(救急线程)：cpu核数*2 这个参数我们考虑到能够对任务处理最大化，设置的都比较大(救急线程过期时间)：60unit(时间单位)：一般是s(线程工厂) ：我们项目采用的默认提供的(阻塞队列) ：这个参数首光要保证的有界，其次，再根据是否有对执行有效有更高要求的场景。
Java8 CompletableFuture异步任务编排
qq_35771266的博客
07-15 1504
在系统开发过程中我们经常会遇到很多串行化比较耗时的业务逻辑。但是很多时候如果仔细分析会发现其实很多这种串行业务部分是可以拆解为并行的。这时候我们就可以使用CompletableFuture来进行异步任务编排。举个例子假如现在有一个业务分为如下几步1.业务一耗时0.5秒2.业务二耗时0.5秒3.业务三耗时1秒4.业务四耗时0.5秒（需要用到业务一的结果）5.业务五耗时1秒（需要用到业务二或者业务三的结果）......
实现PHP多线程异步请求的3种方法
10-26
在PHP中实现多线程异步...总之，虽然PHP不支持原生多线程，但通过各种策略和工具，开发者仍然可以实现异步请求，以满足不同场景下的并发处理需求。不断学习和探索新的技术方案，将有助于提升PHP应用的性能和响应能力。
C#多线程与异步的区别详解
12-31
C#多线程与异步的区别详解 随着拥有多个硬线程 CPU（超线程、双核）的普及，多线程和异步操作等并发程序设计方法也受到了更多的关注和讨论。本文主要是想与各位高手一同探讨一下如何使用并发来最大化程序的性能。 ...
Java多线程实现异步调用的方法
09-03
Java多线程实现异步调用是提高程序效率的关键技术之一。在Java中，通过创建新线程并让它们独立运行来实现异步调用，这样可以使得主线程不被长时间阻塞，从而提高程序的响应速度。以下将详细介绍如何在Java中实现这一...
多线程异步编程之CompletableFuture入门-release
02-02
强化学习.您将收获: - 为什么会选择 CompletableFuture - 如何创建CompletableFuture异步任务 - CompletableFuture异步任务回调使用 - CompletableFuture异步任务编排 - CompletableFuture的异常处理
JavaSE多线程的复习和多线程的异步编排详解（CompletableFuture详细介绍和使用）
weixin_47316183的博客
10-16 2026
在实际项目中，我们多线程环基本都不使用前三种方式来创建多线程，因为那样太消耗资源了，而是通过线程池的方式来提交任务，而线程池的使用，用的更多则是JDK8新特征中的 CompletableFuture。
java多线程及异步编排
最新发布
qq_60275529的博客
04-26 1678
核心线程数，创建好就准备就绪的线程数量，就等待接受异步任务去执行，此核心线程一直存活，除非线程池消毁或指定allowCoreThreadTimeOut参数，:存活时间，如果当前的线程数大于核心线程数，只要线程空闲大于指定的存活时间就释放空闲的线程（maximumPoolSize-corePoolSize）方法以Async结尾，意味着Action使用相同的线程执行，而Async可能会使用其他线程执行（如果是使用相同的线程池，也可能被同一个线程选中执行）接收任务的处理结果，并消费处理，无返回结果。
CompletableFuture用法详解——多线程系列
超人2028的博客
11-20 4809
常见的两种创建线程的方式。继承Thread或者实现Runnable接口，但是这两种方法都存在一个缺陷，那就是没有返回值。虽然简单场景下已经满足，但是当我们需要返回值的时候怎么办呢？ Java 1.5 以后的Callable和Future接口就解决了这个问题， public static CompletableFuture<Void> runAsync(Runnable runnable) public static CompletableFuture<Void> runAsync(R
一文秒懂 Java CompletableFuture
华章IT官方博客
06-12 410
在Java 8中，新增了许多非常有趣的功能，比如Labmda表达式、流式API（Stream API）等。这些语法糖或API让Java这门“古老”的编程语言也开始具备“现代”的气息。但是...
多线程之CompletableFuture
wang0907的博客
06-29 678
/ 使用自定义的线程池执行任务 public static void myThread() {System . out . println("当前线程：" + Thread . currentThread() . getName());System . out . println("运行结果：" + i);try {
异步编排与多线程
isbn0123的博客
06-15 336
异步 初始化线程的4种方式 继承thread 实现Runnable接口 实现Callable接口+FutureTask（可以拿到返回结果，可以处理异常）jdk1.5后添加的 可以将Callable转化为Future Future内部继承Runable接口 线程池 定义一个配置类，改配置类向容器中注入一个threadPoolExecutor `@Configuration public class MyThreadConfig { @Bean public ThreadPoolExe
CompletableFuture 多线程下操作数据库的事务问题
weixin_45707839的博客
12-08 5364
多线程下数据库事务的处理办法
CompletableFuture 异步多线程使用方法
卓越之识论道，平常之识论事，狭隘之识论人
08-08 3799
CompletableFuture使用教程
CompletableFuture实现多线程异步超时处理
07-20
CompletableFuture 是 Java 8 引入的一个类，用于实现多线程的异步编程。它提供了丰富的方法来处理异步任务的结果、组合多个异步任务以及处理异常情况。 要实现超时处理，你可以结合 CompletableFuture 的方法和 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值