异步编排-CompletableFuture

CompletableFuture实现异步编排 为什么需要异步执行?①获取商品基本信息 ②获取商品图片信息 ③获取商品促销活动信息 ④获取商品各种类的基本信息等操作,如果使用串行方式去执行这些操作,假设每个操作执行1s,那么用户看到完整的商品详情就需要4s的时间,如果使用并行方式执行这些操作,可能只需要1s就可以完成。所以这就是异步执行的好处。JDK5的Future接口Future接口用于代表异步计算的结果,通过Future接口提供的方法可以查看异步计算是否执行完成,或者等待执行结果并获取执行结果,同时还可以取消执行。列举Futureget() 阅读详情

一、CompletableFuture 异步编排

1、业务场景

​ 查询商品详情页的逻辑比较复杂,有些数据还需要远程调用,必然需要花费更多的时间。
在这里插入图片描述
假如商品详情页的每个查询,需要如下标注的时间才能完成 那么,用户需要 5.5s 后才能看到商品详情页的内容。很显然是不能接受的。 如果有多个线程同时完成这 6 步操作,也许只需要 1.5s 即可完成响应。

2、java8 - CompletableFuture

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

CompletableFuture 和 FutureTask 同属于 Future 接口的实现类,都可以获取线程的执行结果。
在这里插入图片描述

2.1 创建异步对象

​ CompletableFuture 提供了四个静态方法来创建一个异步操作。
在这里插入图片描述

  • runXxxx 都是没有返回结果的,supplyXxx 都是可以获取返回结果的

  • 可以传入自定义的线程池,否则就用默认的线程池;

2.2 runAsync方法 - 无返回值
@Slf4j
public class Test01 {

    public static ExecutorService executor = Executors.newFixedThreadPool(10);

    public static void main(String[] args) {
        log.info("main...start...");
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            log.info("当前线程:{}",Thread.currentThread().getName());
        }, executor);
        log.info("main...end...");
    }
}

打印结果:
在这里插入图片描述

2.3 supplyAsync方法 - 有返回值
@Slf4j
public class Test01 {

    public static ExecutorService executor = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> supplyAsync = CompletableFuture.supplyAsync(() -> {
            log.info("当前线程:{}", Thread.currentThread().getId());
            int i = 10 / 2;
            log.info("运行结果:{}", i);
            return i;
        }, executor);
        // 获取结果
        Integer res = supplyAsync.get();
        log.info("获取结果:{}",res);
    }
}

打印结果:
在这里插入图片描述

2.4 计算完成时回调方法

在这里插入图片描述

whenComplete 可以处理正常和异常的计算结果,exceptionally 处理异常情况。

whenComplete 和 whenCompleteAsync 的区别:

​ whenComplete:是执行当前任务的线程执行继续执行 whenComplete 的任务。

​ whenCompleteAsync:是执行把 whenCompleteAsync 这个任务继续提交给线程池 来进行执行。

@Slf4j
public class Test01 {

    public static ExecutorService executor = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> supplyAsync = CompletableFuture.supplyAsync(() -> {
            log.info("当前线程:{}", Thread.currentThread().getId());
            int i = 10 / 0;
            log.info("运行结果:{}", i);
            return i;
        }, executor).whenComplete((res,exception)->{
            log.info("异步任务成功完成了,结果是:{},异常是:{}",res,exception);
        }).exceptionally(t->{
            // 可以感知异常,同时返回默认值
            return 10;
        });

        Integer integer = supplyAsync.get();
        log.info("获取结果:{}",integer);

    }
}

打印结果:
在这里插入图片描述

2.5 handle方法

​ 和 complete 一样,可对结果做最后的处理(可处理异常),可改变返回值。

		/**
         * 方法执行完成后的处理
         */
        CompletableFuture<Integer> supplyAsync = CompletableFuture.supplyAsync(() -> {
            log.info("当前线程:{}", Thread.currentThread().getId());
            int i = 10 / 5;
            log.info("运行结果:{}", i);
            return i;
        }, executor).handle((res,thr) ->{
            // 如果上一步的返回结果不为空,则将返回结果乘以2返回
            if(res != null){
                return res*2;
            }
            // 如果异常不为空,表示出现异常,则返回0
            if(thr != null){
                return 0;
            }
            return 0;
        });

        Integer integer = supplyAsync.get();
        log.info("获取结果:{}",integer);
2.6 线程串行化方法在这里插入图片描述

thenApply 方法:当一个线程依赖另一个线程时,获取上一个任务返回的结果,并返回当前 任务的返回值。

thenAccept 方法:消费处理结果。接收任务的处理结果,并消费处理,无返回结果。

thenRun 方法:只要上面的任务执行完成,就开始执行 thenRun,只是处理完任务后,执行 thenRun 的后续操作 带有 Async 默认是异步执行的,即开启一个新的线程执行该异步任务。同之前。

  • thenRun、thenRunAsync方法:不能获取到上一步的执行结果,无返回值

    // thenRun方法
    CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
                log.info("当前线程:{}", Thread.currentThread().getId());
                int i = 10 / 5;
                log.info("运行结果:{}", i);
                return i;
            }, executor).thenRun(() -> {
                log.info("执行任务2");
            });
    
    // thenRunAsync:可指定自己的线程池
    CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
                log.info("当前线程:{}", Thread.currentThread().getId());
                int i = 10 / 5;
                log.info("运行结果:{}", i);
                return i;
            }, executor).thenRunAsync(()->{
                log.info("执行任务2....");
            },executor);
    
  • thenAcceptAsync:可以获取上一步的执行结果,但是无返回值

    CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
                log.info("当前线程:{}", Thread.currentThread().getId());
                int i = 10 / 5;
                log.info("运行结果:{}", i);
                return i;
            }, executor).thenAcceptAsync(res->{
                log.info("任务2执行...上一步的执行结果:{}",res);
            },executor);
    

    打印结果:
    在这里插入图片描述

  • thenApplyAsync:可以获取上一步的执行结果,有返回值并且以下一个任务的执行结果为返回值

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            log.info("当前线程:{}", Thread.currentThread().getId());
            int i = 10 / 5;
            log.info("运行结果:{}", i);
            return i;
        }, executor).thenApplyAsync(res -> {
            log.info("任务2开始执行....");
            return "hello " + res;
        }, executor);
        log.info("最终的返回结果:{}",future.get());
2.7 两任务组合 - 都要完成
  • runAfterBothAsync

    组合两个 future,不需要获取 future 的结果,只需两个 future 处理完任务后, 处理该任务

    CompletableFuture<Integer> future01 = CompletableFuture.supplyAsync(() -> {
                log.info("任务1开始....");
                int i = 10 / 5;
                log.info("任务1运行结果:{}", i);
                return i;
            }, executor);
    
    CompletableFuture<String> future02 = CompletableFuture.supplyAsync(() -> {
        log.info("任务2开始....");
        log.info("任务2结束....");
        return "hello";
    }, executor);
    
    // 任务1、任务2执行完成后,再执行任务3
    future01.runAfterBothAsync(future02,()->{
    	log.info("任务3开始....");
    },executor);
    
    

    打印结果:因为任务1和任务2是异步执行的,所以没有执行的先后顺序,但是任务3一定是在两个任务完成后才执行的
    在这里插入图片描述

  • thenAcceptBothAsync:可以获取前两个任务的返回结果

    CompletableFuture<Integer> future01 = CompletableFuture.supplyAsync(() -> {
                log.info("任务1开始....");
                int i = 10 / 5;
                log.info("任务1运行结果:{}", i);
                return i;
            }, executor);
    
    CompletableFuture<String> future02 = CompletableFuture.supplyAsync(() -> {
        log.info("任务2开始....");
        log.info("任务2结束....");
        return "hello";
    }, executor);
    
    // 可以获取前两个任务的返回结果
    future01.thenAcceptBothAsync(future02,(f1,f2)->{
    	log.info("任务3,获取前两个任务的结果:{}---》{}",f1,f2);
    },executor);
    

    打印结果:

在这里插入图片描述

  • thenCombineAsync:可以接受前两个任务的返回值,并有返回值
CompletableFuture<Integer> future01 = CompletableFuture.supplyAsync(() -> {
            log.info("任务1开始....");
            int i = 10 / 5;
            log.info("任务1运行结果:{}", i);
            return i;
        }, executor);

CompletableFuture<String> future02 = CompletableFuture.supplyAsync(() -> {
            log.info("任务2开始....");
            log.info("任务2结束....");
            return "hello";
        }, executor);

CompletableFuture<String> future = future01.thenCombineAsync(future02, (f1, f2) -> {
            return f1 + " : " + f2 + "haha!";
        }, executor);
 log.info("任务3返回的结果:{}",future.get());

打印结果:
在这里插入图片描述

  • runAfterEitherAsync:两个任务,只要有一个完成,就执行任务3,不感知结果,自己业务返回值

    CompletableFuture<Integer> future01 = CompletableFuture.supplyAsync(() -> {
                log.info("任务1开始....");
                int i = 10 / 5;
                log.info("任务1运行结果:{}", i);
                return i;
            }, executor);
    
    CompletableFuture<String> future02 = CompletableFuture.supplyAsync(() -> {
                log.info("任务2开始....");
                try {
                    Thread.sleep(3000);
                    log.info("任务2结束....");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return "hello";
            }, executor);
    
    future01.runAfterEitherAsync(future02,()->{
                log.info("任务3...");
            },executor);
       log.info("mian....end....");
    

    打印结果:
    在这里插入图片描述

  • acceptEitherAsync:感知结果,自己没有返回值

    CompletableFuture<Object> future01 = CompletableFuture.supplyAsync(() -> {
                log.info("任务1开始....");
                int i = 10 / 5;
                log.info("任务1运行结果:{}", i);
                return i;
            }, executor);
    
            CompletableFuture<Object> future02 = CompletableFuture.supplyAsync(() -> {
                log.info("任务2开始....");
                try {
                    Thread.sleep(3000);
                    log.info("任务2结束....");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return "hello";
            }, executor);
    
            future01.acceptEitherAsync(future02,(res)->{
                log.info("任务3开始,返回的结果:{}",res);
            },executor);
    

    打印结果:
    在这里插入图片描述

  • applyToEitherAsync: 感知结果,并有返回值

    CompletableFuture<Object> future01 = CompletableFuture.supplyAsync(() -> {
                log.info("任务1开始....");
                int i = 10 / 5;
                log.info("任务1运行结果:{}", i);
                return i;
            }, executor);
    
    CompletableFuture<Object> future02 = CompletableFuture.supplyAsync(() -> {
                log.info("任务2开始....");
                try {
                    Thread.sleep(3000);
                    log.info("任务2结束....");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return "hello";
            }, executor);
    
    CompletableFuture<String> future = future01.applyToEitherAsync(future02, (res) -> {
                log.info("任务3执行...");
                return res.toString() + "haha";
            }, executor);
     log.info("任务3返回结果:{}",future.get());
    

    打印结果:
    在这里插入图片描述

2.8 多任务组合

在这里插入图片描述

allOf:等待所有任务完成

anyOf:只要有一个任务完成
在这里插入图片描述

异步编程利器:CompletableFuture详解 |Java 开发实战 06日阅读 1005 关注 前言 文正在参加「Java主题月 - Java 开发实战」, 我们异步执行一个任务时,一般是用线程池Executor去创建。如果不需要有返回值, 任务实现Runnable接口;如果需要有返回值,任务实现Callable接口,调用Executor的submit方法,再使用Future获取即可。如果多个线程存在依赖组合的话,我们怎么处理呢?可使用同步组件CountDownLatch、CyclicBarrier等,但是比较麻烦。其实有简单的方法,就是用Compele.. 阅读详情

相关推荐

多线程任务编排:CompletableFuture从入门到精通

我们把Runnable理解为最基本的,只具备在线程下执行一段逻辑的能力。为了获取执行的返回值,创造了Callable和与其配合使用的Future。为了将任务之间进行逻辑编排,就诞生了CompletableFuture。关于如何理解任务的逻辑编排,举一个简单的例子:打开电脑-更新系统这两个操作是有先后顺序的,但是泡茶和这两个操作没有先后顺序,是可以并行的,而开始办公必须要等待其他操作结束之后才能进行,这就形成了任务编排的执行链。在IO密集型系统中,类似的场景有很多。

qq_39239712的博客 1382

多线程-异步编排

多线程-异步编排

HGW的博客 4046

70 CompletableFuture异步编排

在企业级开发中,传统的接口存在诸多局限性,而提供了强大的异步编程能力:传统Future的痛点:CompletableFuture的优势:典型应用场景:并行查询多个数据源 批量异步处理 复杂业务流程编排 超时控制与降级 CompletableFuture与Future的对比 传统Future代码: CompletableFuture代码: CompletableFuture状态机 CompletableFuture内部维护三种状态: 2 runAsync - 无返回值异步执行 2.1 核心原

云上凯歌 41

CompletableFuture异步编排

异步一、线程基本了解1、创建线程的四种方式1.1、继承Thread类1.2、实现Runnable接口1.3、实现Callable接口 + FutureTask (可以拿到返回结果,可以处理异常)1.4、使用线程池2、线程池2.1、线程池七大参数2.2、运行流程2.3、常见的4种线程池特点二、CompletableFuture异步编排1、创建CompletableFuture1.1、runAsync(无返回值)1.2、supplyAsync(有返回值)2、各个方法使用1、`whenComplete`2、`ha

qq_48721706的博客 2197

BK3296蓝牙音频SoC深度评测:如何用这颗芯片打造超低功耗TWS耳机?

本文深度评测BK3296蓝牙音频SoC在TWS耳机中的应用,重点解析其22nm工艺带来的超低功耗优势(A2DP模式仅2.8mA)和3×3mm封装设计。通过芯片架构分析、双麦降噪调优及开发套件使用指南,为工程师提供打造高性能TWS耳机的完整解决方案,显著提升续航和音频质量。

rice5的博客 659

高云FPGA开发实战:手把手教你用ModelSim做功能仿真与时序分析(附Testbench写法)

本文详细介绍了高云FPGA开发中如何使用ModelSim进行功能仿真与时序分析,包括环境搭建、Testbench编写、波形调试和时序优化等实战技巧。通过具体案例和代码示例,帮助开发者掌握FPGA仿真验证的核心方法,提升设计可靠性。特别针对高云GW5A系列器件提供了专业的仿真库配置指南和时序分析策略。

weixin_30412167的博客 470

CompletableFuture异步编排+实战

Future是Java 5添加的类,用来描述一个异步计算的结果。你可以使用isDone方法检查计算是否完成,或者使用get阻塞住调用线程,直到计算完成返回结果,你也可以使用cancel方法停止任务的执行。在Java 8中, 新增加了一个包含50个方法左右的类: CompletableFuture,提供了非常强大的Future的扩展功能,可以帮助我们简化异步编程的复杂性,提供了函数式编程的能力,可以通过回调的方式处理计算结果,并且提供了转换和组合CompletableFuture的方法。

Knight 2229

科普:Frenet坐标

理想情况下,描述这种常见驾驶行为在数学上应该很容易。一种方法是使用新的坐标系。现在,而不是放下一个正常的笛卡尔网格,我们做一些事情,就像你看到下面…Frenet Coordinates是一种以比传统x,y笛卡尔坐标更直观的方式表示道路位置的方式。如果我们想要方程式来描述这个动作,那就不容易了!想象一下像下面这样一条弯曲的道路,笛卡尔坐标系就位于它的上面…使用这些笛卡尔坐标,我们可以尝试描述车辆通常在路上行驶的路径…那么在Frenet坐标系下呈现的典型轨迹是什么样的?在这里,我们定义了一个新的坐标系统。

OceanStar的博客 1万+

CompletableFuture异步编排类详解

这篇文章简洁明了的介绍了CompletableFuture异步编程类,帮助大家快速入门。

2301_76827227的博客 1013

weblogic等保测评操作过程

weblogic网络安全等级测评保护操作

qq_48257021的博客 2762

告别Keil手动分区!用CubeMX+VS Code一键生成带Bootloader的STM32 OTA工程

本文详细介绍了如何利用STM32CubeMX和VS Code实现STM32 OTA工程的自动化构建,告别传统Keil手动分区的繁琐流程。通过图形化配置Flash分区、自动生成链接脚本以及实现Bootloader跳转逻辑,开发者可以高效完成远程升级功能开发,显著提升嵌入式开发效率。

weixin_33720956的博客 390

ThreadPoolExecutor线程池与CompletableFuture线程异步编排

ThreadPoolExecutor线程池与CompletableFuture线程异步编排

zyxzyx666的博客 2306

SAP MM | 批次管理:OMCT 批次级别设置与自动寻批机制

SAP批次管理中的批次级别(OMCT配置)是核心设置,决定批次号的唯一性范围。推荐选择“物料级别唯一”,避免跨工厂调拨问题;若配置错误,后期修改需复杂数据转换。此外,通过SD模块的自动批次决定功能(VCH1策略),可实现FIFO/FEFO出库规则,需后台激活并配置查找策略。批次管理需跨模块协作(MM/PP/SD),确保从生产到出库的全流程精准追踪。**关键点:**批次级别需在项目初期锁定,避免后期修改风险。

RiverRia的专栏 970

CompletableFuture异步编排,你还不会?

对于不需要返回结果的任务,使用runAsync。对于需要返回结果的任务,使用。在任务完成后,无论是否成功,都要执行某些操作时,使用或。仅在任务发生异常时处理异常并提供替代结果,使用。处理任务结果但不返回新值时,使用thenAccept。处理任务结果并返回新值时,使用thenApply或。根据是否需要异步执行选择同步或异步版本。带Async代表异步,异步就是启动另外线程去执行。有xxpply的就代表有返回值java代码解读复制代码。

Maisucsdn的博客 418

脑电数据预处理十四:主成分分析(PCA)用于伪迹去除与降维

本文探讨了主成分分析(PCA)在脑电图(EEG)预处理中的双重应用。针对EEG数据的高维特性和伪迹干扰问题,PCA既可有效去除高振幅伪迹(如眼动、心电等),又能实现数据降维。文章详细解析了PCA的核心原理,包括正交基向量投影和方差最大保留机制,并提供了基于MNE-Python的完整实现方案。通过代码示例展示了PCA在伪迹去除和降维中的具体应用效果,包括功率谱密度和时域波形的可视化对比。虽然ICA在复杂伪迹处理上更具优势,但PCA以其算法简单、计算高效的特点,成为EEG分析流程中不可或缺的基础工具。

qq_32516809的博客 1419

【LLC快速上手系列】LLC轻载时,死区时间怎么调才对?别再傻傻乱搞了!

死区时间,就是指。如果你死区设得好,就能让开通前 ( V_DS to 0 ),完美实现!

weixin_43199439的博客 1857

使用CompletableFuture异步编排

异步编排可以很好的利用cpu的并行计算资源,缩短单线程任务的耗时,CompletableFuture优点可以总结如下:通过异步执行任务,可以充分利用多核CPU的优势,提高程序的吞吐量和响应速度。CompletableFuture提供了丰富的API,使得异步编程更加简单和直观,减少了回调地狱(Callback Hell)的问题。可以使用thenApply、thenCompose等方法对任务结果进行处理,还可以使用thenCombine等方法组合多个任务,编排十分灵活。

PleaseBeStrong的博客 430

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

CompletableFuture实现异步编排全面分析和总结

异步回调方法可以选择是否传递线程池参数Executor,这里为了实现线程池隔离,当不传递线程池时,默认会使用ForkJoinPool中的公共线程池CommonPool,这个线程池默认创建的线程数是CPU的核数,如果所有的异步回调共享一个线程池,核心与非核心业务都竞争同一个池中的线程,那么一旦有任务执行一些很慢的I/O 操作,就会导致线程池中所有线程都阻塞在I/O操作上,很容易成为系统瓶颈,影响整个系统的性能。因此, 建议强制传线程池,且根据实际情况做线程池隔离,减少不同业务之间的相互干扰。

蓝天⊙白云的博客 670

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

Java中CompletableFuture多线程任务异步编排

今天来简单看一下CompletableFuture多线程任务异步编排 为什么需要CompletableFuture? 当多线程任务出现了相互依赖,需要按照一定的顺序执行的时候就需要用到CompletableFuture多线程任务异步编排 按照我的理解:CompletableFuture可以分为一下几种情况 1、单任务 2、两任务的编排 3、三任务的编排 4、多任务的编排 ...

曹举的个人博客 4170

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

CompletableFuture 异步编排

文章目录3、 CompletableFuture 异步编排3.1 创建异步对象3.2 获取值3.3 计算结果完成时的处理3.4 handle方法3.5线程串行化3.6 两任务组合--都完成3.7 两任务组合--一个完成3.8 多任务组合 【笔记于学习尚硅谷课程所作】 3、 CompletableFuture 异步编排 3.1 创建异步对象 以下四个静态方法用来为一段异步执行的代码创建CompletableFuture对象 //使用ForkJoinPool.commonPool()作为它的线程池执行异步代

一个巨大的博客 820

线程基础和CompletableFuture异步编排

程基础和CompletableFuture异步编排

m0_62946761的博客 2572

CompletableFuture 异步编排详解

CompletableFuture 异步编排详解 详情请查看:JulyWhj博客 业务场景: 查询商品详情页面逻辑比较复杂,有些数据需要远程调用,必然需要花费更多的时间。 假如商品详情每个页面查询,需要的如下的标准时间完成,那么用户需要10s才能完成。这里我们需采用异步查询,但是比如接口A查询商品信息,而接口B需要查询商品的SKU,接口C需要查询商品供应商等信息,如接口C必须依赖接口A或接口B的返回值。那么我们就需要使用CompletableFuture接口来实现。 一、开启异步编程 runAsync:无入

July_whj 992
上一篇: 线程池(一)
下一篇: java8(一)
程序员老石
博客等级 码龄8年 286粉丝 162原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值