基于CompletableFuture并发任务编排实现

最新推荐文章于 2024-06-13 09:33:38 发布
最新推荐文章于 2024-06-13 09:33:38 发布
阅读量1.4k 收藏 10
点赞数 1
分类专栏： # 核心技术 Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dreamzuora/article/details/117456541
版权

文章目录

并发任务编排实现

其实Java8中提供了并发编程框架CompletableFuture，以下结合不同场景进行使用。

不带返回值/参数传递任务

模拟任务代码：

    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    class TaskA implements Runnable{

        @SneakyThrows
        @Override
        public void run() {
            Thread.sleep(2000);
            System.out.println(String.format("threadName: [%s] taskName:[%s] time:[%s]", Thread.currentThread().getName(), "任务A", LocalDateTime.now().format(formatter)));
        }
    }

    class TaskB implements Runnable{

        @SneakyThrows
        @Override
        public void run() {
            Thread.sleep(1000);
            System.out.println(String.format("threadName: [%s] taskName:[%s] time:[%s]", Thread.currentThread().getName(), "任务B", LocalDateTime.now().format(formatter)));
        }
    }

    class TaskC implements Runnable{

        @SneakyThrows
        @Override
        public void run() {
            Thread.sleep(50);
            System.out.println(String.format("threadName: [%s] taskName:[%s] time:[%s]", Thread.currentThread().getName(), "任务C", LocalDateTime.now().format(formatter)));
        }
    }

串行执行

A、B、C任务串行执行
在这里插入图片描述

CompletableFuture,runAsync()：异步执行
thenRun():上个任务结束再执行(不带上一个返回值结果)下一个任务
get()：阻塞等待任务执行完成

实现方式：

    @Test
    void thenRunTest() throws ExecutionException, InterruptedException {
        CompletableFuture<Void> future = CompletableFuture.runAsync(new TaskA()).thenRun(new TaskB()).thenRun(new TaskC());
        future.get();
    }

输出：

threadName: [ForkJoinPool.commonPool-worker-1] taskName:[任务A] time:[2021-06-01 22:56:51]
threadName: [ForkJoinPool.commonPool-worker-1] taskName:[任务B] time:[2021-06-01 22:56:52]
threadName: [ForkJoinPool.commonPool-worker-1] taskName:[任务C] time:[2021-06-01 22:56:53]

从日志就能看出串行执行就是通过单线程执行多个任务。

并行执行

A、B、C任务并行执行
在这里插入图片描述

CompletableFuture.allOf():等待所有的CompletableFuture执行完成，无返回值

代码实现：

    /**
     * 并发执行ABC任务
     */
    @SneakyThrows
    @Test
    void SeqTest(){
        String start = LocalDateTime.now().format(formatter);
        System.out.println(String.format("start task [%s]", start));
        CompletableFuture[] futures = new CompletableFuture[3];
        futures[0] = CompletableFuture.runAsync(new TaskA());
        futures[1] = CompletableFuture.runAsync(new TaskB());
        futures[2] = CompletableFuture.runAsync(new TaskC());
        CompletableFuture.allOf(futures).get();
        String end = LocalDateTime.now().format(formatter);
        System.out.println(String.format("end task [%s]", end));
    }

输出：

start task [2021-06-01 23:03:49]
threadName: [ForkJoinPool.commonPool-worker-3] taskName:[任务C] time:[2021-06-01 23:03:49]
threadName: [ForkJoinPool.commonPool-worker-2] taskName:[任务B] time:[2021-06-01 23:03:50]
threadName: [ForkJoinPool.commonPool-worker-1] taskName:[任务A] time:[2021-06-01 23:03:51]
end task [2021-06-01 23:03:51]

上述这种方式执行可以看出CompletableFuture默认使用的是ForkJoinPool.commonPool线程池，居然用的默认线程池那线程数是如何配置的呢？后来找到源码发现commonPool线程池配置代码如下
在这里插入图片描述

  1. 先去看看java环境变量有没有制定线程数（如果没有特殊制定默认没有）
  2. 如果没有配置则通过操作系统的核心数减一来设置线程数（我理解的减一应该是为了给main thread执行）
  3. 这种默认配置方式适合用于CPU密集型任务，如果IO型需要我们自己去配置线程池

并行执行-自定义线程池

不是所有任务都是CPU密集型，为了解决上述问题，尤其是IO场景，我们需要根据业务场景配置合理线程数充分使其利用cpu资源。
如何合理配置线程数可以参考我之前文章

    @SneakyThrows
    @Test
    void ParTestWithThreadPool(){
        String start = LocalDateTime.now().format(formatter);
        System.out.println(String.format("start task [%s]", start));
        ThreadPoolExecutor customThreadPool = new ThreadPoolExecutor(24, 32, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<>(1000));
        CompletableFuture[] futures = new CompletableFuture[3];
        futures[0] = CompletableFuture.runAsync(new TaskA(), customThreadPool);
        futures[1] = CompletableFuture.runAsync(new TaskB(), customThreadPool);
        futures[2] = CompletableFuture.runAsync(new TaskC(), customThreadPool);
        CompletableFuture.allOf(futures).get();
        String end = LocalDateTime.now().format(formatter);
        System.out.println(String.format("end task [%s]", end));
    }

输出：

start task [2021-06-02 00:00:05]
threadName: [pool-1-thread-3] taskName:[任务C] time:[2021-06-02 00:00:05]
threadName: [pool-1-thread-2] taskName:[任务B] time:[2021-06-02 00:00:06]
threadName: [pool-1-thread-1] taskName:[任务A] time:[2021-06-02 00:00:07]
end task [2021-06-02 00:00:07]

阻塞等待：多并行任务执行完再执行

A、B并行都执行完后再执行C任务
在这里插入图片描述

    @AfterTest
    void after(){
        String end = LocalDateTime.now().format(formatter);
        System.out.println(String.format("end task [%s]", end));
    }


    @Test
    void SeqAndParTest() throws ExecutionException, InterruptedException {
        ThreadPoolExecutor customThreadPool = new ThreadPoolExecutor(8, 16, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<>(1000));
        CompletableFuture[] futures = new CompletableFuture[2];
        futures[0] = CompletableFuture.runAsync(new TaskA(), customThreadPool);
        futures[1] = CompletableFuture.runAsync(new TaskB(), customThreadPool);
        CompletableFuture.allOf(futures).get();
        CompletableFuture.runAsync(new TaskC(), customThreadPool).get();
    }

输出：

start task [2021-06-02 16:56:42]
threadName: [pool-1-thread-2] taskName:[任务B] time:[2021-06-02 16:56:43]
threadName: [pool-1-thread-1] taskName:[任务A] time:[2021-06-02 16:56:44]
threadName: [pool-1-thread-3] taskName:[任务C] time:[2021-06-02 16:56:44]
end task [2021-06-02 16:56:44]

从输出中能看出B、A任务并发执行完成以后再执行C任务

任意一个任务并发执行完就执行下个任务

A、B并发执行，只要有一个执行完就执行C任务
在这里插入图片描述

anyOf:只要有任意一个CompletableFuture结束，就可以做接下来的事情，而无须像AllOf那样，等待所有的CompletableFuture结束

    @Test
    void anyOf() throws ExecutionException, InterruptedException {
        ThreadPoolExecutor customThreadPool = new ThreadPoolExecutor(8, 16, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<>(1000));
        CompletableFuture[] futures = new CompletableFuture[2];
        futures[0] = CompletableFuture.runAsync(new TaskA(), customThreadPool);
        futures[1] = CompletableFuture.runAsync(new TaskB(), customThreadPool);
        CompletableFuture.anyOf(futures).get();
        CompletableFuture.runAsync(new TaskC(), customThreadPool).get();
    }

输出：

start task [2021-06-02 17:43:42]
threadName: [pool-1-thread-2] taskName:[任务B] time:[2021-06-02 17:43:43]
threadName: [pool-1-thread-3] taskName:[任务C] time:[2021-06-02 17:43:43]
-----------
end task [2021-06-02 17:43:43]

串并行任务依赖场景

在这里插入图片描述

    @Test
    void multiSeqAndParTest() throws ExecutionException, InterruptedException {
        ThreadPoolExecutor customThreadPool = new ThreadPoolExecutor(8, 16, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<>(1000));
        CompletableFuture.runAsync(new TaskA(), customThreadPool).get();
        CompletableFuture[] futures = new CompletableFuture[2];
        futures[0] = CompletableFuture.runAsync(new TaskB(), customThreadPool).thenRun(new TaskC());
        futures[1] = CompletableFuture.runAsync(new TaskD(), customThreadPool).thenRun(new TaskE());
        CompletableFuture.allOf(futures).get();
        CompletableFuture.runAsync(new TaskF(), customThreadPool).get();
    }

输出：

start task [2021-06-02 17:33:35]
threadName: [pool-1-thread-1] taskName:[任务A] time:[2021-06-02 17:33:37]
-----------
threadName: [pool-1-thread-3] taskName:[任务D] time:[2021-06-02 17:33:37]
threadName: [pool-1-thread-3] taskName:[任务E] time:[2021-06-02 17:33:37]
-----------
threadName: [pool-1-thread-2] taskName:[任务B] time:[2021-06-02 17:33:38]
threadName: [pool-1-thread-2] taskName:[任务C] time:[2021-06-02 17:33:38]
-----------
threadName: [pool-1-thread-4] taskName:[任务F] time:[2021-06-02 17:33:38]
end task [2021-06-02 17:33:38]

带返回值/参数传递任务

模拟任务


    String taskA(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        String v = String.format("threadName: [%s] taskName:[%s] time:[%s]", Thread.currentThread().getName(), "任务A", LocalDateTime.now().format(formatter));
        return v;
    }

    String taskB(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        String v = String.format("threadName: [%s] taskName:[%s] time:[%s]", Thread.currentThread().getName(), "任务B", LocalDateTime.now().format(formatter));
        return v;
    }

    String taskC(){
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        String v = String.format("threadName: [%s] taskName:[%s] time:[%s]", Thread.currentThread().getName(), "任务C", LocalDateTime.now().format(formatter));
        return v;
    }

带返回值实现

supplyAsync():异步执行并带返回值

    @Test
    void supplyAsync() throws ExecutionException, InterruptedException {
        CompletableFuture<String> stringCompletableFuture = CompletableFuture.supplyAsync(() -> taskA());
        String result = stringCompletableFuture.get();
        System.out.println(result);
    }

    String taskA(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        return "hello";
    }

串行执行

在这里插入图片描述

thenApply(): 后面跟的是一个有参数、有返回值的方法，称为Function。返回值是CompletableFuture类型。
thenAccept()：上个任务结束再执行(前面任务的结果作为下一个任务的入参)下一个任务

    String taskA(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        String v = String.format("threadName: [%s] taskName:[%s] time:[%s]", Thread.currentThread().getName(), "任务A", LocalDateTime.now().format(formatter));
        return v;
    }
    
    void taskC(String param){
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        String v = String.format("threadName: [%s] taskName:[%s] time:[%s]", Thread.currentThread().getName(), "任务C", LocalDateTime.now().format(formatter));
        System.out.println(param + "\n ->" + v);
    }

    @Test
    void seqTest1() throws ExecutionException, InterruptedException {
        CompletableFuture<Void> completableFuture = CompletableFuture.supplyAsync(() -> taskA()).thenApply(param -> {
            String v = String.format("threadName: [%s] taskName:[%s] time:[%s]", Thread.currentThread().getName(), "任务B", LocalDateTime.now().format(formatter));
            return param + "\n ->" + v;
        }).thenAccept(param -> taskC(param));
        completableFuture.get();
    }

输出：

start task [2021-06-03 11:14:27]
threadName: [ForkJoinPool.commonPool-worker-1] taskName:[任务A] time:[2021-06-03 11:14:30]
 ->threadName: [ForkJoinPool.commonPool-worker-1] taskName:[任务B] time:[2021-06-03 11:14:30]
 ->threadName: [ForkJoinPool.commonPool-worker-1] taskName:[任务C] time:[2021-06-03 11:14:31]
end task [2021-06-03 11:14:31]

多线程任务串行执行

A、B、C任务在多个线程环境下执行，但是执行需要带要带参数传递A->B->C，感觉这种使用场景比较少
在这里插入图片描述

thenCompose()：第1个参数是一个CompletableFuture类型，第2个参数是一个方法，并且是一个BiFunction，也就是该方法有2个输入参数，1个返回值。从该接口的定义可以大致推测，它是要在2个 CompletableFuture 完成之后，把2个CompletableFuture的返回值传进去，再额外做一些事情。

模拟任务：

    String taskA(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        String v = String.format("threadName: [%s] taskName:[%s] time:[%s]", Thread.currentThread().getName(), "任务A", LocalDateTime.now().format(formatter));
        return v;
    }

    String taskB(String param){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        String v = String.format("threadName: [%s] taskName:[%s] time:[%s]", Thread.currentThread().getName(), "任务B", LocalDateTime.now().format(formatter));
        return param + "\n ->" + v;
    }
    String taskC2(String param){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        String v = String.format("threadName: [%s] taskName:[%s] time:[%s]", Thread.currentThread().getName(), "任务C", LocalDateTime.now().format(formatter));
        return param + "\n ->" + v;
    }

实现一：

        @Test
    void multiCompletableFutureSeqTest() throws ExecutionException, InterruptedException {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> taskA()).
                thenCompose(firstTaskReturn -> CompletableFuture.supplyAsync(() -> taskB(firstTaskReturn))).
                thenCompose(secondTaskReturn -> CompletableFuture.supplyAsync(() -> taskC2(secondTaskReturn)));
        System.out.println(future.get());
    }

输出：

start task [2021-06-03 15:04:45]
threadName: [ForkJoinPool.commonPool-worker-1] taskName:[任务A] time:[2021-06-03 15:04:48]
 ->threadName: [ForkJoinPool.commonPool-worker-2] taskName:[任务B] time:[2021-06-03 15:04:51]
 ->threadName: [ForkJoinPool.commonPool-worker-2] taskName:[任务C] time:[2021-06-03 15:04:54]
end task [2021-06-03 15:04:54]

对任务并行执行，返回值combine

如果希望返回值是一个非嵌套的CompletableFuture，可以使用thenCompose

    @SneakyThrows
    @Test
    void multiCombineTest(){
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> taskA()).
                thenCombine(CompletableFuture.supplyAsync(() -> taskB2()), (s1, s2) -> s1 + "\n" +  s2 + "\n" + "combine: " + Thread.currentThread().getName())
                .thenCombine(CompletableFuture.supplyAsync(() -> taskC2()), (s1, s2) -> s1 + "\n" +  s2 + "\n" + "combine: " + Thread.currentThread().getName())
                ;
        System.out.println(future.get());
    }

写在最后

推荐一个大佬的并发编程框架，文章思路是照着他的readme去写的

成长的小牛233
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
简述CompletableFuture异步任务编排
m0_73311735的博客
11-21 704
在之前的项目开发中，都没怎么使用过CompletableFuture的功能，只听说过和异步编程有关。为了能够在将来有需要的时候用得上，这两天花了点时间学习了一下，并简单地总结一下如何使用CompletableFuture完成异步任务编排。​@Override// 设置为守护线程，main线程结束就跟着一起结束，否则main函数结束jvm还在return t;}复制代码。
Java实现的并发任务处理实例
09-03
本文将深入探讨如何使用Java来实现并发任务处理，主要关注线程池的使用以及并发控制策略。 首先，我们看到一个`ThreadPoolExecutor`的实例化，这是Java并发库中的一个核心组件。`ThreadPoolExecutor`允许我们自定义...
后台模仿promise.all实现异步，提升代码速度
weixin_42499566的博客
08-25 358
后台模仿promise.all实现异步，提升代码速度
并发编程(十六)-CompletableFuture原理与实践
及时当勉励，岁月不待人
06-27 1619
并发编程(十六)-CompletableFuture原理与实践
推荐：自主任务编排管理器（ATOM）框架
最新发布
gitblog_00042的博客
06-13 328
推荐：自主任务编排管理器（ATOM）框架 项目地址:https://gitcode.com/daveshap/ATOM_Framework 引言 随着人工智能的飞速发展，我们需要强大而灵活的框架来构建能够高效管理任务、跟踪目标并适应变化条件的自主系统。现在，我们向您隆重推荐ATOM框架——一个集成认知控制、启发式指令和广泛考虑因素的全面解决方案。 自主任务编排管理器（ATOM） ATOM框架结合了...
【JAVA8】CompletableFuture使用详解
热门推荐
胖虎儿的博客
08-22 1万+
CompletableFuture！让你的代码免受阻塞之苦！ 灵活的使用`CompletableFuture`可以让我们感受java8的异步编程之美!
多线程之CompletableFuture使用
适恒
06-22 3651
一、简单介绍 CompletableFuture是java8新增的并发工具类，继承了FutureTask的同步任务的特点，同时新增了异步调用的特点（其中异步的方法名称都带有Async），换而言之同步获取方法的返回值的方式可以用CompletableFuture完成，与此同时，想要异步获取方法的返回值也可以使用CompletableFuture来完成。 异步带Async，并且底层执行的线程由ForkJoinPool支持。于此同时还多了异常处理（执行任务的时候可能会发生异常，以前使用FutureTask的
Java并发 CompletableFuture异步编程的实现
08-25
Java并发 CompletableFuture异步编程的实现 在 Java 中，CompletableFuture 是一种异步编程的实现方式，它可以帮助开发者轻松地实现异步操作。CompletableFuture 的核心优势在于它可以将串行操作变成并行操作，从而...
SpringBoot中并发定时任务的实现、动态定时任务的实现（看这一篇就够了）推荐
08-26
- `ScheduledExecutorService`：基于线程池设计，支持并发执行任务，适合处理并发需求，但调度功能较弱。 2. **Spring Task**： - Spring提供的任务调度工具，支持注解配置和Cron表达式，简洁易用，功能相对较全...
SpringBoot基于数据库实现定时任务过程解析
08-25
SpringBoot基于数据库实现定时任务过程解析 在 SpringBoot 应用程序中，实现定时任务是非常常见的需求。传统的实现方法是使用 @Scheduled 注解来创建定时任务，但是这种方法有很大的缺点和局限，就是当我们调整了...
Python基于gevent实现高并发代码实例
09-16
gevent是基于协程的库，它利用greenlet（一种轻量级的线程实现）来实现高效的并发。 协程是一种用户级的轻量级线程，相比于系统级线程，它们不需要频繁地进行上下文切换，从而提高了性能。gevent通过猴子补丁...
CompletableFuture（可完成的异步执行的任务）源码解析(史上最全分析 借鉴深入理解并发原理)
s.lm的博客
09-21 2082
CompletableFuture源码解析（会持续更新）
任务编排：CompletableFuture从入门到精通
Java技术攻略的博客
03-22 1651
最近遇到了一个业务场景，涉及到多数据源之间的请求的流程编排，正好看到了一篇某团介绍CompletableFuture原理和使用的技术文章，主要还是涉及使用层面。网上很多文章涉及原理的部分讲的不是特别详细且比较抽象。因为涉及到多线程的工具必须要理解原理，不然一旦遇到问题排查起来就只能凭玄学，正好借此梳理一下CompletableFuture的工作原理。
使用CompletableFuture并发处理任务并将结果汇总
亦疏爱吃肉
12-14 5198
先说一下业务场景，在查询用户信息的时候需要顺便查询很多与用户相关的信息，这些信息都在不同的系统里面。每个信息都要查几个不同的表才能得到完整数据，相对比较耗时。 伪代码如下: List<User> user = getUser(); // 循环 for(User u:user) { u.setXXX(//某信息查询结果); U.setXXX(//某信息查询结果); } 解决方案也很简单，把顺序查询转为并发查询即可 ExecutorService executor = new Thre
CompletableFuture之线程池运行选择
qq_40306697的博客
06-12 1919
java的CompletableFuture执行任务时用的什么线程池
【并发】强大的CompletableFuture
啤酒就辣条
03-02 197
引子 为了让程序更加高效，让CPU最大效率的工作，我们会采用异步编程。首先想到的是开启一个新的线程去做某项工作。再进一步，为了让新线程可以返回一个值，告诉主线程事情做完了，于是乎Future粉墨登场。然而Future提供的方式是主线程主动问询新线程，要是有个回调函数就爽了。所以，为了满足Future的某些遗憾，强大的CompletableFuture随着Java8一起来了。 Future 传统多...
CompletableFuture实现多任务并行，取第一个完成的结果
laolvbig的博客
11-29 1248
public static void main(String[] args){ String result = CompletableFuture.supplyAsync(() -> { try { System.out.println("1"); Thread.sleep(3000);...
多线程并发执行任务，取结果归集。终极总结：Future、FutureTask、CompletionService、CompletableFuture
zdy0_2004的专栏
06-20 8784
http://www.cnblogs.com/dennyzhangdd/p/7010972.html 目录 1.Futrue 2.FutureTask 3.CompletionService 4.CompletableFuture 5.总结 ================正文分割线================= 开启线程执行
用个小例子来介绍一下JDK8的CompletableFuture
zjysource的专栏
01-13 9508
代码要解决的问题是：在两个线程里并行执行任务A和任务B，只要有一个任务完成了，就执行任务C。代码如下： import java.time.LocalTime; import java.util.Random; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException;
用completablefuture进行任务编排的实际例子
03-09
使用CompletableFuture可以将这些步骤进行异步编排，提高订单处理的效率和并发性。例如，可以使用CompletableFuture的thenCompose方法将多个步骤串联起来，形成一个完整的订单处理流程。这样可以避免阻塞线程，提高...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值