【Java】多线程异步编排CompletableFuture的Api方法学习

置顶杰肥啊

已于 2022-07-21 21:43:22 修改

阅读量5.3k

点赞数 4

分类专栏： Java 文章标签：多线程 java

于 2020-12-16 15:38:33 首次发布

本文链接：https://blog.csdn.net/javaboyweng/article/details/111281421

版权

Java 专栏收录该内容

47 篇文章 5 订阅

订阅专栏

异步任务编排CompletableFuture

特别说明：JDK1.8+之后引入 CompletableFuture

背景

在一些需求中，我们常常要给前端返回一些复杂的视图数据，数据之间可能有关联，比如查询了A数据之后才可以根据A数据中的一些信息来查询B数据。

再比如查询A数据与查询B数据一般没有相关性。假设查询A数据需要1秒,查询B数据需要1秒，那么以往的写法中，第一种情况返回给前端的时间总共花费2秒，

第二种情况返回给前端的时间也会是2秒。但这并不是我们愿意看到的，既然A数据跟B数据没有依赖性很强的情况下，应该可以并行查询进行封装，这样返回给前端的时间只需要花费1秒，这样大大增大了吞吐量，所以可以使用异步编排来解决该问题。

1.创建异步对象

提供四个静态方法来创建一个异步操作。

//创建异步
public static CompletableFuture<Void> runAsync(Runnable runnable);
//创建异步，支持传入线程池
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor);
//创建异步,并返回执行后的结果
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> sup);
//创建异步,支持传入线程池,并返回执行后的结果
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> sup, Executor executor)

1.runAsync方法都没有返回结果,supplyAsync方法都是有返回结果.

2.可以支持传入自己的线程池，或不传使用默认。

runAsync示例

//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
//第一种方式: runAsync
CompletableFuture.runAsync(() -> {
    System.out.println("执行runAsync方法....");
}, executorService);
System.out.println("执行main方法....");
//结果:
//执行main方法....
//执行runAsync方法....

supplyAsync示例

//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(5); 
//第二种方式:supplyAsync
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("执行supplyAsync方法...");
    return "hello,world";
}, executorService);
System.out.println("返回的结果是:"+future.get());
System.out.println("执行main方法....");
/**
结果:
执行supplyAsync方法...
返回的结果是:hello,world
执行main方法....
*/

2.完成回调和异常感知

某个异步任务完成之后执行某个任务


public CompletableFuture<T> whenComplete(
        BiConsumer<? super T, ? super Throwable> action);
//成功后回调异步执行,arg1:上次执行的结果，arg2:上次执行的异常
public CompletableFuture<T> whenCompleteAsync(
        BiConsumer<? super T, ? super Throwable> action);
//成功后回调异步执行,支持传入自己的线程池。arg1:上次执行的结果，arg2:上次执行的异常 
public CompletableFuture<T> whenCompleteAsync(
        BiConsumer<? super T, ? super Throwable> action, Executor executor);

whenComplete与whenCompleteAsync 区别在于一个是上一个执行完的线程继续执行,一个是交由其他线程来执行。

whenComplete示例

//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
//完成回调  成功后执行某个事情
CompletableFuture.supplyAsync(()->{
    System.out.println("刷牙....");
    return "先刷牙";
},executorService).whenComplete((res,err)->{
    System.out.println("洗脸..."+"上一次结果:"+res+"--错误:"+err);
});
System.out.println("执行main方法....");
/*
刷牙....
洗脸...上一次结果:先刷牙--错误:null
执行main方法....
*/

//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
//完成回调  成功后执行某个事情
CompletableFuture.supplyAsync(()->{
    System.out.println("刷牙....");
    int i=1/0;
    return "先刷牙";
},executorService).whenComplete((res,err)->{
    System.out.println("洗脸..."+"上一次结果:"+res+"--错误:"+err);
});
System.out.println("执行main方法....");
/*
执行main方法....
刷牙....
洗脸...上一次结果:null--错误:java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
*/

虽然能得到异常信息，但是没办法修改返回数据。使用方法exceptionally可以得到解决。

//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
//完成回调  成功后执行某个事情
CompletableFuture<String> exceptionally = CompletableFuture.supplyAsync(() -> {
    System.out.println("刷牙....");
    int i = 1 / 0;
    return "先刷牙";
}, executorService).whenComplete((res, err) -> {
    System.out.println("洗脸..." + "上一次结果:" + res + "--错误:" + err);
}).exceptionally(e->{
    return "异常了";
});
System.out.println("执行结果:"+exceptionally.get());
System.out.println("执行main方法....");
/*
刷牙....
洗脸...上一次结果:null--错误:java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
执行结果:异常了
执行main方法....
*/

3.使用handle方法

以上的whenComplete 以及exceptionally 都可以用handler代替

//由上一个执行的线程来继续执行  T:上一次执行的结果  U:返回结果
public <U> CompletableFuture<U> handle(
        BiFunction<? super T, Throwable, ? extends U> fn);
//由其他线程来执行 T:上一次执行的结果  U:返回结果
public <U> CompletableFuture<U> handleAsync(
        BiFunction<? super T, Throwable, ? extends U> fn);
//由其他线程来执行，支持传入线程池。 T:上一次执行的结果  U:返回结果
public <U> CompletableFuture<U> handleAsync(
        BiFunction<? super T, Throwable, ? extends U> fn, Executor executor);

handle示例

//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
CompletableFuture<String> handle = CompletableFuture.supplyAsync(() -> {
    System.out.println("刷牙...");
    int i = 1 / 0;
    return "正常刷完牙了";
}).handleAsync((res, err) -> {
    if (res != null) {
        return res;
    }
    if (err != null) {
        return "刷牙的时候有问题";
    }
    return "返回值是null,但也没抛异常";
},executorService);
System.out.println("执行结果:"+handle.get());
System.out.println("执行main方法....");
/*
刷牙...
执行结果:刷牙的时候有问题
执行main方法....
*/

4.线程串行化方法

//上一个任务执行后，接下来执行的任务  由上一次任务执行后的线程继续执行.
public CompletableFuture<Void> thenRun(Runnable action);
//上一个任务执行后，接下来执行的任务  由不同的线程继续执行.
public CompletableFuture<Void> thenRunAsync(Runnable action);
//上一个任务执行后，接下来执行的任务  由线程池继续执行.
public CompletableFuture<Void> thenRunAsync(Runnable action,Executor executor);

//上一个任务执行后，接收并接下来执行的任务
public CompletableFuture<Void> thenAccept(Consumer<? super T> action)；
//上一个任务执行后，接收并接下来执行的任务
public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action)；
//上一个任务执行后，接收并接下来执行的任务
public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action,Executor executor)；

//上一个任务执行后，接收并接下来执行的任务,并返回结果
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);

thenRun都是无返回值的，不需要上一次任务执行的结果。

thenAccept 都是可以接收到上一次任务执行的结果，用于下一次执行使用。

thenApply 接收上一次执行的结果，并有返回值。

thenRun示例

//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("刷牙...");
    return null;
}, executorService).thenRun(() -> {
    System.out.println("洗脸");
});
//阻塞等待方法
future.get();
/*
刷牙...
洗脸
*/

thenAccept示例

//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("刷牙...");
    return "我刷完了";
}, executorService).thenAcceptAsync(result -> {
    System.out.println("接收结果:"+result);
    System.out.println("洗脸");
});
//阻塞等待方法
future.get();
/*
刷牙...
接收结果:我刷完了
洗脸
*/

thenApply示例

//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("刷牙...");
    return "我刷完了";
}, executorService).thenApplyAsync(result -> {
    System.out.println("接受结果:"+result);
    System.out.println("洗脸");
    return "我洗完了";
});
//阻塞等待方法
String s = future.get();
System.out.println("最终结果:"+s);
/*
刷牙...
接受结果:我刷完了
洗脸
最终结果:我洗完了
*/

5.两任务组合-都要完成

当两个任务都执行完毕之后，再执行当前任务。

//两个任务都完成,没有接收他们的结果，没有返回值
public CompletableFuture<Void> runAfterBoth(CompletionStage<?> other,Runnable action) 
public CompletableFuture<Void> runAfterBothAsync(CompletionStage<?> other, Runnable action)
public CompletableFuture<Void> runAfterBothAsync(CompletionStage<?> other,Runnable action, Executor executor);
//两个任务都完成 ,接收他们的结果并执行新任务，没有返回值
public <U> CompletableFuture<Void> thenAcceptBoth(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action)
public <U> CompletableFuture<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action);
public <U> CompletableFuture<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action, Executor executor);
//两个任务都完成 接收他们的结果并执行新任务 并返回当前任务的返回值。
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);

runAfterBoth示例

//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("刷牙...");
    return "我刷完了";
}, executorService);

CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("洗脸...");
    return "我洗完了";
}, executorService);
future1.runAfterBothAsync(future2, () -> {
    System.out.println("吃饭");
}, executorService);
/*
刷牙...
洗脸...
吃饭
*/

thenAcceptBoth示例

//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("刷牙...");
    return "我刷完了";
}, executorService);

CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("洗脸...");
    return "我洗完了";
}, executorService);
future1.thenAcceptBothAsync(future2, (f1,f2) -> {
    System.out.println("接受f1结果:"+f1);
    System.out.println("接受f2结果:"+f2);
    System.out.println("吃饭");
}, executorService);
/*
刷牙...
洗脸...
接受f1结果:我刷完了
接受f2结果:我洗完了
吃饭
*/

thenCombine示例

//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("刷牙...");
    return "我刷完了";
}, executorService);

CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("洗脸...");
    return "我洗完了";
}, executorService);
CompletableFuture<String> future3 = future1.thenCombineAsync(future2, (f1, f2) -> {
    System.out.println("接受f1结果:" + f1);
    System.out.println("接受f2结果:" + f2);
    System.out.println("吃饭");
    return "吃完了";
}, executorService);
String s = future3.get();
System.out.println("最终结果:"+s);
/*
刷牙...
洗脸...
接受f1结果:我刷完了
接受f2结果:我洗完了
吃饭
最终结果:吃完了
*/

6.两任务组合-一个完成

只要两个任务完成一个，就会触发第三个任务的执行。

//接收某个任务执行完成的结果，有返回值.
public <U> CompletableFuture<U> applyToEither(CompletionStage<? extends T> other, Function<? super T, U> fn) 
public <U> CompletableFuture<U> applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T, U> fn)
public <U> CompletableFuture<U> applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T, U> fn
                                                   ,Executor executor);
//接收某个任务执行完成的结果，无返回值.
public CompletableFuture<Void> acceptEither(CompletionStage<? extends T> other, Consumer<? super T> action) ;
public CompletableFuture<Void> acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action);
public CompletableFuture<Void> acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action,Executor executor);
//不接收某个任务执行完成的结果，也无返回值.
public CompletableFuture<Void> runAfterEither(CompletionStage<?> other, Runnable action);
public CompletableFuture<Void> runAfterEitherAsync(CompletionStage<?> other,Runnable action) ;
public CompletableFuture<Void> runAfterEitherAsync(CompletionStage<?> other,Runnable action,Executor executor);

杰肥啊

关注

4
点赞
踩
12

收藏

觉得还不错? 一键收藏
打赏
4
评论
【Java】多线程异步编排CompletableFuture的Api方法学习

异步任务编排CompletableFuture特别说明：JDK1.8+之后引入 CompletableFuture背景在一些需求中，我们常常要给前端返回一些复杂的视图数据，数据之间可能有关联，比如查询了A数据之后才可以根据A数据中的一些信息来查询B数据。再比如查询A数据与查询B数据一般没有相关性。假设查询A数据需要1秒,查询B数据需要1秒，那么以往的写法中，第一种情况返回给前端的时间总共花费2秒，第二种情况返回给前端的时间也会是2秒。但这并不是我们愿意看到的，既然A数据跟B数据没有依赖性很强
复制链接

扫一扫