CompletableFuture API详解

  这篇文章介绍了CompletableFuture 类的功能和一些使用实例。在我们介绍开始之前，先来了解一下这个类的背景。在JAVA中，一个异步任务的调用可以使用Threads。然而，为了获得最佳性能，需要仔细规划业务流程中的各个步骤的编排，这对于不了解JAVA整个并发体系的人来说，非常容易出错。如果JAVA提供了一个即用的容器来连接一系列任务，并且能为任务的运行提供并发性但是却不用编写复杂的多线程代码呢？CompletableFuture就是这样一个别致的小东西。

创建CompletableFuture对象。

  我们可以直接new一个对象出来，也可以使用CompletableFuture为我们提供的静态方法。
  注意：这种方法直接new出来的CompletableFuture对象是无法运行的，因为他并没有处于一个“完成”状态，也就是说你调用get()方法是会被阻塞的。

CompletableFuture futrue = new CompletableFuture();

  推荐下面这种方法，使用CompletableFuture的静态方法completedFuture(U value)。直接会拿到一个“完成”状态的对象，当用get()方法拿值时，你拿到的值也就是value。

String expectedValue = "the expected value";
CompletableFuture alreadyCompleted = CompletableFuture.completedFuture(expectedValue);
assertThat(alreadyCompleted.get(), is(expectedValue));

开始运行我们的第一个Task

• runAsync(Runnable)
• runAsync(Runnable,Executor)
• supplyAsync(Supplier)
• supplyAsync(Supplier,Executor)

这里有2种方法来初始化我们的异步任务——使用runAsync()或者supplyAsnync()。先上一段代码：

CompletableFuture cf = CompletableFuture.runAsync(() -> {
         System.out.printf("[%s] I am Cool\n", Thread.currentThread().getName());
     });

CompletableFuture cf1 = CompletableFuture.supplyAsync(() -> {
         System.out.printf("[%s] Am Awesome\n", Thread.currentThread().getName());
         return null;
      });

打印结果：

[ForkJoinPool.commonPool-worker-3] I am Cool
[ForkJoinPool.commonPool-worker-3] Am Awesome

  从上面的例子中可以看出，有2种初始化CompletableFuture对象并运行我们的异步任务的方法。使用runAsync()和supplyAsync()。可以很容易的看出来两者之间的差别，supplyAsync()有返回值，这个返回值可以用于被下一个任务链结点所消费，后面我们会讲到。除此之外，上述方法还提供了重载方法，当我们传入Executor时，该Task会使用传入的Executor去执行，否则默认去执行任务的线程池就是fork-join thread pool，关于该线程池，暂不赘述。

PS：我个人觉得supplyAsync方法中传入Callable比传入Supplier更合适。它们俩都是函数式接口，但是Callable和异步任务的联系更紧，并且可以抛出非运行时异常。

构造任务链

  上述方法中我们只是异步的去执行了一个任务，如果我们想拿到这个任务的执行结果，并执行后面的任务呢？或者当该任务运行抛出异常时我们想来处理这些异常时呢（后面讲）？
  CompletableFuture为我们提供了几十种方法来构造任务链，这些任务链的构造过程类似于Stream.map()方法，下面将结合实例详细讲解。

• thenAccept(Consumer)
  该方法是非静态方法，是用来消费上一个任务运行之后的结点的返回值的。可以将该方法中的Consumer参数视为上一个任务在完成时要调用的回调函数。
    

Tip：该任务有两种方式来执行。第一种是如果当前线程调用thenAccept方法时，上一个任务还没执行完成时（这并不影响任务链执行的顺序性，因为这些任务都被存放在一个容器中），这时候调用此任务的线程就是上一个执行上任务的线程（ForkJoinPool-Thread）；第二种是如果当前线程调用该方法时，上一个任务执行完成，这时候调用到了thenAccept方法，那么此任务会被调用thenAccept方法的线程（Main）所调用

请看下面的例子：

while (true) {
            {
                CompletableFuture cf = CompletableFuture.supplyAsync(() -> "I am Cool").thenAccept(msg ->
                        System.out.printf("[%s] %s and am also Awesome\n", Thread.currentThread().getName(), msg));
                try {
                    cf.get();
                } catch (Exception ex) {
                    ex.printStackTrace(System.err);
                }
            }
        }

可以看到有多个运行结果：

[ForkJoinPool.commonPool-worker-2] I am Cool and am also Awesome
[main] I am Cool and am also Awesome

• thenApply(Function)
  该方法接收一个Function参数，T类型是上一个结点传入，需要被消费的值，U类型是生成的，会被输出的值。此Function会在上一个任务执行结束时被调用。调用该Function的线程使用规则请参考上述的Tip。以下是调用该线程的实例：

CompletableFuture cf = CompletableFuture.supplyAsync(() -> "I'm Awesome")
/*这里的msg就是上一个异步任务的返回结果：I'm Awesome*/
        .thenApply(msg -> String.format("%s and am Super COOL !!!", msg))
        .thenAccept(msg -> System.out.printf("%s\n", msg));

输出结果：

I'm Awesome and am Super COOL !!!

对比于thenApply，thenAccept更适用于作为任务链的结尾。

• thenCombine(CompletionStage, BiFunction)
  该方法能组合2个彼此独立的异步任务的输出。该方法接收2个参数，一个CompletionStage引用和一个BiFunction，类型T和类型U就是2个异步任务的输入，类型R为输出值。BiFunction会在上一个任务和传入第一个参数（CompletionStage）完成时被调用。下面给出实例代码：

ExecutorService executor = Executors.newFixedThreadPool(4);
CompletableFuture cf = CompletableFuture.supplyAsync(() -> "I'm Stunning", executor)
        .thenCombineAsync(CompletableFuture.supplyAsync(() -> "am New !!!"),
            (s1, s2) -> String.format("%s AND %s", s1, s2), executor)
         .thenAcceptAsync(msg -> 
                System.out.printf("[%s] %s\n", Thread.currentThread().getName(), msg), executor);

输出结果：

[pool-1-thread-3] I'm Stunning AND am New !!!

注意这里用的是自定义线程池。当线程池在任务执行结束之前shutdown则会抛出rejectedExecution。

• thenCompose(Function>)
  该方法接收一个Function，也是用来消费上一个任务结点的，不过返回的是CompletionStage，当这个CompletionStage执行结束时，它会返回一个类型U的值。请看下面代码：

 CompletableFuture cf = CompletableFuture.supplyAsync(() -> "I'm Smart")
         .thenCompose(s -> CompletableFuture.supplyAsync(() -> s + " & am NIMBLE !!!"))
         .thenAccept(msg -> 
         System.out.printf("[%s] %s\n", Thread.currentThread().getName(), msg));

输出结果：

I'm Smart & am NIMBLE !!!

thenCompose VS thenApply
这两个方法都是接收一个参数并且返回的是CompletableFuture对象。它们的不同之处在于Function的返回值，thenCompose返回的是CompletableFuture，是一个你自己已经包装好的对象；而thenApply返回的是值，它底层会将这个值包装成对象返回给你。这就类似于Optianal中faltMap()和map()之间的区别。如果你想链接一个已经存在的返回CompletableFuture的方法，thenCompose是一个更好的选择，如下：

CompletableFuture computeAnother(Integer i){
    return CompletableFuture.supplyAsync(() -> 10 + i);
}
CompletableFuture finalResult = compute().thenCompose(this::computeAnother);

• thenAcceptBoth(CompletionStage, BiConsumer)
  该方法作用如其名，该方法的功能可以为2个不相关的并行执行的异步任务都执行完成时，提供回调。第一个传入的参数CompletionStage就是其中一个需要执行的异步任务，BiConsumer这个参数就是当2个异步任务都执行完成时执行的回调函数。类型T是上一个任务的返回值，U就是传入的任务完成时的返回值。下面请看代码：

CompletableFuture cf1 = CompletableFuture.supplyAsync(() -> "I am Fast");
CompletableFuture cf2 = CompletableFuture.supplyAsync(() -> "am Nimble !!!");
CompletableFuture cf3 = cf1.thenAcceptBoth(cf2, (s1, s2) -> 
System.out.printf("[%s] %s and %s\n", Thread.currentThread().getName(), s1, s2));

输出结果：

[main] I am Fast and am Nimble !!!

• acceptEither(CompletionStage, Consumer)
  该方法接收2个参数：一个CompletionStage的引用和一个Consumer函数式接口。该回调函数会在上一个任务执行完成或第一个传入的参数执行完成时被调用。返回值为CompletableFuture。下面请看代码：

CompletableFuture cf1 = CompletableFuture.supplyAsync(() -> {
        randomDelay();
        return "I am Awesome";
            });
CompletableFuture cf2 = CompletableFuture.supplyAsync(() -> {
        randomDelay();
        return "I am Cool";
            });
CompletableFuture cf3 = cf1.acceptEither(cf2, msg ->
System.out.printf("[%s] %s and am NIMBLE !!!\n", Thread.currentThread().getName(), msg));

可能的输出结果：

[ForkJoinPool.commonPool-worker-9] I am Awesome and am NIMBLE !!!
或者
[ForkJoinPool.commonPool-worker-2] I am Cool and am NIMBLE !!!

• applyToEither(CompletionStage, Function)该方法和上述方法类型，两个异步任务的其中一个执行完成时会调用Function，不过返回值为CompletableFuture。

CompletableFuture cf1 = CompletableFuture.supplyAsync(() -> {
      randomDelay();
      return "I am Awesome";
      });
CompletableFuture cf2 = CompletableFuture.supplyAsync(() -> {
      randomDelay();
      return "I am Bold";
      });
CompletableFuture cf3 = cf1.applyToEither(cf2, msg -> String.format("%s and am Cool !!!", msg))
            .thenAccept(msg -> System.out.printf("[%s] %s\n", Thread.currentThread().getName(), msg));

可能出现以下结果

[ForkJoinPool.commonPool-worker-9] I am Awesome and am Cool !!!
或者
[ForkJoinPool.commonPool-worker-2] I am Bold and am Cool !!!

值得注意的是：以上两种"Either"方法在执行完成时，另一个还没执行完的任务会继续执行。

还有2个静态方法和Either，Both类方法大同小异

• CompletableFuture allOf(CompletableFuture... cfs) 会执行cfs中所有的异步任务。
• CompletableFuture