CompletableFuture 的使用方法

「爱情、让人受尽委屈。」 2022-09-09 11:53 223阅读 0赞

https://www.jianshu.com/p/6bac52527ca4

1.  CompletableFuture是java8引入的新类，**该类实现了 Future 接口和 CompletionStage 接口**，封装了future、forkjoin相关类来执行异步，所以你还是可以像以前一样通过阻塞(get)或者轮询的方式获得结果，尽管这种方式不推荐使用。
2.  CompletionStage 接口代表异步计算中的 不同阶段，以及如何 组合 这些计算阶段。
3.  CompletableStage 接口中有 50 多个方法，可以对 CompletableStage 进行组合、计算，方法看似很多，但可以按功能对其分类，大多数方法都有 3 种变体：
    
    > 1.  不带 Async 方法：同步方法
    > 2.  带 Async，只有一个参数：异步方法，使用默认的 ForkJoinPool.commonPool() 获取线程池
    > 3.  带 Async，有两个参数：异步方法，且使用第二个参数指定的 ExecutorService 线程池

## 1、 runAsync 和 supplyAsync方法 ##

CompletableFuture 提供了四个静态方法来创建一个异步操作。

public static CompletableFuture<Void> runAsync(Runnable runnable)
 public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor)
 public static CompletableFuture supplyAsync(Supplier supplier)
 public static CompletableFuture supplyAsync(Supplier supplier, Executor executor)

没有指定Executor的方法会使用ForkJoinPool.commonPool() 作为它的线程池执行异步代码。如果指定线程池，则使用指定的线程池运行。以下所有的方法都类同。

*  runAsync方法不支持返回值。
 *  supplyAsync可以支持返回值。

## 示例 ##

//无返回值
 public static void runAsync() throws Exception {
 CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
 try {
 TimeUnit.SECONDS.sleep(1);
 } catch (InterruptedException e) {
 }
 System.out.println("run end ...");
 });
 
 future.get();
 }
 
 //有返回值
 public static void supplyAsync() throws Exception { 
 CompletableFuture<Long> future = CompletableFuture.supplyAsync(() -> {
 try {
 TimeUnit.SECONDS.sleep(1);
 } catch (InterruptedException e) {
 }
 System.out.println("run end ...");
 return System.currentTimeMillis();
 });
 
 long time = future.get();
 System.out.println("time = "+time);
 }

## 2、计算结果完成时的回调方法 ##

当CompletableFuture的计算结果完成，或者抛出异常的时候，可以执行特定的Action。主要是下面的方法：

public CompletableFuture<T> whenComplete(BiConsumer<? super T,? super Throwable> action)
 public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T,? super Throwable> action)
 public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T,? super Throwable> action, Executor executor)
 public CompletableFuture<T> exceptionally(Function<Throwable,? extends T> fn)

可以看到Action的类型是BiConsumer<? super T,? super Throwable>它可以处理正常的计算结果，或者异常情况。

whenComplete 和 whenCompleteAsync 的区别：  
whenComplete：是执行当前任务的线程执行继续执行 whenComplete 的任务。  
whenCompleteAsync：是执行把 whenCompleteAsync 这个任务继续提交给线程池来进行执行。

## 示例 ##

public static void whenComplete() throws Exception {
 CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
 try {
 TimeUnit.SECONDS.sleep(1);
 } catch (InterruptedException e) {
 }
 if(new Random().nextInt()%2>=0) {
 int i = 12/0;
 }
 System.out.println("run end ...");
 });
 
 future.whenComplete(new BiConsumer<Void, Throwable>() {
 @Override
 public void accept(Void t, Throwable action) {
 System.out.println("执行完成！");
 }
 
 });
 future.exceptionally(new Function<Throwable, Void>() {
 @Override
 public Void apply(Throwable t) {
 System.out.println("执行失败！"+t.getMessage());
 return null;
 }
 });
 
 TimeUnit.SECONDS.sleep(2);
 }

## 3、 thenApply 方法 ##

当一个线程依赖另一个线程时，可以使用 thenApply 方法来把这两个线程串行化。

public CompletableFuture thenApply(Function<? super T,? extends U> fn)
 public CompletableFuture thenApplyAsync(Function<? super T,? extends U> fn)
 public CompletableFuture thenApplyAsync(Function<? super T,? extends U> fn, Executor executor)

Function<? super T,? extends U> 
T：上一个任务返回结果的类型 
U：当前任务的返回值类型

## 示例 ##

private static void thenApply() throws Exception {
 CompletableFuture<Long> future = CompletableFuture.supplyAsync(new Supplier<Long>() {
 @Override
 public Long get() {
 long result = new Random().nextInt(100);
 System.out.println("result1="+result);
 return result;
 }
 }).thenApply(new Function<Long, Long>() {
 @Override
 public Long apply(Long t) {
 long result = t*5;
 System.out.println("result2="+result);
 return result;
 }
 });
 
 long result = future.get();
 System.out.println(result);
 }

第二个任务依赖第一个任务的结果。

## 4、 handle 方法 ##

handle 是执行任务完成时对结果的处理。  
handle 方法和 thenApply 方法处理方式基本一样。不同的是 handle 是在任务完成后再执行，还可以处理异常的任务。thenApply 只可以执行正常的任务，任务出现异常则不执行 thenApply 方法。

public CompletionStage handle(BiFunction<? super T, Throwable, ? extends U> fn);
 public CompletionStage handleAsync(BiFunction<? super T, Throwable, ? extends U> fn);
 public CompletionStage handleAsync(BiFunction<? super T, Throwable, ? extends U> fn,Executor executor);

## 示例 ##

public static void handle() throws Exception{
 CompletableFuture<Integer> future = CompletableFuture.supplyAsync(new Supplier<Integer>() {
 
 @Override
 public Integer get() {
 int i= 10/0;
 return new Random().nextInt(10);
 }
 }).handle(new BiFunction<Integer, Throwable, Integer>() {
 @Override
 public Integer apply(Integer param, Throwable throwable) {
 int result = -1;
 if(throwable==null){
 result = param * 2;
 }else{
 System.out.println(throwable.getMessage());
 }
 return result;
 }
 });
 System.out.println(future.get());
 }

从示例中可以看出，在 handle 中可以根据任务是否有异常来进行做相应的后续处理操作。而 thenApply 方法，如果上个任务出现错误，则不会执行 thenApply 方法。

## 5、 thenAccept 消费处理结果 ##

接收任务的处理结果，并消费处理，无返回结果。

public CompletionStage<Void> thenAccept(Consumer<? super T> action);
 public CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action);
 public CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action,Executor executor);

## 示例 ##

public static void thenAccept() throws Exception{
 CompletableFuture<Void> future = CompletableFuture.supplyAsync(new Supplier<Integer>() {
 @Override
 public Integer get() {
 return new Random().nextInt(10);
 }
 }).thenAccept(integer -> {
 System.out.println(integer);
 });
 future.get();
 }

从示例代码中可以看出，该方法只是消费执行完成的任务，并可以根据上面的任务返回的结果进行处理。并没有后续的输错操作。

## 6、thenRun 方法 ##

跟 thenAccept 方法不一样的是，不关心任务的处理结果。只要上面的任务执行完成，就开始执行 thenAccept 。

public CompletionStage<Void> thenRun(Runnable action);
 public CompletionStage<Void> thenRunAsync(Runnable action);
 public CompletionStage<Void> thenRunAsync(Runnable action,Executor executor);

## 示例 ##

public static void thenRun() throws Exception{
 CompletableFuture<Void> future = CompletableFuture.supplyAsync(new Supplier<Integer>() {
 @Override
 public Integer get() {
 return new Random().nextInt(10);
 }
 }).thenRun(() -> {
 System.out.println("thenRun ...");
 });
 future.get();
 }

该方法同 thenAccept 方法类似。不同的是上个任务处理完成后，并不会把计算的结果传给 thenRun 方法。只是处理玩任务后，执行 thenAccept 的后续操作。

## 7、thenCombine 合并任务 ##

thenCombine 会把 两个 CompletionStage 的任务都执行完成后，把两个任务的结果一块交给 thenCombine 来处理。

public <U,V> CompletionStage<V> thenCombine(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn);
 public <U,V> CompletionStage<V> thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn);
 public <U,V> CompletionStage<V> thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn,Executor executor);

## 示例 ##

private static void thenCombine() throws Exception {
 CompletableFuture<String> future1 = CompletableFuture.supplyAsync(new Supplier<String>() {
 @Override
 public String get() {
 return "hello";
 }
 });
 CompletableFuture<String> future2 = CompletableFuture.supplyAsync(new Supplier<String>() {
 @Override
 public String get() {
 return "hello";
 }
 });
 CompletableFuture<String> result = future1.thenCombine(future2, new BiFunction<String, String, String>() {
 @Override
 public String apply(String t, String u) {
 return t+" "+u;
 }
 });
 System.out.println(result.get());
 }

## 8、thenAcceptBoth ##

当两个CompletionStage都执行完成后，把结果一块交给thenAcceptBoth来进行消耗

public CompletionStage<Void> thenAcceptBoth(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action);
 public CompletionStage<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action);
 public CompletionStage<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action, Executor executor);

## 示例 ##

private static void thenAcceptBoth() throws Exception {
 CompletableFuture<Integer> f1 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
 @Override
 public Integer get() {
 int t = new Random().nextInt(3);
 try {
 TimeUnit.SECONDS.sleep(t);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 System.out.println("f1="+t);
 return t;
 }
 });
 
 CompletableFuture<Integer> f2 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
 @Override
 public Integer get() {
 int t = new Random().nextInt(3);
 try {
 TimeUnit.SECONDS.sleep(t);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 System.out.println("f2="+t);
 return t;
 }
 });
 f1.thenAcceptBoth(f2, new BiConsumer<Integer, Integer>() {
 @Override
 public void accept(Integer t, Integer u) {
 System.out.println("f1="+t+";f2="+u+";");
 }
 });
 }

**thenAcceptBothAsync 方法：**

CompletableFuture<String> future1 = CompletableFuture.supplyAsync(new Supplier<String>() {
 @Override
 public String get() {
 return "zhangphil";
 }
 });
 
 CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
 @Override
 public Integer get() {
 return 2018;
 }
 });
 
 future2.thenAcceptBothAsync(future1, new BiConsumer<Integer, String>() {
 @Override
 public void accept(Integer integer, String s) {
 System.out.println(integer + " , " + s);
 }
 });

输出：

2018 , zhangphil

## 9、applyToEither 方法 ##

两个CompletionStage，谁执行返回的结果快，我就用那个CompletionStage的结果进行下一步的转化操作。

public CompletionStage applyToEither(CompletionStage<? extends T> other,Function<? super T, U> fn);
 public CompletionStage applyToEitherAsync(CompletionStage<? extends T> other,Function<? super T, U> fn);
 public CompletionStage applyToEitherAsync(CompletionStage<? extends T> other,Function<? super T, U> fn,Executor executor);

## 示例 ##

private static void applyToEither() throws Exception {
 CompletableFuture<Integer> f1 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
 @Override
 public Integer get() {
 int t = new Random().nextInt(3);
 try {
 TimeUnit.SECONDS.sleep(t);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 System.out.println("f1="+t);
 return t;
 }
 });
 CompletableFuture<Integer> f2 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
 @Override
 public Integer get() {
 int t = new Random().nextInt(3);
 try {
 TimeUnit.SECONDS.sleep(t);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 System.out.println("f2="+t);
 return t;
 }
 });
 
 CompletableFuture<Integer> result = f1.applyToEither(f2, new Function<Integer, Integer>() {
 @Override
 public Integer apply(Integer t) {
 System.out.println(t);
 return t * 2;
 }
 });
 
 System.out.println(result.get());
 }

## 10、acceptEither 方法 ##

两个CompletionStage，谁执行返回的结果快，我就用那个CompletionStage的结果进行下一步的消耗操作。

public CompletionStage<Void> acceptEither(CompletionStage<? extends T> other,Consumer<? super T> action);
 public CompletionStage<Void> acceptEitherAsync(CompletionStage<? extends T> other,Consumer<? super T> action);
 public CompletionStage<Void> acceptEitherAsync(CompletionStage<? extends T> other,Consumer<? super T> action,Executor executor);

## 示例 ##

private static void acceptEither() throws Exception {
 CompletableFuture<Integer> f1 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
 @Override
 public Integer get() {
 int t = new Random().nextInt(3);
 try {
 TimeUnit.SECONDS.sleep(t);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 System.out.println("f1="+t);
 return t;
 }
 });
 
 CompletableFuture<Integer> f2 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
 @Override
 public Integer get() {
 int t = new Random().nextInt(3);
 try {
 TimeUnit.SECONDS.sleep(t);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 System.out.println("f2="+t);
 return t;
 }
 });
 f1.acceptEither(f2, new Consumer<Integer>() {
 @Override
 public void accept(Integer t) {
 System.out.println(t);
 }
 });
 }

## 11、runAfterEither 方法 ##

两个CompletionStage，任何一个完成了都会执行下一步的操作（Runnable）

public CompletionStage<Void> runAfterEither(CompletionStage<?> other,Runnable action);
 public CompletionStage<Void> runAfterEitherAsync(CompletionStage<?> other,Runnable action);
 public CompletionStage<Void> runAfterEitherAsync(CompletionStage<?> other,Runnable action,Executor executor);

## 示例 ##

private static void runAfterEither() throws Exception {
 CompletableFuture<Integer> f1 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
 @Override
 public Integer get() {
 int t = new Random().nextInt(3);
 try {
 TimeUnit.SECONDS.sleep(t);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 System.out.println("f1="+t);
 return t;
 }
 });
 
 CompletableFuture<Integer> f2 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
 @Override
 public Integer get() {
 int t = new Random().nextInt(3);
 try {
 TimeUnit.SECONDS.sleep(t);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 System.out.println("f2="+t);
 return t;
 }
 });
 f1.runAfterEither(f2, new Runnable() {
 
 @Override
 public void run() {
 System.out.println("上面有一个已经完成了。");
 }
 });
 }

## 12、runAfterBoth ##

两个CompletionStage，都完成了计算才会执行下一步的操作（Runnable）

public CompletionStage<Void> runAfterBoth(CompletionStage<?> other,Runnable action);
 public CompletionStage<Void> runAfterBothAsync(CompletionStage<?> other,Runnable action);
 public CompletionStage<Void> runAfterBothAsync(CompletionStage<?> other,Runnable action,Executor executor);

## 示例 ##

private static void runAfterBoth() throws Exception {
 CompletableFuture<Integer> f1 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
 @Override
 public Integer get() {
 int t = new Random().nextInt(3);
 try {
 TimeUnit.SECONDS.sleep(t);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 System.out.println("f1="+t);
 return t;
 }
 });
 
 CompletableFuture<Integer> f2 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
 @Override
 public Integer get() {
 int t = new Random().nextInt(3);
 try {
 TimeUnit.SECONDS.sleep(t);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 System.out.println("f2="+t);
 return t;
 }
 });
 f1.runAfterBoth(f2, new Runnable() {
 
 @Override
 public void run() {
 System.out.println("上面两个任务都执行完成了。");
 }
 });
 }

## 13、thenCompose 方法 ##

thenCompose 方法允许你对两个 CompletionStage 进行流水线操作，第一个操作完成时，将其结果作为参数传递给第二个操作。

public CompletableFuture thenCompose(Function<? super T, ? extends CompletionStage> fn);
 public CompletableFuture thenComposeAsync(Function<? super T, ? extends CompletionStage> fn) ;
 public CompletableFuture thenComposeAsync(Function<? super T, ? extends CompletionStage> fn, Executor executor) ;

## 示例 ##

private static void thenCompose() throws Exception {
 CompletableFuture<Integer> f = CompletableFuture.supplyAsync(new Supplier<Integer>() {
 @Override
 public Integer get() {
 int t = new Random().nextInt(3);
 System.out.println("t1="+t);
 return t;
 }
 }).thenCompose(new Function<Integer, CompletionStage<Integer>>() {
 @Override
 public CompletionStage<Integer> apply(Integer param) {
 return CompletableFuture.supplyAsync(new Supplier<Integer>() {
 @Override
 public Integer get() {
 int t = param *2;
 System.out.println("t2="+t);
 return t;
 }
 });
 }
 
 });
 System.out.println("thenCompose result : "+f.get());
 }

## 14、**thenComposeAsync 的使用** ##

**组合 : thenComposeAsync**

**f2虽然依赖f1的结果，但不会等待f1结果返回，而是再包装成一个future返回**

CompletableFuture<String> f1 = CompletableFuture.supplyAsync(() ->
 "hello"
 );
 // f2虽然依赖f1的结果，但不会等待f1结果返回，而是再包装成一个future返回
 CompletableFuture<String> f2 = f1.thenComposeAsync(t ->
 CompletableFuture.supplyAsync(() ->
 t + " world"
 )
 );
 // 等到真正调用的时候再执行f2里的逻辑
 System.out.println("异步结果:" + f2.get());
 
 // 输出结果：
 异步结果:hello world

**转换 : thenApplyAsync**

CompletableFuture<String> f1 = CompletableFuture.supplyAsync(() ->
 "hello"
 );
 // f2依赖f1的结果做转换
 CompletableFuture<String> f2 = f1.thenApplyAsync(t ->
 t + " world"
 );
 System.out.println("异步结果:" + f2.get());
 
 // 输出结果：
 异步结果:hello world

**这里先说明一下，示例代码只关注核心功能，如果要实际使用需要考虑超时和异常情况，大家需要注意。**

在上面的代码中异步任务f2需要异步任务f1的结果才能执行，但对于我们的主线程来说，无须等到f1返回结果后再调用函数f2，即不会阻塞主流程，而是告诉CompletableFuture当执行完了f1的方法再去执行f2，只有当需要最后的结果时再获取。

## **15.创建CompletableFuture 对象** ##

创建CompletableFuture 对象publicstatic CompletableFuture completedFuture(U value)

如果你已经知道计算的结果，也可以用变成同步的方式来返回结果。Future completableFuture =

> CompletableFuture.completedFuture("Hello");
> 
> // ...
> 
> String result = completableFuture.get();
> 
> assertEquals("Hello", result);

**其他创建对象的方法：**

创建CompletableFuture对象
 //比较特殊，他入参就是返回值，也就是说他可以用来执行需要其他返回值的异步任务。
 public static CompletableFuture completedFuture(U value)
 
 //无返回值，使用默认线程池
 public static CompletableFuture<Void> 	runAsync(Runnable runnable)
 
 //无返回值，使用自定义线程池
 public static CompletableFuture<Void> 	runAsync(Runnable runnable, Executor executor)
 
 //有返回值，使用默认线程池
 public static CompletableFuture 	supplyAsync(Supplier supplier)
 
 //有返回值，使用自定义线程池
 public static CompletableFuture 	supplyAsync(Supplier supplier, Executor executor)

## 16. complete 方法的使用： ##

<table> 
 <thead> 
 <tr> 
 <th>方法名</th> 
 <th>描述</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>complete(T t)</td> 
 <td>完成异步执行，并返回future的结果</td> 
 </tr> 
 <tr> 
 <td>completeExceptionally(Throwable ex)</td> 
 <td>异步执行不正常的结束</td> 
 </tr> 
 </tbody> 
</table>

future.get()在等待执行结果时，程序会一直block，如果此时调用complete(T t)会立即执行。

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello");
 
 future.complete("World");
 
 try {
 System.out.println(future.get());
 } catch (InterruptedException e) {
 e.printStackTrace();
 } catch (ExecutionException e) {
 e.printStackTrace();
 }

执行结果：

World

可以看到future调用complete(T t)会立即执行。但是complete(T t)只能调用一次，后续的重复调用会失效。

如果future已经执行完毕能够返回结果，此时再调用complete(T t)则会无效。

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello");
 
 try {
 Thread.sleep(5000);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 
 future.complete("World");
 
 try {
 System.out.println(future.get());
 } catch (InterruptedException e) {
 e.printStackTrace();
 } catch (ExecutionException e) {
 e.printStackTrace();
 }

执行结果：

Hello

如果使用completeExceptionally(Throwable ex)则抛出一个异常，而不是一个成功的结果。

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello");
 
 future.completeExceptionally(new Exception());
 
 try {
 System.out.println(future.get());
 } catch (InterruptedException e) {
 e.printStackTrace();
 } catch (ExecutionException e) {
 e.printStackTrace();
 }

执行结果：

java.util.concurrent.ExecutionException: java.lang.Exception
    ...

## 17.处理异步超时机制 ##

在 java 9 引入了 `orTimeout` 和 `completeOnTimeOut` 两个方法支持 异步 timeout 机制：

*  public CompletableFuture orTimeout(long timeout, TimeUnit unit) : completes the CompletableFuture with a TimeoutException after the specified timeout has elapsed.
 *  public CompletableFuture completeOnTimeout(T value, long timeout, TimeUnit unit) : provides a default value in the case that the CompletableFuture pipeline times out.

package cn.codeduck.sftp;
 
 import java.util.concurrent.*;
 
 /**
 * @author luliang
 * @date 2021-02-24 10:05
 */
 public class CompletableFutureTimeout2 {
 public static void main(String[] args) throws ExecutionException, InterruptedException {
 CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
 try {
 Thread.sleep(2000);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 return 10;
 });
 
 CompletableFuture<Integer> within = CompletableFutureTimeout.completeOnTimeout(1, future, 1, TimeUnit.SECONDS);
 System.out.println(within.get());
 
 CompletableFuture<String> futureStr = CompletableFuture.supplyAsync(() -> {
 try {
 Thread.sleep(2000);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 return "正常执行";
 });
 
 CompletableFuture<String> withinStr = CompletableFutureTimeout.completeOnTimeout("异常执行", futureStr, 1, TimeUnit.SECONDS);
 System.out.println(withinStr.get());
 
 }
 }

\-------------------

## CallsManager中重要的使用的几个方法： ##

[thenComposeAsync][]:f2虽然依赖f1的结果，但不会等待f1结果返回，而是再包装成一个future返回

[whenCompleteAsync][]：此方法把这个任务继续提交给线程池来进行执行

[thenCombine][]：会把 两个 CompletionStage 的任务都执行完成后，把两个结果一块处理

[thenAcceptBothAsync][]：当两个CompletionStage都执行完成后，把结果一块交给thenAcceptBoth来进行消耗

[completedFuture][]：创建CompletableFuture 对象，里面的参数是返回结果

[thenAccept][]：接收上一个异步任务的处理结果，并消费处理，无返回结果

[thenApply][]：当一个线程依赖另一个线程时，可以使用 thenApply 方法来把这两个线程串行化

[thenComposeAsync]: https://cs.android.com/android/platform/superproject/+/master:libcore/ojluni/src/main/java/java/util/concurrent/CompletableFuture.java;drc=master;l=2160
[whenCompleteAsync]: https://cs.android.com/android/platform/superproject/+/master:libcore/ojluni/src/main/java/java/util/concurrent/CompletableFuture.java;drc=master;l=2176
[thenCombine]: https://cs.android.com/android/platform/superproject/+/master:libcore/ojluni/src/main/java/java/util/concurrent/CompletableFuture.java;drc=master;l=2050
[thenAcceptBothAsync]: https://cs.android.com/android/platform/superproject/+/master:libcore/ojluni/src/main/java/java/util/concurrent/CompletableFuture.java;drc=master;l=2080
[completedFuture]: https://cs.android.com/android/platform/superproject/+/master:libcore/ojluni/src/main/java/java/util/concurrent/CompletableFuture.java;drc=master;l=1897
[thenAccept]: https://cs.android.com/android/platform/superproject/+/master:libcore/ojluni/src/main/java/java/util/concurrent/CompletableFuture.java;drc=master;l=2024
[thenApply]: https://cs.android.com/android/platform/superproject/+/master:libcore/ojluni/src/main/java/java/util/concurrent/CompletableFuture.java;drc=master;l=2009