CompletableFuture异步编排（两任务组合——其中一个任务执行）

Posted 2022-12-02 小志的博客

目录

• • 一、CompletableFuture源码中两任务组合其中一个任务执行的相关方法
  • 二、runAfterEither方法代码示例
  • 三、acceptEither方法代码示例
  • 四、applyToEither方法代码示例

一、CompletableFuture源码中两任务组合其中一个任务执行的相关方法

• CompletableFuture源码中两任务组合其中一个任务执行的相关方法
  
  

二、runAfterEither方法代码示例

• runAfterEither方法： 两个任务有一个执行完成，不需要获取future的结果，处理任务，也没有返回值。

• 代码示例

  package com.xz.thread.day1;
  import lombok.SneakyThrows;
  import java.util.concurrent.*;
  /**
   * @description: 两任务组合（一个任务执行）
   *              runAfterEither 两个任务有一个执行完成，不需要获取future的结果，处理任务，也没有返回值。
   * @author: xz
   * @create: 2022-08-23
   */
  public class Test14 
      /**
       * 定义线程池
       */
      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(() -> 
              try 
                  Thread.sleep(1000);
               catch (InterruptedException e) 
                  e.printStackTrace();
              
              System.out.println("开启异步任务2...");
              return "hello world!";
          , service);
  
          future1.runAfterEitherAsync(future2, () -> 
              System.out.println("任务3 启动了....");
          , service);
  
          System.out.println("main end ...");
      
  
  

• 输出结果
  

• 由上述输出结果可知，任务1执行完成后，任务3不需要等待任务2执行完成，即可启动任务3。但是使用runAfterEitherAsync不能感知任务的返回值，自身也无返回值。

三、acceptEither方法代码示例

• acceptEither方法： 两个任务有一个执行完成，获取它的返回值，处理任务，没有新的返回值。

• 代码示例

  package com.xz.thread.day1;
  import lombok.SneakyThrows;
  import java.util.concurrent.*;
  /**
   * @description: 两任务组合（一个任务执行）
   *              acceptEither 两个任务有一个执行完成，获取它的返回值，处理任务，没有新的返回值。
   * @author: xz
   * @create: 2022-08-23
   */
  public class Test15 
      /**
       * 定义线程池
       */
      public static ExecutorService service = Executors.newFixedThreadPool(5);
  
      @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<Integer> future2 = CompletableFuture.supplyAsync(() -> 
              try 
                  Thread.sleep(1000);
               catch (InterruptedException e) 
                  e.printStackTrace();
              
              System.out.println("开启异步任务2...");
              return 20;
          , service);
  
          future1.acceptEitherAsync(future2, (res) -> 
              System.out.println("任务3 启动了...., 任务结果是：" + res);
          , service);
  
          System.out.println("main end ...");
      
  
  

• 输出结果
  

• 由上述输出结果可知，可以获取任务1的执行结果，但不返回执行结果。

四、applyToEither方法代码示例

• applyToEither方法： 两个任务有一个任务执行完成，获取它的返回值，处理任务并有新的返回值。

• 代码示例

  package com.xz.thread.day1;
  import lombok.SneakyThrows;
  import java.util.concurrent.*;
  /**
   * @description:
   *          ApplyToEither 两个任务有一个任务执行完成，获取它的返回值，处理任务并有新的返回值。
   * @author: xz
   * @create: 2022-08-23
   */
  public class Test16 
      /**
       * 定义线程池
       */
      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<Integer> future2 = CompletableFuture.supplyAsync(() -> 
              try 
                  Thread.sleep(1000);
               catch (InterruptedException e) 
                  e.printStackTrace();
              
              System.out.println("开启异步任务2...");
              return 20;
          , service);
  
          CompletableFuture<String> stringCompletableFuture = future1.applyToEitherAsync(future2, (res) -> 
              System.out.println("任务3 启动了...., 上个任务结果是：" + res);
              return "我是任务3的返回值， 上个任务的执行结果是：" + res;
          , service);
          System.out.println("======"+stringCompletableFuture.get());
  
          System.out.println("main end ...");
      
  
  

• 输出结果
  

• 由上述输出结果可知，可以获取任务1的执行结果，并且返回执行结果。