Java8 CompletableFuture

http://colobu.com/2016/02/29/Java-CompletableFuture/

http://www.deadcoderising.com/java8-writing-asynchronous-code-with-completablefuture/

https://www.jianshu.com/p/558b090ae4bb，CompletableFuture API详解

Java8 lamda

http://ifeve.com/lambda/

lamda可以认为是匿名函数，用过scala的都很熟悉

Java8 supplier

http://www.byteslounge.com/tutorials/java-8-consumer-and-supplier

supplier，

Suppliers represent a function that accepts no arguments and produce a result of some arbitrary type.

A Future represents the pending result of an asynchronous computation. It offers a method — get — that returns the result of the computation when it's done.

The problem is that a call to get is blocking until the computation is done. This is quite restrictive and can quickly make the asynchronous computation pointless.

传统的Future，提供异步计算的可能性

不过Future的结果需要用get去获取，这个过程是block的或者轮询，所以这样又限制了异步

Beside implementing the Future interface, CompletableFuture also implements the CompletionStage interface.

A CompletionStage is a promise. It promises that the computation eventually will be done.

The great thing about the CompletionStage is that it offers a vast selection of methods that let you attach callbacks that will be executed on completion.

This way we can build systems in a non-blocking fashion.

所以我们需要CompletableFuture，除了future接口，还实现CompletionStage接口

CompletionStage的作用是，提供给你很多方法，让你可以attach各种callbacks用于future执行完成后的followup

这样我们更容易build non-blocking的系统

例子，

Let's start with the absolute basics — creating a simple asynchronous computation.

CompletableFuture.supplyAsync(this::sendMsg);  

It's as easy as that.

supplyAsync takes a Supplier containing the code we want to execute asynchronously — in our case the sendMsgmethod.

异步执行supplier的逻辑，什么是supplier见上面

If you've worked a bit with Futures in the past, you may wonder where the Executor went. If you want to, you can still define it as a second argument. However, if you leave it out it will be submitted to the ForkJoinPool.commonPool().

ForkJoinPool.commonPool

Java 8为ForkJoinPool添加了一个通用线程池，这个线程池用来处理那些没有被显式提交到任何线程池的任务。它是ForkJoinPool类型上的一个静态元素，它拥有的默认线程数量等于运行计算机上的处理器数量

commonPool可以理解为由JVM管理的一个通用线程池，谁都可以用

加上callback

In the first example, we simply sent a message asynchronously by executing sendMsg in its own thread.

Now let's add a callback where we notify about how the sending of the message went.

CompletableFuture.supplyAsync(this::sendMsg)  
                 .thenAccept(this::notify);

thenAccept is one of many ways to add a callback. It takes a Consumer — in our case notify — which handles the result of the preceding computation when it's done.

thenAccept是加callback的一种方式，当然有很多种加callback的方式；

这里thenAccept是一种Consumer function，consumer即接受参数没有返回的一种function

在这里notify会作为consumer会接收sendMsg是输出作为输入来继续处理

加上多个callbacks

If you want to continue passing values from one callback to another, thenAccept won't cut it since Consumer doesn't return anything.

To keep passing values, you can simply use thenApply instead.

上面说了thenAccept是一种Consumer，是不会有返回值的，所以如果要级联多个callback，需要用thenApply，它是既有输入参数，又有返回值

thenApply takes a Function which accepts a value, but also return one.

To see how this works, let's extend our previous example by first finding a receiver.

    CompletableFuture.supplyAsync(this::findReceiver)
                     .thenApply(this::sendMsg)
                     .thenAccept(this::notify);

Now the asynchronous task will first find a receiver, then send a message to the receiver before it passes the result on to the last callback to notify.

thenCompose

Until now, sendMsg has been a normal blocking function. Let's now assume that we got a sendMsgAsync method that returns a CompletionStage.

If we kept using thenApply to compose the example above, we would end up with nested CompletionStages.

CompletableFuture.supplyAsync(this::findReceiver)  
                 .thenApply(this::sendMsgAsync);

// Returns type CompletionStage<CompletionStage<String>> 

这个例子会出现多个异步的嵌套，

所以这里用thenCompose，去除掉嵌套

CompletableFuture.supplyAsync(this::findReceiver)  
                 .thenCompose(this::sendMsgAsync);

// Returns type CompletionStage<String>

异步的执行callback

Until now all our callbacks have been executed on the same thread as their predecessor.

If you want to, you can submit the callback to the ForkJoinPool.commonPool() independently instead of using the same thread as the predecessor. This is done by using the async suffix version of the methods CompletionStage offers.

我们也可以异步的执行callback，

CompletableFuture<String> receiver  
            = CompletableFuture.supplyAsync(this::findReceiver);

receiver.thenApply(this::sendMsg);  
receiver.thenApply(this::sendOtherMsg);  

这个例子中，两次的消息发送都是在当前线程中完成的，我们也可以给加上async前缀，让他们异步的执行，

CompletableFuture<String> receiver  
            = CompletableFuture.supplyAsync(this::findReceiver);

receiver.thenApplyAsync(this::sendMsg);  
receiver.thenApplyAsync(this::sendMsg);

异常处理

CompletableFuture.supplyAsync(this::failingMsg)  
                 .exceptionally(ex -> new Result(Status.FAILED))
                 .thenAccept(this::notify);

exceptionally gives us a chance to recover by taking an alternative function that will be executed if preceding calculation fails with an exception.

This way succeeding callbacks can continue with the alternative result as input.

If you need more flexibility, check out whenComplete and handle for more ways of handling errors.

thenCombine

thenCombine allows us to register a BiFunction callback depending on the result of two CompletionStages.

CompletableFuture<String> to =  
    CompletableFuture.supplyAsync(this::findReceiver);

CompletableFuture<String> text =  
    CompletableFuture.supplyAsync(this::createContent);

to.thenCombine(text, this::sendMsg);  

上面的是both的case

下面的是either的case

Let’s say you have two sources of finding a receiver. You’ll ask both, but will be happy with the first one returning with a result.

CompletableFuture<String> firstSource =  
    CompletableFuture.supplyAsync(this::findByFirstSource);

CompletableFuture<String> secondSource =  
    CompletableFuture.supplyAsync(this::findBySecondSource);

firstSource.acceptEither(secondSource, this::sendMsg); 

完成时回调

T get() throws InterruptedException, ExecutionException
T join()
这两个方法都是从CompletableFuture里面取值的，调用时会阻塞当前线程。可以很容易看出join没有抛出非运行时异常，不过它会抛出2个运行时异常：
当这个任务被取消时会抛出CancellationException；当任务执行时抛出异常时，会抛出CompletionException。
当我们需要从任务中拿值时，推荐join()方法。

boolean complete(T)
如果任务未完成，则在拿取返回值时返回T。如果此次调用将CompletableFuture转化为“完成”状态，则返回true，否则返回false。
通过get()或join()拿到的是类型T的值，则返回true，否则返回false。
whenComplete(BiConsumer<T, Throwable>)
该方法有点像thenAccept(Consumer<T>) ，只不过增加了一个异常处理的功能。
传入的参数类似于handle，如果上一个任务出了异常，则传入的T类型为null，Throwable为抛出的异常；
如果正常运行，则T类型为之前任务运行后的返回值，Throwable为null