首页  思维导图  详情

CompletableFuture

2024-12-18 01:42:54   1  举报





AI智能生成

知识结构

CompletableFuture

异步线程

技能提升

后端开发

作者其他创作

大纲/内容

基础介绍

CompletableFuture是jdk8的新特性。CompletableFuture实现了CompletionStage接口和Future接口，前者是对后者的一个扩展，增加了异步会点、流式处理、多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利。

文章地址

https://blog.csdn.net/zsx_xiaoxin/article/details/123898171

创建异步任务

supplyAsync

说明

supplyAsync是创建带有返回值的异步任务。它有如下两个方法，一个是使用默认线程池（ForkJoinPool.commonPool()）的方法，一个是带有自定义线程池的重载方法

使用

// 带返回值异步请求，默认线程池 public static CompletableFuture supplyAsync(Supplier supplier) // 带返回值的异步请求，可以自定义线程池 public static CompletableFuture supplyAsync(Supplier supplier, Executor executor)

测试代码

public static void main(String[] args) throws ExecutionException, InterruptedException {         CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> {             System.out.println("do something....");             return "result";         });         //等待任务执行完成         System.out.println("结果->" + cf.get()); } public static void main(String[] args) throws ExecutionException, InterruptedException {         // 自定义线程池         ExecutorService executorService = Executors.newSingleThreadExecutor();         CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> {             System.out.println("do something....");             return "result";         }, executorService);         //等待子任务执行完成         System.out.println("结果->" + cf.get()); }

结果

runAsync

说明

runAsync是创建没有返回值的异步任务。它有如下两个方法，一个是使用默认线程池（ForkJoinPool.commonPool()）的方法，一个是带有自定义线程池的重载方法

使用

// 不带返回值的异步请求，默认线程池 public static CompletableFuture<Void> runAsync(Runnable runnable) // 不带返回值的异步请求，可以自定义线程池 public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor)

测试代码

public static void main(String[] args) throws ExecutionException, InterruptedException {         CompletableFuture<Void> cf = CompletableFuture.runAsync(() -> {             System.out.println("do something....");         });         //等待任务执行完成         System.out.println("结果->" + cf.get()); } public static void main(String[] args) throws ExecutionException, InterruptedException {         // 自定义线程池         ExecutorService executorService = Executors.newSingleThreadExecutor();         CompletableFuture<Void> cf = CompletableFuture.runAsync(() -> {             System.out.println("do something....");         }, executorService);         //等待任务执行完成         System.out.println("结果->" + cf.get()); }

结果

获取任务结果的方法

// 如果完成则返回结果，否则就抛出具体的异常 public T get() throws InterruptedException, ExecutionException // 最大时间等待返回结果，否则就抛出具体异常 public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException // 完成时返回结果值，否则抛出unchecked异常。为了更好地符合通用函数形式的使用，如果完成此 CompletableFuture所涉及的计算引发异常，则此方法将引发unchecked异常并将底层异常作为其原因 public T join() // 如果完成则返回结果值（或抛出任何遇到的异常），否则返回给定的 valueIfAbsent。 public T getNow(T valueIfAbsent) // 如果任务没有完成，返回的值设置为给定值 public boolean complete(T value) // 如果任务没有完成，就抛出给定异常 public boolean completeExceptionally(Throwable ex)

异步回调处理

thenApply和thenApplyAsync

thenApply

说明

thenApply 表示某个任务执行完成后执行的动作，即回调方法，会将该任务的执行结果即方法返回值作为入参传递到回调方法中，带有返回值。

测试代码

public static void main(String[] args) throws ExecutionException, InterruptedException {         CompletableFuture<Integer> cf1 = CompletableFuture.supplyAsync(() -> {             System.out.println(Thread.currentThread() + " cf1 do something....");             return 1;         });         CompletableFuture<Integer> cf2 = cf1.thenApply((result) -> {             System.out.println(Thread.currentThread() + " cf2 do something....");             result += 2;             return result;         });         //等待任务1执行完成         System.out.println("cf1结果->" + cf1.get());         //等待任务2执行完成         System.out.println("cf2结果->" + cf2.get()); }

结果

thenApplyAsync

测试代码

public static void main(String[] args) throws ExecutionException, InterruptedException {         CompletableFuture<Integer> cf1 = CompletableFuture.supplyAsync(() -> {             System.out.println(Thread.currentThread() + " cf1 do something....");             return 1;         });         CompletableFuture<Integer> cf2 = cf1.thenApplyAsync((result) -> {             System.out.println(Thread.currentThread() + " cf2 do something....");             result += 2;             return result;         });         //等待任务1执行完成         System.out.println("cf1结果->" + cf1.get());         //等待任务2执行完成         System.out.println("cf2结果->" + cf2.get()); }

结果

总结

从上面代码和测试结果我们发现thenApply和thenApplyAsync区别在于，使用thenApply方法时子任务与父任务使用的是同一个线程，而thenApplyAsync在子任务中是另起一个线程执行任务，并且thenApplyAsync可以自定义线程池，默认的使用ForkJoinPool.commonPool()线程池。

thenAccept和thenAcceptAsync

thenAccep

说明

thenAccep表示某个任务执行完成后执行的动作，即回调方法，会将该任务的执行结果即方法返回值作为入参传递到回调方法中，无返回值。

测试代码

public static void main(String[] args) throws ExecutionException, InterruptedException {         CompletableFuture<Integer> cf1 = CompletableFuture.supplyAsync(() -> {             System.out.println(Thread.currentThread() + " cf1 do something....");             return 1;         });         CompletableFuture<Void> cf2 = cf1.thenAccept((result) -> {             System.out.println(Thread.currentThread() + " cf2 do something....");         });         //等待任务1执行完成         System.out.println("cf1结果->" + cf1.get());         //等待任务2执行完成         System.out.println("cf2结果->" + cf2.get()); }

结果

thenAcceptAsync

测试代码

public static void main(String[] args) throws ExecutionException, InterruptedException {         CompletableFuture<Integer> cf1 = CompletableFuture.supplyAsync(() -> {             System.out.println(Thread.currentThread() + " cf1 do something....");             return 1;         });         CompletableFuture<Void> cf2 = cf1.thenAcceptAsync((result) -> {             System.out.println(Thread.currentThread() + " cf2 do something....");         });         //等待任务1执行完成         System.out.println("cf1结果->" + cf1.get());         //等待任务2执行完成         System.out.println("cf2结果->" + cf2.get()); }

结果

总结

测试结果我们发现thenAccep和thenAccepAsync区别在于，使用thenAccep方法时子任务与父任务使用的是同一个线程，而thenAccepAsync在子任务中可能是另起一个线程执行任务，并且thenAccepAsync可以自定义线程池，默认的使用ForkJoinPool.commonPool()线程池。

thenRun和thenRunAsync

thenRun

说明

thenRun表示某个任务执行完成后执行的动作，即回调方法，无入参，无返回值。

测试代码

public static void main(String[] args) throws ExecutionException, InterruptedException {         CompletableFuture<Integer> cf1 = CompletableFuture.supplyAsync(() -> {             System.out.println(Thread.currentThread() + " cf1 do something....");             return 1;         });         CompletableFuture<Void> cf2 = cf1.thenRun(() -> {             System.out.println(Thread.currentThread() + " cf2 do something....");         });         //等待任务1执行完成         System.out.println("cf1结果->" + cf1.get());         //等待任务2执行完成         System.out.println("cf2结果->" + cf2.get()); }

结果

thenRunAsync

测试代码

public static void main(String[] args) throws ExecutionException, InterruptedException {         CompletableFuture<Integer> cf1 = CompletableFuture.supplyAsync(() -> {             System.out.println(Thread.currentThread() + " cf1 do something....");             return 1;         });         CompletableFuture<Void> cf2 = cf1.thenRunAsync(() -> {             System.out.println(Thread.currentThread() + " cf2 do something....");         });         //等待任务1执行完成         System.out.println("cf1结果->" + cf1.get());         //等待任务2执行完成         System.out.println("cf2结果->" + cf2.get()); }

结果

whenComplete和whenCompleteAsync

whenComplete

说明

whenComplete是当某个任务执行完成后执行的回调方法，会将执行结果或者执行期间抛出的异常传递给回调方法，如果是正常执行则异常为null，回调方法对应的CompletableFuture的result和该任务一致，如果该任务正常执行，则get方法返回执行结果，如果是执行异常，则get方法抛出异常。

测试代码

public static void main(String[] args) throws ExecutionException, InterruptedException {         CompletableFuture<Integer> cf1 = CompletableFuture.supplyAsync(() -> {             System.out.println(Thread.currentThread() + " cf1 do something....");             int a = 1/0;             return 1;         });         CompletableFuture<Integer> cf2 = cf1.whenComplete((result, e) -> {             System.out.println("上个任务结果：" + result);             System.out.println("上个任务抛出异常：" + e);             System.out.println(Thread.currentThread() + " cf2 do something....");         }); //        //等待任务1执行完成 //        System.out.println("cf1结果->" + cf1.get()); //        //等待任务2执行完成         System.out.println("cf2结果->" + cf2.get());     }

结果

whenCompleteAsync

测试代码

public static void main(String[] args) throws ExecutionException, InterruptedException {         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();         executor.setCorePoolSize(10);         executor.setMaxPoolSize(10);         executor.setQueueCapacity(10);         executor.setThreadNamePrefix("MyExecutor-");         // for passing in request scope context 转换请求范围的上下文         // rejection-policy：当pool已经达到max size的时候，如何处理新任务         // CALLER_RUNS：不在新线程中执行任务，而是有调用者所在的线程来执行         executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());         executor.setWaitForTasksToCompleteOnShutdown(true);         executor.initialize();                 CompletableFuture<Integer> cf1 = CompletableFuture.supplyAsync(() -> {             System.out.println(Thread.currentThread() + " cf1 do something....");             int a = 1/0;             return 1;         });         CompletableFuture<Integer> cf2 = cf1.whenCompleteAsync((result, e) -> {             System.out.println("上个任务结果：" + result);             System.out.println("上个任务抛出异常：" + e);             System.out.println(Thread.currentThread() + " cf2 do something....");         }, executor);         System.out.println("cf2结果->" + cf2.get());     }

结果

Thread[ForkJoinPool.commonPool-worker-1,5,main] cf1 do something.... 上个任务结果：null 上个任务抛出异常：java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero Thread[MyExecutor-1,5,main] cf2 do something.... Exception in thread "main" java.util.concurrent.ExecutionException: java.lang.ArithmeticException: / by zero at java.base/java.util.concurrent.CompletableFuture.reportGet(CompletableFuture.java:396) at java.base/java.util.concurrent.CompletableFuture.get(CompletableFuture.java:2073) at vehicle.booking.com.test.CompletableFutureTest.main(CompletableFutureTest.java:40) Caused by: java.lang.ArithmeticException: / by zero at vehicle.booking.com.test.CompletableFutureTest.lambda$main$0(CompletableFutureTest.java:27) at java.base/java.util.concurrent.CompletableFuture$AsyncSupply.run(CompletableFuture.java:1768) at java.base/java.util.concurrent.CompletableFuture$AsyncSupply.exec(CompletableFuture.java:1760) at java.base/java.util.concurrent.ForkJoinTask.doExec(ForkJoinTask.java:373) at java.base/java.util.concurrent.ForkJoinPool$WorkQueue.topLevelExec(ForkJoinPool.java:1182) at java.base/java.util.concurrent.ForkJoinPool.scan(ForkJoinPool.java:1655) at java.base/java.util.concurrent.ForkJoinPool.runWorker(ForkJoinPool.java:1622) at java.base/java.util.concurrent.ForkJoinWorkerThread.run(ForkJoinWorkerThread.java:165)

总结

whenCompleteAsync和whenComplete区别也是whenCompleteAsync可能会另起一个线程执行任务，并且thenRunAsync可以自定义线程池，默认的使用ForkJoinPool.commonPool()线程池。

handle和handleAsync

handle

说明

跟whenComplete基本一致，区别在于handle的回调方法有返回值。

测试代码

public static void main(String[] args) throws ExecutionException, InterruptedException {         CompletableFuture<Integer> cf1 = CompletableFuture.supplyAsync(() -> {             System.out.println(Thread.currentThread() + " cf1 do something....");             // int a = 1/0;             return 1;         });         CompletableFuture<Integer> cf2 = cf1.handle((result, e) -> {             System.out.println(Thread.currentThread() + " cf2 do something....");             System.out.println("上个任务结果：" + result);             System.out.println("上个任务抛出异常：" + e);             return result+2;         });         //等待任务2执行完成         System.out.println("cf2结果->" + cf2.get()); }

结果

handleAsync

测试代码

public static void main(String[] args) throws ExecutionException, InterruptedException {         CompletableFuture<Integer> cf1 = CompletableFuture.supplyAsync(() -> {             System.out.println(Thread.currentThread() + " cf1 do something....");             // int a = 1/0;             return 1;         });         CompletableFuture<Integer> cf2 = cf1.handleAsync((result, e) -> {             System.out.println(Thread.currentThread() + " cf2 do something....");             System.out.println("上个任务结果：" + result);             System.out.println("上个任务抛出异常：" + e);             return result+2;         });         //等待任务2执行完成         System.out.println("cf2结果->" + cf2.get()); }

结果

多任务组合处理

thenCombine、thenAcceptBoth 和runAfterBoth

说明

这三个方法都是将两个CompletableFuture组合起来处理，只有两个任务都正常完成时，才进行下阶段任务。

thenCombine

说明

thenCombine会将两个任务的执行结果作为所提供函数的参数，且该方法有返回值；

测试代码

public static void main(String[] args) throws ExecutionException, InterruptedException {         CompletableFuture<Integer> cf1 = CompletableFuture.supplyAsync(() -> {             System.out.println(Thread.currentThread() + " cf1 do something....");             return 1;         });         CompletableFuture<Integer> cf2 = CompletableFuture.supplyAsync(() -> {             System.out.println(Thread.currentThread() + " cf2 do something....");             return 2;         });         CompletableFuture<Integer> cf3 = cf1.thenCombine(cf2, (a, b) -> {             System.out.println(Thread.currentThread() + " cf3 do something....");             return a + b;         });         System.out.println("cf3结果->" + cf3.get()); }

结果

thenAcceptBoth

说明

thenAcceptBoth同样将两个任务的执行结果作为方法入参，但是无返回值

测试代码

public static void main(String[] args) throws ExecutionException, InterruptedException {         CompletableFuture<Integer> cf1 = CompletableFuture.supplyAsync(() -> {             System.out.println(Thread.currentThread() + " cf1 do something....");             return 1;         });         CompletableFuture<Integer> cf2 = CompletableFuture.supplyAsync(() -> {             System.out.println(Thread.currentThread() + " cf2 do something....");             return 2;         });                 CompletableFuture<Void> cf3 = cf1.thenAcceptBoth(cf2, (a, b) -> {             System.out.println(Thread.currentThread() + " cf3 do something....");             System.out.println(a + b);         });         System.out.println("cf3结果->" + cf3.get()); }

结果

runAfterBoth

说明

runAfterBoth没有入参，也没有返回值。注意两个任务中只要有一个执行异常，则将该异常信息作为指定任务的执行结果。

测试代码

public static void main(String[] args) throws ExecutionException, InterruptedException {         CompletableFuture<Integer> cf1 = CompletableFuture.supplyAsync(() -> {             System.out.println(Thread.currentThread() + " cf1 do something....");             return 1;         });         CompletableFuture<Integer> cf2 = CompletableFuture.supplyAsync(() -> {             System.out.println(Thread.currentThread() + " cf2 do something....");             return 2;         });         CompletableFuture<Void> cf3 = cf1.runAfterBoth(cf2, () -> {             System.out.println(Thread.currentThread() + " cf3 do something....");         });         System.out.println("cf3结果->" + cf3.get()); }

结果

applyToEither、acceptEither和runAfterEither

说明

这三个方法和上面一样也是将两个CompletableFuture组合起来处理，当有一个任务正常完成时，就会进行下阶段任务。

applyToEither

说明

applyToEither会将已经完成任务的执行结果作为所提供函数的参数，且该方法有返回值

测试代码

public static void main(String[] args) throws ExecutionException, InterruptedException {         CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {             try {                 System.out.println(Thread.currentThread() + " cf1 do something....");                 Thread.sleep(2000);             } catch (InterruptedException e) {                 e.printStackTrace();             }             return "cf1 任务完成";         });         CompletableFuture<String> cf2 = CompletableFuture.supplyAsync(() -> {             try {                 System.out.println(Thread.currentThread() + " cf2 do something....");                 Thread.sleep(5000);             } catch (InterruptedException e) {                 e.printStackTrace();             }             return "cf2 任务完成";         });         CompletableFuture<String> cf3 = cf1.applyToEither(cf2, (result) -> {             System.out.println("接收到" + result);             System.out.println(Thread.currentThread() + " cf3 do something....");             return "cf3 任务完成";         });         System.out.println("cf3结果->" + cf3.get()); }

结果

acceptEither

说明

acceptEither同样将已经完成任务的执行结果作为方法入参，但是无返回值；

测试代码

public static void main(String[] args) throws ExecutionException, InterruptedException {         CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {             try {                 System.out.println(Thread.currentThread() + " cf1 do something....");                 Thread.sleep(2000);             } catch (InterruptedException e) {                 e.printStackTrace();             }             return "cf1 任务完成";         });         CompletableFuture<String> cf2 = CompletableFuture.supplyAsync(() -> {             try {                 System.out.println(Thread.currentThread() + " cf2 do something....");                 Thread.sleep(5000);             } catch (InterruptedException e) {                 e.printStackTrace();             }             return "cf2 任务完成";         });         CompletableFuture<Void> cf3 = cf1.acceptEither(cf2, (result) -> {             System.out.println("接收到" + result);             System.out.println(Thread.currentThread() + " cf3 do something....");         });         System.out.println("cf3结果->" + cf3.get()); }

结果

runAfterEither

说明

runAfterEither没有入参，也没有返回值。

测试代码

public static void main(String[] args) throws ExecutionException, InterruptedException {         CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {             try {                 System.out.println(Thread.currentThread() + " cf1 do something....");                 Thread.sleep(2000);             } catch (InterruptedException e) {                 e.printStackTrace();             }             System.out.println("cf1 任务完成");             return "cf1 任务完成";         });         CompletableFuture<String> cf2 = CompletableFuture.supplyAsync(() -> {             try {                 System.out.println(Thread.currentThread() + " cf2 do something....");                 Thread.sleep(5000);             } catch (InterruptedException e) {                 e.printStackTrace();             }             System.out.println("cf2 任务完成");             return "cf2 任务完成";         });         CompletableFuture<Void> cf3 = cf1.runAfterEither(cf2, () -> {             System.out.println(Thread.currentThread() + " cf3 do something....");             System.out.println("cf3 任务完成");         });         System.out.println("cf3结果->" + cf3.get()); }

allOf / anyOf

allOf

说明

allOf：CompletableFuture是多个任务都执行完成后才会执行，只要有一个任务执行异常，则返回的CompletableFuture执行get方法时会抛出异常，如果都是正常执行，则get返回null。

测试代码

public static void main(String[] args) throws ExecutionException, InterruptedException {         CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {             try {                 System.out.println(Thread.currentThread() + " cf1 do something....");                 Thread.sleep(2000);             } catch (InterruptedException e) {                 e.printStackTrace();             }             System.out.println("cf1 任务完成");             return "cf1 任务完成";         });         CompletableFuture<String> cf2 = CompletableFuture.supplyAsync(() -> {             try {                 System.out.println(Thread.currentThread() + " cf2 do something....");                 int a = 1/0;                 Thread.sleep(5000);             } catch (InterruptedException e) {                 e.printStackTrace();             }             System.out.println("cf2 任务完成");             return "cf2 任务完成";         });         CompletableFuture<String> cf3 = CompletableFuture.supplyAsync(() -> {             try {                 System.out.println(Thread.currentThread() + " cf2 do something....");                 Thread.sleep(3000);             } catch (InterruptedException e) {                 e.printStackTrace();             }             System.out.println("cf3 任务完成");             return "cf3 任务完成";         });         CompletableFuture<Void> cfAll = CompletableFuture.allOf(cf1, cf2, cf3);         System.out.println("cfAll结果->" + cfAll.get()); }

结果

anyOf

说明

anyOf ：CompletableFuture是多个任务只要有一个任务执行完成，则返回的CompletableFuture执行get方法时会抛出异常，如果都是正常执行，则get返回执行完成任务的结果。

测试代码

public static void main(String[] args) throws ExecutionException, InterruptedException {         CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {             try {                 System.out.println(Thread.currentThread() + " cf1 do something....");                 Thread.sleep(2000);             } catch (InterruptedException e) {                 e.printStackTrace();             }             System.out.println("cf1 任务完成");             return "cf1 任务完成";         });         CompletableFuture<String> cf2 = CompletableFuture.supplyAsync(() -> {             try {                 System.out.println(Thread.currentThread() + " cf2 do something....");                 Thread.sleep(5000);             } catch (InterruptedException e) {                 e.printStackTrace();             }             System.out.println("cf2 任务完成");             return "cf2 任务完成";         });         CompletableFuture<String> cf3 = CompletableFuture.supplyAsync(() -> {             try {                 System.out.println(Thread.currentThread() + " cf2 do something....");                 Thread.sleep(3000);             } catch (InterruptedException e) {                 e.printStackTrace();             }             System.out.println("cf3 任务完成");             return "cf3 任务完成";         });         CompletableFuture<Object> cfAll = CompletableFuture.anyOf(cf1, cf2, cf3);         System.out.println("cfAll结果->" + cfAll.get()); }

结果