多线程CompletableFuture之常用方法示例

最新推荐文章于 2024-09-18 17:05:42 发布
最新推荐文章于 2024-09-18 17:05:42 发布
阅读量1.4k 收藏 4
点赞数
分类专栏： Springboot Java 多线程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50989469/article/details/127691878
版权
Java 同时被 3 个专栏收录
25 篇文章 1 订阅
订阅专栏
Springboot
14 篇文章 2 订阅
订阅专栏
多线程
4 篇文章 0 订阅
订阅专栏

文章目录


        多线程开发中CompletableFuture必不可少，对比传统的Thread、ThreadPool，CompletableFuture最大的优势是其非常强大的Future的扩展功能，可以在异步方法中获取返回值，类似前端的Promise，CompletableFuture最常用的方法中，run…方法都是没有返回结果的，supply…方法可以获取返回结果。想要写出高并发的程序需要CompletableFuture的支持，CompletableFuture可以完美解决各类复杂的高并发场景。

前期准备

配置ThreadPoolExecutor线程池，在相关类中把线程池注入进来

@Configuration
public class ThreadPoolExecutorConfig {
    @Bean
    public ThreadPoolExecutor threadPoolExecutor() {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(10, 20, 5, TimeUnit.SECONDS, new ArrayBlockingQueue<>(50));
        executor.allowCoreThreadTimeOut(true);
        return executor;
    }
}

	@Autowired
    private ThreadPoolExecutor executor;

1.runAsync

无返回值异步线程，泛型中为void类型，默认主程序不等待子线程

	@GetMapping("/test1")
    public void test1(){
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程任务执行结束");
        }, executor);
        System.out.println("执行主程序结束");
    }

执行结果

执行主程序结束
子线程任务执行结束

2.supplyAsync

有返回值异步线程，线程中必须要返回数据，泛型中的值与线程中的返回值需一致，默认主程序不等待子线程。如果需要获取子线程的返回值，调用get方法，主程序会等待子线程结束后执行

	@GetMapping("/test2")
    public void test2() throws ExecutionException, InterruptedException {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程任务执行结束");
            return "123";
        }, executor);
        System.out.println("执行主程序结束，不考虑返回值");
        System.out.println("执行主程序结束，线程返回值："+future.get());
    }

执行结果

执行主程序结束，不考虑返回值
子线程任务执行结束
执行主程序结束，线程返回值：123

3.thenRunAsync

上一步之后链式调用，一般与runAsync搭配使用，thenRunAsync中的方法在runAsync之后执行

	@GetMapping("/test3")
    public void test3(){
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程任务1执行结束");
        }, executor).thenRunAsync(() -> {
            System.out.println("子线程任务2执行结束");
        });
        System.out.println("执行主程序结束");
    }

执行结果

执行主程序结束
子线程任务1执行结束
子线程任务2执行结束

4.thenAcceptAsync

上一步之后调用（可以获取上一步的返回值），一般与supplyAsync搭配使用，thenAcceptAsync中的方法可以在supplyAsync之后才执行，可以获取supplyAsync的返回值

	@GetMapping("/test4")
    public void test4(){
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程任务1执行结束");
            return "456";
        }, executor);
        CompletableFuture<Void> future2 = future1.thenAcceptAsync((s) -> {
            System.out.println("子线程任务2获取任务1的数据：" + s);
        }, executor);
        System.out.println("执行主程序结束");
    }

执行结果

执行主程序结束
子线程任务1执行结束
子线程任务2获取任务1的数据：456

5.runAfterBothAsync

任务一、二都完成后执行当前任务，二者都要完成，组合任务不获取前两个任务返回值，且自己无返回值

	@GetMapping("/test5")
    public void test5() {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程任务1执行结束");
            return 10 / 2;
        }, executor);
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程任务2执行结束");
            return "hello";
        }, executor);
        CompletableFuture<Void> future3 = future1.runAfterBothAsync(future2, () -> {
            System.out.println("子线程任务3执行结束");
        }, executor);
        System.out.println("执行主程序结束");
    }

执行结果

执行主程序结束
子线程任务1执行结束
子线程任务2执行结束
子线程任务3执行结束

6.thenCombineAsync

任务一、二都完成后执行当前任务（可以获取任务一、二的返回值），二者都要完成，组合任务获取前两个任务返回值，且自己有返回值

	@GetMapping("/test6")
    public void test6() throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程任务1执行结束");
            return 10 / 2;
        }, executor);
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程任务2执行结束");
            return "hello";
        }, executor);
        CompletableFuture<String> future3 = future1.thenCombineAsync(future2, (s1,s2) -> {
            System.out.println("子线程任务3执行结束");
            return s1 + s2;
        }, executor);
        System.out.println("执行主程序结束，不考虑返回值");
        System.out.println("执行主程序结束，线程返回值：future1 = "+future1.get());
        System.out.println("执行主程序结束，线程返回值：future2 = "+future2.get());
        System.out.println("执行主程序结束，线程返回值：future3 = "+future3.get());
    }

执行结果

执行主程序结束，不考虑返回值
子线程任务1执行结束
执行主程序结束，线程返回值：future1 = 5
子线程任务2执行结束
执行主程序结束，线程返回值：future2 = hello
子线程任务3执行结束
执行主程序结束，线程返回值：future3 = 5hello

7.exceptionally

获取上一步的异常，指定某个任务执行异常时执行的回调方法，会将抛出异常作为参数传递到回调方法中

	@GetMapping("/test7")
    public void test7() throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(()->{
            return 10 / 0;
        }, executor);
        CompletableFuture<Integer> future2 = future1.exceptionally(exception -> {
            System.out.println("出现异常：" + exception);
            return 10; //出现异常，使用默认返回值
        });
        System.out.println("执行主程序结束，线程返回值："+future2.get());
    }

执行结果

出现异常：java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
执行主程序结束，线程返回值：10

8.handle

方法执行完成后的处理，获取返回值，处理异常，与exceptionally类似

	@GetMapping("/test8")
    public void test8() throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(()->{
            return 10 / 0;
        }, executor);
        CompletableFuture<Integer> future2 = future1.handle((result,exception) -> {
            if (exception == null) {
                return result;
            }
            System.out.println("handle处理异常：" + exception);
            return 10; //出现异常，使用默认返回值
        });
        System.out.println("执行主程序结束，线程返回值："+future2.get());
    }

执行结果

handle处理异常：java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
执行主程序结束，线程返回值：10

9.allOf

阻塞等待所有异步任务返回

	@GetMapping("/test9")
    public void test9() throws ExecutionException, InterruptedException {
        CompletableFuture<Void> future1 = CompletableFuture.runAsync(()->{
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程任务1执行结束");
        }, executor);
        CompletableFuture<Void> future2 = CompletableFuture.runAsync(()->{
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程任务2执行结束");
        }, executor);
        CompletableFuture<Void> future3 = CompletableFuture.runAsync(()->{
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程任务3执行结束");
        }, executor);
        // 阻塞等待所有异步任务返回
        CompletableFuture.allOf(future1, future2, future3).get();
        System.out.println("执行主程序结束");
    }

执行结果

子线程任务1执行结束
子线程任务2执行结束
子线程任务3执行结束
执行主程序结束

10.anyOf

所有异步任务只要有一个完成

	@GetMapping("/test10")
    public void test10() throws ExecutionException, InterruptedException {
        CompletableFuture<Void> future1 = CompletableFuture.runAsync(()->{
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程任务1执行结束");
        }, executor);
        CompletableFuture<Void> future2 = CompletableFuture.runAsync(()->{
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程任务2执行结束");
        }, executor);
        CompletableFuture<Void> future3 = CompletableFuture.runAsync(()->{
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程任务3执行结束");
        }, executor);
        // 阻塞等待某一个异步任务返回
        CompletableFuture.anyOf(future1, future2, future3).get();
        System.out.println("执行主程序结束");
    }

执行结果

子线程任务1执行结束
执行主程序结束
子线程任务2执行结束
子线程任务3执行结束
Jon Young
关注
专栏目录
【Java多线程】JUC之线程池(五) CompletionService 、CompletableFuture
墩墩分墩
03-10 1470
- 异步编程是编写`非阻塞的代码`，运行的任务`在一个单独的线程`，与`主线程隔离`，并且会`通知主线程它的进度`，`成功或者失败`。在这种方式中，`主线程不会被阻塞`，不需要一直等到子线程完成。`主线程可以并行的执行其他任务。`使用这种并行方式，可以极大的提高程序的性能。
Java 多线程工作之CompletableFuture.runAsync案例
u011556070的博客
01-26 3万+
在实际的工作中，我们会需要执行一些无返回的多线程任务以改善系统的运行效率。 接受kafka消息并对这些消息进行处理是一个典型案例，如果这里使用多线程的处理方式可以大大提高系统的处理性能。 以下就对CompletableFuture.runAsync的使用方式做一个案例展示 先定义一个处理的任务，这里可能是一个Runnable也可能是一个Callable，区别就是在于有无返回值 import lombok.extern.slf4j.Slf4j; /** * @author yhgu * @date 20
史上最强异步编程~CompletableFuture精读
最新发布
cnzzs的博客
09-18 1401
为什么用CompletableFuture？FutureCompletableFutureRxJavaReactorComposable(可组合)❌✔️✔️✔️Asynchronous(异步)✔️✔️✔️✔️Operator fusion(操作融合)❌❌✔️✔️Lazy(延迟执行)❌❌✔️✔️Backpressure(回压...
CompletableFuture的runAsync
Zhang Phil
07-13 2万+
CompletableFuture的runAsyncCompletableFuture的runAsync只是简单的异步执行一个线程，但是它将返回一个CompletableFuture，有了这个CompletableFuture，可以重新组装和调配，这是和一个普通Runnable不同之处。CompletableFuture future = CompletableFuture.runAsync(ne...
CompletableFuture详解~runAsync
热门推荐
小强快跑~~
02-27 3万+
这个例子创建一个一个异步执行的阶段： static void runAsyncExample() { CompletableFuture cf = CompletableFuture.runAsync(() -> { assertTrue(Thread.currentThread().isDaemon()); randomSleep(); }); assertFalse(cf.isDone()); sleepEnough();
CompletableFuture中的thenRun和thenRunAsync方法
liushuyul的博客
04-14 9018
需求： 我需要在做完第一件事情后返回结果A，再做第二件事情，第二件事情依赖结果A。 代码编程： @Resource(name = "globalThreadPool") private ThreadPoolExecutor threadPoolExecutor; CompletableFuture.supplyAsync(() -> { 做第一件事情; return A; },threadPoolExecutor).thenRun(()->{ 做第二件
【CompletableFuture的所有方法示例】
qq_41619801的博客
06-16 760
使用场景：当需要获取 CompletableFuture 的结果时，可以使用该方法。使用场景：当需要将一个 CompletableFuture 的结果传递给下一个阶段，并将结果合并成一个新的 CompletableFuture 对象时，可以使用该方法。使用场景：当需要在一个 CompletableFuture 的阶段完成后执行一个任务，而不需要访问阶段的结果时，可以使用该方法。使用场景：当需要将一个 CompletableFuture 的结果传递给下一个阶段，并对结果进行转换时，可以使用该方法。
多线程系列(二十) -CompletableFuture使用详解
程序员志哥的博客
03-11 1426
在上篇文章中，我们介绍了Future相关的用法，使用它可以获取异步任务执行的返回值。我们再次回顾一下Future相关的用法。
Java多线程之异步Future机制的原理和实现共5页.p
11-22
Java多线程是并发编程中的核心概念，尤其在服务器端应用和大数据处理中扮演着重要角色。异步Future机制是Java多线程中用于提升效率和优化资源利用的一种设计模式，它允许我们在主线程中不等待子线程的执行结果，而是...
深入理解Android多线程开发：场景应用与解决方案解析
喻志强的博客
06-09 251
在专栏之前的文章中，我们了解了并发、线程、线程安全、线程池等多线程开发的概念。本篇文章，我们来梳理一下在Android开发中我们面临的多线程开发中常见的应用场景和解决方案。随着技术的飞速发展，我们在处理多线程相关的业务场景时有了更多选择和更为简洁的解决方案。从早期的线程， Handler，到后来的 RxJava，再到现在的 Kotlin协程，每一代技术都在不断提升我们的开发效率和代码质量。及时更新项目的技术栈，采用新的库和框架，能够显著提高我们的开发效率，同时降低出错的成本。
异步使用completablefuture.runasync(() -＞ {})方法调用
m0_47146513的博客
08-19 6806
问题 　　CompletableFuture.runAsync() 返回CompletableFuture<Void>对象，调用CompletableFuture.allOf(f1,f2).join() 是否能够阻塞主线程 public static void main(String[] args) { CompletableFuture<Void> f1 = CompletableFuture.runAsync(() -> { .
使用CompletableFuture.runAsync()来完成异步任务
m0_46539364的博客
01-16 2万+
CompletableFuture 异步编排
CompletableFuture基本用法
weixin_34390105的博客
07-05 502
异步计算 所谓异步调用其实就是实现一个可无需等待被调用函数的返回值而让操作继续运行的方法。在 Java 语言中，简单的讲就是另启一个线程来完成调用中的部分计算，使调用继续运行或返回，而不需要等待计算结果。但调用者仍需要取线程的计算结果。 JDK5新增了Future接口，用于描述一个异步计算的结果。虽然 Future 以及相关使用方法提供了异步执行任务的能力，但是对于结果的获取却...
Java8 CompletableFuture runAsync等使用学习总结 submit() execute()等
weixin_44131922的博客
08-25 4194
返回的CompletableFuture是多个任务都执行完成后才会执行，只要有一个任务执行异常，则返回的 CompletableFuture 执行get方法时会抛出异常，如果都正常执行，则get返回null。指定某个任务执行异常时执行的回调方法，会将抛出异常作为参数传递到回调方法中，如果该任务正常执行则 exceptionally方法返回的CompletionStage的result就是该任务正常执行的结果。当某个任务执行完成后执行的回调方法，会将执行结果或者执行期间抛出的异常传递给回调方法。
Java8中CompletableFuture实现异步任务编排以及示例
BADAO_LIUMANG_QIZHI的博客
01-03 2114
在上面使用Future以及进行并发流程控制之外，可使用Java8新增的CompletableFuture。Future的局限性，它没法直接对多个任务进行链式、组合等处理，需要借助并发工具类才能完成，实现逻辑比较复杂。CompletableFuture是对Future的扩展和增强。CompletableFuture实现了Future接口，并在此基础上进行了丰富的扩展，完美弥补了Future的局限性，同时CompletableFuture实现了对任务编排的能力。
CompletableFuture 详解（二）：supplyAsync / runAsync 实现原理 源码分析(转载)
unlock的博客
02-26 3708
前面CompletableFuture详解（一）：基本概念及用法中讲了CompletableFuture的使用，从这篇开始，我会逐步讲解CompletableFuture的实现，以便于大家更深入的理解CompletableFuture是如何运行的，从而有利于大家正确且灵活地使用CompletableFuture。 本篇主要介绍 supplyAsync和runAsync的实现。 1、supplyAsync的实现 ...
java 多线程CompletableFuture.runAsync
qq_33101025的博客
11-23 894
点击跳转https://blog.csdn.net/u011556070/article/details/113177186
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值