CompletableFuture 用法详解解

原理介绍

Java 文档说明，创建线程的方式只有两种：继承 Thread 或者实现 Runnable 接口，具体源码说明如下

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
// 继承 Thread 类
 class PrimeThread extends Thread {
          long minPrime;
          PrimeThread(long minPrime) {
              this.minPrime = minPrime;
          }
 
          public void run() {
              // compute primes larger than minPrime
               . . .
          }
      }
 // The following code would then create a thread and start it running:
  PrimeThread p = new PrimeThread(143);
  p.start();
      
 // 实现 Runnable 接口
  class PrimeRun implements Runnable {
          long minPrime;
          PrimeRun(long minPrime) {
              this.minPrime = minPrime;
          }
 
          public void run() {
              // compute primes larger than minPrime
               . . .
          }
      }
 // The following code would then create a thread and start it running:
PrimeRun p = new PrimeRun(143);
new Thread(p).start();

由上述代码可以在对应线程执行 run 方法以后返回值为 void
为了满足需要返回值的场景，Java 1.5 以后的 Callable 和 Future 接口
但是 Future 获取返回值时阻塞当前线程，在一些复杂的场景下 Future 和 FutureTask 无法满足需求。所以在 Future 基础之上设计出了 CompletableFuture

CompletableFuture 方法使用流程图

关于 CompletableFuture 的文档描述 具体文档描述

组合式异步编程

将两个异步计算合并为一个，这两个异步计算之间相互独立，同时第二个又依赖于第一个的结果，Future 无法做到

Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
CompletableFuture<List<String>> painting = CompletableFuture.supplyAsync(() -> {
    // 第一个任务获取美术课需要带的东西，返回一个 list
    List<String> stuff = new ArrayList<>();
    stuff.add("画笔");
    stuff.add("颜料");
    return stuff;
});
CompletableFuture<List<String>> handWork = CompletableFuture.supplyAsync(() -> {
    // 第二个任务获取劳技课需要带的东西，返回一个 list
    List<String> stuff = new ArrayList<>();
    stuff.add("剪刀");
    stuff.add("折纸");
    return stuff;
});
CompletableFuture<List<String>> total = painting
        // 传入 handWork 列表，然后得到两个 CompletableFuture 的参数 Stuff1和2
        .thenCombine(handWork, (stuff1, stuff2) -> {
            // 合并成新的 list
            return Stream.of(stuff1, stuff2)
                         .flatMap(Collection::stream)
                         .collect(Collectors.toList());
        });
System.out.println(total.join());