CompletableFuture异步编排+实战

最新推荐文章于 2024-12-20 19:44:14 发布
最新推荐文章于 2024-12-20 19:44:14 发布
阅读量1.7k 收藏 24
点赞数 40
分类专栏： # Spring Boot 文章标签： 性能优化 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46548855/article/details/131552047
版权
本文详细介绍了JavaCompletableFuture在商品详情页查询中如何通过异步编排和线程管理提高性能，包括CompletableFuture的原理、创建异步对象、回调方法、线程控制以及一个多任务组合的实际应用案例。
摘要由CSDN通过智能技术生成

目录

一、CompletableFuture异步编排

问题：查询商品详情页的逻辑非常复杂，数据的获取都需要远程调用，必然需要花费更多的时间。
假如商品详情页的每个查询，需要如下标注的时间才能完成


// 1. 获取sku的基本信息	1.5s

// 2. 获取sku的图片信息	0.5s

// 3. 获取spu的所有销售属性	1s

// 4. sku价格	0.5s
...

那么，用户需要3.5s后才能看到商品详情页的内容。很显然是不能接受的。
如果有多个线程同时完成这4步操作，也许只需要1.5s即可完成响应。

1.CompletableFuture介绍

Future是Java 5添加的类，用来描述一个异步计算的结果。你可以使用isDone方法检查计算是否完成，或者使用get阻塞住调用线程，直到计算完成返回结果，你也可以使用cancel方法停止任务的执行。

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

2.创建异步对象

CompletableFuture 提供了四个静态方法来创建一个异步操作。
在这里插入图片描述
没有指定Executor的方法会使用ForkJoinPool.commonPool() 作为它的线程池执行异步代码。如果指定线程池，则 。

  • runAsync方法不支持返回值。
  • supplyAsync可以支持返回值。

3.计算完成时回调方法

当CompletableFuture的计算结果完成，或者抛出异常的时候，可以执行特定的Action。主要是下面的方法：
在这里插入图片描述
whenComplete可以处理正常或异常的计算结果，exceptionally处理异常情况。BiConsumer<? super T,? super Throwable>可以定义处理业务

whenComplete 和 whenCompleteAsync 的区别：
whenComplete：是执行当前任务的线程执行继续执行 whenComplete 的任务。
whenCompleteAsync：是执行把 whenCompleteAsync 这个任务继续提交给线程池来进行执行。

方法不以Async结尾，意味着Action使用相同的线程执行，而Async可能会使用其他线程执行（如果是使用相同的线程池，也可能会被同一个线程选中执行）

代码示例：

public class CompletableFutureDemo2 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture future = CompletableFuture.supplyAsync(new Supplier<Object>() {
            @Override
            public Object get() {
                System.out.println(Thread.currentThread().getName() + "\t completableFuture");
                int i = 10 / 0;
                return 1024;
            }
        }).whenComplete(new BiConsumer<Object, Throwable>() {
            @Override
            public void accept(Object o, Throwable throwable) {
                System.out.println("-------o=" + o.toString());
                System.out.println("-------throwable=" + throwable);
            }
        }).exceptionally(new Function<Throwable, Object>() {
            @Override
            public Object apply(Throwable throwable) {
                System.out.println("throwable=" + throwable);
                return 6666;
            }
        });
        System.out.println(future.get());
    }
}

在这里插入图片描述

4.线程串行化与并行化方法

thenApply 方法：当一个线程依赖另一个线程时，获取上一个任务返回的结果，并返回当前任务的返回值。
在这里插入图片描述
thenAccept方法：消费处理结果。接收任务的处理结果，并消费处理，无返回结果。
在这里插入图片描述
thenRun方法：只要上面的任务执行完成，就开始执行thenRun，只是处理完任务后，执行 thenRun的后续操作
在这里插入图片描述
带有Async默认是异步执行的。这里所谓的异步指的是不在当前线程内执行。

Function<? super T,? extends U>
T：上一个任务返回结果的类型
U：当前任务的返回值类型

代码演示：

public class CompletableFutureDemo2 {
    public static void main(String[] args) {

        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(50, 500, 30, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10000));
        //创建一个异步任务对象A

        CompletableFuture<Object> futureA = CompletableFuture.supplyAsync(new Supplier<Object>() {
            @Override
            public Object get() {
                return "404";
            }
        },threadPoolExecutor);
        //创建一个B
        futureA.thenAcceptAsync(new Consumer<Object>() {
            @Override
            public void accept(Object o) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("我是B");



            }
        },threadPoolExecutor);

        //创建一个C
        futureA.thenAcceptAsync(new Consumer<Object>() {
            @Override
            public void accept(Object o) {

                System.out.println("我是C");
            }
        },threadPoolExecutor);

    }
}

在这里插入图片描述

5.多任务组合

public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs);
public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs);

allOf：等待所有任务完成
anyOf：只要有一个任务完成

6.优化商品详情页-实战

对下面6个进行异步编排

获取sku信息和图片列表
获取实时价格
获取三级分类
获取销售属性和选中状态
获取商品切换数据
获取平台信息

    @Override
    public HashMap<String, Object> getItem(Long skuId) {

        HashMap<String, Object> resultMap=new HashMap<>();

        //获取sku信息和图片列表
        SkuInfo skuInfo = productFeignClient.getSkuInfo(skuId);
        resultMap.put("skuInfo",skuInfo);

        //获取实时价格
        BigDecimal skuPrice = productFeignClient.getSkuPrice(skuId);
        resultMap.put("price",skuPrice);

        //判断
        if(skuInfo!=null){
            //获取三级分类
            BaseCategoryView categoryView = productFeignClient.getCategoryView(skuInfo.getCategory3Id());
            resultMap.put("categoryView",categoryView);
            //获取销售属性和选中状态
            List<SpuSaleAttr> spuSaleAttrListCheckBySku = productFeignClient.getSpuSaleAttrListCheckBySku(skuId,skuInfo.getSpuId());
            resultMap.put("spuSaleAttrList",spuSaleAttrListCheckBySku);
            //获取商品切换数据
            Map skuValueIdsMap = productFeignClient.getSkuValueIdsMap(skuInfo.getSpuId());
            resultMap.put("valuesSkuJson", JSON.toJSONString(skuValueIdsMap));

            //获取海报信息
            List<SpuPoster> spuPosterBySpuId = productFeignClient.findSpuPosterBySpuId(skuInfo.getSpuId());
            resultMap.put("spuPosterList",spuPosterBySpuId);
        }


        //获取平台信息
        List<BaseAttrInfo> attrList = productFeignClient.getAttrList(skuId);

        //处理符合要求 List  Obj  key attrName   key attrValue
        List<Map<String, String>> spuAttrList = attrList.stream().map(baseAttrInfo -> {

            Map<String, String> map = new HashMap<>();
            map.put("attrName", baseAttrInfo.getAttrName());
            map.put("attrValue", baseAttrInfo.getAttrValueList().get(0).getValueName());


            return map;
        }).collect(Collectors.toList());

        resultMap.put("skuAttrList",spuAttrList);

        return resultMap;
    }

代码实现

    @Autowired
    private ThreadPoolExecutor executor;

    /**
     * 获取商品详情
     * @param skuId
     * @return
     */
    @Override
    public HashMap<String, Object> getItem(Long skuId) {

        HashMap<String, Object> resultMap=new HashMap<>();

        //为啥需要返回值，因为下面的内容需要skuInfo
        CompletableFuture<SkuInfo> skuInfoCompletableFuture = CompletableFuture.supplyAsync(() -> {
            //获取sku信息和图片列表
            SkuInfo skuInfo = productFeignClient.getSkuInfo(skuId);
            resultMap.put("skuInfo", skuInfo);
            return skuInfo;
        }, executor);

        //下面的代码没用到skuPrice，所以不需要返回值
        CompletableFuture<Void> skuPriceCompletableFuture = CompletableFuture.runAsync(() -> {
            //获取实时价格
            BigDecimal skuPrice = productFeignClient.getSkuPrice(skuId);
            resultMap.put("price", skuPrice);
        }, executor);

        //三级分类要依赖于上面的 sku信息和图片列表
        CompletableFuture<Void> categoryViewCompletableFuture = skuInfoCompletableFuture.thenAcceptAsync((skuInfo) -> {
            //获取三级分类
            BaseCategoryView categoryView = productFeignClient.getCategoryView(skuInfo.getCategory3Id());
            resultMap.put("categoryView", categoryView);
        }, executor);


        CompletableFuture<Void> spuSaleAttrListCheckBySkuCompletableFuture = skuInfoCompletableFuture.thenAcceptAsync((skuInfo) -> {
            //获取销售属性和选中状态
            List<SpuSaleAttr> spuSaleAttrListCheckBySku = productFeignClient.getSpuSaleAttrListCheckBySku(skuId, skuInfo.getSpuId());
            resultMap.put("spuSaleAttrList", spuSaleAttrListCheckBySku);
        }, executor);


        CompletableFuture<Void> skuValueIdsMapCompletableFuture = skuInfoCompletableFuture.thenAcceptAsync((skuInfo) -> {
            //获取商品切换数据
            Map skuValueIdsMap = productFeignClient.getSkuValueIdsMap(skuInfo.getSpuId());
            resultMap.put("valuesSkuJson", JSON.toJSONString(skuValueIdsMap));
        }, executor);


        CompletableFuture<Void> spuPosterBySpuIdCompletableFuture = skuInfoCompletableFuture.thenAcceptAsync((skuInfo) -> {
            //获取海报信息
            List<SpuPoster> spuPosterBySpuId = productFeignClient.findSpuPosterBySpuId(skuInfo.getSpuId());
            resultMap.put("spuPosterList",spuPosterBySpuId);
        }, executor);


        CompletableFuture<Void> attrListCompletableFuture = CompletableFuture.runAsync(() -> {
            //获取平台信息
            List<BaseAttrInfo> attrList = productFeignClient.getAttrList(skuId);

            //处理符合要求 List  Obj  key attrName   key attrValue
            List<Map<String, String>> spuAttrList = attrList.stream().map(baseAttrInfo -> {

                Map<String, String> map = new HashMap<>();
                map.put("attrName", baseAttrInfo.getAttrName());
                map.put("attrValue", baseAttrInfo.getAttrValueList().get(0).getValueName());


                return map;
            }).collect(Collectors.toList());

            resultMap.put("skuAttrList", spuAttrList);
        }, executor);

        //多任务组合 ---所有的异步任务执行完成才是完成
        CompletableFuture.allOf(skuInfoCompletableFuture,
                skuPriceCompletableFuture,
                categoryViewCompletableFuture,
                spuSaleAttrListCheckBySkuCompletableFuture,
                skuValueIdsMapCompletableFuture,
                spuPosterBySpuIdCompletableFuture,
                attrListCompletableFuture).join();


        return resultMap;
    }

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

@Configuration
public class ThreadPoolConfig {
    @Bean
    public ThreadPoolExecutor threadPoolExecutor(){
        /**
         * 核心线程数
         * 拥有最多线程数
         * 表示空闲线程的存活时间
         * 存活时间单位
         * 用于缓存任务的阻塞队列
         * 省略：
         *  threadFactory：指定创建线程的工厂
         *  handler：表示当workQueue已满，且池中的线程数达到maximumPoolSize时，线程池拒绝添加新任务时采取的策略。
         */
        return new ThreadPoolExecutor(50,500,30, TimeUnit.SECONDS,new ArrayBlockingQueue<>(10000));
    }
}
项目实战第十七讲：使用异步编排优化商品详情页(对外流量最大)
Jet_qi的博客
08-24 437
使用异步编排优化商品详情页， 商品详情页在业务高峰期频繁超时，导致下游业务受到影响； 难点：商详页是整个系统中日均访问次数最高的页面之一, 数量多（4亿一千万商品、11.3亿sku），重量大(商详页包含了大量文字、图片) 项目职责：①接口减负：提供大量入参上下文，减少数据量；②提供缓存+批量查询：减少查询次数；③异步编排：优化线程依赖关系，获取上一个任务返回的结果，并返回当前任务的返回值
Java8中CompletableFuture实现异步任务编排以及示例
BADAO_LIUMANG_QIZHI的博客
01-03 2151
在上面使用Future以及进行并发流程控制之外，可使用Java8新增的CompletableFuture。Future的局限性，它没法直接对多个任务进行链式、组合等处理，需要借助并发工具类才能完成，实现逻辑比较复杂。CompletableFuture是对Future的扩展和增强。CompletableFuture实现了Future接口，并在此基础上进行了丰富的扩展，完美弥补了Future的局限性，同时CompletableFuture实现了对任务编排的能力。
CompletableFuture实现异步编排
m0_73311735的博客
01-30 235
为什么需要异步执行？①获取商品基本信息 ②获取商品图片信息 ③获取商品促销活动信息 ④获取商品各种类的基本信息等操作，如果使用串行方式去执行这些操作，假设每个操作执行1s，那么用户看到完整的商品详情就需要4s的时间，如果使用并行方式执行这些操作，可能只需要1s就可以完成。所以这就是异步执行的好处。JDK5的Future接口Future接口用于代表异步计算的结果，通过Future接口提供的方法可以查看异步计算是否执行完成，或者等待执行结果并获取执行结果，同时还可以取消执行。列举Futureget()
CompletableFuture异步编排
CB_Beginner的博客
11-27 495
解决问题：是在复杂的义务里面，拆分为多线程使用异步编排执行对应的业务，提高响应速度 一、创建异步对象 1.CompletableFuture 提供了四个静态方法来创建一个异步操作 runXxxx 都是没有返回结果的，supplyXxx 都是可以获取返回结果的 可以传入自定义的线程池，否则就用默认的线程池； runAsync: CompletableFuture.runAsync(()->{ System.out.println("当前线程："+..
Java异步编程利器：CompletableFuture实战
最新发布
CoderJia的学习之路
12-20 962
在现代 Java 应用程序开发中，异步编程已经成为提升系统性能和用户体验的重要手段。CompletableFuture 作为 Java 8 引入的异步编程工具，不仅提供了 Future 接口的增强版本，还支持函数式编程，使得异步任务的编排和组合变得更加灵活和直观。本文将深入探讨 CompletableFuture 的各种应用场景，帮助你更好地掌握这个强大的工具。
CompletableFuture 异步编排
老男孩的架构路
08-16 568
在 Java8 中，新增了 CompletableFuture 异步编程工具类。它与我们之前使用的 Future 接口有何区别呢？本文将对这个重要的 CompletableFuture 类进行分析学习。1、runXxx 都是没有返回结果的，supplyXxx 都是可以获取返回值的；2、可以传入自定义的线程池，否则就用默认的线程池：ForkJoinPool.commonPool()；3、Async 代表异步的意思。2.1 获得结果和触发计算获得结果get() :不见不散。...
实战分析Java的异步编程，并通过CompletableFuture进行高效调优
JavaBuild的博客
06-09 977
好了，今天就讲这么多，其实在Java中通过条用CompletableFuture实现异步编排的工作还是稍微有点难度的，大量的API支持，需要我们在一次次的实战中去熟悉，并灵活使用。推荐大家去看看京东的asyncTool这个框架，里面就大量使用了CompletableFuture。
十三、异步并发进修——异步并发实战
流楚丶格念的博客
08-27 1501
在传统的同步调用模式下，线程会因为等待依赖服务响应而被长期阻塞，导致系统吞吐量下降。因此，在实际应用中，合理设计和利用异步并发，不仅能提升系统性能，还能在复杂场景中提供更加稳定的服务体验。在这个场景中，我们首先执行服务1，然后在服务1完成后，服务2和服务3并发执行，最终合并服务2和服务3的结果进行处理。在同步阻塞调用中，所有依赖服务的调用按顺序进行，导致总的响应时间是所有依赖服务响应时间的累加。通过这种方式，我们可以有效地管理服务间的依赖关系，利用异步编程提高系统的并发处理能力，同时保持主线程的非阻塞。
Java异步编程实战：CompletableFuture的使用示例
Java中的CompletableFuture是处理异步编程的一种有效手段，它允许你以更加灵活的方式进行任务的编排和组合。以下是关于Java中CompletableFuture的一些详细知识点： 1. 异步编程简介： 在Java中，异步编程指的是在不...
并发编程之CompletableFuture异步编排的详细介绍和基本使用（全网最细最全）
m0_56466015的博客
03-20 4658
CompletableFutyre异步编排最详细介绍和所有用法的举例说明（附源码），全网最全最细
CompletableFuture: 异步编排
yubin1285570923的博客
04-27 289
一、CompletableFuture 1 异步编排，可以编配任务执行，与vue的promise类似。 futrue可以获取异步任务的结果 1 public static CompletableFuture<Void> runAsync(Runnable runnable) { return asyncRunStage(asyncPool, runnable); } 2 public static CompletableFuture<Void&gt
completablefuture 异步编排
07-19
CompletableFuture 是 Java 8 中引入的一个强大的工具，用于处理异步计算任务。它是一个代表最终完成结果的对象，可以表示一个计算过程是否已经完成、成功还是失败，并提供了一系列方法来进行异步操作的串联、并行和错误处理。 1. **链式调用**：CompletableFuture 提供了 `.thenApply()`, `.thenAccept()`, 和 `.thenCompose()` 等方法，允许程序员通过链式调用的方式将多个异步操作串联起来，形成一个任务序列。 2. **并发处理**：你可以使用 `.thenRun()`, `.thenCombine()`, 或者 `.parallel()` 等方法并发地执行多个Future，提高效率。 3. **异常管理**：当其中一个阶段抛出异常时，可以通过 `.exceptionally()` 方法捕获并处理这个异常，而不会影响整个链条的其他部分。 4. **回退值**：如果一个阶段未能完成，后续的 `.thenApply()`, `.thenAccept()` 可以接收并处理这个未完成的结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Knight_AL

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

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

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

打赏作者

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

抵扣说明：

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

余额充值