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

已于 2023-02-24 17:36:48 修改
阅读量1.3k 收藏 8
点赞数
分类专栏： # java8新特性 # 线程 文章标签： java 开发语言 jvm
于 2023-02-24 17:26:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_31583645/article/details/129203784
版权
文章介绍了Java8中的CompletableFuture类如何帮助优化复杂查询接口的性能，通过异步处理和线程编排，如runAsync、supplyAsync、whenComplete、exceptionally等方法，减少用户等待时间，提高系统响应速度。
摘要由CSDN通过智能技术生成

问题背景

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

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

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

CompletableFuture介绍

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

                                                CompletableFuture介绍 

具体场景

        先从单个任务开始 

        runAsync：无返回值

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

      supplyAsync：有返回值

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

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

      supplyAsync：有返回值

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

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

两个任务编排

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

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

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

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

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

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

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

三任务编排

       先准备两个任务 

//先准备两个任务
CompletableFuture<Object> future01 = CompletableFuture.supplyAsync(() -> {
     System.out.println("任务1线程" + Thread.currentThread().getId());
     int i = 10 / 4;
     System.out.println("任务1结束：");
     return i;
}, EXECUTOR_SERVICE);

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_SERVICE);

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

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

 //三任务组合，前两个任务都完成，才执行任务3
 CompletableFuture<Void> future = future01.runAfterBothAsync(future02, () -> System.out.println("任务3开始"), EXECUTOR_SERVICE);

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

//三任务组合，前两个任务都完成，才执行任务3
CompletableFuture<Void> future = future01.thenAcceptBothAsync(future02, (f1, f2) -> System.out.println("任务3开始...得到之前的结果：f1:" + f1 + ", f2:" + f2), EXECUTOR_SERVICE);

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

//三任务组合，前两个任务都完成，才执行任务3
CompletableFuture<String> future = future01.thenCombineAsync(future02, (f1, f2) -> f1 + ":" + f2 + "：哈哈", EXECUTOR_SERVICE);

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

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

//三任务组合，前两个任务只要有一个完成，就执行任务3
CompletableFuture<Void> future = future01.runAfterEitherAsync(future02, () -> System.out.println("任务3开始..."), EXECUTOR_SERVICE);

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

//三任务组合，前两个任务只要有一个完成，就执行任务3
CompletableFuture<Void> future = future01.acceptEitherAsync(future02, (res) -> System.out.println("任务3开始...之前的结果" + res), EXECUTOR_SERVICE);

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

//三任务组合，前两个任务只要有一个完成，就执行任务3
CompletableFuture<String> future = future01.applyToEitherAsync(future02, (res) -> {
     System.out.println("任务3开始...之前的结果" + res);
     return "任务3的结果...";
}, EXECUTOR_SERVICE);

多任务的编排

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

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

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

       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;
}

烟雨忆南唐
关注
专栏目录
Java CompletableFuture实现多线程异步编排
m0_73311735的博客
09-07 1023
在Java 8中, 新增加了一个包含50个方法左右的类: CompletableFuture，提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合CompletableFuture的方法。CompletableFuture类实现了Future接口，所以你还是可以像以前一样通过get方法阻塞或者轮询的方式获得结果，但是这种方式不推荐使用。
java多处调用多任务_使用CompletableFuture进行多任务并行处理
weixin_36182568的博客
02-26 951
话不多说，上代码！package com.example.demo.research.async;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.concurrent.*;import java.util.function....
CompletableFuture与多线程结合使用
果酱 の 博客
05-29 6198
在Java 8中，引入了CompletableFuture类，它是Future的增强版，提供了更加灵活的异步编程方式，能够更好地利用多线程的优势。本文将详细讲解CompletableFuture的使用方法，并结合多线程实现异步编程。CompletableFuture是Java 8中新增的一个类，它实现了Future和CompletionStage接口，提供了一种更加灵活的异步编程方式。
CompletableFuture
最新发布
我这个代码你能看懂吗？
07-15 961
提供了丰富的 API 来处理异步任务，包括任务的创建、组合、异常处理、超时处理等。通过这些 API，你可以轻松地实现复杂的异步编程逻辑。
CompletableFuture异步编排（多任务组合）
小志的博客
08-23 714
CompletableFuture异步编排（多任务组合）
多线程之CompletableFuture使用
适恒
06-22 3775
一、简单介绍 CompletableFuture是java8新增的并发工具类，继承了FutureTask的同步任务的特点，同时新增了异步调用的特点（其中异步的方法名称都带有Async），换而言之同步获取方法的返回值的方式可以用CompletableFuture完成，与此同时，想要异步获取方法的返回值也可以使用CompletableFuture来完成。 异步带Async，并且底层执行的线程由ForkJoinPool支持。于此同时还多了异常处理（执行任务的时候可能会发生异常，以前使用FutureTask的
java 多线程CompletableFuture.runAsync
qq_33101025的博客
11-23 877
点击跳转https://blog.csdn.net/u011556070/article/details/113177186
CompletableFuture实现异步编排全面分析和总结
m0_71777195的博客
03-14 491
结合了Future的优点，提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合的方法。被设计在Java中进行异步编程。异步编程意味着在主线程之外创建一个独立的线程，与主线程分隔开，并在上面运行一个非阻塞的任务，然后通知主线程进展，成功或者失败。是由Java8引入的，在Java8之前我们一般通过Future实现异步。Future。
Java多线程【异步编排】
大脑不能为空
10-13 3916
Java线程和进程的区别，为什么要有线程池，JUC并发编程教程。
CompletableFuture异步任务编排用法和详解
endwas
10-31 1499
在工作中，常常会调用多个服务或者方法去获取不同的数据，如果传统做法就是串行一个个获取，然后封装返回。我们可以尝试使用CompletableFuture，将多个操作交给异步线程执行，然后主线程等待最长任务完成，将所有结果一并返回即可。 Future局限性 当我们得到包含结果的Future时，我们可以使用get方法等待线程完成并获取返回值，但我们都知道future.get()是阻塞的方法，会一直等到线程执行完毕拿到返回值。我们可以看到FutureTask中的get方法，就是循环代码直到线程执行完成返回。 .
使用CompletableFuture.runAsync()来完成异步任务
热门推荐
m0_46539364的博客
01-16 2万+
CompletableFuture 异步编排
CompletableFuture异步和线程池
weixin_44674424的博客
06-07 4331
CompletableFuture异步和线程池讲解
CompletableFuture多任务执行及简单使用场景
来都来了
06-30 5049
CompletableFuture多任务执行
CompletableFuture异步多任务最佳实践
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
12-10 3975
Java并发编程实战》一书中，Brian Goetz和合著者们为线程池大小的优化提供了不少中肯的建议。这非常重要，如果线程池中线程的数量过多，最终它们会竞争稀缺的处理器和内存资源，浪费大量的时间在上下文切换上。反之，如果线程的数目过少，正如你的应用所面临的 情况，处理器的一些核可能就无法充分利用。
1000条数据开10个线程处理，每次处理50条CompletableFuture 实现
原&点、、
08-31 559
【代码】1000条数据开10个线程处理，每次处理50条CompletableFuture 实现。
CompletableFuture 异步多线程使用方法
卓越之识论道，平常之识论事，狭隘之识论人
08-08 3490
CompletableFuture使用教程
CompletableFuture多线程异步编排
python15397的博客
02-05 2095
由于默认情况下多线程执行任务都是异步的，且线程之间任务执行没有先后顺序，都是哪个线程先抢到任务，哪个线程先执行，所以当一个业务请求需要多线程完成(假如需要 A、B、C 三个线程)且线程AB之间存在前后的依赖关系，而C线程和AB线程无关(例如：A线程启动依赖于B线程的执行返回结果，C线程自个玩) ，所以A和B线程就需要线程编排。CompletableFuture异步编排的方式有四种，分别是 runAsync、supplyAsync方法，这两个方法分别有两种入参，常用的是使用自定义线程池的那两种。
CompletableFuture开启异步线程
weixin_44433826的博客
11-14 1319
CompletableFuture异步线程
CompletableFuture实现多线程异步超时处理
07-20
CompletableFuture 是 Java 8 引入的一个类，用于实现多线程的异步编程。它提供了丰富的方法来处理异步任务的结果、组合多个异步任务以及处理异常情况。 要实现超时处理，你可以结合 CompletableFuture 的方法和 Java 的 ScheduledExecutorService 来实现。下面是一个示例： ```java import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; public class CompletableFutureTimeoutExample { public static void main(String[] args) { // 创建一个 ScheduledExecutorService 用于超时处理 ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1); // 创建一个 CompletableFuture 对象 CompletableFuture<String> future = new CompletableFuture<>(); // 设置超时时间 long timeout = 5000; // 5秒 // 在指定时间后取消 CompletableFuture executorService.schedule(() -> { if (!future.isDone()) { future.completeExceptionally(new TimeoutException("Timeout")); } }, timeout, TimeUnit.MILLISECONDS); // 异步任务 CompletableFuture.runAsync(() -> { try { // 执行异步操作，例如网络请求、数据库查询等 String result = performAsyncTask(); // 当任务完成时，设置结果给 CompletableFuture future.complete(result); } catch (Exception e) { future.completeExceptionally(e); } }); // 获取结果或处理超时异常 try { String result = future.get(); // 处理成功结果 } catch (TimeoutException e) { // 处理超时异常 } catch (InterruptedException | ExecutionException e) { // 处理其他异常 } // 关闭 ScheduledExecutorService executorService.shutdown(); } private static String performAsyncTask() { // 执行异步任务的逻辑 return "Async task result"; } } ``` 在上面的示例中，我们创建了一个 CompletableFuture 对象，并使用 ScheduledExecutorService 在指定的超时时间后取消 CompletableFuture。然后，我们使用 CompletableFuture.runAsync 方法执行异步任务，并在任务完成时设置结果给 CompletableFuture。最后，我们使用 future.get() 方法来获取结果或处理超时异常。 希望以上信息能够帮助到你！如果你还有其他问题，请随时提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

烟雨忆南唐

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值