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<U> CompletableFuture<U> thenApply(
Function<? super T,? extends U> fn) {returnuniApplyStage(null,fn);} public <U> CompletableFuture<U> thenApplyAsync(
Function<? super T,? extends U> fn) {returnuniApplyStage(asyncPool,fn);} public <U> CompletableFuture<U> thenApplyAsync(
Function<? super T,? extends U> 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;}
publicstatic<U>CompletableFuture<U>supplyAsync(Supplier<U>supplier){returnasyncSupplyStage(asyncPool,supplier);}publicstatic<U>CompletableFuture<U>supplyAsync(Supplier<U>supplier,Executorexecutor){returnasyncSupplyStage(screenExecutor(executor),supplier);}
publicstaticCompletableFuture<Void>runAsync(Runnablerunnable){returnasyncRunStage(asyncPool,runnable);}publicstaticCompletableFuture<Void>runAsync(Runnablerunnable,Executorexecutor){returnasyncRunStage(screenExecutor(executor),runnable);}
4.中间组合操作
Runnable类型的参数会忽略计算的结果
Consumer是纯消费计算结果，BiConsumer会组合另外一个CompletionStage纯消费
Function会对计算结果做转换，BiFunction会组合另外一个CompletionStage的计算结果做转换。
4.1 转换
thenApply功能相当于将CompletableFuture<T>转换成CompletableFuture<U>。
public<U> CompletableFuture<U> thenApply(
Function<? super T,? extends U> fn) {returnuniApplyStage(null,fn);}
public<U>CompletableFuture<U>applyToEither( CompletionStage<?extendsT>other, Function<?superT,U>fn) { return orApplyStage(null, other, fn); }
其实从功能上来讲，thenCombine的功能更类似thenAcceptBoth，只不过thenAcceptBoth是纯消费，它的函数参数没有返回值，而thenCombine的函数参数fn有返回值。
public<U,V>CompletableFuture<V> thenCombine(
CompletionStage<? extends U> other,
BiFunction<? super T,? super U,? extends V> fn) {returnbiApplyStage(null,other,fn);}
这一组方法接受一个Function作为参数，这个Function的输入是当前的CompletableFuture的计算值，返回结果将是一个新的CompletableFuture，这个新的CompletableFuture会组合原来的CompletableFuture和函数返回的CompletableFuture。
public<U> CompletableFuture<U> thenCompose(
Function<? super T, ? extends CompletionStage<U>> fn) {returnuniComposeStage(null,fn);}
示例：
publicclassTest3{publicstaticvoidmain(String[]args)throws ExecutionException,InterruptedException{CompletableFuture<Integer>future=CompletableFuture.supplyAsync(()->{return100;});CompletableFuture<String>f=future.thenApplyAsync(i->i*10).thenApply(i->i.toString());System.out.println(f.get());}}
结果：
1000
publicclassTest6{publicstaticvoidmain(String[]args)throws ExecutionException,InterruptedException{CompletableFuture<Integer>future=CompletableFuture.supplyAsync(()->{return100;});CompletableFuture<String>future2=CompletableFuture.supplyAsync(()->{return"abc";});CompletableFuture<String>f=future.thenCombine(future2,(x,y)->y+"-"+x);System.out.println(f.get());}}
结果：
abc-100
publicclassTest7{publicstaticvoidmain(String[]args)throws ExecutionException,InterruptedException{CompletableFuture<Integer>future=CompletableFuture.supplyAsync(()->{return100;});CompletableFuture<String>f=future.thenCompose(i->{returnCompletableFuture.supplyAsync(()->{return(i*10)+"";});});System.out.println(f.get());}}
结果：
1000
4.2 消费
thenAccept只对结果执行Action，而不返回新的计算值。
publicCompletableFuture<Void>thenAccept(Consumer<?superT>action){returnuniAcceptStage(null,action);}
public<U>CompletableFuture<Void>thenAcceptBoth(CompletionStage<?extends U>other,BiConsumer<?superT,?superU>action){returnbiAcceptStage(null,other,action);}
public<U>CompletableFuture<U>applyToEither( CompletionStage<?extendsT>other, Function<?superT,U>fn) { return orApplyStage(null, other, fn); }
示例：
publicclassTest4{publicstatic voidmain(String[]args)throws ExecutionException,InterruptedException{CompletableFuture<Integer>future=CompletableFuture.supplyAsync(()->{return100;});CompletableFuture<Void>f=future.thenAccept(System.out::println);System.out.println(f.get());}}
结果：
100null
publicclassTest5{publicstaticvoidmain(String[]args)throws ExecutionException,InterruptedException{CompletableFuture<Integer>future=CompletableFuture.supplyAsync(()->{return100;});CompletableFuture<Void>f=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计算的结果。
publicCompletableFuture<Void>thenRun(Runnable action){returnuniRunStage(null,action);}
publicCompletableFuture<Void>runAfterBoth(CompletionStage<?>other,Runnable action){returnbiRunStage(null,other,action);}
publicCompletableFuture<Void>runAfterEither(CompletionStage<?>other,Runnable action){returnorRunStage(null,other,action);}
4.4 批量
publicstaticCompletableFuture<Void>allOf(CompletableFuture<?>...cfs){returnandTree(cfs,0,cfs.length-1);}
publicstaticCompletableFuture<Object>anyOf(CompletableFuture<?>...cfs){returnorTree(cfs,0,cfs.length-1);}
5.终止操作
public<U>CompletableFuture<U>handle(BiFunction<?superT,Throwable,?extendsU>fn){returnuniHandleStage(null,fn);}
publicCompletableFuture<T>whenComplete(BiConsumer<?superT,?superThrowable>action){returnuniWhenCompleteStage(null,action);}
publicCompletableFuture<T>exceptionally(Function<Throwable,?extendsT>fn){returnuniExceptionallyStage(fn);}
6.通过阻塞或者轮询的方式获得结果
get在遇到底层异常时，会抛出受查异常ExecutionException。
publicTget()throwsInterruptedException,ExecutionException{Objectr;returnreportGet((r=result)==null?waitingGet(true):r);}publicTget(longtimeout,TimeUnitunit)throwsInterruptedException,ExecutionException,TimeoutException{Objectr;longnanos=unit.toNanos(timeout);returnreportGet((r=result)==null?timedGet(nanos):r);}
join在遇到底层的异常时，会抛出未受查的CompletionException。
publicTjoin(){Objectr;returnreportJoin((r=result)==null?waitingGet(false):r);}
publicTgetNow(TvalueIfAbsent){Objectr;return((r=result)==null)?valueIfAbsent:reportJoin(r);}
示例：
publicclassTest1{publicstaticvoidmain(String[]args)throws ExecutionException,InterruptedException{CompletableFuture<Integer>future=CompletableFuture.supplyAsync(()->{inti=1/0;return100;});System.out.println(future.get());}}
结果：
Exceptioninthread"main"java.util.concurrent.ExecutionException:java.lang.ArithmeticException:/by zero at java.util.concurrent.CompletableFuture.reportGet(CompletableFuture.java:357)at java.util.concurrent.CompletableFuture.get(CompletableFuture.java:1895)at com.enjoy.learn.core.concurrency.completablefuture.Test1.main(Test1.java:19)Causedby:java.lang.ArithmeticException:/by zero
publicstaticvoidmain(String[]args)throws ExecutionException,InterruptedException{CompletableFuture<Integer>future=CompletableFuture.supplyAsync(()->{inti=1/0;return100;});System.out.println(future.join());}
结果：
Exception in thread "main" java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero at java.util.concurrent.CompletableFuture.encodeThrowable(CompletableFuture.java:273) at java.util.concurrent.CompletableFuture.completeThrowable(CompletableFuture.java:280) at java.util.concurrent.CompletableFuture$AsyncSupply.run(CompletableFuture.java:1592) at java.util.concurrent.CompletableFuture$AsyncSupply.exec(CompletableFuture.java:1582) at java.util.concurrent.ForkJoinTask.doExec(ForkJoinTask.java:289) at java.util.concurrent.ForkJoinPool$WorkQueue.runTask(ForkJoinPool.java:1056) at java.util.concurrent.ForkJoinPool.runWorker(ForkJoinPool.java:1692) at java.util.concurrent.ForkJoinWorkerThread.run(ForkJoinWorkerThread.java:157)Caused by: java.lang.ArithmeticException: / by zero
