CompletableFuture

已于 2024-09-01 16:30:23 修改
阅读量342 收藏 11
点赞数 5
分类专栏： # 并发 文章标签： java 开发语言
于 2024-09-01 00:22:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16992475/article/details/141761488
版权

文章目录

参考

CompletableFuture使用详解

CompletableFuture使用详解（超详细）

【深度解析】万字长文，一文讲透CompletableFuture：Java异步编程的利器！

test_futureTask

public class Test002 {

    public static Logger log = LoggerFactory.getLogger(Test002.class);

    public static void main(String[] args) {

        test_futureTask();      
    }


    private static void test_futureTask() {

        // 1. Runnable没有返回值且无声明异常: run():void
        //    Callable有返回值且有声明异常:   call() throws Exception():V

        // 2. Runnable能够被线程所执行, Callable不能够被线程所执行

        // 3 Future接口定义了与异步任务相关的方法
        //     cancel(boolean):boolean
        //     get():V  throws InterruptedException, ExecutionException 
        //        如果任务中发生异常, 此方法将会抛出ExecutionException
        //        如果任务正在执行, 尚未执行完, 其它线程调用FutureTask的cancel(true)方法, 此方法将抛出CancelException
        //     get(long, TimeUnit):V throws InterruptedException, ExecutionException, TimeoutException
        //        如果任务中发生异常, 此方法将会抛出ExecutionException
        //        如果任务正在执行, 尚未执行完, 其它线程调用FutureTask的cancel(true)方法, 此方法将抛出CancelException
        //        如果超时未获取到结果, 此方法将抛出异常
        //     isCancelled():boolean
        //     isDone():boolean

        // 4. RunnableFuture接口继承了 Runnable接口 和 Future接口, 而 FutureTask实现了 RunnableFuture接口,
        //    所以FutureTask还需要传入1个Callable, 才能同时满足 多线程、异步接口、有返回值


        Callable<String> callable = () -> {

            log.info("come in===>");

            return "ok";
        };


        FutureTask<String> futureTask = new FutureTask<String>(callable);

        Thread t1 = new Thread(futureTask, "t1");

        t1.start();
    }

}

test_futureTaskWithThreadPool

package cn.itcast.redisdemo;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.*;

public class Test002 {

    public static Logger log = LoggerFactory.getLogger(Test002.class);

    public static void main(String[] args) {

        test_futureTaskWithThreadPool();

    }

    private static void test_futureTaskWithThreadPool() {

        ExecutorService threadPool = Executors.newFixedThreadPool(3);

        log.info("start...");

        // FutureTask是Runnable（可以被线程执行）和Future（可以获取异步结果）的组合
        // 而传入的Callable的call()方法则是封装了产生结果的逻辑
        FutureTask<String> futureTask1 = new FutureTask<String>(()->{
            TimeUnit.SECONDS.sleep(1);
            return "halo1";
        });

        FutureTask<String> futureTask2 = new FutureTask<String>(()->{
            TimeUnit.SECONDS.sleep(3);
            return "halo2";
        });

        FutureTask<String> futureTask3 = new FutureTask<String>(()->{
            TimeUnit.SECONDS.sleep(2);
            return "halo3";
        });

        threadPool.submit(futureTask1);
        threadPool.submit(futureTask2);
        threadPool.submit(futureTask3);

        // 提交1个Callable给线程池, 实际上会把这个Callable传给1个新创建的FutureTask, 并将此FutureTask返回
        Callable callable = new Callable() {
            @Override
            public Object call() throws Exception {
                TimeUnit.SECONDS.sleep(2);
                return "call";
            }
        };
        Future futureTask4 = threadPool.submit(callable);

        // 提交1个Runnable给线程池, 但是通过前面我们知道提交给线程池的会被封装为FutureTask, 而FutureTask需要的是1个Callable,
        // 所以这里使用了适配器模式 RunnableAdapter实现了Callable接口, 当执行完run方法后, 直接将此处传入的结果返回
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        Future futureTask5 = threadPool.submit(runnable, "run");


        try {
            futureTask1.get();
            futureTask2.get();
            futureTask3.get();

            futureTask4.get();
            futureTask5.get();

        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        log.info("end");


    }


}

FutureTask的缺点

  1. 对于简单的业务场景使用Future完全OK
  2. 回调通知
    • 应对Future的完成时间, 完成了可以告诉我, 也就是我们的回调通知
    • 通过轮询的方式去判断任务是否完成这样非常占用CPU并且代码不优雅
  3. 创建异步任务
    • Future + 线程池配合
  4. 多个任务前后依赖可以组合处理
    • 想将多个异步任务的计算结果组合起来，后一个异步任务的计算结果需要前一个异步任务的值
    • 将两个或多个异步计算合成一个异步计算，这几个异步计算五相独立，同时后面这个又依赖前一个处理的结果
  5. 对计算速度选最快
    • 当Future集合中某个任务最快结束时，返回结果，返回第一名处理结果

FutureTask的缺点: Future对于结果的获取不是很友好, 只能通过阻塞(future.get())或轮询(while(true) + future.isDone())的方式获得任务的结果

  1. get()方法在Future 计算完成之前会一直处在阻塞状态下
  2. isDone()方法容易耗费CPU资源
  3. 对于真正的异步处理我们希望是可以通过传入回调函数，在Future结束时自动调用该回调函数，这样，我们就不用等待结果。

阻塞的方式和异步编程的设计理念相违背，而轮询的方式会耗费无谓的CPU资源。因此，JDK8设计出CompletableFuture。

CompletableFuture提供了一种观察者模式类似的机制，可以让任务执行完成后通知监听的一方

CompletableFuture

CompletableFuture实现了 CompletionStage接口 和 Future接口

CompletionStage接口

代表异步计算过程中的某一个阶段，一个阶段完成以后可能会触发另外一个阶段，有些类似Linux系统的管道分隔符传参数

  1. CompletionStage代表异步计算过程中的某一个阶段，一个阶段完成以后可能会触发另外一个阶段
  2. 阶段的计算执行可以是一个Function, Consumer或者Runnable，
    比如: stage.thenApply(x -> square(x))
    .thenAccept(x-> System.out.print(x))
    .thenRun(() -> System.out.println())
  3. 一个阶段的执行可能是被单个阶段的完成触发，也可能是由多个阶段一起触发

CompletableFuture类

  1. 在Java8中，CompletableFuture提供了非常涯大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，并且提供了函数式编程的能力，可以通过回调的方式处理计算结果，也提供了转换和组合
  2. CompletableFuture 的方法它可能代表一个明确完成的Future， 也有可能代表一个完成阶段 ( CompletionSstage)，它支持在计算完成以后触发一些函数或执行某些动作。
  3. 它实现了Future和CompletionStage接口

CompletableFuture的4个静态方法

  1. runAsync无返回值
    public static CompletableFuture<Void> runAsync(Runnable runnable)
    public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor)
  2. supplyAsync有返回值
    public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)
    public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)

executor参数说明

  • 没有指定Executor的方法，直接使用默认的ForkJoinPool.commonPool()作为它的线程池执行异步代码。
  • 如果指定线程池，则使用我们自定义的或者特别指定的线程池执行异步代码

无返回值示例

ExecutorService threadPool = Executors.newFixedThreadPool(3);

// 一提交, 就开始异步执行了
CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
    try {
        log.info("runAsync无返回值");
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}, threadPool);


System.out.println(completableFuture.get());

有返回值示例

ExecutorService threadPool = Executors.newFixedThreadPool(3);

// 一提交, 就开始异步执行了
CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
    try {
        log.info("supplyAsync有返回值");
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "ok~";
}, threadPool);

// 也可以调用completableFuture.join()来获取结果
System.out.println(completableFuture.get());

Completable减少阻塞和轮询，自动回调

  • 从Java8开始引入了CompletableFuture，它是Future的功能增强版，减少阻塞和轮询
  • 可以传入回调对象，当异步任务完成或者发生异常时，自动调用回调对象的回调方注
CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
    log.info("enter...");
    try {
        TimeUnit.SECONDS.sleep(2);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    if (true) throw new RuntimeException("异常1");
    return new Random().nextInt(10);
}).whenComplete((result, throwable) -> {

    // 1. 不管上一步的任务是否发生异常, 这里都会走
    // 2. 这个whenComplete的返回值也是个CompletableFuture,
    //       如果上一步任务发生了异常, 那么whenComplete返回的CompletableFuture就是个失败的CompletableFuture, 所以后面如果再接exceptionally就会走exceptionally的逻辑
    //       如果上一步任务没有发生异常, 那么whenComplete返回的CompletableFuture就是个成功的CompletableFuture, 所以后面如果再接exceptionally就不会走exceptionally的逻辑
    //    总结来说就是这个whenComplete不会影响上个任务的CompletableFuture的状态
    // 3. 获取的result是上个任务的结果, throwable是上个任务的异常(如果有的话)
    // 4. 这里的whenComplete是去消费结果, 是上一步做完了(正常执行完获得结果而结束 或者是 发生了异常而结束), 再去处理这个做完的结果

    log.info("任务完成");

    // if (true) throw new RuntimeException("异常2");

    if (throwable == null) {
        log.info("产生的随机数是: {}", result);
    }


}).exceptionally(throwable -> {

    // 1. 如果发生了异常, 这里才会走(可以跟js的Promise一起理解, 1个CompletableFuture就是1个Promise, 就看这个CompletableFuture是个什么状态)
    // 2. 如果调用此exceptionally方法的CompletableFuture是失败的, 那么会走exceptionally中定义的逻辑,
    //    而exceptionally定义的方法返回的是1个新的CompletableFuture, 这个新的CompletableFuture状态与方法的逻辑有关
    log.info("任务发生异常:{}, 返回1个默认的值", throwable.getMessage());

	// 这里如果抛出异常, 当前的这个exceptionally后面再接exceptionally, 则后面的这个exceptinally收到的异常就是这里抛出来的异常了
    // if (true) throw new RuntimeException("异常3");

    return 100;

}); // 这里后面还可以继续接whenComplete和exceptionally

log.info("main...");

// 也可以通过CompletableFuture来获取结果
log.info("获取到最终的结果: {}", completableFuture.get());

// 主线程不要立刻结束，否则CompletableFuture默认使用的线程池会立刻关闭
LockSupport.park();


// CompletableFuture的优点
// 1. 异步任务结束时，会自动回调某个对象的方法;
// 2. 主线程设置好回调后，不再关心异步任务的执行，
// 3. 异步任务之间可以顺序执行异步任务出错时，会自动回调某个对象的方法;

CompletableFuture常用方法

1.获得结果和触发计算

@Slf4j
public class Test004 {

    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {

            log.info("enter...");

            //暂停几秒钟线程
            try {
                TimeUnit.SECONDS.sleep(1);
                if(true) throw new RuntimeException("异常1");
            } catch (Exception e) {
                e.printStackTrace();
            }

            log.info("ending...");

            return "abc";

        });

        // 一直等到有结果为止, 或者任务抛出异常
        // System.out.println(completableFuture.get());

        // 一直等到有结果为止, 或者任务抛出异常, 或者因超时而抛出超时异常
        // System.out.println(completableFuture.get(2L, TimeUnit.SECONDS));

        // 一直等到有结果为止, 或者任务抛出异常
        // System.out.println(completableFuture.join());

        // 立即拿结果不阻塞, 如果没有结果则返回给定值
        // System.out.println(completableFuture.getNow("xxx"));

        // TimeUnit.MILLISECONDS.sleep(100);

        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 尝试使用指定的值作为任务结果来结束任务, 返回值表示当前结束任务操作是否成功了
        // (如果任务尚未完成, 任务会继续执行, 但这个任务已经有结果了, 即使后面任务完成也不会修改结果)
        boolean triggered = completableFuture.complete("completedVal");

        log.info("trigger: {}", triggered);

        log.info("结果: {}", completableFuture.get());

        LockSupport.park();
    }
}

2.对计算结果进行处理

thenApply：计算结果存在依赖关系，使得这两个线程串行化（中间一步有异常时，不走下一步）

handle：计算结果存在依赖关系，使得这两个线程串行化（中间一步有异常时，接着往下处理）

3.对计算结果进行消费

thenAccept：接收上一步任务的处理结果，并消费处理，当前任务无返回结果

注意区别：

  • thenApply（需要上一步任务的结果，并且当前任务有返回结果）
  • thenRun（不需要上一步任务的结果）

异步线程池：

  1. 没有传入自定义线程池，都用默认线程池ForkJoinPool:
  2. 传入了一个自定义线程池的情况
    • 如果你执行第一个任务的时候，传入了一个自定义线程池:
      • 调用thenRun方法执行第二个任务时，则第二个任务和第一个任务是共用同一个线程池。
      • 调用thenRunAsync执行第二个时，则第一个任务使用的是你自己传入的线程池，第二个任务使用的是ForkJoin线程池

4.对计算速度进行选用

谁快用谁：applyEither

5.对计算结果进行合并

thenCombine

  • 两个CompletionStage任务都完成后，最终能把两个任务的结果一起交给thenCombine来处理
  • 先完成的先等着，等待其它分支任务
ps酷教程
关注
  • 5
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CompletableFuture实现的工具类
04-24
CompletableFuture实现的工具类 ，使用泛型实现各类多线程操作，满足大部分要求
Java多线程实战-CompletableFuture异步编程优化查询接口响应速度
热门推荐
qq_35716689的博客
03-20 22万+
CompletableFuture为Java提供了强大的异步编程能力,可以极大地提高应用的并发能力和响应速度。通过并行执行多个查询任务,我们可以大幅减少接口的响应时间,优化用户体验。同时,CompletableFuture的代码风格函数式、简洁、优雅,也使得代码更加易读易维护。 但是,异步编程也不是万能的,它需要开发者转变思维模式,还需要权衡利弊。在实际项目中,我们可以结合其他优化手段,选择合适的方案,以达到最佳的性能效果。
CompletableFuture使用详解
sermonlizhi的博客
03-08 11万+
一、简介 1.1 概述 在上一篇文章《CompletionService使用与源码分析》中，已经介绍过了Future的局限性，它没法直接对多个任务进行链式、组合等处理，需要借助并发工具类才能完成，实现逻辑比较复杂。 而CompletableFuture是对Future的扩展和增强。CompletableFuture实现了Future接口，并在此基础上进行了丰富的扩展，完美弥补了Future的局限性，同时CompletableFuture实现了对任务编排的能力。借助这项能力，可以轻松地组织不同任务的运行顺序、
在Spring Boot2中使用CompletableFuture的方法教程
08-26
在Spring Boot 2中，`CompletableFuture`是一个强大的工具，用于构建异步、非阻塞的应用程序。结合`@Async`注解，可以轻松地实现并发处理，提高应用的性能和响应速度。本文将深入探讨如何在Spring Boot 2中有效地...
Java并发 CompletableFuture异步编程的实现
08-25
Java并发 CompletableFuture异步编程的实现 在 Java 中，CompletableFuture 是一种异步编程的实现方式，它可以帮助开发者轻松地实现异步操作。CompletableFuture 的核心优势在于它可以将串行操作变成并行操作，从而...
CompletableFuture 异步处理
07-16
CompletableFuture<String> future = CompletableFuture.supplyAsync(task); future.thenAccept(result -> System.out.println("Received result: " + result)); ``` 在这个例子中，主线程不会阻塞，而是立即返回并...
Java基础（6）- Java代码笔记3
weixin_47062560的博客
08-30 617
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 9459
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
《深入理解 Java 中的适配器模式》
面团到油条的成长日记
08-29 6507
在软件开发的广阔领域中，不同接口之间不匹配的问题时常像个棘手的难题困扰着开发者。而适配器模式就像是一位得力的助手，专门用来解决这类问题。它的关键作用在于把一个类的接口有效地转化为客户端所期望的另一种接口，让原本因接口不相符而不能一起工作的两个类可以共同协作，学习本文希望你能有所收获
Java设计模式之建造者模式详细讲解和案例示范
weixin_39996520的博客
08-28 5091
建造者模式是一种创建型设计模式，允许用户通过一步步地构造复杂对象的方式来避免直接使用大量的构造函数或复杂的初始化过程。它通过将对象的创建过程分解为多个步骤，并允许这些步骤以链式调用的方式来执行，最终生成一个完全构建的对象。首先，我们定义一个Order类，该类包括了多个字段，如订单ID、客户信息、商品列表、配送地址等。// Getter方法省略...在这个例子中，类提供了构建Order对象所需的各个方法，每个方法返回实例，以便进行链式调用。
操作系统原子操作
zzt_is_me的博客
08-28 6130
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
基于Java+Springboot+Vue+elememt宠物用品商城系统设计实现
最新发布
央顺科技官方博客
08-31 991
随着信息技术的不断发展，我们现在已经步入了信息化的时代了，而信息时代的代表便是网络技术的日渐成熟，而现在网络已经和我们的生活紧密的联系起来了，我们不敢想象没有网络我们的生活会像怎么样，也许就像食物中没有调料现在的生活离开了网络会变得索然无味。通过网络我们可以足不出户的做许多事情，例如工作、娱乐、学习，交友和购物等等许多我们数之不尽的事情，而就是因为网络我们的生活变得多姿多彩，或许有时甚至帮我们省下不少的时间和给予了我们更多的机遇。宠物网上商城对我们来说就有这些意义。
spring-data-redis中RedisRepository仓储
OceanSky的专栏
08-27 459
Id@RedisHash注解的value属性和@Id注解指定键值的命名空间，组合成user:id；@RedisHash的属性timeToLive属性指定键值的超时时间。CrudRepository接口中默认定义实现了save、saveAll、findById、existsById、findAll、findAllById、count、deleteById、delete、deleteAllById、deleteAll等方法，基本满足了对redis操作的需求；如果有特殊需求可以自定义实现。
死锁及其产生条件
秋夫人
08-26 2851
死锁是指两个或多个线程（或进程）互相等待对方释放资源，导致所有相关线程都无法继续执行的情况。这是并发编程中的一个常见问题，可能会导致系统部分或完全停止响应。
优秀的开源项目
猪猪
08-28 556
目录热key多线程并行秒级百G级日志工具ES操作工具消息推送平台HTTP 客户端业务层的分布式限流组件企业级微服务解决方案hotkey: 京东App后台中间件，毫秒级探测热点数据，毫秒级推送至服务器集群内存，大幅降低热key对数据层查询压力asyncTool: 解决任意的多线程并行、串行、阻塞、依赖、回调的并行框架，可以任意组合各线程的执行顺序，带全链路执行结果回调。多线程编排一站式解决方案。来自于京东主App后台。asyncTool: 解决任意的多线程并行、串行、阻塞、依赖、回调的并行框架，可以任意组合各
输入三个正整数，找出不大不小的值
laocooon的博客
08-30 608
/ 找出最大值，找出最小值，然后不是最大值也不是最小值的。// 2、输入三个正整数，找出不大不小的值。
SpringBoot日常：扩展接口之CommandLineRunner和ApplicationRunner
qq_32590535的博客
08-28 489
日常开发中我们可能经常会遇到这样的场景，像启动容器完成后需要去执行一些业务逻辑，SpringBoot给我们提供了两个接口来帮助我们实现这种需求，两个启动加载接口分别是CommandLineRunner和ApplicationRunner。本文简单介绍如何使用该扩展点实现业务。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值