springboot~CompletableFuture并行计算

在Spring中，CompletableFuture通常用于异步编程，可以方便地处理异步使命的实行和效果处理，CompletableFuture 是 Java 8 引入的一个类，用于支持异步编程和并发操纵。它基于 Future 和 CompletionStage 接口，提供了丰富的方法来处理异步使命的实行和效果处理。
下面是 CompletableFuture 实现的一些关键原理：

• 线程池支持：CompletableFuture 内部使用线程池来实行异步使命，可以通过指定差别的线程池来控制使命的实行方式。默认情况下，CompletableFuture 使用 ForkJoinPool.commonPool() 作为默认的线程池。
  
• 回调函数：CompletableFuture 支持链式调用，可以通过 thenApply(), thenAccept(), thenRun(), thenCompose() 等方法添加回调函数，在异步使命完成后处理使命的效果或实行下一步操纵。
  
• 异常处理：CompletableFuture 提供了 exceptionally(), handle(), whenComplete() 等方法来处理异步使命中可能抛出的异常，确保异常能够被捕捉并处理。
  
• 组合操纵：CompletableFuture 支持多个 CompletableFuture 对象之间的组合操纵，如 thenCombine(), thenCompose(), allOf(), anyOf() 等方法，实现并行实行、串行实行、等候全部使命完成等功能。
  
• CompletableFuture 工厂方法：除了 supplyAsync() 方法外，CompletableFuture 还提供了一系列工厂方法来创建 CompletableFuture 对象，如 runAsync(), completedFuture(), failedFuture() 等，方便快速创建并管理异步使命。
  

总的来说，CompletableFuture 的实现基于 Future 和 CompletionStage 接口，使用线程池、回调函数、异常处理、组合操纵等机制，提供了强盛而灵活的异步编程功能，使得开发人员能够更加方便地处理异步使命的实行和效果处理。
使用方法（一）链式

如果我们的业务方法已经写完了，这时可以直接通过supplyAsync方法来调用这些已知的方法，而不需要重新开发

1. CompletableFuture<String> a1 = CompletableFuture.supplyAsync(() -> {
2.       try {
3.           Thread.sleep(1000);
4.       } catch (InterruptedException e) {
5.           throw new RuntimeException(e);
6.       }
7.       return "Hello World";
8.   });
9.   CompletableFuture<String> a2 = CompletableFuture.supplyAsync(() -> {
10.       try {
11.           Thread.sleep(2000);
12.       } catch (InterruptedException e) {
13.           throw new RuntimeException(e);
14.       }
15.       return "Hello World";
16.   });
17.   CompletableFuture<String> a3 = CompletableFuture.supplyAsync(() -> {
18.       try {
19.           Thread.sleep(3000);
20.       } catch (InterruptedException e) {
21.           throw new RuntimeException(e);
22.       }
23.       return "Hello World";
24.   });
26.   // 这块最后是并行计算时间为3秒
27.   CompletableFuture.allOf(a1, a2, a3).join();
29.   String result = a1.get() + " | " + a2.get() + " | " + a3.get();

复制代码

使用方法（二）独立方法

如果方法比较独立，并且之前没有开发过，那么你可以通过异步方法来将这些逻辑与调用代码解耦

1. @Service
2. @EnableAsync
3. public class ParallelTaskService {
5.     @Async
6.     public CompletableFuture<String> task1() {
7.         // 模拟一个耗时操作
8.         try {
9.             Thread.sleep(3000);
10.         } catch (InterruptedException e) {
11.             e.printStackTrace();
12.         }
14.         return CompletableFuture.completedFuture("Task 1 completed");
15.     }
17.     @Async
18.     public CompletableFuture<String> task2() {
19.         // 模拟另一个耗时操作
20.         try {
21.             Thread.sleep(2000);
22.         } catch (InterruptedException e) {
23.             e.printStackTrace();
24.         }
26.         return CompletableFuture.completedFuture("Task 2 completed");
27.     }
28. }
30. // 并行计算时，响应时间是2和3秒之中最大值，即3秒
31. @GetMapping("/hello-world2")
32. public CompletableFuture<String> helloWorld2() {
33.     CompletableFuture<String> task1Result = parallelTaskService.task1();
34.     CompletableFuture<String> task2Result = parallelTaskService.task2();
36.     // 等待所有任务都完成
37.     CompletableFuture<Void> allOf = CompletableFuture.allOf(task1Result, task2Result);
39.     // 处理所有任务完成后的逻辑
40.     return allOf.thenApply(voidResult -> {
41.         String result = task1Result.join() + " | " + task2Result.join();
42.         return result;
43.     });
44. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。