异步多线程 CompletableFuture

最新推荐文章于 2025-06-11 19:36:21 发布
原创 最新推荐文章于 2025-06-11 19:36:21 发布 · 701 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #jvm

本文详细介绍了Java中CompletableFuture的使用，包括无返回值的runAsync，有返回值的supplyAsync及其whenComplete、exceptionally、handle方法的用法，以及如何进行多任务的串行化组合，如thenRunAsync、thenApplyAsync、runAfterBothAsync、thenAcceptBothAsync、thenCombineAsync，最后讲解了allOf和anyOf在多任务组合中的应用。通过实例展示了每个方法的执行流程和结果，帮助读者深入理解Future的异步处理和任务组合方式。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、单个任务

1、runAsync： 无返回值

 /** runAsync 无返回值 */
        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(()->{
            System.out.println("线程" + Thread.currentThread().getName());
        });

2、supplyAsync：有返回值

2.1 whenComplete

示例：能感知结果，无法修改返回值；能感知异常

/** 可以感知结果，感知异常，但是没有返回值,抛异常也无法被外部感知 */
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(()->{
            System.out.println("1、线程" + Thread.currentThread().getName());
            return 0;
        },executorService).whenComplete((res, exception)->{
            System.out.println("2、可获得结果" + res + "可获取异常" + exception);
            throw new BadRequestAlertException("抛出异常不会被外部感知");
        });
        try {
            System.out.println("3、通过future.get()获取结果" + future.get());
        }catch (Exception e){
            System.out.println("4、异常");
        }

控制台打印：

1、线程pool-1-thread-1
2、可获得结果0可获取异常null
4、异常

2.2 exceptionally

示例：可以处理异常，替换返回值，不能接收传入结果

/** exceptionally：可以处理异常，替换返回值，不能接收传入结果 */
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(()->{
            System.out.println("1、线程" + Thread.currentThread().getName());
            return 0;
        },executorService).whenComplete((res, exception)->{
            System.out.println("2、可获得结果" + res + "可获取异常" + exception);
            throw new BadRequestAlertException("抛出异常不会被外部感知");
        }).exceptionally(throwable -> 1);
        try {
            System.out.println("3、通过future.get()获取结果" + future.get());
        }catch (Exception e){
            System.out.println("4、异常");
        }

控制台打印：

1、线程pool-1-thread-1
2、可获得结果0可获取异常null
3、通过future.get()获取结果1

2.3 handle

示例：可获得返回结果，可获得异常信息，也能修改返回值

	    CompletableFuture<Integer> future = CompletableFuture.supplyAsync(()->{
            System.out.println("1、线程：" + Thread.currentThread().getName());
            return 0;
        },executorService).handle((res, exception)-> exception == null ? 1 : 2);
        try {
            System.out.println("3、通过future.get()获取结果：" + future.get());
        }catch (Exception e){
            System.out.println("4、异常");
        }

控制台打印：

1、线程：pool-1-thread-1
3、通过future.get()获取结果：1

二、任务组合（2线程串行化）

1、thenRunAsync：

示例：不能接收上一次的执行结果，也没返回值

		ExecutorService executorService = Executors.newFixedThreadPool(10);
        CompletableFuture<Void> future1 = CompletableFuture.supplyAsync(()->{
            System.out.println("1、线程：" + Thread.currentThread().getName());
            return 0;
        },executorService).thenRunAsync(()->{
            System.out.println("2、线程：" + Thread.currentThread().getName());
        },executorService);
        try       {
            System.out.println("3、通过future.get()获取结果：" + future1.get());
        }catch (Exception e){
            System.out.println("4、异常");
        }

控制台打印：

1、线程：pool-1-thread-1
2、线程：pool-1-thread-2
3、通过future1.get()获取结果：null

2、thenApplyAsync

示例：能接收上次执行结果，有返回值

		ExecutorService executorService = Executors.newFixedThreadPool(10);
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(()->{
            System.out.println("1、线程：" + Thread.currentThread().getName());
            return "线程1返回值";
        },executorService).thenApplyAsync((res)->{
            System.out.println("2、线程：" + Thread.currentThread().getName());
            return "线程2返回值";
        },executorService);
        try{
            System.out.println("3、通过future.get()获取结果：" + future1.get());
        }catch (Exception e){
            System.out.println("4、异常");
        }

控制台打印：

1、线程：pool-1-thread-1
2、线程：pool-1-thread-2
3、通过future.get()获取结果：线程2返回值

三、任务组合（3线程串行化）

准备两个任务：

		ExecutorService executorService = Executors.newFixedThreadPool(10);
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(()->{
            System.out.println("1、线程：" + Thread.currentThread().getName());
            return "线程1返回值";
        },executorService);
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(()->{
            System.out.println("2、线程：" + Thread.currentThread().getName());
            return "线程2返回值";
        },executorService);

1、runAfterBothAsync：

示例：任务01 任务02都完成了，再开始执行任务3，不感知任务1、2的结果的，也没返回值

		CompletableFuture<Void> future3 = future1.runAfterBothAsync(future2,()->{
            System.out.println("3、线程：" + Thread.currentThread().getName());
        });

控制台打印：

1、线程：pool-1-thread-1
2、线程：pool-1-thread-2
3、线程：ForkJoinPool.commonPool-worker-9

2、thenAcceptBothAsync：

示例：任务01 任务02都完成了，再开始执行任务3，能感知到任务1、2的结果，但没返回值

 		CompletableFuture<Void> future3 = future1.thenAcceptBothAsync(future2,(res1,res2)->{
            System.out.println("3、线程：" + Thread.currentThread().getName() + "\n"
                    + "线程1结果: "+ res1+ "\n线程2结果：" + res2 );
        });
        // 打印最后执行线程的返回值
        try{
            System.out.println("4、通过future.get()获取结果：" + future3.get());
        }catch (Exception e){
            System.out.println("5、异常");
        }

控制台打印：

1、线程：pool-1-thread-1
2、线程：pool-1-thread-2
3、线程：ForkJoinPool.commonPool-worker-9
线程1结果: 线程1返回值
线程2结果：线程2返回值
4、通过future.get()获取结果：null

thenCombineAsync：

示例：任务01 任务02都完成了，再开始执行任务3，能感知到任务1、2的结果，而且自己可以带返回值

		 CompletableFuture<String> future3 = future1.thenCombineAsync(future2,(res1,res2)->{
            System.out.println("3、线程：" + Thread.currentThread().getName() + "\n"
                    + "线程1结果: "+ res1+ "\n线程2结果：" + res2 );
            return "线程3结果";
        });
        // 打印最后执行线程的返回值
        try{
            System.out.println("4、通过future.get()获取结果：" + future3.get());
        }catch (Exception e){
            System.out.println("5、异常");
        }

控制台打印：

1、线程：pool-1-thread-1
2、线程：pool-1-thread-2
3、线程：ForkJoinPool.commonPool-worker-9
线程1结果: 线程1返回值
线程2结果：线程2返回值
4、通过future.get()获取结果：线程3结果

四、多任务组合

准备三个任务

 		ExecutorService executorService = Executors.newFixedThreadPool(10);
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(()->{
            System.out.println("1、线程：" + Thread.currentThread().getName());
            return "线程1返回值";
        },executorService);
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(()->{
            System.out.println("2、线程：" + Thread.currentThread().getName());
            return "线程2返回值";
        },executorService);
        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(()->{
            System.out.println("3、线程：" + Thread.currentThread().getName());
            return "线程3返回值";
        },executorService);

1、allOf：

示例：所有任务都执行完

		CompletableFuture<String> future3 = CompletableFuture.supplyAsync(()->{
            System.out.println("3、线程：" + Thread.currentThread().getName());
            return "线程3返回值";
        },executorService);
        CompletableFuture<Void> future = CompletableFuture.allOf(future1,future2,future3);
      
        try{
            System.out.println("4、通过future.get()获取结果：" + future.get());
        }catch (Exception e){
            System.out.println("5、异常");
        }
        System.out.println("等待3个线程执行完毕");

控制台打印：

1、线程：pool-1-thread-1
2、线程：pool-1-thread-2
3、线程：pool-1-thread-3
4、通过future.get()获取结果：null
等待3个线程执行完毕

2、anyOf：

示例：其中有一个任务执行完就可以

		CompletableFuture<String> future3 = CompletableFuture.supplyAsync(()->{
            System.out.println("3、线程：" + Thread.currentThread().getName());
            return "线程3返回值";
        },executorService);
        CompletableFuture<Object> future = CompletableFuture.anyOf(future1,future2,future3);
        try{
            System.out.println("4、通过future.get()获取结果：" + future.get());
        }catch (Exception e){
            System.out.println("5、异常");
        }
        System.out.println("有一个任务执行完毕即可往下执行");

控制台打印：

1、线程：pool-1-thread-1
2、线程：pool-1-thread-2
4、通过future.get()获取结果：线程1返回值
等待3个线程执行完毕
3、线程：pool-1-thread-3

参考博客：
https://blog.csdn.net/u014571143/article/details/125617736

CompletableFuture详解~异常处理
小强快跑~~
02-28 9404
计算结果完成时的回调方法 当 CompletableFuture 的计算结果完成，或者抛出异常的时候，可以执行特定的 Action。主要是下面的方法： public CompletableFuture<T> whenComplete(BiConsumer<? super T,? super Throwable> action) public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T,
【多线程】多线程接口并行对数据字典的查询优化,多线程异步任务编排CompletableFuture详情
qq_50446805的博客
07-25 1086
我们将对接口的调用提出优化方案，让大家学会如何提升请求访问效率。如何学会高并发接口设计？如何掌握线程与线程池？如何学会CompletableFuture异步编排？如何学会线程有序与并行？如何学会线程任务、多任务组组合？
CompletableFuture.supplyAsync 异步调用,捕获异常并抛出到主线程
u011250186的博客
12-29 6525
CompletableFuture.supplyAsync 异步调用,捕获异常并抛出到主线程
Future与CompletableFuture：异步编程对比
最新发布
m0_52551369的博客
06-11 455
Future是一种表示异步计算结果的接口。提交一个任务给线程池时返回一个Future对象，通过它可以检查任务是否完成、获取任务结果或取消任务。实现了Future接口，并提供了更强大的异步编程能力。支持链式调用、组合多个异步任务、异常处理等功能。对于简单的异步任务，Future已经足够使用；但对于涉及多个异步任务的组合、依赖关系或者需要复杂错误处理的情况，提供了更为强大和灵活的解决方案。掌握可以帮助开发者编写出更加高效、易读和可扩展的异步代码。
CompletableFuture异步关于异常的坑
记录、总结
03-22 3886
在使用异步CompletableFuture时，无论是否有返回值都要调用get()/join()方法，避免程序执行报错了，仍然返回成功。如果在程序报错时需要对上一个异步任务结果做其他操作，可以调用whenComplete()、handle()处理，如果只是对异常做处理，不涉及对上一个异步任务结果的情况，调用exceptionally()处理。
CompletableFuture在异常处理方面的一些常见问题和解决方案，建议牢记！
IT枫斗者的博客
03-13 5203
CompletableFuture是Java 8引入的一个类，位于包下。它提供了一种方便的方式来进行异步编程，尤其是在处理一系列并发任务时非常有用。CompletableFuture支持链式调用和组合多个异步任务。我们可以通过调用各种方法来注册回调函数，在任务完成时获取结果或处理异常。CompletableFuture提供了强大的功能来处理异步编程中的结果和异常。然而，在处理异常时，我们需要注意一些常见的陷阱。这包括异常被吞噬、异常处理丢失、堆栈追踪丢失和异常处理过于冗长。
JDK8-11-CompletableFuture（7）- thenApply，thenApplyAsync方法使用
sql2008help的博客
10-23 1940
回到顾客点餐，厨师炒菜打饭的例子：1.顾客进入餐厅2.顾客开始点餐3.厨师按照顾客所选菜品开始炒菜4.厨师打饭（假设没有服务员）5.顾客开始吃饭。
多线程异步编程之CompletableFuture入门-release
02-02
强化学习.您将收获: - 为什么会选择 CompletableFuture - 如何创建CompletableFuture异步任务 - CompletableFuture异步任务回调使用 - CompletableFuture异步任务编排 - CompletableFuture的异常处理
Java 异步编程——异步编排(CompletableFuture)
longool的博客
10-21 2043
CompletableFuture 是 JDK8 提出的一个支持非阻塞的多功能的 Future，提供了一种强大的异步编程模型，实现了 Future 接口；在使用 Future 的过程中，大家会发现 Future 有两种方式返回结果的方式CompletableFuture 接口提供了非常多的方法用于编排异步任务，基本每个方法都有两套实现，Async 版本的函数与非 Async 版本的函数。
Java 多线程与并发编程：使用 CompletableFuture 处理异步任务
数字魔方操控师的博客
05-05 812
在传统的同步编程模式下，程序按照顺序依次执行各个任务，当前任务完成后才会执行下一个任务。这种模式在处理 I/O 密集型任务（如网络请求、文件读写等）时，会造成线程长时间阻塞，导致系统资源浪费和响应速度下降。而异步编程允许程序在执行某个任务时，无需等待该任务完成即可继续执行其他任务，从而充分利用系统资源，提高程序的并发性能和响应效率。例如，在一个 Web 应用中，当服务器处理用户请求时，如果采用同步方式读取数据库或调用远程服务，线程会被阻塞，直到数据返回。
奇淫巧技，CompletableFuture 异步多线程是真的优雅
胸纳甲兵，烽烟起可靖疆晏海。
12-13 943
一个示例回顾Future通过CompletableFuture实现上面示例CompletableFuture创建方式异步回调方法异常回调多任务组合回调CompletableFuture使用有哪些注意点。
CompletableFuture详解~runAsync
热门推荐
小强快跑~~
02-27 3万+
这个例子创建一个一个异步执行的阶段： static void runAsyncExample() { CompletableFuture cf = CompletableFuture.runAsync(() -> { assertTrue(Thread.currentThread().isDaemon()); randomSleep(); }); assertFalse(cf.isDone()); sleepEnough();
Springboot利用CompletableFuture异步执行线程（有回调和无回调）
weixin_42966151的博客
10-12 7360
项目中总会有需要异步执行来避免浪费时间资源的情况，这就需要异步操作。异步又分两种： 1、无回调：有一些执行过程对用户而言不需要反馈回调，只需要自己执行即可，且执行过程时间较长（某些第三方接口，如发送短信验证码、查取ip属地等等），如果同步执行，势必会影响到用户体验，这时候就可以使用CompletableFuture.runAsync()方法了。 2、有回调：在执行异步操作结束后，需要获得异步方法返回的值，然后再回调给用户展示，这时候就需要用到CompletableFuture.supplyAsync()
【异步操作工具 CompletableFuture 详解】
Java之行
04-19 3557
CompletableFuture方法详解
CompletableFuture异步
qq_46229848的博客
04-10 1360
异步就是使用的线程，创建的时候使用 new 一个 Runnable，默认底层使用ForkJoinPool线程池。 CompletableFuture会从全局ForkJoinPool.commonPool()线程池获取来执行这些任务，当然， 你也可以创建一个线程池，并将其传递给runAsync() 和supplyAsync()方法，以使它们在从你指定的线程池获得的线程中执行任务。 CompletableFuture API中的所有方法都有两种变体，一种是接受传入的Executor参数作为指定的线程池，而另一个
java completableFuture并发异常抛出上层处理方法
qq976511508的博客
03-22 491
并发异常处理
CompletableFuture详解-初遇者-很细
码灵的博客
05-26 7078
CompletableFuture是jdk8的新特性。CompletableFuture实现了CompletionStage接口和Future接口，前者是对后者的一个扩展，增加了异步会点、流式处理、多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利。代码涉及到lambda表达式用法，不熟悉的可先看下。
CompletableFuture多任务异步，获取返回值，汇总结果
Cyms,BgXmSfXtsj !!!! Battle Each Moment !!!!
10-20 4896
supplyAsync(): 异步处理任务，有返回值whenComplete()：任务完成后触发，该方法有返回值。还有两个参数，第一个参数是任务的返回值，第二个参数是异常。allOf()：就是所有任务都完成时触发。allOf()可以配合get()一起使用。/*** 异步，多任务。汇总返回值*///该线程池仅用于示例，实际建议使用自定义的线程池//线程安全的list，适合写多读少的场景//任务完成时执行。用list存放任务的返回值if (result!= null) {
java 异步 返回值_java 异步
weixin_35864328的博客
02-13 5213
注：本文基于 jdk1.81. 异步不需要返回值；CompletableFuture.runAsync()示例代码如下：public JsonResult test() {JsonResult result = new JsonResult();CompletableFuture.runAsync(() -> {// 准备请求JsonResult postResult = appTool.p...
JAVA异步多线程批处理组件的设计与应用
下面将从标题“用JAVA写的一个异步多线程批处理的组件”所暗示的技术背景出发，详细阐述相关的知识点。 首先，要明确什么是批处理（Batch Processing）与多线程（Multithreading）。 批处理是指将大量的数据一次性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值