CompletableFuture使用

最新推荐文章于 2025-04-10 15:37:50 发布
最新推荐文章于 2025-04-10 15:37:50 发布
阅读量498 收藏
点赞数
分类专栏： Thread java springboot 文章标签： java
原文链接：https://www.cnblogs.com/fingerboy/p/9948736.html
版权

CompletableFuture使用

在之前多线程的文章中会遇到一些问题：

 				while(!fs.isDone());//Future返回如果没有完成，则一直循环等待，直到Future返回完成
                System.out.println(fs.get());    //打印各个线程（任务）执行的结果

1）若Future返回没有完成，当前主线程是堵塞的，主线程业务会一直等着。

2）轮询调用isDone，不优雅。

解决上述问题并应对更多的需要：

1）很多个异步线程执行时间不一致，主线程业务不需要一直等着，可能只等最快的线程执行完或者最重要的任务执行完，或者等待固定的时间（比如几秒钟，防止调用超时），至于没返回结果的线程我就用默认值代替.

2）两个异步任务之间执行独立，但是第二个依赖第一个的执行结果。

CompletableFuture提供了函数式编程能力，使代码更加美观优雅，而且可以通过回调的方式计算处理结果，对异常处理也有了更好的处理手段。

CompletableFuture类四个静态方法执行异步任务:

  • 执行有返回值的任务了，方法的入参如果没有传入Executor对象将会使用ForkJoinPool.commonPool() 作为它的线程池执行异步代码。在实际使用中，一般使用自己创建的线程池对象来作为参数传入使用，提高线程速度。
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier){..}

public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier,Executor executor){..}
  • 用于执行没有返回值的任务，因为它的入参是Runnable对象。
public static CompletableFuture<Void> runAsync(Runnable runnable){..}

public static CompletableFuture<Void> runAsync(Runnable runnable,Executor executor)){..}

获取执行结果的几个方法

  • Future中的实现方式，get()会堵塞当前的线程，如果执行线程迟迟没有返回数据，get()会一直等待下去。抛出的是经过检查的异常，ExecutionException, InterruptedException 需要用户手动处理（抛出或者 try catch）。
V get();
  • 可以设置等待的时间。
V get(long timeout,Timeout unit);
  • 当有了返回结果时会正常返回，如果异步线程抛了异常会返回设置的默认值。
T getNow(T defaultValue);
  • 功能和 get() 方法是一样的，都是阻塞获取值，它们的区别在于 join() 抛出的是 unchecked Exception，不会强制开发者抛出，会将异常包装成CompletionException异常 /CancellationException异常，但是本质原因还是代码内存在的真正的异常。Exception in thread “main” java.util.concurrent.CompletionException: java.lang.ArithmeticException:
T join();

thenAccept()

  • 功能：当前任务的执行结果可以作为下一任务的输入参数，无返回值。
public CompletionStage<Void> thenAccept(Consumer<? super T> action);
public CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action);
public CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action,Executor executor);
  • 使用场景：执行任务A，待任务A正常返回之后，用A的返回值执行任务B。
    public static void main(String[] args) {
        CompletableFuture<String> futureA = CompletableFuture.supplyAsync(() -> {
            return "A";
        });
        futureA.thenAccept(A -> {
            System.out.println("打印依赖的线程返回值-"+ A);
        });
    }

thenApply()

  • 功能：当前任务正常完成以后执行，前任务的执行的结果会作为下一任务的输入参数，可实现任意多个任务的串联执行，有返回值
public <U> CompletableFuture<U>     thenApply(Function<? super T,? extends U> fn)
public <U> CompletableFuture<U>     thenApplyAsync(Function<? super T,? extends U> fn)
public <U> CompletableFuture<U>     thenApplyAsync(Function<? super T,? extends U> fn, Executor executor
  • 使用场景：执行任务A，待任务A正常返回之后，用A的返回值执行任务B，下一个任务的执行依赖上一个任务的结果，每个任务都有输入和输出。
public class MyCompletableFuture {
    public static void main(String[] args) {
        CompletableFuture<String> futureA = CompletableFuture.supplyAsync(() -> {
            return "A";
        });
        CompletableFuture<String> futureB = futureA.thenApply(A -> {
            System.out.println("打印依赖的线程返回值-"+ A);
            return "B";
        });
    }
}
  • 以上功能实现，我们可以先调用future.join()先得到任务A的返回值,然后再拿返回值做入参去执行任务B，而thenApply的存在就在于简化了这一步，我们不必因为等待一个计算完成而一直阻塞着调用线程，而是告诉CompletableFuture何时执行完就进行下一步，将多个任务串联起来了。

thenRun(…)

  • 功能：不关心上一步的计算结果，上一步执行完以后执行下一个操作。
public CompletionStage<Void> thenRun(Runnable action);
public CompletionStage<Void> thenRunAsync(Runnable action);
public CompletionStage<Void> thenRunAsync(Runnable action,Executor executor);
  • 场景：先执行任务A，任务A执行完以后执行任务B，任务B不接受任务A的返回值(不管A有没有返回值)，无返回值。
/**
* @creater keke
* @time 2021/1/22 15:29
* @description
*/
public class MyCompletableFuture2 {
   public static void main(String[] args) {
       CompletableFuture<String> futureA = CompletableFuture.supplyAsync(() -> {
           System.out.println("执行任务A");
           return "A";
       });
       futureA.thenRun(() -> System.out.println("执行任务B"));
   }
}

thenCombine(…) runAfterBoth(…)

  • 功能：结合两个CompletionStage的结果，进行转化后返回
public <U,V> CompletableFuture<V>     thenCombine(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn)
public <U,V> CompletableFuture<V>     thenCombineAsync(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn)
public <U,V> CompletableFuture<V>     thenCombineAsync(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn, Executor executor)
  • 场景：future1 和future2 相互独立，当都执行完毕的时候，使用方法:thenCombine(…)将两个任务的结果一块交给 thenCombine 来处理。

   public static void main(String[] args) throws ExecutionException, InterruptedException {

       CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "hello");
       CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "world");
       CompletableFuture<String> result = future1.thenCombine(future2, (t, u) ->
               t + " " + u
       );
       System.out.println(result.get());
   }

thenAcceptBoth(…)

  • 功能：当两个CompletionStage都执行完成后，把结果一块交给thenAcceptBoth来进行消耗。
public class MyThenAcceptBoth {
   public static void main(String[] args) {
       CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 1);
       CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 3);
       future1.thenAcceptBoth(future2, (t, u) ->
               System.out.println(t * u));
   }
}

applyToEither(…) acceptEither(…) runAfterEither(…)

  • 功能：两个CompletionStage，谁执行返回的结果快，我就用那个CompletionStage的结果进行下一步的转化操作。
public <U> CompletionStage<U> applyToEither(CompletionStage<? extends T> other,Function<? super T, U> fn);
public <U> CompletionStage<U> applyToEitherAsync(CompletionStage<? extends T> other,Function<? super T, U> fn);
public <U> CompletionStage<U> applyToEitherAsync(CompletionStage<? extends T> other,Function<? super T, U> fn,Executor executor);
  • 场景：查询结果有两种方式蓝牙和网络，两种方式查询速度不一致，我们希望哪个先返回就用那个的返回值。
public class MyApplyToEither {
    public static void main(String[] args) {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 5);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() ->{
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 7;
        });
        CompletableFuture<Integer> future3 = future1.applyToEither(future2,result -> result);
        System.out.println(future3.join());//输出：5
    }
}

exceptionally(…)

  • 功能：当运行出现异常时，调用该方法可进行一些补偿操作，如设置默认值.
public CompletionStage<T> exceptionally(Function<Throwable, ? extends T> fn);
  • 场景：异步执行任务A获取结果,如果任务A执行过程中抛出异常,则使用默认值"请重试！"返回.
public class MyExceptionally {
    public static void main(String[] args) {
        CompletableFuture<String> f1 = CompletableFuture.supplyAsync(() -> "异常:" + 100 / 0)
                .thenApply(s -> "f1 result:" + s)
                .exceptionally(e -> {
                    System.out.println(e.getMessage()); //java.lang.ArithmeticException: / by zero
                    return "f1 result: 请重试！";
                });

        System.out.println(f1.join());//输出"f1 result: 请重试！"
        CompletableFuture<String> f2 = CompletableFuture.supplyAsync(() -> "成功！" )
                .thenApply(s -> "f2 result:" + s)
                .exceptionally(e -> {
                    System.out.println(e.getMessage()); //java.lang.ArithmeticException: / by zero
                    return "f2 result: 请重试！";
                });

        System.out.println(f2.join());//输出"f2 result: 成功！"
    }
}

whenComplete(…)

  • 功能:：当CompletableFuture的结果成功执行，或者抛出异常的时候，都可以进入whenComplete方法执行。
public CompletionStage<T> whenComplete(BiConsumer<? super T, ? super Throwable> action);
public CompletionStage<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action);
public CompletionStage<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action,Executor executor);
  • 功能:当CompletableFuture的计算结果完成，或者抛出异常的时候，都可以进入whenComplete方法执行.
public class MyWhenComplete {
    public static void main(String[] args) {
        CompletableFuture<String> f1 = CompletableFuture.supplyAsync(() -> "结果是：" + 100 / 0)
                .thenApply(s -> "正确的结果是：" + s)
                .whenComplete((s, e) -> {
                    if (!Objects.isNull(s)) {
                        System.out.println(s);//未执行
                    }
                    if (Objects.isNull(e)) {
                        System.out.println(s);//未执行
                    } else {
                        System.out.println(e.getMessage());//java.lang.ArithmeticException: / by zero
                    }
                })
                .exceptionally(e -> {
                            System.out.println(e.getMessage());
                            return "请重试！";
                        }
                );
        System.out.println(f1.join());//请重试！
    }

}

  • 根据控制台,我们可以看出执行流程是这样,supplyAsync->whenComplete->exceptionally，,可以看出并没有进入thenApply执行，可见，thenApply只有当正常返回时才会去执行，而whenComplete不管是否正常执行都会进入。还要注意一点，whenComplete是没有返回值的。

  • 上面代码我们先调用whenComplete再调用exceptionally。如果我们先调用exceptionally再调用whenComplete会发生什么呢。结果是输出“返回结果是：请重试！请重试！”


public class MyWhenComplete {
    public static void main(String[] args) {
        CompletableFuture<String> f1 = CompletableFuture.supplyAsync(() -> "结果是：" + 100 / 0)
                .thenApply(s -> "正确的结果是：" + s)
                .exceptionally(e -> {
                            System.out.println(e.getMessage());
                            return "请重试！";
                        }
                )
                .whenComplete((s, e) -> {
                    if (Objects.isNull(e)) {
                        System.out.println("返回结果是："+s);//返回结果是：请重试！
                    } else {
                        System.out.println(e.getMessage());//java.lang.ArithmeticException: / by zero
                    }
                });
        System.out.println(f1.join());//请重试！
    }
}

handle(…)

  • 功能:：当CompletableFuture的计算结果完成，或者抛出异常的时候，可以通过handle方法对结果进行处理。
  • handle和whenComplete的区别
    　1.都是对结果进行处理,handle有返回值,whenComplete没有返回值
    　2.由于1的存在,使得handle多了一个特性,可在handle里实现exceptionally的功能
public <U> CompletionStage<U> handle(BiFunction<? super T, Throwable, ? extends U> fn);
public <U> CompletionStage<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn);
public <U> CompletionStage<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn,Executor executor);
  • 场景：用handle实现whenComplete+exceptionally的组合功能。
public class MyHandle {
   public static void main(String[] args) {
       CompletableFuture<String> f1 = CompletableFuture.supplyAsync(() -> "结果是：" + 100 / 0)
               .thenApply(s -> "正确的结果是：" + s)
               .handle((s,e)->{
                   if(Objects.isNull(e)){
                       System.out.println(s);//未执行
                   }else{
                       System.out.println(e.getMessage());//java.lang.ArithmeticException: / by zero
                   }
                   return "结果是:" + (s == null ? "请重试" : s);
               })
               .exceptionally(e-> e.getMessage());//未执行
       System.out.println(f1.join());//输出”结果是:请重试“
   }
}

allOf(…) anyOf(…)

  • 功能：　
    1.allOf:当所有的CompletableFuture都执行完后执行计算
    2.anyOf:最快的那个CompletableFuture执行完之后执行计算
public static CompletableFuture<Void>  allOf(CompletableFuture<?>... cfs)
public static CompletableFuture<Object>  anyOf(CompletableFuture<?>... cfs)
  • 场景：根据货物id分别查询订单，支付，物流，积分。
 public static void main(String[] args) {
       ExecutorService executorService = Executors.newFixedThreadPool(4);

       CompletableFuture<String> futureA = CompletableFuture.supplyAsync(() -> {
           try {
               Thread.sleep(1000 + RandomUtils.nextInt(1000));
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           return "订单详情";
       },executorService)
               .whenComplete((s,e)-> System.out.println(s));

       CompletableFuture<String> futureB = CompletableFuture.supplyAsync(() -> {
           return "支付信息";
       },executorService)
               .whenComplete((s,e)-> System.out.println(s));;

       CompletableFuture<String> futureC = CompletableFuture.supplyAsync(() -> {

           return "物流信息";
       },executorService)
               .whenComplete((s,e)-> System.out.println(s));;

       CompletableFuture<String> futureD = CompletableFuture.supplyAsync(() -> {
           return "积分信息";
       },executorService)
               .whenComplete((s,e)-> System.out.println(s));;

       CompletableFuture.allOf(futureA, futureB, futureC, futureD);
       /*输出：
       “支付信息
       物流信息
       积分信息
       订单详情”*/
       executorService.shutdown();
   }
shell的wait等待多后台执行
weixin_43588364的博客
09-14 2572
测试shell中的wait,linux版本Linux 3.10.0-327.62.59.83.h162.x86_64 x86_64, 在a.sh脚本中调用b.sh和c.sh脚本 a.sh脚本的内容 #!/bin/bash sh b.sh & sh c.sh & wait echo 'a脚本' `date` 执行完成 b.sh脚本的内容: #!/bin/bash echo 'start b' `date` sleep 20s echo 'b执行完成' `date` c.sh的脚本 #!/b
探索CompletableFuture：高效异步编程的利器
热门推荐
张彦峰的博客
11-19 169万+
随着现代软件系统的复杂性和用户需求的多样化，异步编程成为了提升系统性能和响应速度的重要手段。在Java领域，CompletableFuture作为Java 8引入的新特性，提供了强大的异步编程能力，极大地简化了多线程和并发任务的处理。本文将深入探讨CompletableFuture的基本功能和使用方法，介绍如何利用其提升程序的并发性能和代码的可维护性。
Git 回退版本
David_jiahuan的博客
11-12 494
如果想回退当前的提交操作，可以执行下面的操作步骤！ 1、先执行 git reset -hard 需要回退的版本号 注：需要回退的版本号可以通过项目的 gitlab 网址查看；也可以通过执行 git log 命令查看 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20201112173303740.png#pic_center) 执行了上面这一步之后，只是将本地的仓库回退到了指定版本，远程的仓库还未回退，所以还需要执行下面一步： 2、接着执行 git push .
JUC之Future、CompletableFuture
chengwe17的博客
04-10 778
可以把它简单理解为 系统中运行的一个应用程序，每个进程都有它自己的内存空间和 系统资源。同一个进程会有1个或多个线程，是大多数操作系统进行时序调度的基本单元，也被称为“轻量级进程（它是CPU调度的最小单位）get、join、getNow、complete方法（主动触发计算）。以上方法用来获取CompletableFuture的结果。// 获得结果和触发计算m1();/*** 获得结果和触发计算*/try {});// get会造成阻塞。
shell wait 等待命令
爱死亡机器人
10-16 1万+
bash wait 命令是一个 Shell 命令，它等待后台运行的进程完成并返回退出状态。与等待指定时间的sleep 命令不同，该wait命令等待所有或特定后台任务完成。
shell脚本中等待上一条命令执行结束在执行下一条。
attack_city_lion的博客
10-17 6万+
首先了解下背景知识。 命令生效顺序 Linux系统下命令生效的顺序有以下4条： 绝对路径或相对执行的命令； 别名； Bash的内部命令； 按照$PATH环境变量定义的目录查找顺序搜到的第一个命令。 实际shell脚本编写过程中，总会有这么一个场景， #!/bin/bash file=command1 command2 $file ​ 下...
shell 等待执行完成_如何解决 shell 脚本重复执行的问题
weixin_39876856的博客
12-18 2304
在开发过程中，经常会使用shell脚本去完成定时备份的任务，普遍的做法是通过系统的定时任务定时执行备份脚本设想这样一种场景，本次备份时间到了，自动执行备份脚本，如果备份比较耗时的话，会一直持续到下一次备份时间到了还未结束，下次备份又会自动调用备份脚本，相当于同一时间有两个进程在执行备份脚本，这可能会导致备份数据错乱或其他不可预知的问题更进一步，假如执行备份脚本消耗的时间远大于设置的备份间...
CompletableFuture使用中的生产事故
BUG指挥课堂
01-22 779
此时，尽管异步线程还在进行数据处理和外部 API 调用，但由于主线程的退出，所有异步操作都被中断，导致了未完成的任务丢失，数据处理中断，API 请求未能完成。这种行为在某些情况下会导致异步任务的中断或丢失，尤其是在异步线程需要较长时间执行的情况下，主线程退出后，异步线程的生命周期会受到影响，从而导致任务没有被正确完成。在没有线程池管理的情况下，当主线程退出时，如果没有其他活跃的用户线程，JVM 会检测到这是最后一个活跃的用户线程，因此会自动终止所有其他用户线程，包括异步线程。而引发线上事故的故事。
【异步编程】CompletableFuture使用示例
鹏啊鹏
09-05 785
通过几个demo来快速学习CompletableFuture的使用
多线程系列(二十) -CompletableFuture使用详解
程序员志哥的博客
03-11 1521
在上篇文章中，我们介绍了Future相关的用法，使用它可以获取异步任务执行的返回值。我们再次回顾一下Future相关的用法。
completablefuture 使用
最新发布
04-22
### 关于 CompletableFuture 的使用方法 #### 1. 基本概念 `CompletableFuture` 是 Java 中用于异步编程的一个强大工具类。相比传统的 `Future`，它不仅支持获取执行结果的功能，还扩展了许多特性，例如异常处理、...
调用Shell 执行exe 等待返回例子(VB)
11-27
在编程时，有些时候需要调用外部exe. 而且需要知道调用的情况，这个例子就是解决这个问题的……虽然是VB写的，我感觉看看思路……还是不错的
【博客179】创建守护进程步骤（一）
qq_43684922的博客
03-11 435
内容： 记录如何创建一个守护进程 守护进程： 一、概念 守护进程，又叫daemon进程，是Linux中的后台服务进程。 它是一个生存期较长的进程，通常独立于控制终端并且周期性地执行某种任务或者等待处理某些发生的事件。 二、意义 在Linux中，每一个系统与用户进行交流的界面称为终端，每一个从此终端开始运行的进程都会依附于这个 终端，这个终端称为这些进程的控制终端，当控制终端关闭时，相应的进程...
shell中等待其他程序执行完毕
evilstar2015的专栏
03-16 1万+
有时候，该shell脚本需要等到另一个shell脚本 或 程序执行完毕之后，才开始执行。   提供一种方法：   查看 前序 脚本或程序 的进程是否已经执行结束：   #如果有程序在make，则等待make结束 cnt=`ps -ef|grep "make"|grep "all"|grep -v grep|grep -v vi|wc -l` echo $cnt do    
x[:,:,None,:]-x[:,:,:,None]
j515332019的博客
09-16 5550
x[:,:,None,:]-x[:,:,:,None] None相当于在数组中多加一个维度。 输入： x = np.arange(24).reshape((2,3,4)) 输出： array([[[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]], [[12, 13, 14, 15], [16, 17, 18, 19], [20, 21, 22, 23]]]) x
【shell】shell实现等待用户输入
shuaixio的博客
03-30 1524
shell脚本等待用户输入，实现交互脚本，-n/-p/-t/-s选项，安装选项实现等
Shell 脚本等待上一行执行完成再执行下一行的方法
weixin_42609121的博客
10-12 3万+
在开发中，我们有时候需要使用 Shell 脚本完成一些简单的操作，但是往往有的操作比较耗时，但是我们又不得不等待它执行完成后才能进行下面的步骤，所以许多朋友往往使用sleep等方法来强制等待操作完成，其实完全没有必要，我们只需要使用一个小小的 tricky 方法就可以实现精准等待操作完成的效果。 Shell 默认提供了获取命令执行输出的方法，即用 ` 号将需要获取输出的操作括起来，并赋值给一个变量...
linux shell中的等待
weixin_33777877的博客
06-02 1412
sleep 等待进程完成（wait命令）--自：http://book.51cto.com/art/201003/188513.htm 格式： wait [n] Shell本身（不通过创建新进程的方法）执行wait，等待进程号为n的后台进程终止，并报告它的终止状态。如默认参数n，则等待Shell上所有当前活动的后台进程终止，并返回代码0。 还不是...
shell中wait命令详解
weixin_33973609的博客
04-20 1714
wait命令介绍 　　wait [作业指示或进程号] 　　1.等待作业号或者进程号制定的进程退出，返回最后一个作业或进程的退出状态状态。如果没有制定参数，则等待所有子进程的退出，其退出状态为0. 　　2.如果是shell中等待使用wait，则不会等待调用函数中子任务。在函数中使用wait，则只等待函数中启动的后台子任务。 　　3.在shell中使用wait命令，相当于高级语言里的多线程同步...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值