CompletableFuture初识

1为什么引入CompletableFuture？

1.1 回调

回调函数比较通用的解释是，它是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外一方调用的，用于对该事件或条件进行响应。

回调函数的机制：

定义一个回调函数；

提供函数实现的一方在初始化时候，将回调函数的函数指针注册给调用者；

当特定的事件或条件发生的时候，调用者使用函数指针调用回调函数对事件进行处理。

1.2 回调方式的异步编程

JDK5 新增了 Future 接口，用于描述一个异步计算的结果。虽然 Future 以及相关使用方法提供了异步执行任务的能力，但是对于结果的获取却是很不方便，只能通过阻塞或者轮询的方式得到任务的结果。阻塞的方式显然和我们的异步编程的初衷相违背，轮询的方式又会耗费无谓的 CPU 资源，而且也不能及时地得到计算结果。

为什么不能用观察者设计模式呢？即当计算结果完成及时通知监听者。

有一些开源框架实现了我们的设想：

例如 Netty 的 ChannelFuture 类扩展了 Future 接口，通过提供 addListener 方法实现支持回调方式的异步编程。Netty 中所有的 I/O 操作都是异步的,这意味着任何的 I/O 调用都将立即返回，而不保证这些被请求的 I/O 操作在调用结束的时候已经完成。取而代之地，你会得到一个返回的 ChannelFuture 实例，这个实例将给你一些关于 I/O 操作结果或者状态的信息。当一个 I/O 操作开始的时候，一个新的 Future 对象就会被创建。在开始的时候，新的 Future 是未完成的状态－－它既非成功、失败，也非被取消，因为 I/O 操作还没有结束。如果 I/O 操作以成功、失败或者被取消中的任何一种状态结束了，那么这个 Future 将会被标记为已完成，并包含更多详细的信息（例如：失败的原因）。请注意，即使是失败和被取消的状态，也是属于已完成的状态。

Google guava也提供了通用的扩展Future:ListenableFuture、SettableFuture 以及辅助类Futures等，方便异步编程。

Scala也提供了简单易用且功能强大的Future/Promise异步编程模式。

CompletableFuture提供了非常强大的 Future 的扩展功能，可以帮助我们简化异步编程的复杂性，并且提供了函数式编程的能力，可以通过回调的方式处理计算结果，也提供了转换和组合 CompletableFuture 的方法。

1.3 CompletableFuture

处理非阻塞调用的传统方法是使用事件处理器，程序员为任务完成之后要出现的动作注册一个处理器。但是，要尝试在一组事件处理器中实现一个控制流会很困难。

CompletableFuture提供了一种候选方法，与事件处理器不同，CompletableFuture可以组合。利用CompletableFuture，可以指定希望做什么，以及希望以什么顺序执行这些工作。这些动作不会立即发生，不过重要的是将所有代码放在一起。

CompletableFuture提供了非常强大的 Future 的扩展功能，可以帮助我们简化异步编程的复杂性，并且提供了函数式编程的能力，可以通过回调的方式处理计算结果，也提供了转换和组合 CompletableFuture 的方法。

对于阻塞或者轮询方式，依然可以通过 CompletableFuture 类的 CompletionStage 和 Future 接口方式支持。

CompletableFuture 类声明了 CompletionStage 接口，CompletionStage 接口实际上提供了同步或异步运行计算的舞台，所以我们可以通过实现多个 CompletionStage 命令，并且将这些命令串联在一起的方式实现多个命令之间的触发。

2.每一种方法的三种形式

public CompletableFuture thenApply(

        Function fn) {returnuniApplyStage(null,fn);}    public CompletableFuture thenApplyAsync(

        Function fn) {returnuniApplyStage(asyncPool,fn);}    public CompletableFuture thenApplyAsync(

        Function fn, Executor executor) {returnuniApplyStage(screenExecutor(executor),fn);}

privatestaticfinalbooleanuseCommonPool=(ForkJoinPool.getCommonPoolParallelism()>1);/**

    * Default executor -- ForkJoinPool.commonPool() unless it cannot

    * support parallelism.

    */privatestaticfinalExecutorasyncPool=useCommonPool?ForkJoinPool.commonPool():newThreadPerTaskExecutor();/** Fallback if ForkJoinPool.commonPool() cannot support parallelism */staticfinalclassThreadPerTaskExecutorimplementsExecutor{publicvoidexecute(Runnabler){newThread(r).start();}}

非异步方法由当前线程或调用线程执行

不带executor的异步方法使用asyncPool来执行

1）如果不支持多线程，则新建一个线程专门执行

2）否则使用ForkJoinPool.commonPool()执行

另一种异步方法使用executor执行

3.创建CompletableFuture

publicCompletableFuture(){}privateCompletableFuture(Object r){this.result=r;}

publicstaticCompletableFuturesupplyAsync(Suppliersupplier){returnasyncSupplyStage(asyncPool,supplier);}publicstaticCompletableFuturesupplyAsync(Suppliersupplier,Executorexecutor){returnasyncSupplyStage(screenExecutor(executor),supplier);}

publicstaticCompletableFuturerunAsync(Runnablerunnable){returnasyncRunStage(asyncPool,runnable);}publicstaticCompletableFuturerunAsync(Runnablerunnable,Executorexecutor){returnasyncRunStage(screenExecutor(executor),runnable);}

4.中间组合操作

Runnable类型的参数会忽略计算的结果

Consumer是纯消费计算结果，BiConsumer会组合另外一个CompletionStage纯消费

Function会对计算结果做转换，BiFunction会组合另外一个CompletionStage的计算结果做转换。

4.1 转换

thenApply功能相当于将CompletableFuture转换成CompletableFuture。

public CompletableFuture thenApply(

        Function fn) {returnuniApplyStage(null,fn);}

publicCompletableFutureapplyToEither(        CompletionStageother, Functionfn) {        return orApplyStage(null, other, fn);    }

其实从功能上来讲，thenCombine的功能更类似thenAcceptBoth，只不过thenAcceptBoth是纯消费，它的函数参数没有返回值，而thenCombine的函数参数fn有返回值。

publicCompletableFuture thenCombine(

        CompletionStage other,

        BiFunction fn) {returnbiApplyStage(null,other,fn);}

这一组方法接受一个Function作为参数，这个Function的输入是当前的CompletableFuture的计算值，返回结果将是一个新的CompletableFuture，这个新的CompletableFuture会组合原来的CompletableFuture和函数返回的CompletableFuture。

public CompletableFuture thenCompose(

        Function> fn) {returnuniComposeStage(null,fn);}

示例：

publicclassTest3{publicstaticvoidmain(String[]args)throws ExecutionException,InterruptedException{CompletableFuturefuture=CompletableFuture.supplyAsync(()->{return100;});CompletableFuturef=future.thenApplyAsync(i->i*10).thenApply(i->i.toString());System.out.println(f.get());}}

结果：

1000

publicclassTest6{publicstaticvoidmain(String[]args)throws ExecutionException,InterruptedException{CompletableFuturefuture=CompletableFuture.supplyAsync(()->{return100;});CompletableFuturefuture2=CompletableFuture.supplyAsync(()->{return"abc";});CompletableFuturef=future.thenCombine(future2,(x,y)->y+"-"+x);System.out.println(f.get());}}

结果：

abc-100

publicclassTest7{publicstaticvoidmain(String[]args)throws ExecutionException,InterruptedException{CompletableFuturefuture=CompletableFuture.supplyAsync(()->{return100;});CompletableFuturef=future.thenCompose(i->{returnCompletableFuture.supplyAsync(()->{return(i*10)+"";});});System.out.println(f.get());}}

结果：

1000

4.2 消费

thenAccept只对结果执行Action，而不返回新的计算值。

publicCompletableFuturethenAccept(Consumeraction){returnuniAcceptStage(null,action);}

publicCompletableFuturethenAcceptBoth(CompletionStageother,BiConsumeraction){returnbiAcceptStage(null,other,action);}

publicCompletableFutureapplyToEither(        CompletionStageother, Functionfn) {        return orApplyStage(null, other, fn);    }

示例：

publicclassTest4{publicstatic voidmain(String[]args)throws ExecutionException,InterruptedException{CompletableFuturefuture=CompletableFuture.supplyAsync(()->{return100;});CompletableFuturef=future.thenAccept(System.out::println);System.out.println(f.get());}}

结果：

100null

publicclassTest5{publicstaticvoidmain(String[]args)throws ExecutionException,InterruptedException{CompletableFuturefuture=CompletableFuture.supplyAsync(()->{return100;});CompletableFuturef=future.thenAcceptBoth(CompletableFuture.completedFuture(10),(x,y)->System.out.println(x*y));System.out.println(f.get());}}

结果：

1000null

4.3 运行

thenRun更彻底地，下面一组方法当计算完成的时候会执行一个Runnable，与thenAccept不同，Runnable并不使用CompletableFuture计算的结果。

publicCompletableFuturethenRun(Runnable action){returnuniRunStage(null,action);}

publicCompletableFuturerunAfterBoth(CompletionStageother,Runnable action){returnbiRunStage(null,other,action);}

publicCompletableFuturerunAfterEither(CompletionStageother,Runnable action){returnorRunStage(null,other,action);}

4.4 批量

publicstaticCompletableFutureallOf(CompletableFuture...cfs){returnandTree(cfs,0,cfs.length-1);}

publicstaticCompletableFuture