百练成钢02之异步编排(CompletableFuture)使用笔记

已于 2023-04-26 17:27:16 修改
阅读量447 收藏
点赞数
文章标签： java
于 2023-03-25 00:55:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41276800/article/details/129760627
版权

一、CompletableFuture创建

CompletableFuture提供了4中静态方法创建CompletableFuture对象，返回异步完成的新CompletableFuture，分别是：

1、CompletableFuture runAsync(Runnable runnable)：线程执行无返回值，使用CompletableFuture默认的线程池执行
2、CompletableFuture runAsync(Runnable runnable, Executor executor)：线程执行无返回值，使用传入的线程池
3、CompletableFuture supplyAsync(Supplier supplier)：线程执行有返回值，使用CompletableFuture默认的线程池执行
4、CompletableFuture supplyAsync(Supplier supplier,Executor executor)：线程执行有返回值，使用传入的线程池
注：
runAsync和supplyAsync区别：
runAsync无线程执行返回值，supplyAsync有线程执行返回值

方式一

CompletableFuture runAsync(Runnable runnable)
1、使用

CompletableFuture<Void> runAsyncFuture1 = CompletableFuture.runAsync(() -> System.out.println("打印当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName()));
System.out.println("等待线程执行完，获取CompletableFuture.runAsync响应结果"+runAsyncFuture1.get());

2、输出结果

打印当前运行线程，线程ID=20，线程名=ForkJoinPool.commonPool-worker-25
等待线程执行完，获取CompletableFuture.runAsync响应结果null

方式二

CompletableFuture runAsync(Runnable runnable, Executor executor)
1、使用

ThreadFactory threadFactory1 = runnable -> {
    Thread thread = new Thread(runnable);
    thread.setName("[threadFactory1]");
    return thread;
};
ThreadPoolExecutor executor1 = new ThreadPoolExecutor(5, 10, 10, TimeUnit.MILLISECONDS,new LinkedBlockingDeque<>(10) , threadFactory1, new ThreadPoolExecutor.AbortPolicy());
CompletableFuture<Void> runAsyncFuture2 = CompletableFuture.runAsync(() -> System.out.println("打印当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName()), executor1);
System.out.println("等待线程执行完，获取CompletableFuture.runAsync响应结果"+runAsyncFuture2.get());
executor1.shutdown();

2、结果输出

打印当前运行线程，线程ID=21，线程名=[threadFactory1]
等待线程执行完，获取CompletableFuture.runAsync响应结果nu

方式三

CompletableFuture supplyAsync(Supplier supplier)
1、使用

CompletableFuture<Integer> integerSupplyAsynFuture1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("打印当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
    return 10;
});
System.out.println("等待线程执行完，获取CompletableFuture.supplyAsync响应结果"+integerSupplyAsynFuture1.get());

2、结果输出

打印当前运行线程，线程ID=20，线程名=ForkJoinPool.commonPool-worker-25
等待线程执行完，获取CompletableFuture.supplyAsync响应结果10

方式四

CompletableFuture supplyAsync(Supplier supplier,Executor executor)
1、使用

ThreadPoolExecutor executor2 = new ThreadPoolExecutor(5, 10, 10, TimeUnit.MILLISECONDS,new LinkedBlockingDeque<>(10) , threadFactory2, new ThreadPoolExecutor.AbortPolicy());
CompletableFuture<Integer> integerSupplyAsynFuture2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("打印当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
    return 10;
},executor2);
System.out.println("等待线程执行完，获取CompletableFuture.supplyAsync响应结果"+integerSupplyAsynFuture2.get());
executor2.shutdown();

2、结果输出

打印当前运行线程，线程ID=22，线程名=[threadFactory2]
等待线程执行完，获取CompletableFuture.supplyAsync响应结果10

注: 以上创建CompletableFuture就会执行线程

public static CompletableFuture<Void> runAsync(Runnable runnable) {
	return asyncRunStage(asyncPool, runnable);
}

public static CompletableFuture<Void> asyncRunStage(Executor e, Runnable f) {
	if (f == null) throw new NullPointerException();
	CompletableFuture<Void> d = new CompletableFuture<Void>();
	e.execute(new AsyncRun(d, f));
	return d;
}

二、计算完成时回调方法

方法介绍

1、CompletableFuture whenComplete(BiConsumer<? super T, ? super Throwable> action)
2、CompletionStage whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action)
3、CompletionStage whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action,Executor executor)
4、CompletableFuture exceptionally(Function<Throwable, ? extends T> fn)
注：使用whenComplete不能改变返回结果，使用exceptionally根据异常处理情况可以更改。
whenComplete 可以处理正常和异常的计算结果，exceptionally 处理异常情况
方法加Async和不加Async的区别
a、不加Async是执行当前任务的线程执行继续执行 whenComplete 的任务（非默认线程池和自定义线程池，可以理解为main线程）
b、加Async是执行把 whenCompleteAsync 这个任务继续提交给线程池来进行执行。

方法一

CompletableFuture whenComplete(BiConsumer<? super T, ? super Throwable> action)
1、使用

System.out.println("===1、使用CompletableFuture<T> whenComplete(BiConsumer<? super T, ? super Throwable> action)====================================================================================");
// 1、使用CompletableFuture<T> whenComplete(BiConsumer<? super T, ? super Throwable> action)
CompletableFuture<String> whenCompleteFuture1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("打印CompletableFuture.runAsync当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
//            int i = 1/0;
    return "CompletableFuture.supplyAsync";
}).whenComplete((result, exception) -> {
    if (result != null){
        System.out.println("打印线程执行完成的结果参数：返回值=" + result + "，异常参数=" + exception);
    }
    if (exception !=null){
        System.out.println("打印线程执行完成的结果参数：返回值=" + result + "，异常参数=" + exception);
    }
    System.out.println("打印whenComplete当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
});
System.out.println("打印输出结果whenCompleteFuture1:"+whenCompleteFuture1.get());

2、结果输出

任务正常执行

===1、使用CompletableFuture<T> whenComplete(BiConsumer<? super T, ? super Throwable> action)====================================================================================
打印CompletableFuture.runAsync当前运行线程，线程ID=22，线程名=ForkJoinPool.commonPool-worker-25
打印线程执行完成的结果参数：返回值=CompletableFuture.supplyAsync，异常参数=null
打印whenComplete当前运行线程，线程ID=1，线程名=main
打印输出结果whenCompleteFuture1:CompletableFuture.supplyAsync

任务异常执行

===1、使用CompletableFuture<T> whenComplete(BiConsumer<? super T, ? super Throwable> action)====================================================================================
打印CompletableFuture.runAsync当前运行线程，线程ID=22，线程名=ForkJoinPool.commonPool-worker-25
打印线程执行完成的结果参数：返回值=null，异常参数=java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
打印whenComplete当前运行线程，线程ID=1，线程名=main
`Exception in thread "main" java.util.concurrent.ExecutionException: java.lang.ArithmeticException: / by zero
	at java.util.concurrent.CompletableFuture.reportGet(CompletableFuture.java:357)
	at java.util.concurrent.CompletableFuture.get(CompletableFuture.java:1908)
	at cn.study.zgm.thread01.completablefuture.create.CompletableFutureTest.main(CompletableFutureTest.java:111)
Caused by: java.lang.ArithmeticException: / by zero
	at cn.study.zgm.thread01.completablefuture.create.CompletableFutureTest.lambda$main$6(CompletableFutureTest.java:100)
	at java.util.concurrent.CompletableFuture$AsyncSupply.run$$$capture(CompletableFuture.java:1604)
	at java.util.concurrent.CompletableFuture$AsyncSupply.run(CompletableFuture.java)
	at java.util.concurrent.CompletableFuture$AsyncSupply.exec(CompletableFuture.java:1596)
	at java.util.concurrent.ForkJoinTask.doExec(ForkJoinTask.java:289)
	at java.util.concurrent.ForkJoinPool$WorkQueue.runTask(ForkJoinPool.java:1067)
	at java.util.concurrent.ForkJoinPool.runWorker(ForkJoinPool.java:1703)
	at java.util.concurrent.ForkJoinWorkerThread.run(ForkJoinWorkerThread.java:172)`

结果说明：CompletableFuture.runAsync中执行的线程CompletableFuture默认线程池调度的，而whenComplete中线程执行是使用main

方法二

CompletionStage whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action)
1、使用

CompletableFuture<String> whenCompleteAsyncFuture2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("打印CompletableFuture.runAsync当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
//            int i = 1/0;
    return "CompletableFuture.supplyAsync";
}).whenCompleteAsync((result, exception) -> {
    if (result != null){
        System.out.println("打印线程执行完成的结果参数：返回值=" + result + "，异常参数=" + exception);
    }
    if (exception !=null){
        System.out.println("打印线程执行完成的结果参数：返回值=" + result + "，异常参数=" + exception);
    }
    System.out.println("打印whenCompleteAsync(p1)当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
});
System.out.println("打印输出结果whenCompleteAsyncFuture2:"+whenCompleteAsyncFuture2.get());

2、结果输出

任务正常执行

===2、使用CompletionStage<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action)===================================================================================
打印CompletableFuture.runAsync当前运行线程，线程ID=22，线程名=ForkJoinPool.commonPool-worker-25
打印线程执行完成的结果参数：返回值=CompletableFuture.supplyAsync，异常参数=null
打印whenCompleteAsync(p1)当前运行线程，线程ID=22，线程名=ForkJoinPool.commonPool-worker-25
打印输出结果whenCompleteAsyncFuture2:CompletableFuture.supplyAsyn

任务异常执行

===2、使用CompletionStage<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action)===================================================================================
打印CompletableFuture.runAsync当前运行线程，线程ID=22，线程名=ForkJoinPool.commonPool-worker-25
打印线程执行完成的结果参数：返回值=null，异常参数=java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
打印whenCompleteAsync(p1)当前运行线程，线程ID=22，线程名=ForkJoinPool.commonPool-worker-25
`Exception in thread "main" java.util.concurrent.ExecutionException: java.lang.ArithmeticException: / by zero
	at java.util.concurrent.CompletableFuture.reportGet(CompletableFuture.java:357)
	at java.util.concurrent.CompletableFuture.get(CompletableFuture.java:1908)
	at cn.study.zgm.thread01.completablefuture.create.CompletableFutureTest.main(CompletableFutureTest.java:136)
Caused by: java.lang.ArithmeticException: / by zero
	at cn.study.zgm.thread01.completablefuture.create.CompletableFutureTest.lambda$main$8(CompletableFutureTest.java:125)
	at java.util.concurrent.CompletableFuture$AsyncSupply.run$$$capture(CompletableFuture.java:1604)
	at java.util.concurrent.CompletableFuture$AsyncSupply.run(CompletableFuture.java)
	at java.util.concurrent.CompletableFuture$AsyncSupply.exec(CompletableFuture.java:1596)
	at java.util.concurrent.ForkJoinTask.doExec(ForkJoinTask.java:289)
	at java.util.concurrent.ForkJoinPool$WorkQueue.runTask(ForkJoinPool.java:1067)
	at java.util.concurrent.ForkJoinPool.runWorker(ForkJoinPool.java:1703)
	at java.util.concurrent.ForkJoinWorkerThread.run(ForkJoinWorkerThread.java:172)`

结果说明：whenCompleteAsync不传线程池，使用CompletableFuture的默认线程池

方法三

CompletionStage whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action,Executor executor)
1、使用

        System.out.println("===3、CompletionStage<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action,Executor executor)===================================================================================");
// 3、CompletionStage<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action,Executor executor)
ThreadFactory threadFactory3 = runnable -> {
    Thread thread = new Thread(runnable);
    thread.setName("[threadFactory3]");
    return thread;
};
ThreadPoolExecutor executor3 = new ThreadPoolExecutor(5, 10, 10, TimeUnit.MILLISECONDS,new LinkedBlockingDeque<>(10) , threadFactory3, new ThreadPoolExecutor.AbortPolicy());
CompletableFuture<String> whenCompleteAsyncFuture3 = CompletableFuture.supplyAsync(() -> {
    System.out.println("打印CompletableFuture.runAsync当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
//            int i = 1/0;
    return "CompletableFuture.supplyAsync";
}).whenCompleteAsync((result, exception) -> {
    if (result != null){
        System.out.println("打印线程执行完成的结果参数：返回值=" + result + "，异常参数=" + exception);
    }
    if (exception !=null){
        System.out.println("打印线程执行完成的结果参数：返回值=" + result + "，异常参数=" + exception);
    }
    System.out.println("打印whenCompleteAsync(p1,p2) 当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
},executor3);
System.out.println("打印输出结果whenCompleteAsyncFuture3:"+whenCompleteAsyncFuture3.get());

2、结果输出

===3、CompletionStage<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action,Executor executor)===================================================================================
打印CompletableFuture.runAsync当前运行线程，线程ID=22，线程名=ForkJoinPool.commonPool-worker-25
打印线程执行完成的结果参数：返回值=CompletableFuture.supplyAsync，异常参数=null
打印whenCompleteAsync(p1,p2) 当前运行线程，线程ID=25，线程名=[threadFactory3]
打印输出结果whenCompleteAsyncFuture3:CompletableFuture.supplyAsync

结果说明：传入了线程池，调用whenCompleteAsync使用传入线程池创建的线程

方法四

CompletableFuture exceptionally(Function<Throwable, ? extends T> fn)
1、使用

System.out.println("===4、CompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn)===================================================================================");
//4、CompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn)
CompletableFuture<String> exceptionallyFuture4 = CompletableFuture.supplyAsync(() -> {
    System.out.println("打印CompletableFuture.runAsync当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
//            int i = 1/0;
    return "CompletableFuture.supplyAsync";
}).exceptionally(exception -> {
    if (exception != null) {
        System.out.println("打印线程执行完成的结果参数：异常参数=" + exception);
    }
    System.out.println("exceptionally当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
    return exception != null ? exception.toString() : "null";
});
System.out.println("打印输出结果exceptionallyFuture4:"+exceptionallyFuture4.get());

2、结果输出

任务正常执行

===4、CompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn)===================================================================================
打印CompletableFuture.runAsync当前运行线程，线程ID=22，线程名=ForkJoinPool.commonPool-worker-25
打印输出结果exceptionallyFuture4:CompletableFuture.supplyAsync

任务异常执行

===4、CompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn)===================================================================================
打印CompletableFuture.runAsync当前运行线程，线程ID=22，线程名=ForkJoinPool.commonPool-worker-25
打印线程执行完成的结果参数：异常参数=java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
exceptionally当前运行线程，线程ID=1，线程名=main
打印输出结果exceptionallyFuture4:java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero

结果说明：如果任务执行异常，则会执行exceptionally中的任务，并且可以对异常作为任务参数进行处理。

三、handle方法

CompletableFuture中handle相关方法如下：

1、CompletableFuture handle(BiFunction<? super T, Throwable, ? extends U> fn)
2、CompletableFuture handleAsync(BiFunction<? super T, Throwable, ? extends U> fn)
3、CompletableFuture handleAsync(BiFunction<? super T, Throwable, ? extends U> fn, Executor executor)
注： handle和但whenComplete的区别为：handler中可以对结果进行处理，而whenComplete不能

handleAsync方法

1、使用

System.out.println("CompletableFuture<U> handle(BiFunction<? super T, Throwable, ? extends U> fn)");
CompletableFuture<String> handleCompletableFuture = CompletableFuture.supplyAsync(() -> {
    System.out.println("打印CompletableFuture.runAsync当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
    int i = 1/0;
    return "CompletableFuture.supplyAsync";
}).handle((result, exception) -> {
    if (result != null){
        System.out.println("打印线程执行完成的结果参数：返回值=" + result + "，异常参数=" + exception);
    }
    if (exception !=null){
        System.out.println("打印线程执行完成的结果参数：返回值=" + result + "，异常参数=" + exception);
    }
    System.out.println("打印handle当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
    return "handle";
});
System.out.println("打印输出结果handleCompletableFuture="+handleCompletableFuture.get());

2、结果输出

CompletableFuture<U> handle(BiFunction<? super T, Throwable, ? extends U> fn)
打印CompletableFuture.runAsync当前运行线程，线程ID=20，线程名=ForkJoinPool.commonPool-worker-25
打印线程执行完成的结果参数：返回值=null，异常参数=java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
打印handle当前运行线程，线程ID=20，线程名=ForkJoinPool.commonPool-worker-25
打印输出结果handleCompletableFuture=handle

四、线程串行化方法

方法介绍

1、thenApply：可以接收前一个CompletableFuture 任务返回值，执行then后能返回结果
CompletableFuture thenApply(Function<? super T,? extends U> fn)
CompletableFuture thenApplyAsync(Function<? super T,? extends U> fn)
CompletableFuture thenApplyAsync(Function<? super T,? extends U> fn,Executor executor)
2、thenAccept：可以接收前一个CompletableFuture 任务返回值，执行then后不能返回结果
CompletableFuture thenAccept(Consumer<? super T> action)
CompletableFuture thenAcceptAsync(Consumer<? super T> action)
CompletableFuture thenAcceptAsync(Consumer<? super T> action,Executor executor)
3、thenRun： 不能接收前一个CompletableFuture 任务返回值，执行then后不能返回结果
CompletableFuture thenRun(Runnable action)
CompletableFuture thenRunAsync(Runnable action)
CompletableFuture thenRunAsync(Runnable action,Executor executor)
注：三者都是等待CompletableFuture前置任务执行完后，才会执行then中任务

方法使用

1、使用

 System.out.println("===1、CompletableFuture.supplyAsync=========================================");
 CompletableFuture<Void> thenRunCompletableFuture = CompletableFuture.supplyAsync(() -> {
//            try {
//                Thread.sleep(1000);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
     System.out.println("打印CompletableFuture.runAsync当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
//            int i = 1 / 0;
     return "CompletableFuture.supplyAsync";
 }).thenRunAsync(() -> {
     System.out.println("打印thenRun当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
 });
 System.out.println("返回thenRunCompletableFuture输出结果="+thenRunCompletableFuture.get());

 System.out.println("===2、CompletableFuture.thenAccept=========================================");
 CompletableFuture<Void> thenAcceptCompletableFuture = CompletableFuture.supplyAsync(() -> {
     try {
         Thread.sleep(1000);
     } catch (InterruptedException e) {
         e.printStackTrace();
     }
     System.out.println("打印CompletableFuture.runAsync当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
//            int i = 1 / 0;
     return "CompletableFuture.supplyAsync";
 }).thenAcceptAsync((result) -> {
     System.out.println("打印thenRun当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
     if (result!=null){
         System.out.println("打印CompletableFuture.supplyAsync执行结果="+result);
     }
 });
 System.out.println("返回thenRunCompletableFuture输出结果="+thenAcceptCompletableFuture.get());

 System.out.println("===3、CompletableFuture.thenAccept=========================================");
 CompletableFuture<String> thenApplyCompletableFuture = CompletableFuture.supplyAsync(() -> {
     try {
         Thread.sleep(1000);
     } catch (InterruptedException e) {
         e.printStackTrace();
     }
     System.out.println("打印CompletableFuture.runAsync当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
//            int i = 1 / 0;
     return "CompletableFuture.supplyAsync";
 }).thenApply((result) -> {
     System.out.println("打印thenRun当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
     if (result!=null){
         System.out.println("打印CompletableFuture.supplyAsync执行结果="+result);
     }
     return "thenApply";
 });
 System.out.println("返回thenRunCompletableFuture输出结果="+thenApplyCompletableFuture.get());

2、结果输出

===1、CompletableFuture.supplyAsync=========================================
打印CompletableFuture.runAsync当前运行线程，线程ID=22，线程名=ForkJoinPool.commonPool-worker-25
打印thenRun当前运行线程，线程ID=22，线程名=ForkJoinPool.commonPool-worker-25
返回thenRunCompletableFuture输出结果=null
===2、CompletableFuture.thenAccept=========================================
打印CompletableFuture.runAsync当前运行线程，线程ID=22，线程名=ForkJoinPool.commonPool-worker-25
打印thenRun当前运行线程，线程ID=22，线程名=ForkJoinPool.commonPool-worker-25
打印CompletableFuture.supplyAsync执行结果=CompletableFuture.supplyAsync
返回thenRunCompletableFuture输出结果=null
===3、CompletableFuture.thenAccept=========================================
打印CompletableFuture.runAsync当前运行线程，线程ID=23，线程名=ForkJoinPool.commonPool-worker-18
打印thenRun当前运行线程，线程ID=23，线程名=ForkJoinPool.commonPool-worker-18
打印CompletableFuture.supplyAsync执行结果=CompletableFuture.supplyAsync
返回thenRunCompletableFuture输出结果=thenApply

五、两任务组合-都要完成

方法介绍

任务一、任务二、两者都执行完成后,再执行任务三
1、thenCombine 能够接受前两个任务的返值作为参数任务三的参数，并且任务三可以有返回值
CompletableFuture thenCombine(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn)
CompletableFuture thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn)
CompletableFuture thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn, Executor executor)

2、thenAcceptBoth 能够接受前两个任务的返值作为参数任务三的参数，并且任务三没有有返回值
CompletableFuture thenAcceptBoth(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action)
CompletableFuture thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action)
CompletableFuture thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action, Executor executor)

3、runAfterBoth 不能接受前两个任务的返值作为参数任务三的参数，并且任务三没有有返回值
CompletableFuture runAfterBoth(CompletionStage<?> other,Runnable action) CompletableFuture runAfterBothAsync(CompletionStage<?> other,Runnable action)
CompletableFuture runAfterBothAsync(CompletionStage<?> other,Runnable action,Executor executor)

方法使用

以下以thenCombineAsync、runAfterBothAsync、runAfterBothAsync方法介绍
1、使用

CompletableFuture<String> supplyAsyncCompletableFuture1 = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(500);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("打印CompletableFuture.runAsync1当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
//            int i = 1 / 0;
    return "CompletableFuture.supplyAsync";
});
CompletableFuture<String> supplyAsyncCompletableFuture2 = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("打印CompletableFuture.runAsync2当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
//            int i = 1 / 0;
    return "CompletableFuture.supplyAsync";
});
System.out.println("===1、thenCombineAsync ===========================================================");
CompletableFuture<String> thenCombineAsyncFuture = supplyAsyncCompletableFuture1.thenCombineAsync(supplyAsyncCompletableFuture2, (o1, o2) -> {
    System.out.println("打印任务1结果="+o1+"，任务2结果="+o2);
    System.out.println("打印thenCombineAsync当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
    return "o1输出结果=" + o1 + " + o2输出结果=" + o2;
});
System.out.println("thenCombineAsyncFuture："+thenCombineAsyncFuture.get());
System.out.println("===2、thenAcceptBothFuture ===========================================================");
CompletableFuture<Void> thenAcceptBothFuture = supplyAsyncCompletableFuture1.thenAcceptBothAsync(supplyAsyncCompletableFuture2, (o1, o2) -> {
    System.out.println("打印任务1结果="+o1+"，任务2结果="+o2);
    System.out.println("打印thenCombineAsync当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
});
System.out.println("打印thenAcceptBothFuture输出结果："+thenAcceptBothFuture.get());
System.out.println("===3、thenAcceptBothAsync ===========================================================");
CompletableFuture<Void> runAfterBothAsyncFuture = supplyAsyncCompletableFuture1.runAfterBothAsync(supplyAsyncCompletableFuture2, () -> {
    System.out.println("打印thenCombineAsync当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
});
System.out.println("打印runAfterBothAsyncFuture输出结果："+runAfterBothAsyncFuture.get());

System.out.println("===main.sleep(2000)==========================================================================");
Thread.sleep(2000);

2、结果输出

===1、thenCombineAsync ===========================================================
打印CompletableFuture.runAsync1当前运行线程，线程ID=22，线程名=ForkJoinPool.commonPool-worker-25
打印CompletableFuture.runAsync2当前运行线程，线程ID=23，线程名=ForkJoinPool.commonPool-worker-18
打印任务1结果=CompletableFuture.supplyAsync，任务2结果=CompletableFuture.supplyAsync
打印thenCombineAsync当前运行线程，线程ID=23，线程名=ForkJoinPool.commonPool-worker-18
thenCombineAsyncFuture：o1输出结果=CompletableFuture.supplyAsync + o2输出结果=CompletableFuture.supplyAsync
===2、thenAcceptBothFuture ===========================================================
打印任务1结果=CompletableFuture.supplyAsync，任务2结果=CompletableFuture.supplyAsync
打印thenCombineAsync当前运行线程，线程ID=23，线程名=ForkJoinPool.commonPool-worker-18
打印thenAcceptBothFuture输出结果：null
===3、thenAcceptBothAsync ===========================================================
打印thenCombineAsync当前运行线程，线程ID=23，线程名=ForkJoinPool.commonPool-worker-18
打印runAfterBothAsyncFuture输出结果：null
===main.sleep(2000)==========================================================================

六、两任务组合-任一任务完成

方法介绍

任务一、任务二、两者任一个执行完成,立即执行任务三
1、applyToEither 能够接受前两个任务先执行完成的返回值作为参数任务三的参数，并且任务三可以有返回值
CompletableFuture applyToEither(CompletionStage<? extends T> other, Function<? super T, U> fn) CompletableFuture applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T, U> fn) CompletableFuture applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T, U> fn, Executor executor) 2、thenAcceptBoth 能够接受前两个任务先执行完成的返回值作为参数任务三的参数，并且任务三没有有返回值 CompletableFuture acceptEither(CompletionStage<? extends T> other, Consumer<? super T> action) CompletableFuture acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action) CompletableFuture acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action,Executor executor) 3、runAfterBoth 不能接受前接受前两个任务先执行完成的返回值作为参数任务三的参数，并且任务三没有有返回值 CompletableFuture runAfterEither(CompletionStage<?> other, Runnable action)
CompletableFuture runAfterEitherAsync(CompletionStage<?> other, Runnable action) CompletableFuture runAfterEitherAsync(CompletionStage<?> other, Runnable action,Executor executor)

方法使用

以下为applyToEitherAsync、acceptEitherAsync、runAfterEitherAsync方法介绍
1、使用

CompletableFuture<String> supplyAsyncFuture1 = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("打印CompletableFuture.runAsync1当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
//            int i = 1 / 0;
    return "CompletableFuture.supplyAsync1";
});
CompletableFuture<String> supplyAsyncFuture2 = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(500);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("打印CompletableFuture.runAsync2当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
//            int i = 1 / 0;
    return "CompletableFuture.supplyAsync2";
});
System.out.println("===1、applyToEitherAsync==============================================================");
// 注意因为是两者任一执行完，所以此处参数先执行完成任务的返回值
CompletableFuture<String> applyToEitherAsyncFuture = supplyAsyncFuture1.applyToEitherAsync(supplyAsyncFuture2, (o1) -> {
    System.out.println("打印任务结果=" + o1);
    System.out.println("打印applyToEitherAsync当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
    return "o1输出结果=" + o1;
});
System.out.println("打印applyToEitherAsyncFuture输出结果："+applyToEitherAsyncFuture.get());
System.out.println("===2、acceptEitherAsync==============================================================");
// 注意因为是两者任一执行完，所以此处参数先执行完成任务的返回值
CompletableFuture<Void> acceptEitherAsyncFuture = supplyAsyncFuture1.acceptEitherAsync(supplyAsyncFuture2, (o1) -> {
    System.out.println("打印任务结果=" + o1);
    System.out.println("打印acceptEitherAsync当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
});
System.out.println("acceptEitherAsyncFuture："+acceptEitherAsyncFuture.get());
System.out.println("===3、runAfterEitherAsync==============================================================");
// 注意因为是两者任一执行完，所以此处参数先执行完成任务的返回值
CompletableFuture<Void> runAfterEitherAsyncFuture = supplyAsyncFuture1.runAfterEitherAsync(supplyAsyncFuture2, () -> {
    System.out.println("打印runAfterEitherAsync当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
});
System.out.println("runAfterEitherAsyncFuture："+runAfterEitherAsyncFuture.get());

System.out.println("===main.sleep(2000)==========================================================================");
Thread.sleep(2000);

2、使用

===1、applyToEitherAsync==============================================================
打印CompletableFuture.runAsync2当前运行线程，线程ID=23，线程名=ForkJoinPool.commonPool-worker-18
打印任务结果=CompletableFuture.supplyAsync2
打印applyToEitherAsync当前运行线程，线程ID=23，线程名=ForkJoinPool.commonPool-worker-18
打印applyToEitherAsyncFuture输出结果：o1输出结果=CompletableFuture.supplyAsync2
===2、acceptEitherAsync==============================================================
打印任务结果=CompletableFuture.supplyAsync2
打印acceptEitherAsync当前运行线程，线程ID=24，线程名=ForkJoinPool.commonPool-worker-11
acceptEitherAsyncFuture：null
===3、runAfterEitherAsync==============================================================
打印runAfterEitherAsync当前运行线程，线程ID=24，线程名=ForkJoinPool.commonPool-worker-11
runAfterEitherAsyncFuture：null
===main.sleep(2000)==========================================================================
打印CompletableFuture.runAsync1当前运行线程，线程ID=22，线程名=ForkJoinPool.commonPool-worker-25

七、多任务组合

方法介绍

1、static CompletableFuture allOf(CompletableFuture<?>… cfs)

2、static CompletableFuture anyOf(CompletableFuture<?>… cfs)

方法使用

1、使用

        System.out.println("===CompletableFuture.allOf===========================");
CompletableFuture<String> supplyAsyncFuture1 = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("打印CompletableFuture.runAsync1当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
//            int i = 1 / 0;
    return "CompletableFuture.supplyAsync1";
});
CompletableFuture<String> supplyAsyncFuture2 = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(500);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("打印CompletableFuture.runAsync2当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
//            int i = 1 / 0;
    return "CompletableFuture.supplyAsync2";
});
CompletableFuture<Void> allOfFuture = CompletableFuture.allOf(supplyAsyncFuture1, supplyAsyncFuture2);
System.out.println("打印allOfFuture输出结果="+allOfFuture.get());
System.out.println("打印supplyAsyncFuture1输出结果="+supplyAsyncFuture1.get());
System.out.println("打印supplyAsyncFuture2输出结果="+supplyAsyncFuture2.get());

Thread.sleep(5000);
System.out.println("===CompletableFuture.anyOf===========================");
CompletableFuture<String> supplyAsyncFuture3 = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("打印CompletableFuture.runAsync3当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
//            int i = 1 / 0;
    return "CompletableFuture.supplyAsync3";
});
CompletableFuture<String> supplyAsyncFuture4 = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(500);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("打印CompletableFuture.runAsync4当前运行线程，线程ID=" + Thread.currentThread().getId() + "，线程名=" + Thread.currentThread().getName());
//            int i = 1 / 0;
    return "CompletableFuture.supplyAsync4";
});
CompletableFuture<Object> anyOfFuture = CompletableFuture.anyOf(supplyAsyncFuture3, supplyAsyncFuture4);
System.out.println("打印anyOfFuture输出结果="+anyOfFuture.get());
System.out.println("打印supplyAsyncFuture3输出结果="+supplyAsyncFuture3.get());
System.out.println("打印supplyAsyncFuture4输出结果="+supplyAsyncFuture4.get());
Thread.sleep(5000);

2、结果输出

===CompletableFuture.allOf===========================
打印CompletableFuture.runAsync2当前运行线程，线程ID=23，线程名=ForkJoinPool.commonPool-worker-18
打印CompletableFuture.runAsync1当前运行线程，线程ID=22，线程名=ForkJoinPool.commonPool-worker-25
打印allOfFuture输出结果=null
打印supplyAsyncFuture1输出结果=CompletableFuture.supplyAsync1
打印supplyAsyncFuture2输出结果=CompletableFuture.supplyAsync2
===CompletableFuture.anyOf===========================
打印CompletableFuture.runAsync4当前运行线程，线程ID=23，线程名=ForkJoinPool.commonPool-worker-18
打印anyOfFuture输出结果=CompletableFuture.supplyAsync4
打印CompletableFuture.runAsync3当前运行线程，线程ID=22，线程名=ForkJoinPool.commonPool-worker-25
打印supplyAsyncFuture3输出结果=CompletableFuture.supplyAsync3
打印supplyAsyncFuture4输出结果=CompletableFuture.supplyAsync4
好过难过去
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
颜成钢_Visual C++ 2010开发权威指南.part1.rar
01-12
颜成钢_Visual C++ 2010开发权威指南.part1.rar
奇淫巧技，CompletableFuture 异步多线程是真的优雅
weixin_57907028的博客
08-16 3076
CompletableFuture的get()方法是阻塞的，我们一般建议使用future.get(5, TimeUnit.SECONDS)。并且一般建议使用自定义线程池。但是如果线程池拒绝策略是DiscardPolicy或者DiscardOldestPolicy，当线程池饱和时，会直接丢弃任务，不会抛弃异常。因此建议，CompletableFuture线程池策略最好使用AbortPolicy，然后耗时的异步线程，做好线程池隔离哈。...
CompletableFuture 详解（二）：supplyAsync / runAsync 实现原理 源码分析
热门推荐
tongtest的博客
07-25 4万+
前面CompletableFuture详解（一）：基本概念及用法讲了CompletableFuture的使用，从这篇开始，我们深入了解CompletableFuture的实现，以便于大家更深入的理解CompletableFuture是如何运行的，这也有利于大家正确地使用CompletableFuture。 本篇主要介绍 supplyAsync和runAsync的实现。 1、supplyAsync的实现 我们主要看入参为Supplier的版本。因为另外一个版本的supplyAsync函数，除了增加了自定
CompletableFuture 使用详解
nickDaDa的博客
07-24 4232
以下所有的方法都类同。thenCombine会把两个CompletionStage的任务都执行完成后，把两个任务的结果一块交给thenCombine来处理。两个CompletionStage，谁执行返回的结果快，我就用那个CompletionStage的结果进行下一步的转化操作。两个CompletionStage，谁执行返回的结果快，我就用那个CompletionStage的结果进行下一步的消耗操作。从示例代码中可以看出，该方法只是消费执行完成的任务，并可以根据上面的任务返回的结果进行处理。...
CompletableFuture在异常处理方面的一些常见问题和解决方案，建议牢记！
m0_73311735的博客
06-29 7868
CompletableFuture是Java 8引入的一个类，位于java.util.concurrent包下。它提供了一种方便的方式来进行异步编程，尤其是在处理一系列并发任务时非常有用。CompletableFuture支持链式调用和组合多个异步任务。我们可以通过调用各种方法来注册回调函数，在任务完成时获取结果或处理异常。CompletableFuture提供了强大的功能来处理异步编程中的结果和异常。然而，在处理异常时，我们需要注意一些常见的陷阱。
Java8 CompletableFuture（3）异常处理 exceptionally
Java Spring Elasticsearch
05-07 1万+
Java8 CompletableFuture exceptionally一、前言二、测试案例 一、前言 在写代码时，经常需要对异常进行处理，最常用的就是try catch。 在用CompletableFuture编写多线程时，如果需要处理异常，可以用exceptionally，它的作用相当于catch。 exceptionally的特点： 当出现异常时，会触发回调方法exceptionally exceptionally中可指定默认返回结果，如果出现异常，则返回默认的返回结果 二、测试案例 publi
CompletableFuture详解~异常处理
小强快跑~~
02-28 8856
计算结果完成时的回调方法 当 CompletableFuture 的计算结果完成，或者抛出异常的时候，可以执行特定的 Action。主要是下面的方法： public CompletableFuture<T> whenComplete(BiConsumer<? super T,? super Throwable> action) public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T,
CompletableFuture的exceptionally
Zhang Phil
07-12 1万+
CompletableFuture的exceptionally代码：private void test() { System.out.println("开始..."); CompletableFuture.supplyAsync(new Supplier&lt;String&gt;() { @Override public String get()...
CompletableFuture异步编程详解
我还可以
06-25 818
先来回顾下Future，Future是JDK1.5中添加的接口，主要功能为：但Future也有着非常明显的缺点：上面介绍了Future的缺点，这些问题都可以通过类解决，主要方法有： 可以看出，supply开头的两个方法是有返回值的，而run开头的两个方法是没有返回值的，至于第二个方法传入的Executor，这个在编码中可以自定义； 功能：当前任务正常完成以后，可将当前任务的返回值作为参数传给下一个任务； 执行任务A，任务A执行完成之后，将任务A返回值作为参数传入给任务B，打印结果为3： 实际场景 以工作中常
CompletableFuture中的CompletionException异常真是坑到我了！
BASK2312的博客
03-09 1316
复制代码。
JavaSE百练成钢之新手入门
07-03
这是我专栏博客第一篇文章的配套资源，如果有不想看博客的可以直接下载，适合没有接触过java的新手小白，主要讲了计算机、java的背景知识和JDK环境的安装配置。
颜成钢_Visual C++ 2010开发权威指南.part3.rar
01-12
颜成钢_Visual C++ 2010开发权威指南.part3.rar
Visual C++ 2010开发权威指南—作者：尹成 , 颜成钢
02-06
Visual C++ 2010开发权威指南—作者：尹成 , 颜成钢 文件较大，故只提供下载地址，内含《Visual C++ 2010开发权威指南》（书籍）、代码、以及视频讲解！（版权所有，请勿翻录！）
颜成钢_Visual C++ 2010开发权威指南.part2.rar
01-12
颜成钢_Visual C++ 2010开发权威指南.part2.rar
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 304
都是符合我们的预期的。
string模拟实现
m0_73969414的博客
04-23 1421
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 570
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
javaweb-SpringBoot基础
kussm_的博客
04-20 1319
Spring的官网(Spring的简介：Spring makes Java simple。Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率。创建一个子包controller。
第5 章 Consul服务注册与发现
a13763926743的博客
04-22 752
consul官网地址。
迭代器模式
最新发布
LuckFairyLuckBaby的博客
04-23 477
迭代器模式(Iterator),提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值