CompletableFuture异步任务编排使用

已于 2023-05-11 16:07:38 修改
阅读量1.5k 收藏 7
点赞数 4
分类专栏： API 文章标签： java
于 2023-05-11 16:04:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35794202/article/details/130617433
版权

CompletableFuture异步任务编排使用

runAsync 和 supplyAsync

  • runAsync(runnable)：无返回值
  • runAsync(runnable, executor)：无返回值，可自定义线程池
  • supplyAsync(runnable)：有返回值
  • supplyAsync(runnable, executor)：有回值，可自定义线程池

相关代码演示：

    public static void testOne(){
        CompletableFuture<Void> oneFuture = CompletableFuture.runAsync(() -> {
            System.out.println("start1");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("end1");
        });
        CompletableFuture<String> twoFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("start2");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("end2");
            return "this is twoFuture";
        });
        CompletableFuture.allOf(oneFuture, twoFuture).join();
        System.out.println(oneFuture.join());
        System.out.println(twoFuture.join());
    }

start1
start2
end1
end2
null
this is twoFuture

解析：oneFuture.join()获取的执行结果为null，因为runAsync是没有返回结果的。

allOf 和 anyOf

  • allOf(future1,future2,future3…)：等待所有future任务都完成，才可以做接下来的事。无返回值
  • anyOf(future1,future2,future3…)：任意一个任务完成，就可以做接下来的事。返回object

allOf用法示例：

    public static void testTwo(){
        long startTime = System.currentTimeMillis();
        CompletableFuture<Void> oneFuture = CompletableFuture.runAsync(() -> {
            System.out.println("start1");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("end1");
        });
        CompletableFuture<String> twoFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("start2");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("end2");
            return "this is twoFuture";
        });
        CompletableFuture<Integer> threeFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("start3");
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("end3");
            return 100;
        });
        CompletableFuture.allOf(oneFuture, twoFuture, threeFuture).join();
        System.out.println(twoFuture.join() + threeFuture.join());
        System.out.println("cost:" + (System.currentTimeMillis() - startTime) + "ms");
    }

start1
start2
start3
end1
end3
end2
this is twoFuture100
cost:2067ms

解析：allOf后的join起阻塞主线程作用。从结果可以看出，所有future执行完成后，再执行的主线程逻辑。

anyOf用法示例：

    public static void testThree(){
        long startTime = System.currentTimeMillis();
        CompletableFuture<Void> oneFuture = CompletableFuture.runAsync(() -> {
            System.out.println("start1");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("end1");
        });
        CompletableFuture<String> twoFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("start2");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("end2");
            return "this is twoFuture";
        });
        CompletableFuture<Integer> threeFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("start3");
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("end3");
            return 100;
        });
        Object result = CompletableFuture.anyOf(oneFuture, twoFuture, threeFuture).join();
        System.out.println("result:" + result);
        System.out.println("cost:" + (System.currentTimeMillis() - startTime) + "ms");
    }

start1
start2
start3
end1
result:null
cost:1058ms

解析：oneFuture 最先完成，因为没有返回值，所以获得的结果是null

join 和 get

都是用于获取Completable的返回值的

  • join方法可能会抛出未检验的异常
  • get方法强制用户手动处理异常

whenComplete 和 whenCompleteAsync 和 exceptionally

  • whenComplete：执行当前线程的任务继续执行whenComplete的任务
  • whenCompleteAsync：whenCompleteAsync的任务是由线程池来执行
  • CompleableFuture即使发生异常也会执行whenComplete、whenCompleteAsync
  • exceptionally是用来处理异常的

以whenComplete举例
正常逻辑：

    public static void testFour() {
        long startTime = System.currentTimeMillis();
        CompletableFuture<Integer> oneFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("start1");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("end1");
            return 100;
        }).whenComplete((res, e) ->{
            System.out.println("res:" + res);
            System.out.println("e:" + e);
        }).exceptionally((e) ->{
            System.out.println("error:" + e);
            return -1;
        });
        System.out.println("result:" + oneFuture.join());
        System.out.println("cost:" + (System.currentTimeMillis() - startTime) + "ms");
    }

start1
end1
res:100
e:null
result:100
cost:1084ms

捕获和处理异常：

    public static void testFive() {
        long startTime = System.currentTimeMillis();
        CompletableFuture<Integer> oneFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("start1");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("end1");
            return 100/0;
        }).whenComplete((res, e) ->{
            System.out.println("res:" + res);
            System.out.println("e:" + e);
        }).exceptionally((e) ->{
            System.out.println("error:" + e);
            return -1;
        });
        System.out.println("result:" + oneFuture.join());
        System.out.println("cost:" + (System.currentTimeMillis() - startTime) + "ms");
    }

start1
end1
res:null
e:java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
error:java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
result:-1
cost:1073ms

handle 和 handleAsync

  • handle和handleAsync的区别是后者用线程池管理
  • handle相当于whenComplete和exceptionally的组合，能够对异常捕获和处理

handle捕获和处理异常：

    public static void testSix() {
        long startTime = System.currentTimeMillis();
        CompletableFuture<Integer> oneFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("start1");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("end1");
            return 100/0;
        }).handle((res, e) ->{
            System.out.println("res:" + res);
            System.out.println("e:" + e);
            return -1;
        });
        System.out.println("result:" + oneFuture.join());
        System.out.println("cost:" + (System.currentTimeMillis() - startTime) + "ms");
    }

start1
end1
res:null
e:java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
result:-1
cost:1081ms

串行编排

  • 该模块用到的api都有普通版和async版本，这里不做赘述。async版本可以传入线程池，用线程池管理逻辑。

runAsync().thenRunAsync()

  • runAsync没有返回值，thenRunAsync也没有返回值
    public static void testSeven(){
        long startTime = System.currentTimeMillis();
        CompletableFuture<Void> oneFuture = CompletableFuture.runAsync(() -> {
            System.out.println("start1");
            System.out.println("end1");
        }).thenRunAsync(() ->{
            System.out.println("do something");
        });
        oneFuture.join();
        System.out.println("cost:" + (System.currentTimeMillis() - startTime) + "ms");
    }

start1
end1
do something
cost:72ms

supplyAsync().thenAcceptAsync((res) ->{})

  • thenAcceptAsync取supplyAsync的返回值，自身没有返回值
    public static void testEight(){
        long startTime = System.currentTimeMillis();
        CompletableFuture<Void> oneFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("start1");
            System.out.println("end1");
            return 100;
        }).thenAcceptAsync((res) ->{
            System.out.println("res:"+ res);
        });
        oneFuture.join();
        System.out.println("cost:" + (System.currentTimeMillis() - startTime) + "ms");
    }

start1
end1
res:100
cost:83ms

supplyAsync().thenApplyAsync((res) ->{return}

  • thenApplyAsync取supplyAsync的返回值，自身也有返回值
    public static void testNine(){
        long startTime = System.currentTimeMillis();
        CompletableFuture<Integer> oneFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("start1");
            System.out.println("end1");
            return 100;
        }).thenApplyAsync((res) ->{
            return 100* 10;
        });
        System.out.println("result:" + oneFuture.join());
        System.out.println("cost:" + (System.currentTimeMillis() - startTime) + "ms");
    }

start1
end1
result:1000
cost:75ms

两个任务都完成，再做其他事

runAfterBothAsync

  • 无入参、无出参
    public static void testTen(){
        CompletableFuture<Integer> oneFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("start1");
            System.out.println("end1");
            return 100;
        });
        CompletableFuture<Void> twoFuture = CompletableFuture.runAsync(() -> {
            System.out.println("start2");
            System.out.println("end2");
        });
        oneFuture.runAfterBothAsync(twoFuture, ()->{
            System.out.println("do something");
        });
        System.out.println("result:" + oneFuture.join());
    }

start1
end1
start2
end2
do something
result:100

thenAcceptBothAsync

  • 有入参、无出参
    public static void testEleven(){
        CompletableFuture<Integer> oneFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("start1");
            System.out.println("end1");
            return 100;
        });
        CompletableFuture<Void> twoFuture = CompletableFuture.runAsync(() -> {
            System.out.println("start2");
            System.out.println("end2");
        });
        oneFuture.thenAcceptBothAsync(twoFuture, (res1, res2)->{
            System.out.println("res1:" + res1);
            System.out.println("res2:" + res2);
        });
        System.out.println("result:" + oneFuture.join());
    }

start1
end1
start2
end2
result:100
res1:100
res2:null

thenCombine

  • 有入参、有出参
    public static void testTwelve(){
        CompletableFuture<Integer> oneFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("start1");
            System.out.println("end1");
            return 100;
        });
        CompletableFuture<Void> twoFuture = CompletableFuture.runAsync(() -> {
            System.out.println("start2");
            System.out.println("end2");
        });
        CompletableFuture<Integer> combineFuture = oneFuture.thenCombine(twoFuture, (res1, res2) -> {
            System.out.println("res1:" + res1);
            System.out.println("res2:" + res2);
            return res1 == 100 ? res1 : -1;
        });
        System.out.println("result1:" + oneFuture.join());
        System.out.println("combine:" + combineFuture.join());
    }

start1
end1
start2
end2
res1:100
res2:null
result1:100
combine:100

任意一个任务完成，再做其他事

runAfterEitherAsync

  • 无入参、无出参
    public static void testThirteen(){
        CompletableFuture<Integer> oneFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("start1");
            System.out.println("end1");
            return 100;
        });
        CompletableFuture<Void> twoFuture = CompletableFuture.runAsync(() -> {
            System.out.println("start2");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("end2");
        });
        oneFuture.runAfterEitherAsync(twoFuture, ()->{
            System.out.println("do something");
        });
        System.out.println("result:" + oneFuture.join());
    }

start1
end1
start2
result:100
do something

acceptEitherAsync

  • 有入参、无出参
    public static void testFourteen(){
        CompletableFuture<Integer> oneFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("start1");
            System.out.println("end1");
            return 100;
        });
        CompletableFuture<Integer> twoFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("start2");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("end2");
            return 10;
        });
        oneFuture.acceptEitherAsync(twoFuture, (res)->{
            System.out.println("res:"+ res);
        });
        System.out.println("result:" + oneFuture.join());
    }

start1
end1
start2
result:100
res:100

applyToEitherAsync

  • 有入参、有出参
    public static void testFifteen(){
        CompletableFuture<Integer> oneFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("start1");
            System.out.println("end1");
            return 100;
        });
        CompletableFuture<Integer> twoFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("start2");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("end2");
            return 10;
        });
        CompletableFuture<Integer> applyFuture = oneFuture.applyToEitherAsync(twoFuture, (res) -> {
            System.out.println("res:" + res);
            return res * 10;
        });
        System.out.println("result:" + oneFuture.join());
        System.out.println("applyFuture:" + applyFuture.join());
    }

start1
end1
start2
result:100
res:100
applyFuture:1000

总结

根据以上api，在多任务的情况下可以实现任意组合，实现异步执行逻辑，并提高了代码的执行效率。

GitNohup
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
编程老司机带你玩转 CompletableFuture 异步编程
楼下小黑哥
03-09 1150
本文从实例出发，介绍 CompletableFuture 基本用法。不过讲的再多，不如亲自上手练习一下。所以建议各位小伙伴看完，上机练习一把，快速掌握 CompletableFuture。 个人博文地址：https://sourl.cn/s5MbCm 全文摘要： Future VS CompletableFuture CompletableFuture 基本用法 0x00. 前言 一些业务...
CompletableFuture 异步处理
07-16
总结，CompletableFuture是Java中处理异步编程的强大工具，它通过提供丰富的API和灵活的任务编排方式，简化了异步编程的复杂性，提升了代码的可读性和可维护性。开发者可以根据具体需求选择合适的方法，创建和组合...
CompletableFuture.supplyAsync和runAsync区别
瓜瓜嘟嘟
06-10 1903
CompletableFuture 是 Java 中用于异步编程的一个重要类，提供了一种方便的方式来处理异步任务。CompletableFuture.supplyAsync 和 CompletableFuture.runAsync 是 CompletableFuture 中的两个常用方法。它们都用于启动一个异步任务，但是它们之间也有一些差异。下面我们分别描述这两个方法。
【异步操作工具 CompletableFuture 详解】
最新发布
Java之行
04-19 1371
CompletableFuture方法详解
CompletableFuture.runAsync() 跟supplyAsync()方法的区别
Fairytail__的博客
06-09 2809
【代码】CompletableFuture.runAsync() 跟supplyAsync()方法的区别。
一文搞懂CompletableFuture的使用
weixin_45987961的博客
01-24 4257
前言 创建线程的方式只有两种：继承Thread或者实现Runnable接口。 但是这两种方法都存在一个缺陷，没有返回值 Java 1.5 以后，可以通过向线程池提交一个Callable来获取一个包含返回值的Future对象 Future接口的局限性 当Future的线程进行了一个非常耗时的操作，那我们的主线程也就阻塞了。 当我们在简单业务上，可以使用Future的另一个重载方法get(long,TimeUnit)来设置超时时间，避免我们的主线程被无穷尽地阻塞。 单纯使用Future接口或者Fut
Java8 CompletableFuture 异步执行
ACGkaka的博客
06-22 1490
目录1.简介2.异步执行3.守护线程4.处理执行结果 1.简介 CompletableFuture 是 JDK8 提供的一个异步执行工具。 示例1： public static void main(String[] args) throws ExecutionException, InterruptedException { CompletableFuture<Void> future = CompletableFuture.runAsync(() -> { f
Java并发 CompletableFuture异步编程的实现
08-25
使用 CompletableFuture 可以简化异步编程的实现，并且代码更加简洁、易读。 CompletableFuture 的使用方法有多种，例如使用 runAsync 方法和 supplyAsync 方法来创建 CompletableFuture 对象。runAsync 方法用于...
SpringBoot异步任务使用方法详解
08-19
SpringBoot异步任务使用方法详解 SpringBoot异步任务使用方法详解是基于Java的SpringBoot框架中的一种异步任务处理机制。该机制允许开发者在SpringBoot应用程序中执行异步任务，以提高应用程序的性能和响应速度。 ...
Python Celery异步任务队列使用方法解析
09-16
在`sms`包中的`tasks.py`文件里，定义一个需要异步执行的函数，如发送短信验证码，并使用`@app.task`装饰器将其转化为Celery任务。`config.py`文件则用于配置Celery的代理（broker），这里推荐使用Redis或RabbitMQ...
Django异步任务线程池实现原理
09-18
主要介绍了Django异步任务线程池实现原理,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
CompletableFuture多线程执行并发任务工具封装
fengchengwu2012的博客
01-17 872
多线程非阻塞
CompletableFuture详解~runAsync
小强快跑~~
02-27 3万+
这个例子创建一个一个异步执行的阶段： static void runAsyncExample() { CompletableFuture cf = CompletableFuture.runAsync(() -> { assertTrue(Thread.currentThread().isDaemon()); randomSleep(); }); assertFalse(cf.isDone()); sleepEnough();
CompletableFuture 使用详解
nickDaDa的博客
07-24 4450
以下所有的方法都类同。thenCombine会把两个CompletionStage的任务都执行完成后，把两个任务的结果一块交给thenCombine来处理。两个CompletionStage，谁执行返回的结果快，我就用那个CompletionStage的结果进行下一步的转化操作。两个CompletionStage，谁执行返回的结果快，我就用那个CompletionStage的结果进行下一步的消耗操作。从示例代码中可以看出，该方法只是消费执行完成的任务，并可以根据上面的任务返回的结果进行处理。...
CompletableFuture 详解（二）：supplyAsync / runAsync 实现原理 源码分析
热门推荐
tongtest的博客
07-25 4万+
前面CompletableFuture详解（一）：基本概念及用法讲了CompletableFuture的使用，从这篇开始，我们深入了解CompletableFuture的实现，以便于大家更深入的理解CompletableFuture是如何运行的，这也有利于大家正确地使用CompletableFuture。 本篇主要介绍 supplyAsync和runAsync的实现。 1、supplyAsync的实现 我们主要看入参为Supplier的版本。因为另外一个版本的supplyAsync函数，除了增加了自定
Java并发编程——CompletableFuture类
Hopefully Sky的博客
07-27 3998
从Future接口开始 java.util.concurrent.Future接口是Java 5添加的类，用来描述一个异步计算的结果。可以使用该接口的isDone()方法检查计算是否完成，或者使用get()阻塞住调用线程，直到计算完成返回结果，也可以使用cancel()方法停止任务的执行。 ExecutorService es = Executors.newFixedThreadPool(10); Future<Integer> f = es.submit(() ->{ /
异步回调模式
weixin_42592415的博客
12-09 1295
所谓异步回调，本质上就是多线程中线程的通信，如今很多业务系统中，某个业务或者功能调用多个外部接口，通常这种调用就是异步的调用。如何得到这些异步调用的结果自然也就很重要了。FutureTask和Callable都是泛型类，泛型参数表示返回结果的类型。通过FutureTask获取异步线程的执行结果，但是其调用get()方法获取异步结果时，主线程也会被阻塞。属于异步阻塞模式。异步阻塞模式属于主动模式的异步调用，异步回调属于被动模式的异步调用。Java中回调模式的标准实现类为CompletableFuture。
并发工具类(四)
二狗家有矿
02-19 647
1.写在前面 前面的几篇博客介绍了并发工具类的其中的一部分，今天是最后并发工具类是最后一篇博客，后面的博客会介绍并发的模式。好了，废话不多说，直接上内容吧。 2.CompletableFuture:异步编程 异步化的编程，利用多线程优化性能这个核心方案得以实施的基础。 2.1CompletableFuture 的核心优势 我们再来看下上篇博客中讲的烧茶泡水的例子，具体的分工图如下： 实现的代码如下： // 任务 1：洗水壶 -> 烧开水 CompletableFuture<V
Java多线程之CompletableFuture
上善若泪
04-28 2万+
文章目录1 CompletableFuture1.1 简介1.2 创建CompletableFuture1.2.1 构造函数创建1.2.2 supplyAsync创建1.2.3 runAsync创建1.3 异步回调方法1.3.1 thenApply / thenAccept / thenRun互相依赖1.3.1.1 thenApply1.3.1.2 thenAccept / thenRun1.3.2 exceptionally有返回1.3.3 whenComplete无返回1.3.4 handle有返回1.
completablefuture异步编排
03-16
CompletableFuture异步编排是一种Java编程语言中的异步编程模型，它可以让开发者更加方便地进行异步编程。CompletableFuture可以用来表示一个异步操作的结果，同时还可以将多个异步操作组合起来，形成一个异步操作链。在异步编排中，我们可以使用CompletableFuture来实现异步操作的串行执行、并行执行、异常处理、超时控制等功能，从而提高程序的性能和可维护性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值