CompletableFuture的介绍及使用

最新推荐文章于 2024-06-26 09:42:02 发布
最新推荐文章于 2024-06-26 09:42:02 发布
阅读量2.1k 收藏 2
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44301905/article/details/126607924
版权

1、介绍

2、使用

2.1 异步执行

        CompletableFuture提供了四种异步方法执行任务，为以下4种

public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier){
     return asyncSupplyStage(ASYNC_POOL, supplier);
}
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier,
                                                       Executor executor) {
     return asyncSupplyStage(screenExecutor(executor), supplier);
}
public static CompletableFuture<Void> runAsync(Runnable runnable) {
     return asyncRunStage(ASYNC_POOL, runnable);
}
public static CompletableFuture<Void> runAsync(Runnable runnable,
                                                   Executor executor) {
     return asyncRunStage(screenExecutor(executor), runnable);
}
  1. 结合入参及方法，我们可用看出，以上四种方法其实可以分为2种 runAsync、supplyAsync。Executor executor 参数为指定的线程池，如果不指定则使用默认线程池。
  2. runAsync方法是返回值方法，supplyAsync为由返回值方法

2.2 并行方法

        添加异步执行方法

private static String sleepSecond(int x) {
        long sleep = 1000L * x;
        try {
            Thread.sleep(sleep);
        }catch (Exception e) {

        }
        String print = "睡眠%d秒";
        System.out.println(String.format(print, x));
        return String.valueOf(x);
    }
  • allOf()：当给定的所有CompletableFuture执行完成时，返回结果
    • allOf() 方法返回值无法获取异步执行方法的值，可以直接根据执行supplyAsync返回结果get()获取值
    • 以下为执行过程及结果
        String print = "任务执行%d秒";
        long start = System.currentTimeMillis();
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> sleepSecond(1));
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> sleepSecond(2));
        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> sleepSecond(3));
        CompletableFuture<Void> voidCompletableFuture = CompletableFuture.allOf(future1, future2, future3);
        System.out.println(voidCompletableFuture.get());
        System.out.println(future1.get());
        System.out.println(future2.get());
        System.out.println(future3.get());
        System.out.println(String.format(print, ( System.currentTimeMillis() - start)/1000));

        

  • anyOf()：当任意CompletableFuture执行完成时，返回结果
    • 使用anyOf()返回值对象进行get()，可以获取运行结果最快的方法的返回值
    • 当使用supplyAsync返回结果get()获取值时，如果，则结果和allOf()一致
        String print = "任务执行%d秒";
        long start = System.currentTimeMillis();
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> sleepSecond(1));
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> sleepSecond(2));
        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> sleepSecond(3));
        CompletableFuture<Object> objectCompletableFuture = CompletableFuture.anyOf(future1, future2, future3);
        System.out.println(objectCompletableFuture.get());
        System.out.println(String.format(print, (System.currentTimeMillis() - start) / 1000));

        

        String print = "任务执行%d秒";
        long start = System.currentTimeMillis();
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> sleepSecond(1));
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> sleepSecond(2));
        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> sleepSecond(3));
        CompletableFuture<Object> objectCompletableFuture = CompletableFuture.anyOf(future1, future2, future3);
        System.out.println(objectCompletableFuture.get());
        System.out.println(future1.get());
        System.out.println(future2.get());
        System.out.println(future3.get());
        System.out.println(String.format(print, (System.currentTimeMillis() - start) / 1000));

         

2.3 依赖关系

        异步执行方法见2.2

  • thenApply()：将前面的任务执行的结果当作入参给thenApply()方法
    • 注：thenApply()的入参类型和前面执行方法的返回值类型相同
    • 以下为方法执行代码及结果
String print = "任务执行%d秒";
        long start = System.currentTimeMillis();
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> sleepSecond(1))
                .thenApply(e -> sleepSecond(Integer.parseInt(e) + 1));
        System.out.println(future.get());
        System.out.println(String.format(print, (System.currentTimeMillis() - start) / 1000));

        

  •  thenCompose()：用来执行两个相关联的任务，返回结果为第二个任务的结果。一般用来执行第二个任务需要第一个任务返回结果处理业务
    • 以下为方法执行代码及结果
  
// 此处为2.2异步演示代码的关联演示代码
private static CompletionStage<String> completionTest(String x) {
        System.out.println("执行关联任务：" + x);
        CompletableFuture<String> future =CompletableFuture.supplyAsync(() -> sleepSecond(Integer.parseInt(x) + 1));
        return future;
}



 // 具体的代码演示
String print = "任务执行%d秒";
long start = System.currentTimeMillis();
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> sleepSecond(1))
      .thenCompose(CompletableFutureDemo::completionTest);
System.out.println(future.get());
System.out.println(String.format(print, (System.currentTimeMillis() - start) / 1000));

                

 2.4 并且合集关系

        异步执行方法见2.2

  • thenCombine()：将任务合并执行(多线程执行)，并且可以将任务返回值进行一起处理
    • 以下为方法执行代码及结果
        String print = "任务执行%d秒";
        long start = System.currentTimeMillis();
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> sleepSecond(1));
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> sleepSecond(2));
        CompletableFuture<String> combine = future.thenCombine(future1, new BiFunction<String, String, String>() {
            @Override
            public String apply(String s, String s2) {
                System.out.println(s + "，" + s2);
                return s + s2;
            }
        });
        System.out.println(combine.get());
        System.out.println(String.format(print, (System.currentTimeMillis() - start) / 1000));

                

  •  thenAcceptBoth()：两个任务执行完成后，将两个任务分返回值进行处理
    • 以下为方法执行代码及结果
        String print = "任务执行%d秒";
        long start = System.currentTimeMillis();
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> sleepSecond(1));
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> sleepSecond(2));
        future.get();
        future1.get();
        future.thenAcceptBoth(future1, new BiConsumer<String, String>() {
           @Override
           public void accept(String s, String s2) {
               System.out.println(s + ',' + s2);
           }
        });
        System.out.println(String.format(print, (System.currentTimeMillis() - start) / 1000));

                

  •  runAfterBoth()：正在两个方法都执行完成后，再执行下一步Runable()方法
    • 以下为方法执行代码及结果
        String print = "任务执行%d秒";
        long start = System.currentTimeMillis();
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> sleepSecond(1));
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> sleepSecond(2));
        future.get();
        future1.get();
        future.runAfterBoth(future1, new Runnable() {
            @Override
            public void run() {
                System.out.println("执行 runAfterBoth()方法");
            }
        });
        System.out.println(String.format(print, (System.currentTimeMillis() - start) / 1000));

                

 2.5 或者聚合执行方法

        异步执行方法见2.2

  • applyToEither()：两个执行的方法使用执行快的方法返回值，该方法有返回值
    • 以下为方法执行代码及结果
        String print = "任务执行%d秒";
        long start = System.currentTimeMillis();
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> sleepSecond(1))
                .applyToEither(CompletableFuture.supplyAsync(() -> sleepSecond(2)), new Function<String, String>() {
                    @Override
                    public String apply(String s) {
                        System.out.println("输出返回最快的结果值" + s);
                        return s;
                    }
                });
        future.get();
        System.out.println(String.format(print, (System.currentTimeMillis() - start) / 1000));

        ​​​​​​​        

  • acceptEither()：两个任务执行后，去执行最快的结果
    • 以下为方法执行代码及结果
        String print = "任务执行%d秒";
        long start = System.currentTimeMillis();
        CompletableFuture<Void> either = CompletableFuture.supplyAsync(() -> sleepSecond(1))
                .acceptEither(CompletableFuture.supplyAsync(() -> sleepSecond(2)), new Consumer<String>() {
                    @Override
                    public void accept(String s) {
                        System.out.println("输出执行快的结果" + s);
                    }
                });
        either.get();
        System.out.println(String.format(print, (System.currentTimeMillis() - start) / 1000));

        

 

  • runAfterEither()：任意一个任务执行完成，执行Runnable()方法
    • 以下为方法执行代码及结果
        String print = "任务执行%d秒";
        long start = System.currentTimeMillis();
        CompletableFuture<Void> either = CompletableFuture.supplyAsync(() -> sleepSecond(1))
                .runAfterEither(CompletableFuture.supplyAsync(() -> sleepSecond(2)), new Runnable() {
                    @Override
                    public void run() {
                        System.out.println("任意任务完成后执行方法");
                    }
                });
        either.get();
        System.out.println(String.format(print, (System.currentTimeMillis() - start) / 1000));

        ​​​​​​​        

 

xulong_87231
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CompletableFuture原理解析和使用
TonyWu的博客
09-09 3144
一：原理说明 原理说了没啥用，先了解一下怎么用，先体会使用的过程，再去了解原理 当前假若有一个任务正在执行，需要创建异步执行任务: 这个事交给异步线程去完成，主线程可以去做其他任务，这个异步线程任务可以将结果返回，主线程不需要阻塞等待获取结果 Callable，有结果的同步行为， Runnable，无结果的同步行为， Future，异步封装Callable/Runnable， CompletableFuture，封装Future， 二：使用 使用一：当前假若有一个任务正在执行，需..
CompletableFuture使用详解
m0_67391121的博客
07-27 3419
在上一篇文章《CompletionService使用与源码分析》中，已经介绍过了Future的局限性，它没法直接对多个任务进行链式、组合等处理，需要借助并发工具类才能完成，实现逻辑比较复杂。而是对Future的扩展和增强。实现了Future接口，并在此基础上进行了丰富的扩展，完美弥补了Future的局限性，同时实现了对任务编排的能力。借助这项能力，可以轻松地组织不同任务的运行顺序、规则以及方式。从某种程度上说，这项能力是它的核心能力。而在以往，虽然通过异步执行的，默认线程池是。中初始化的参数。...
CompletableFuture详解~allOf
热门推荐
小强快跑~~
02-28 4万+
当所有的阶段都完成后创建一个阶段 上一个例子是当任意一个阶段完成后接着处理，接下来的两个例子演示当所有的阶段完成后才继续处理, 同步地方式和异步地方式两种。 static void allOfExample() { StringBuilder result = new StringBuilder(); List messages = Arrays.asList("a", "b", "c"); List<CompletableFuture> futures = mes
Java8 CompletableFuture（7) CompletableFuture allOf 获取所有线程结果
Java Spring Elasticsearch
05-07 2万+
一、CompletableFuture allOf的优点 场景：当有一批任务交给线程池执行，我们需要获取所有线程的返回结果。 Future的get()时阻塞的，如果循环get()每一个线程的结果，一个线程会卡住后面所有线程 CompletionService的take().get()虽然不会因为某个线程阻塞后面的线程，但是功能不丰富 CompletableFuture提供的功能丰富，使用简单，代码优雅 二、测试案例 一串数字1, 2, 3, 4, 5, 6, 7, 8, 9, 10 开启线程，执行乘以
CompletableFuture使用（全网最详细！！！）
最新发布
国家专精特新小巨人、资深消防行业企业、国家高新技术企业、智慧消防技术实验室、准独角兽企业、浙江省电流AI技术研发中心
06-26 1171
前言普通情况下，我们的接口逻辑都是串行化的，有时候在我们方法中可能存在着非常耗时的操作这样就会造成代码阻塞，但是呢，为了用户的体验，我们可能需要将一些复杂的数据开启线程进行异步处理。所谓异步，其实就是实现一个可无需等待被调用函数的返回值而让操作继续运行的方法，简单的讲就是另启一个线程来完成调用中的部分计算，使调用继续运行或返回，而不需要等待计算结果。Java8 提供的可以自定义线程池或使用默认线程池对数据进行异步处理，且可以根据需求选择是否返回异步结果！灵活的使用。
多线程的利器：CompletableFuture 你还可以这样使用多线程
qq_39664892的博客
12-13 4722
Completable 多线程使用
CompletableFuture详细介绍及方法使用示例(一)
Ascend1977的博客
05-25 8623
CompletableFuture是Java 8中引入的一种实现异步编程模型的方式，它是Future的扩展，提供了更强大、更灵活的功能。CompletableFuture可以表示两个异步任务之间的顺序关系或并行关系，同时提供了一些方便的工具方法来组合这些关系。
completabletuture使用
08-19
下面将详细介绍`CompletableFuture`的一些核心知识点： 1. **创建实例：** - `supplyAsync`: 提供一个 Supplier，异步执行并返回结果。 - `thenApply`: 在上一步操作完成时，应用一个 Function 进行转换。 - `...
juc-learn:juc相关源码的分析以及使用介绍
03-23
本项目"juc-learn"专注于JUC相关源码的分析和使用介绍，旨在帮助开发者深入理解并熟练运用这些并发工具。 1. **并发基础** 在Java中，多线程是并发编程的基础。通过创建Thread对象或实现Runnable接口，我们可以...
jdk8新特性详细介绍
01-08
以下是JDK8主要新特性的详细介绍： 1. **Lambda表达式**：这是JDK8最显著的特性之一，它引入了一种新的语法结构，允许开发者以更简洁的方式处理函数式编程。Lambda表达式可以被视为没有名字的方法，可以在需要函数...
Udesk机器人API使用Demo
10-26
8. **异步调用**：为提高用户体验，可能需要使用异步调用来处理API请求，例如使用Java的CompletableFuture或者回调机制。 9. **测试与调试**：开发过程中，需要使用Postman等工具进行接口测试，确保请求和响应格式...
1.刘军 Dubbo 2.7.3_4版本新特性及发版计划介绍1
08-03
- 用户可以直接在接口中定义`CompletableFuture`类型的异步方法，或者同时定义同步和异步方法，方便使用。 5. **配置中心集群**： - 2.7版本支持注册中心、元数据中心和配置中心的集群配置，增强了系统的高可用性...
三、Java8的CompletableFuture，Java的多线程开发
Gefangenes的博客
05-28 6092
test05：开启异步2的改造 —— CompletableFuture.runAsync() 和 supplyAsync() —— 阻塞所有异步方法，一起提交。—— 阻塞线程：get、join。test08：CompletableFuture开启多线程——无返回值的——构建一个新List——先有数据的情况（基本和test07是一个方法）test09：CompletableFuture开启多线程——有返回值的，返回一个新的List——先有数据的情况——使用stream流的map。
completableFuture.allOf().get()方法原理分析
mameng1988的博客
05-07 2597
completableFuture.allOf()用于多任务共同返回，配合get()使用来实现任务的等待。get()方法内部是waittingGet(),其是while()循环判断返回结果为null的话，则一直等待，如果线程不为null、返回结果为null，则线程阻塞等待。
Java8新特性之CompletableFuture
u010074988的博客
07-01 1922
CompletableFuture java8推出，java9增强，功能非常强大，可以编排异步任务，完成串行执行，并行执行，AND 汇聚关系，OR 汇聚关系。任务之间的关系 并发、依赖、互斥先弄个工具类，用来后面进行打印调试。 1、 runAsync 和 supplyAsync方法 没有指定Executor的方法会使用ForkJoinPool.commonPool() 作为它的线程池执行异步代码。如果指定线程池，则使用指定的线程池运行。以下所有的方法都类同。下面例子completableFuture.
CompletableFuture使用教程
weixin_40719914的博客
09-26 1万+
Java 8 CompletableFuture 教程 原文链接：https://www.callicoder.com/java-8-completablefuture-tutorial/ Java 8 有大量的新特性和增强如 Lambda 表达式，Streams，CompletableFuture等。在本篇文章中我将详细解释清楚CompletableFuture以及它所有方法的使用。 什么是CompletableFuture？ 在Java中CompletableFuture用于异步编程，异步编程是编写
CompletableFuture 使用详解
江城宴的博客
12-22 7204
CompletableFuture 使用详解 1、 runAsync 和 supplyAsync方法 CompletableFuture 提供了四个静态方法来创建一个异步操作。 public static CompletableFuture<Void> runAsync(Runnable runnable) public static CompletableFuture&...
CompletableFuture的介绍
09-22
具体地说，你可以使用supplyAsync方法创建一个CompletableFuture对象，然后在该对象上调用get方法来获取任务的返回值。如果有多个CompletableFuture对象，你可以使用allOf方法将它们组合在一起进行并行处理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值