什么，你还不会用CompletableFuture？

上一篇我们讲了Future机制，有兴趣的可以参考谈谈Future、Callable、FutureTask关系

成都创新互联公司专注于普洱网站建设服务及定制，我们拥有丰富的企业做网站经验。 热诚为您提供普洱营销型网站建设，普洱网站制作、普洱网页设计、普洱网站官网定制、微信平台小程序开发服务，打造普洱网络公司原创品牌,更为您提供普洱网站排名全网营销落地服务。

但Future机制，还不那么灵活，比如怎么去利用Future机制描述两个任务串行执行，又或是两个任务并行执行，又或是只关心最先执行结束的任务结果。

Future机制在一定程度上都无法快速地满足以上需求，CompletableFuture便应运而生了。

本片会介绍CompletableFuture的api，并用一些示例演示如何去使用。

1. 创建一个异步任务

 
 
 
 
    
  
  
  
  
  1. public static  CompletableFuture supplyAsync(Supplier supplier) 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.  public static  CompletableFuture supplyAsync(Supplier supplier,Executor executor); 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5.  public static CompletableFuture runAsync(Runnable runnable); 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7.  public static CompletableFuture runAsync(Runnable runnable,Executor executor); 
    8.

supplyAsync与runAsync的区别在于：supplyAsync有返回值，而runAsync没有返回值

带Executor参数的构造函数，则使用线程池中的线程执行异步任务（线程池可以参考说说线程池）

不带Executor参数的构造函数，则使用ForkJoinPool.commonPool()中的线程执行异步任务（Fork/Join框架可以参考谈谈并行流parallelStream）

1.1 示例：使用supplyAsync创建一个有返回值的异步任务

 
 
 
 
    
  
  
  
  
  1. public class Case1 { 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.     public static void main(String[] args) throws Exception { 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5.         CompletableFuture completableFuture=CompletableFuture.supplyAsync(()->{ 
    6.   
  
  
  
  6.             try { 
    7.   
  
  
  
  7.                 Thread.sleep(1000); 
    8.   
  
  
  
  8.             } catch (InterruptedException e) { 
    9.   
  
  
  
  9.                 e.printStackTrace(); 
    10.   
  
  
  
  10.             } 
    11.   
  
  
  
  11.             return 1; 
    12.   
  
  
  
  12.         }); 
    13.   
  
  
  
  13.         //该方法会一直阻塞 
    14.   
  
  
  
  14.         Integer result = completableFuture.get(); 
    15.   
  
  
  
  15.         System.out.println(result); 
    16.   
  
  
  
  16.     } 
    17.   
  
  
  
  17.  
    18.   
  
  
  
  18. } 
    19.

2. 异步任务的回调

 
 
 
 
    
  
  
  
  
  1. public CompletableFuture whenComplete(BiConsumer action); 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.   public CompletableFuture whenCompleteAsync(BiConsumer action); 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5.   public CompletableFuture whenCompleteAsync(BiConsumer action, Executor executor); 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7.   public CompletableFuture exceptionally(Function fn); 
    8.

whenComplete开头的方法在计算任务完成（包括正常完成与出现异常）之后会回调

而exceptionally则只会在计算任务出现异常时才会被回调

如何确定哪个线程去回调whenComplete，比较复杂，先略过。

而回调whenCompleteAsync的线程比较简单，随便拿一个空闲的线程即可，后缀是Async的方法同理。

2.1 示例：计算出现异常，使用whenComplete与exceptionally进行处理

 
 
 
 
    
  
  
  
  
  1. package com.qcy.testCompleteableFuture; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import java.util.concurrent.CompletableFuture; 
    4.   
  
  
  
  4. import java.util.concurrent.ExecutionException; 
    5.   
  
  
  
  5. import java.util.function.BiConsumer; 
    6.   
  
  
  
  6. import java.util.function.Function; 
    7.   
  
  
  
  7. import java.util.stream.IntStream; 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9. /** 
    10.   
  
  
  
  10.  * @author qcy 
    11.   
  
  
  
  11.  * @create 2020/09/07 17:40:44 
    12.   
  
  
  
  12.  */ 
    13.   
  
  
  
  13. public class Case2 { 
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15.     public static void main(String[] args) throws Exception { 
    16.   
  
  
  
  16.  
    17.   
  
  
  
  17.         CompletableFuture completableFuture = CompletableFuture.supplyAsync(() -> { 
    18.   
  
  
  
  18.             try { 
    19.   
  
  
  
  19.                 Thread.sleep(1000); 
    20.   
  
  
  
  20.             } catch (InterruptedException e) { 
    21.   
  
  
  
  21.                 e.printStackTrace(); 
    22.   
  
  
  
  22.             } 
    23.   
  
  
  
  23.             System.out.println("执行supplyAsync的线程:" + Thread.currentThread().getName()); 
    24.   
  
  
  
  24.             int i = 1 / 0; 
    25.   
  
  
  
  25.             return 1; 
    26.   
  
  
  
  26.         }); 
    27.   
  
  
  
  27.  
    28.   
  
  
  
  28.         completableFuture.whenComplete(new BiConsumer() { 
    29.   
  
  
  
  29.             @Override 
    30.   
  
  
  
  30.             public void accept(Integer integer, Throwable throwable) { 
    31.   
  
  
  
  31.                 System.out.println("执行whenComplete的线程:" + Thread.currentThread().getName()); 
    32.   
  
  
  
  32.                 if (throwable == null) { 
    33.   
  
  
  
  33.                     System.out.println("计算未出现异常,结果:" + integer); 
    34.   
  
  
  
  34.                 } 
    35.   
  
  
  
  35.             } 
    36.   
  
  
  
  36.         }); 
    37.   
  
  
  
  37.  
    38.   
  
  
  
  38.         completableFuture.exceptionally(new Function() { 
    39.   
  
  
  
  39.             @Override 
    40.   
  
  
  
  40.             public Integer apply(Throwable throwable) { 
    41.   
  
  
  
  41.                 //出现异常时,则返回一个默认值 
    42.   
  
  
  
  42.                 System.out.println("计算出现异常,信息:" + throwable.getMessage()); 
    43.   
  
  
  
  43.                 return -1; 
    44.   
  
  
  
  44.             } 
    45.   
  
  
  
  45.         }); 
    46.   
  
  
  
  46.  
    47.   
  
  
  
  47.         System.out.println(completableFuture.get()); 
    48.   
  
  
  
  48.     } 
    49.   
  
  
  
  49.  
    50.   
  
  
  
  50. } 
    51.

输出：

当然，CompletableFuture内的各种方法是支持链式调用与Lambda表达式的，我们进行如下改写：

 
 
 
 
    
  
  
  
  
  1. public static void main(String[] args) throws Exception { 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.      CompletableFuture completableFuture = CompletableFuture.supplyAsync(() -> { 
    4.   
  
  
  
  4.          try { 
    5.   
  
  
  
  5.              Thread.sleep(2000); 
    6.   
  
  
  
  6.          } catch (InterruptedException e) { 
    7.   
  
  
  
  7.              e.printStackTrace(); 
    8.   
  
  
  
  8.          } 
    9.   
  
  
  
  9.          System.out.println("执行supplyAsync的线程:" + Thread.currentThread().getName()); 
    10.   
  
  
  
  10.          int i = 1 / 0; 
    11.   
  
  
  
  11.          return 1; 
    12.   
  
  
  
  12.      }).whenComplete((integer, throwable) -> { 
    13.   
  
  
  
  13.          System.out.println("执行whenComplete的线程:" + Thread.currentThread().getName()); 
    14.   
  
  
  
  14.          if (throwable == null) { 
    15.   
  
  
  
  15.              System.out.println("计算未出现异常,结果:" + integer); 
    16.   
  
  
  
  16.          } 
    17.   
  
  
  
  17.      }).exceptionally(throwable -> { 
    18.   
  
  
  
  18.          //出现异常时,则返回一个默认值 
    19.   
  
  
  
  19.          System.out.println("计算出现异常,信息:" + throwable.getMessage()); 
    20.   
  
  
  
  20.          return -1; 
    21.   
  
  
  
  21.      }); 
    22.   
  
  
  
  22.  
    23.   
  
  
  
  23.      System.out.println("计算结果:" + completableFuture.get()); 
    24.   
  
  
  
  24.  } 
    25.

3. 任务串行化执行

 
 
 
 
    
  
  
  
  
  1. public  CompletableFuture thenApply(Function fn); 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.   public CompletableFuture thenRun(Runnable action); 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5.   public CompletableFuture thenAccept(Consumer action); 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7.   public  CompletableFuture handle(BiFunction fn); 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9.   public  CompletableFuture thenCompose(Function> fn); 
    10.

thenApply，依赖上一次任务执行的结果，参数中的Function，T代表上一次任务返回值的类型，U代表当前任务返回值的类型，当上一个任务没有出现异常时，thenApply才会被调用

thenRun，不需要知道上一个任务的返回结果，只是在上一个任务执行完成之后开始执行Runnable

thenAccept，依赖上一次任务的执行结果，因为入参是Consumer，所以不返回任何值。

handle和thenApply相似，不过当上一个任务出现异常时，能够执行handle，却不会去执行thenApply

thenCompose，传入一次任务执行的结果，返回一个新的CompleteableFuture对象

3.1 示例：使用串行化任务分解两数相乘并输出

 
 
 
 
    
  
  
  
  
  1. package com.qcy.testCompleteableFuture; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import java.util.concurrent.CompletableFuture; 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. /** 
    6.   
  
  
  
  6.  * @author qcy 
    7.   
  
  
  
  7.  * @create 2020/09/07 17:40:44 
    8.   
  
  
  
  8.  */ 
    9.   
  
  
  
  9. public class Case4 { 
    10.   
  
  
  
  10.  
    11.   
  
  
  
  11.     public static void main(String[] args) { 
    12.   
  
  
  
  12.          
    13.   
  
  
  
  13.         CompletableFuture.supplyAsync(() -> 2) 
    14.   
  
  
  
  14.                 .thenApply(num -> num * 3) 
    15.   
  
  
  
  15.                 .thenAccept(System.out::print); 
    16.   
  
  
  
  16.     } 
    17.   
  
  
  
  17.  
    18.   
  
  
  
  18. } 
    19.

很显然，输出为6

3.2 示例：使用串行化任务并且模拟出现异常

 
 
 
 
    
  
  
  
  
  1. package com.qcy.testCompleteableFuture; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import java.util.concurrent.CompletableFuture; 
    4.   
  
  
  
  4. import java.util.function.BiFunction; 
    5.   
  
  
  
  5.  
    6.   
  
  
  
  6. /** 
    7.   
  
  
  
  7.  * @author qcy 
    8.   
  
  
  
  8.  * @create 2020/09/07 17:40:44 
    9.   
  
  
  
  9.  */ 
    10.   
  
  
  
  10. public class Case4 { 
    11.   
  
  
  
  11.  
    12.   
  
  
  
  12.     public static void main(String[] args) { 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14.         CompletableFuture.supplyAsync(() -> 2) 
    15.   
  
  
  
  15.                 .thenApply(num -> num / 0) 
    16.   
  
  
  
  16.                 .thenApply(result -> result * 3) 
    17.   
  
  
  
  17.                 .handle((integer, throwable) -> { 
    18.   
  
  
  
  18.                     if (throwable == null) { 
    19.   
  
  
  
  19.                         return integer; 
    20.   
  
  
  
  20.                     } else { 
    21.   
  
  
  
  21.                         throwable.printStackTrace(); 
    22.   
  
  
  
  22.                         return -1; 
    23.   
  
  
  
  23.                     } 
    24.   
  
  
  
  24.                 }).thenAccept(System.out::print); 
    25.   
  
  
  
  25.     } 
    26.   
  
  
  
  26.  
    27.   
  
  
  
  27. } 
    28.

最终会输出-1

4. 任务同时执行，且都需要执行完成

 
 
 
 
    
  
  
  
  
  1. public  CompletableFuture thenCombine(CompletionStage other, 
    2.   
  
  
  
  2. Function fn); 
    3.   
  
  
  
  3.  
    4.   
  
  
  
  4.   public  CompletableFuture thenAcceptBoth(CompletionStage other, 
    5.   
  
  
  
  5. Consumer action); 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7.   public CompletableFuture runAfterBoth(CompletionStage other,Runnable action); 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9.   public static CompletableFuture allOf(CompletableFuture... cfs); 
    10.

thenCombine，合并两个任务，两个任务可以同时执行，都执行成功后，执行最后的BiFunction操作。其中T代表第一个任务的执行结果类型，U代表第二个任务的执行结果类型，V代表合并的结果类型

thenAcceptBoth，和thenCombine特性用法都极其相似，唯一的区别在于thenAcceptBoth进行一个消费，没有返回值

runAfterBoth，两个任务都执行完成后，但不关心他们的返回结构，然后去执行一个Runnable。

allOf，当所有的任务都执行完成后，返回一个CompletableFuture

4.1 示例：使用thenCombine合并任务

 
 
 
 
    
  
  
  
  
  1. package com.qcy.testCompleteableFuture; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import java.util.concurrent.CompletableFuture; 
    4.   
  
  
  
  4. import java.util.concurrent.ExecutionException; 
    5.   
  
  
  
  5.  
    6.   
  
  
  
  6. /** 
    7.   
  
  
  
  7.  * @author qcy 
    8.   
  
  
  
  8.  * @create 2020/09/07 17:40:44 
    9.   
  
  
  
  9.  */ 
    10.   
  
  
  
  10. public class Case5 { 
    11.   
  
  
  
  11.  
    12.   
  
  
  
  12.     public static void main(String[] args) throws Exception { 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14.         CompletableFuture cf1 = CompletableFuture.supplyAsync(() -> { 
    15.   
  
  
  
  15.             System.out.println("任务1开始"); 
    16.   
  
  
  
  16.             try { 
    17.   
  
  
  
  17.                 Thread.sleep(3000); 
    18.   
  
  
  
  18.             } catch (InterruptedException e) { 
    19.   
  
  
  
  19.                 e.printStackTrace(); 
    20.   
  
  
  
  20.             } 
    21.   
  
  
  
  21.             System.out.println("任务1结束"); 
    22.   
  
  
  
  22.             return 2; 
    23.   
  
  
  
  23.         }); 
    24.   
  
  
  
  24.  
    25.   
  
  
  
  25.         CompletableFuture cf2 = CompletableFuture.supplyAsync(() -> { 
    26.   
  
  
  
  26.             System.out.println("任务2开始"); 
    27.   
  
  
  
  27.             try { 
    28.   
  
  
  
  28.                 Thread.sleep(3000); 
    29.   
  
  
  
  29.             } catch (InterruptedException e) { 
    30.   
  
  
  
  30.                 e.printStackTrace(); 
    31.   
  
  
  
  31.             } 
    32.   
  
  
  
  32.             System.out.println("任务2结束"); 
    33.   
  
  
  
  33.             return 3; 
    34.   
  
  
  
  34.         }); 
    35.   
  
  
  
  35.  
    36.   
  
  
  
  36.         CompletableFuture completableFuture = cf1.thenCombine(cf2, (result1, result2) -> result1 * result2); 
    37.   
  
  
  
  37.         System.out.println("计算结果:" + completableFuture.get()); 
    38.   
  
  
  
  38.     } 
    39.   
  
  
  
  39.  
    40.   
  
  
  
  40. } 
    41.

输出：

可以看到两个任务确实是同时执行的

当然，熟练了之后，直接使用链式操作，代码如下：

 
 
 
 
    
  
  
  
  
  1. package com.qcy.testCompleteableFuture; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import java.util.concurrent.CompletableFuture; 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. /** 
    6.   
  
  
  
  6.  * @author qcy 
    7.   
  
  
  
  7.  * @create 2020/09/07 17:40:44 
    8.   
  
  
  
  8.  */ 
    9.   
  
  
  
  9. public class Case6 { 
    10.   
  
  
  
  10.  
    11.   
  
  
  
  11.     public static void main(String[] args) throws Exception { 
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13.         CompletableFuture completableFuture = CompletableFuture.supplyAsync(() -> { 
    14.   
  
  
  
  14.             System.out.println("任务1开始"); 
    15.   
  
  
  
  15.             try { 
    16.   
  
  
  
  16.                 Thread.sleep(3000); 
    17.   
  
  
  
  17.             } catch (InterruptedException e) { 
    18.   
  
  
  
  18.                 e.printStackTrace(); 
    19.   
  
  
  
  19.             } 
    20.   
  
  
  
  20.             System.out.println("任务1结束"); 
    21.   
  
  
  
  21.             return 2; 
    22.   
  
  
  
  22.         }).thenCombine(CompletableFuture.supplyAsync(() -> { 
    23.   
  
  
  
  23.             System.out.println("任务2开始"); 
    24.   
  
  
  
  24.             try { 
    25.   
  
  
  
  25.                 Thread.sleep(2000); 
    26.   
  
  
  
  26.             } catch (InterruptedException e) { 
    27.   
  
  
  
  27.                 e.printStackTrace(); 
    28.   
  
  
  
  28.             } 
    29.   
  
  
  
  29.             System.out.println("任务2结束"); 
    30.   
  
  
  
  30.             return 3; 
    31.   
  
  
  
  31.         }), (result1, result2) -> result1 * result2); 
    32.   
  
  
  
  32.  
    33.   
  
  
  
  33.         System.out.println("计算结果:" + completableFuture.get()); 
    34.   
  
  
  
  34.     } 
    35.   
  
  
  
  35.  
    36.   
  
  
  
  36. } 
    37.

5. 任务同时执行，且只取最先完成的那个任务

 
 
 
 
    
  
  
  
  
  1. public  CompletableFuture applyToEither(CompletionStage other, Function fn); 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.    public CompletableFuture acceptEither(CompletionStage other, Consumer action); 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5.    public CompletableFuture runAfterEither(CompletionStage other,Runnable action); 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7.    public static CompletableFuture anyOf(CompletableFuture... cfs);  
 
 
 
    applyToEither，最新执行完任务，将其结果执行Function操作，其中T是最先执行完的任务结果类型，U是最后输出的类型
    acceptEither，最新执行完的任务，将其结果执行消费操作
    runAfterEither，任意一个任务执行完成之后，执行Runnable操作
    anyOf，多个任务中，返回最先执行完成的CompletableFuture
    5.1 示例：两个任务同时执行，打印最先完成的任务的结果
     
 
 
 
      
  
  
  
  
    1. package com.qcy.testCompleteableFuture; 
      2.   
  
  
  
    2.  
      3.   
  
  
  
    3. import java.util.concurrent.CompletableFuture; 
      4.   
  
  
  
    4.  
      5.   
  
  
  
    5. /** 
      6.   
  
  
  
    6.  * @author qcy 
      7.   
  
  
  
    7.  * @create 2020/09/07 17:40:44 
      8.   
  
  
  
    8.  */ 
      9.   
  
  
  
    9. public class Case7 { 
      10.   
  
  
  
    10.  
      11.   
  
  
  
    11.     public static void main(String[] args) throws Exception { 
      12.   
  
  
  
    12.  
      13.   
  
  
  
    13.         CompletableFuture completableFuture = CompletableFuture.supplyAsync(() -> { 
      14.   
  
  
  
    14.             System.out.println("任务1开始"); 
      15.   
  
  
  
    15.             try { 
      16.   
  
  
  
    16.                 Thread.sleep(3000); 
      17.   
  
  
  
    17.             } catch (InterruptedException e) { 
      18.   
  
  
  
    18.                 e.printStackTrace(); 
      19.   
  
  
  
    19.             } 
      20.   
  
  
  
    20.             System.out.println("任务1结束"); 
      21.   
  
  
  
    21.             return 2; 
      22.   
  
  
  
    22.         }).acceptEither(CompletableFuture.supplyAsync(() -> { 
      23.   
  
  
  
    23.             System.out.println("任务2开始"); 
      24.   
  
  
  
    24.             try { 
      25.   
  
  
  
    25.                 Thread.sleep(2000); 
      26.   
  
  
  
    26.             } catch (InterruptedException e) { 
      27.   
  
  
  
    27.                 e.printStackTrace(); 
      28.   
  
  
  
    28.             } 
      29.   
  
  
  
    29.             System.out.println("任务2结束"); 
      30.   
  
  
  
    30.             return 3; 
      31.   
  
  
  
    31.         }), result -> System.out.println(result)); 
      32.   
  
  
  
    32.  
      33.   
  
  
  
    33.         //等待CompletableFuture返回，防止主线程退出 
      34.   
  
  
  
    34.         completableFuture.join(); 
      35.   
  
  
  
    35.     } 
      36.   
  
  
  
    36.  
      37.   
  
  
  
    37. } 
      38.  
 
 
 
    输出：
    可以看得到，任务2结束后，直接不再执行任务1的剩余代码
    5.2 示例：多个任务同时执行，打印最先完成的任务的结果
     
 
 
 
      
  
  
  
  
    1. package com.qcy.testCompleteableFuture; 
      2.   
  
  
  
    2.  
      3.   
  
  
  
    3. import java.util.concurrent.CompletableFuture; 
      4.   
  
  
  
    4.  
      5.   
  
  
  
    5. /** 
      6.   
  
  
  
    6.  * @author qcy 
      7.   
  
  
  
    7.  * @create 2020/09/07 17:40:44 
      8.   
  
  
  
    8.  */ 
      9.   
  
  
  
    9. public class Case8 { 
      10.   
  
  
  
    10.  
      11.   
  
  
  
    11.     public static void main(String[] args) throws Exception { 
      12.   
  
  
  
    12.  
      13.   
  
  
  
    13.         CompletableFuture cf1 = CompletableFuture.supplyAsync(() -> { 
      14.   
  
  
  
    14.             System.out.println("任务1开始"); 
      15.   
  
  
  
    15.             try { 
      16.   
  
  
  
    16.                 Thread.sleep(3000); 
      17.   
  
  
  
    17.             } catch (InterruptedException e) { 
      18.   
  
  
  
    18.                 e.printStackTrace(); 
      19.   
  
  
  
    19.             } 
      20.   
  
  
  
    20.             System.out.println("任务1结束"); 
      21.   
  
  
  
    21.             return 2; 
      22.   
  
  
  
    22.         }); 
      23.   
  
  
  
    23.  
      24.   
  
  
  
    24.         CompletableFuture cf2 = CompletableFuture.supplyAsync(() -> { 
      25.   
  
  
  
    25.             System.out.println("任务2开始"); 
      26.   
  
  
  
    26.             try { 
      27.   
  
  
  
    27.                 Thread.sleep(2000); 
      28.   
  
  
  
    28.             } catch (InterruptedException e) { 
      29.   
  
  
  
    29.                 e.printStackTrace(); 
      30.   
  
  
  
    30.             } 
      31.   
  
  
  
    31.             System.out.println("任务2结束"); 
      32.   
  
  
  
    32.             return 3; 
      33.   
  
  
  
    33.         }); 
      34.   
  
  
  
    34.  
      35.   
  
  
  
    35.         CompletableFuture cf3 = CompletableFuture.supplyAsync(() -> { 
      36.   
  
  
  
    36.             System.out.println("任务3开始"); 
      37.   
  
  
  
    37.             try { 
      38.   
  
  
  
    38.                 Thread.sleep(4000); 
      39.   
  
  
  
    39.             } catch (InterruptedException e) { 
      40.   
  
  
  
    40.                 e.printStackTrace(); 
      41.   
  
  
  
    41.             } 
      42.   
  
  
  
    42.             System.out.println("任务3结束"); 
      43.   
  
  
  
    43.             return 4; 
      44.   
  
  
  
    44.         }); 
      45.   
  
  
  
    45.  
      46.   
  
  
  
    46.         CompletableFuture firstCf = CompletableFuture.anyOf(cf1, cf2, cf3);   
  
  
  
    47.         System.out.println(firstCf.get()); 
      48.   
  
  
  
    48.     } 
      49.   
  
  
  
    49.  
      50.   
  
  
  
    50. } 
      51.  
 
 
 
      输出：
                  
      
                文章标题：什么，你还不会用CompletableFuture？
                
      
                本文来源：http://www.mswzjz.com/qtweb/news12/169612.html
            
      
            
      
                网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                
      
            
      
                广告
                
            
      
            
      
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                创新互联
            
      
        
        
      
            
      猜你还喜欢下面的内容
      
            
        
      
    
    
      
        
      
            
      网站策划知识
      
            
        
      
        
      
            
      同城分类信息
      
            
        
      
    
      


      
    
      
        成都网站设计　　 　香港服务器空间　　 　医药医疗网站建设方案　　 　中国西部信息中心　　 　成都网站推广营销　　 　网站seo优化　　 　成都商城网站建设　　 　深圳惠宜防蚊纱窗　　 　四川平武网站建设　　 　做网站设计　　 　成都响应式网站建设　　 　温江网站建设　　 　名片设计　　 　广安做网站　　 　成都app软件开发公司　　 　边坡防护网　　 　网站设计　　 　保温橡塑管　　 　德阳机房　　 　成都学生服定制