万字解析 CompletableFuture，拿捏了！

最新推荐文章于 2024-10-30 18:07:32 发布
最新推荐文章于 2024-10-30 18:07:32 发布
阅读量601 收藏 6
点赞数 19
文章标签： java 后端 spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JavaJasper/article/details/135916775
版权

万字解析 CompletableFuture，拿捏了！

0 概述

  • 代码以同步的方式执行：可以看到下图，task1、task2 执行加起来一共需要 25s，有没有一种更快的方式呢？
    在这里插入图片描述
  • 代码以异步的方式执行：可以看到，我只需要以耗时最长的 task 为最长时间即可，速度提升了 10s
    在这里插入图片描述
  • 在真实的开发场景中，许多业务很繁杂，需要查询很多张表或者处理逻辑很麻烦，因此使用同步的方式很有可能会造成阻塞等待，性能严重下降。因此，可以使用 Java8 引入的 CompletableFuture 进行异步任务编排，提高程序的性能。下面我会结合公司里常用的方法进行案例说明。
  • 官方文档地址（JDK17 版本）：官方文档
  • 继承/实现关系图：
    在这里插入图片描述
    在这里插入图片描述

1 使用场景及好处

  • 并行流操作：与并行流结合，允许在多个线程中异步执行流操作，提高处理大数据集的效率
  • 异步任务处理：可以轻松地处理异步任务，避免阻塞主线程
  • 组合多个任务：它可以方便地组合多个任务的执行结果，实现任务的串行或并行组合
  • 错误处理：提供了丰富的异常处理机制，使得异步代码更加健壮
  • 超时处理：允许设置超时时间，当任务无法在规定时间内完成，可以执行一个默认的操作，避免长时间等待
  • 链式调用：支持链式调用，简化了多个任务之间的依赖关系

2 Java5 及以前创建任务的方式

  • 使用 Thread 类来创建线程任务：

    Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        // 这里写入需要执行的任务逻辑
    }
});
thread.start();

  • 通过实现 Runnable 接口来创建线程任务：

    Runnable task = new Runnable() {
    @Override
    public void run() {
        // 这里写入需要执行的任务逻辑
    }
};
Thread thread = new Thread(task);
thread.start();

  • 使用 Lambda 表达式（仅限于 JDK8+）：

    Thread thread = new Thread(() -> {
    // 这里写入需要执行的任务逻辑
});
thread.start();

  • 使用 ExecutorService 和 Callable / Future 对象来管理线程池并获取返回结果：

    public class FutureTest {
	public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        // 线程池 submit 提交，执行任务，能获取返回值
        Future<Double> future = executorService.submit(() -> {
            System.out.println(Thread.currentThread().getName() + " start, time = " + TimeUnit.NANOSECONDS.toSeconds(System.currentTimeMillis()));
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                log.error("异常：{}", e.getMessage(), e);
            }
            System.out.println(Thread.currentThread().getName() + " exit, time = " + TimeUnit.NANOSECONDS.toSeconds(System.currentTimeMillis()));
            return 1.10;
        });
        Double get = future.get();
        System.out.println(get);
    }
    /**
    * 输出：
    * 	pool-2-thread-1 start, time = 1706
	*	pool-2-thread-1 exit, time = 1706
	*	1.1
    */
}

  • 以上方式的弊端：

    • 代码冗余和复杂性： 每次需要创建新的线程任务时，都需要编写大量的代码来实现 Runnable 接口或继承 Thread 类，这增加了代码的冗余和复杂性。
    • 线程管理困难： 需要手动管理线程的生命周期，包括线程的创建、启动、停止等操作，这增加了代码的复杂性和出错的可能性。
    • 异常处理困难： 在实现 Runnable 接口或继承 Thread 类时，需要处理线程运行过程中可能出现的异常，这增加了代码的复杂性和出错的可能性。
    • 不支持并发编程： Java 5 及之前的线程模型不支持并发编程，这限制了程序在处理大量并发任务时的性能。

3 创建任务的核心方法

  • 无返回值的 runAsync，或者说返回值为：CompletableFuture<Void>
    • runAsync(Runnable runnable, Executor executor)
    • runAsync(Runnable runnable)
  • 有返回值的 supplyAsync，返回值为：CompletableFuture<U>
    • supplyAsync(Supplier<U> supplier)
    • supplyAsync(Supplier<U> supplier, Executor executor)
  • 说明：如果没有指定线程池，默认使用 ForkJoinPool.commonPool()，源码如下：
    public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor) {
   return asyncRunStage(screenExecutor(executor), runnable);
}

static Executor screenExecutor(Executor e) {
    if (!USE_COMMON_POOL && e == ForkJoinPool.commonPool())
        return ASYNC_POOL;
    if (e == null) throw new NullPointerException();
    return e;
}
  • 说明：关于线程池的相关知识，下一篇文章再详细讲解

4 任务异步回调的核心方法

  • 前置说明：

    以下的方法都有重载的方法，参数会多一个 Executor，当调用 thenXxx() 方法时，第一个任务和第二个任务使用的是同一个线程池；当调用 thenXxxAsync() 方法时，第一个任务使用的是自己指定的线程池（如果传了的话），第二个任务使用的是 ForkJoinPool.commonPool() 的线程池

  • 无传参 + 无返回值： 任务前后依次执行，且都没有传参和返回值
    在这里插入图片描述

    • thenRun(Runnable action)
    • thenRunAsync(Runnable action)
    import java.util.concurrent.*;

@SuppressWarnings("ALL")
public class MyCompletableFuture {

    private final static ExecutorService myExecutorService = new ThreadPoolExecutor(
            3, // 核心线程大小
            5, // 最大线程大小
            5, // 存活时间
            TimeUnit.SECONDS,  // 存活时间单位
            new ArrayBlockingQueue<>(1000),  // 阻塞队列
            Executors.defaultThreadFactory(), // 线程工厂
            new ThreadPoolExecutor.AbortPolicy()  // 拒绝策略
    );
    
	public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture.supplyAsync(() -> {
            System.out.println("第一个任务先执行");
            return "需要一个返回值";
        }, myExecutorService).thenRun(() -> {
            System.out.println("然后第二个任务执行");
        });
    }

	/**
	* 输出：
	* 	第一个任务先执行
	*	然后第二个任务执行
	*/
}

  • 有传参 + 有返回值： 将上一个任务的结果作为参数传递给下一个任务，且任务执行完有返回值

    • thenApply(Function<? super T,? extends U> fn)
    • thenApplyAsync(Function<? super T,? extends U> fn)
    import java.util.concurrent.*;

@SuppressWarnings("ALL")
public class MyCompletableFuture {

    private final static ExecutorService myExecutorService = new ThreadPoolExecutor(
            3, // 核心线程大小
            5, // 最大线程大小
            5, // 存活时间
            TimeUnit.SECONDS,  // 存活时间单位
            new ArrayBlockingQueue<>(1000),  // 阻塞队列
            Executors.defaultThreadFactory(), // 线程工厂
            new ThreadPoolExecutor.AbortPolicy()  // 拒绝策略
    );
    
	// supplyAsync + thenApply 异步回调，supplyAsync 的返回值作为 thenApply 的入参
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + " start, time = " + TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis()));
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                log.error("异常：{}", e.getMessage(), e);
            }
            System.out.println(Thread.currentThread().getName() + " exit, time = " + TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis()));
            return "supplyAsync";
        }, myExecutorService).thenApply((result) -> {
            return result + " + thenApply";
        });
        System.out.println(future.get());
    }

	/**
	* 输出：
	*   pool-1-thread-1 start, time = 1706537482
    *   pool-1-thread-1 exit, time = 1706537483
    *   supplyAsync + thenApply
	*/
}

  • 有传参 + 无返回值： 将上一个任务的结果作为参数传给下一个任务，但下一个任务执行后无返回值

    • thenAccept(Consumer<? super T> action)
    • thenAcceptAsync(Consumer<? super T> action)
    import java.util.concurrent.*;

@SuppressWarnings("ALL")
public class MyCompletableFuture {

    private final static ExecutorService myExecutorService = new ThreadPoolExecutor(
            3, // 核心线程大小
            5, // 最大线程大小
            5, // 存活时间
            TimeUnit.SECONDS,  // 存活时间单位
            new ArrayBlockingQueue<>(1000),  // 阻塞队列
            Executors.defaultThreadFactory(), // 线程工厂
            new ThreadPoolExecutor.AbortPolicy()  // 拒绝策略
    );
    
	public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + " start, time = " + TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis()));
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                log.error("异常：{}", e.getMessage(), e);
            }
            System.out.println(Thread.currentThread().getName() + " exit, time = " + TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis()));
            return "supplyAsync";
        }, myExecutorService).thenApply((result) -> {
            return result + " + thenApply";
        }).thenAccept((result) -> {
            // thenApply的返回值作为thenAccept的入参
            System.out.println(result + " + " + "thenAccept");
        });
    }

	/**
	* 输出：
	* 	pool-1-thread-1 start, time = 1706537548
    *   pool-1-thread-1 exit, time = 1706537549
	*	supplyAsync + thenApply + thenAccept
	*/
}

  • exceptionlly：任务执行异常后，抛出异常作为参数传递给回调方法

    import java.util.concurrent.*;

@SuppressWarnings("ALL")
public class MyCompletableFuture {

    private final static ExecutorService myExecutorService = new ThreadPoolExecutor(
            3, // 核心线程大小
            5, // 最大线程大小
            5, // 存活时间
            TimeUnit.SECONDS,  // 存活时间单位
            new ArrayBlockingQueue<>(1000),  // 阻塞队列
            Executors.defaultThreadFactory(), // 线程工厂
            new ThreadPoolExecutor.AbortPolicy()  // 拒绝策略
    );
    
	public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + " start, time = " + TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis()));
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                log.error("异常：{}", e.getMessage(), e);
            }
            int i = 1 / 0;
            System.out.println(Thread.currentThread().getName() + " exit, time = " + TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis()));
            return "supplyAsync";
        }, myExecutorService).exceptionally((e) -> {
            // 类似于 try...catch
            return "异常：" + e;
        });
        System.out.println(future.get());
        System.out.println("end");
        myExecutorService.shutdown();
    }

	/**
	* 输出：
	*    pool-1-thread-1 start, time = 1706538066
	*    异常：java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
	*    end
	*/
}

5 多任务组合

  • 图示：
    在这里插入图片描述

  • allOf()：等所有 Future 任务完成，再执行剩余逻辑

  • anyOf()：只要有一个 Future 任务完成，就继续执行剩余逻辑

  • 说明：

    1、需要使用：get() 或 join() 方法等所有任务完成
    2、他们的异同点在于：
              a、get() 会阻塞当前线程直到异步计算完成，而 join() 不会阻塞当前线程
              b、调用 get() 时，会抛出异常，并会传播到调用 get() 的线程
              c、调用 join() 会返回一个包含异常的 CompletionException

  • 注意： 在使用 get() 方法时，由于其是阻塞的，强烈建议添加超时时间，如果在设置的超时时间内，异步计算还没有完成，那么就会抛出一个 TimeoutException 异常

    import java.util.concurrent.*;
	
@SuppressWarnings("ALL")
public class MyCompletableFuture {

    private final static ExecutorService myExecutorService = new ThreadPoolExecutor(
            3, // 核心线程大小
            5, // 最大线程大小
            5, // 存活时间
            TimeUnit.SECONDS,  // 存活时间单位
            new ArrayBlockingQueue<>(1000),  // 阻塞队列
            Executors.defaultThreadFactory(), // 线程工厂
            new ThreadPoolExecutor.AbortPolicy()  // 拒绝策略
    );
    
	public static void main(String[] args) {
        System.out.println("开始时间：" + LocalDateTimeUtil.now());
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            return "1";
        }, myExecutorService);
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            return "2";
        }, myExecutorService);
        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {
            return "3";
        }, myExecutorService);
        CompletableFuture<Void> allFuture = CompletableFuture.allOf(future1, future2, future3);
        try {
            List<String> collect = Stream.of(future1, future2, future3).map(CompletableFuture::join).collect(Collectors.toList());
            System.out.println(collect);
        } catch (Exception e) {
            log.error("异常：{}", e.getMessage(), e);
        } finally {
            myExecutorService.shutdown();
        }
        System.out.println("结束时间：" + LocalDateTimeUtil.now());
    }
}

/**
 *	输出：
 *		开始时间：2024-01-29T22:30:07.535476700
 *		[1, 2, 3]
 *		结束时间：2024-01-29T22:30:07.540478200
*/

  • 在项目的业务中有一个接口需要查询 20+ 张表的数据，并汇总后返回给前端，使用同步的方式性能太差了，因此我使用了上述 CompletableFuture 中的多任务组合的方式进行异步调用，当所有 Future 任务执行完成后，再进行剩余的数据处理逻辑，性能提高了不止一点，接口速度响应比之前快了好几倍。

  • 以上就是 CompletableFuture 的常用方法了，小伙伴们在真实场景中还使用过别的方法吗？在评论区讨论哦~

  • 创作不易，感谢阅读，若遇到问题，可以关注此微信gzh：EzCoding 留言反馈，希望更够帮助到您

JavaJasper
关注
ArrayList源码万字解析！透彻易懂！
静待花开
05-20 8481
本文我们结合源码用通俗易懂的语言来解析ArrayList，尽量给每一行源码都写上注释，给每一个功能加上总结，助你进大厂一臂之力
一文理解Mybatis！万字长文超详细解析！
Viper的程序员修炼手册
10-07 1568
Mybatis入门看这一篇就够了 什么是MyBatis MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis。是一个基于Java的持久层框架 为什么我们要用Mybatis？ 无论是Mybatis、Hibernate都是ORM的一种实现框架，都是对JDBC的一种封装！ 到目前为止，我们已经在持久层中学了几种技术了… Hibernate jdbc SpringDAO
【Java】集合框架，四大集合类+一个工具类，万字解析，超级详细！
m0_60631827的博客
05-11 1384
【Java】集合框架，四大集合类+一个工具类，超详细！
Linux基础(超级无敌认真好用，万字收藏篇!!!!)
IT搬砖工
04-16 6951
内容包括 [Linux概述，Linux特点，Linux文件目录，Linux常用命令，VI/VIM的使用，安装JD,用户和组,权限管理,CentOS7安装软件]> 在西安加中实训学习期间作的笔记用于后边记忆和留存
一网打尽：异步神器 CompletableFuture 万字详解！
Java知音
11-04 758
最近一直畅游在RocketMQ的源码中，发现在RocketMQ中很多地方都使用到了CompletableFuture，所以今天就跟大家来聊一聊JDK1.8提供的异步神器CompletableFuture，并且最后会结合RocketMQ源码分析一下CompletableFuture的使用。Future接口以及它的局限性 我们都知道，Java中创建线程的方式主要有两种方式，继承Thread或者实现Ru...
C++入门基础（万字详解！！！）
忘忧.
08-15 4万+
C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此：C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。
奉劝那些刚参加工作的学弟学妹们：这些计算机与操作系统基础知识越早知道越好！万字长文太顶了！！（建议收藏）
冰河的专栏
04-21 5万+
2.5万字54张图带你彻底学透计算机与操作系统基础，文章有点长，建议收藏后阅读！！
linux进程控制【万字解析，全网最细！！！】
qq_54626677的博客
12-03 1176
在linux中fork函数时非常重要的函数，它从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程. 进程调用fork，当控制转移到内核中的fork代码后，内核做： 当一个进程调用fork之后，就有两个二进制代码相同的进程。而且它们都运行到相同的地方。但每个进程都将可以开始它们自己的旅程，看如下程序。 这里看到了三行输出，一行before，两行after。进程43676先打印before消息，然后它有打印after。另一个after消息有43677打印的。注意到进程43677没有打印before，
C++入门基础(万字总结）（建议收藏！！！）
热门推荐
IamGreeHand的博客
09-22 26万+
文章目录什么是C++C++的发展史C++关键字命名空间命名空间的定义1.命名空间的普通定义2.命名空间可以嵌套3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。命名空间使用1.加命名空间名称及作用域限定符2.使用using namespace 命名空间名称引入3.使用using将命名空间中的成员引入C++中的输入和输出缺省参数全缺省半缺省参数函数重载函数重载的原理extern “C”引用引用的特征1.引用在定义时必须初始化2.一个变量可以有多个引用3.引用一旦引用了一个实体
ArangoDB自学笔记（万字！！全！！）
Amo
11-25 6161
本文乃博主通过对Arangodb的官网自学后所做的笔记，可能有不足的地方，欢迎在评论区中指出，本人定虚心接受 本文是博主写在word上，再复制到博客中的，因此会有些排版问题，如果有影响阅读的地方，也可在评论区指出，或者私聊我 下载与安装 1.1下载 官网下载：www.arangodb.com 登录网页端：127.0.0.1:8529 1.2安装 解压下载的压缩包 用管理员模式运行命令提示符，找到解压文件的bin目录 arangod --install-service，出现如下的情...
西工大计算机操作系统复习（问题+回答）60页！一万字！纯手打！史上最全！
03-13
### 操作系统基础知识点 #### 一、操作系统概念与作用 **操作系统定义**：操作系统（Operating System，简称OS）是一种管理计算机系统资源、控制程序执行、提供用户接口以及支持各种应用软件运行的基础软件。...
服务器虚拟化
最新发布
Hellc007的博客
10-30 463
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
（1）Java 编程基础概览：数据类型、常量、变量、标识符与运算符
码界领航的Cherry Yang的博客
10-28 961
8 位，占1个字节，有符号的，范围 -128（-2^7）至 127（2^7-1）。32 位，占4个字节，范围 -2,147,483,648（-2^31）至 2,147,483,647（2^31 - 1）。Java 提供了六种数字类型，其中四个为整数类型，两个为浮点类型，还有字符类型，以及布尔型。16 位，占2个字节，范围 -32768（-2^15）至 32767（2^15 - 1）64 位，占8个字节，范围 -2^63 至 2^63 - 1。16 位 Unicode 字符，占 2 个字节。
java_方法递归调用
HHppGo的博客
10-27 453
简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁。
Java Web开发教程：从入门到精通
孤客科技
10-25 1090
Java Web开发是一个充满挑战和机遇的领域。通过本文的学习，您应已掌握Java Web开发的基础知识和实践技巧。不断实践、深入学习，将使您在这个领域越走越远。希望您能在未来的开发旅程中创造出更多精彩的Web应用！如有任何问题或想法，欢迎在评论区留言讨论！期待您的参与与分享！
Java复习24（PTA)
2301_79272475的博客
10-30 229
Java复习24（PTA)：多种排序的book类*
Java学习Day54：初遇萍萍(权限控制)
weixin_51721783的博客
10-29 813
web.xml：在health_backend工程的web.xml文件中配置用于整合Spring Security框架的过滤器DelegatingFilterProxy。
Java爬虫的京东“寻宝记”：揭秘商品类目信息
2401_87849308的博客
10-30 635
在这个数据驱动的时代，我们就像一群特工，穿梭在数字的海洋中，寻找着隐藏的宝藏——商品类目信息。今天，我们将带领你一起，用Java这把精密的瑞士军刀，深入京东的神秘领域，揭开商品类目的神秘面纱。为了避免被京东的反爬虫机制发现，我们需要设置合理的请求间隔，并且可能需要模拟浏览器的User-Agent。经过一系列的特工任务和挑战，我们终于成功获取了商品的类目信息，并且安全返回。我们需要找到京东商品类目信息的API接口，这将是我们特工任务的起点。在代码的世界里，我们不仅要追求技术的高度，更要追求道德的底线。
Swagger--注解大全
IT利刃出鞘的博客
10-25 600
本文介绍Swagger的注解的用法。
C++基础入门精要：万字深度解析
资源摘要信息: "C++入门基础(万字总结）" C++是一种高性能的编程语言，广泛用于软件开发领域，特别是系统/应用软件、游戏开发、实时物理模拟等对性能要求极高的场景。该语言自1985年被发明以来，一直是编程语言排行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值