CompletableFuture异步编排（两任务组合——两个任务必须都完成才触发另一个任务 ）

一、CompletableFuture源码中两任务组合方法

• CompletableFuture源码中两任务组合相关方法

  
  

二、runAfterBoth方法代码示例

• runAfterBoth方法： 没有返回值，入参CompletionStage、action; 第一个异步任务.runAfterBoth(第二个异步任务,第三个异步任务）

• 代码示例

  package com.xz.thread.day1;
  import lombok.SneakyThrows;
  
  import java.util.concurrent.*;
  /**
   * @description: 两任务组合（两个任务都执行）
   *              runAfterBoth方法： 没有返回值，入参CompletionStage、action;
   *              第一个异步任务.runAfterBoth(第二个异步任务,第三个异步任务）
   * @author: xz
   * @create: 2022-08-23
   */
  public class Test11 {
      /**
       * 定义线程池
       */
      public static ExecutorService service = Executors.newFixedThreadPool(3);
  
      @SneakyThrows
      public static void main(String[] args) {
          System.out.println("main start ...");
  
          CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
              System.out.println("开启异步任务1...");
              int i = 10 / 1;
              return i;
          }, service);
  
          CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
              System.out.println("开启异步任务2...");
              return "hello world!";
          }, service);
  
          future1.runAfterBothAsync(future2, () -> {
              System.out.println("开启任务3....");
          }, service);
  
          System.out.println("main end ...");
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39

• 输出结果
  

• 有上述输出结果可知，任务3是在任务1和任务2执行完成后，才执行的。

三、thenAcceptBothAsync方法代码示例

• thenAcceptBothAsync方法： 可以获取两个任务的返回值；thenAcceptBoth可以感知任务1和任务2的返回值，但是thenAcceptBoth没有返回值。

• 代码示例

  package com.xz.thread.day1;
  import lombok.SneakyThrows;
  import java.util.concurrent.*;
  /**
   * @description: 两任务组合（两个任务都执行）
   *              thenAcceptBoth方法：可以获取两个任务的返回值。
   *              thenAcceptBoth可以感知任务1和任务2的返回值，但是thenAcceptBoth没有返回值。
   * @author: xz
   * @create: 2022-08-23
   */
  public class Test12 {
      /**
       * 定义线程池
       */
      public static ExecutorService service = Executors.newFixedThreadPool(3);
  
      @SneakyThrows
      public static void main(String[] args) {
          System.out.println("main start ...");
  
          CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
              System.out.println("开启异步任务1...");
              int i = 10 / 1;
              return i;
          }, service);
  
          CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
              System.out.println("开启异步任务2...");
              return "hello world!";
          }, service);
  
          future1.thenAcceptBothAsync(future2, (res1, res2) -> {
              System.out.println("任务3 启动了.... 任务1的返回值：" + res1 + " 任务2的返回值：" + res2);
          }, service);
  
          //System.out.println("获取异步任务最终返回值：" + future.get());
          System.out.println("main end ...");
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39

• 输出结果
  

• 有上述输出结果可知，任务3在任务1和任务2执行后执行了，并获取了任务1和任务2的返回值。

四、thenCombine方法代码示例

• thenCombine方法： 可以获取两个任务的返回值，并可以将任务三结果返回。

• 代码示例

  package com.xz.thread.day1;
  import lombok.SneakyThrows;
  import java.util.concurrent.*;
  /**
   * @description: 两任务组合（两个任务都执行）
   *              thenCombine 可以获取两个任务的返回值，并可以将任务三结果返回。
   * @author: xz
   * @create: 2022-08-23
   */
  public class Test13 {
      /**
       * 定义线程池
       */
      public static ExecutorService service = Executors.newFixedThreadPool(3);
  
      @SneakyThrows
      public static void main(String[] args) {
          System.out.println("main start ...");
  
          CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
              System.out.println("开启异步任务1...");
              int i = 10 / 1;
              return i;
          }, service);
  
          CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
              System.out.println("开启异步任务2...");
              return "hello world!";
          }, service);
  
          CompletableFuture<String> stringCompletableFuture = future1.thenCombineAsync(future2, (res1, res2) -> {
              System.out.println("任务3 启动了.... 任务1的返回值：" + res1 + " 任务2的返回值：" + res2);
              return res1 + "-->" + res2;
          }, service);
          System.out.println("获取异步任务最终返回值：" + stringCompletableFuture.get());
  
          System.out.println("main end ...");
      }
  
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40

• 输出结果