一. Future

JDK 5引入了Future模式。Future接口是Java多线程Future模式的实现，在java.util.concurrent包中，可以来进行异步计算。

Future模式是多线程设计常用的一种设计模式。Future模式可以理解成：我有一个任务，提交给了Future，Future替我完成这个任务。期间我自己可以去做任何想做的事情。一段时间之后，我就便可以从Future那儿取出结果。

Future的接口很简单，只有五个方法。

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
Future接口的方法介绍如下：
 
boolean cancel (boolean mayInterruptIfRunning) 取消任务的执行。参数指定是否立即中断任务执行，或者等等任务结束
boolean isCancelled () 任务是否已经取消，任务正常完成前将其取消，则返回 true
boolean isDone () 任务是否已经完成。需要注意的是如果任务正常终止、异常或取消，都将返回true
V get () throws InterruptedException, ExecutionException 等待任务执行结束，然后获得V类型的结果。InterruptedException 线程被中断异常， ExecutionException任务执行异常，如果任务被取消，还会抛出CancellationException
V get (long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException 同上面的get功能一样，多了设置超时时间。参数timeout指定超时时间，uint指定时间的单位，在枚举类TimeUnit中有相关的定义。如果计 算超时，将抛出TimeoutException
 
一般情况下，我们会结合Callable和Future一起使用，通过ExecutorService的submit方法执行Callable，并返回Future。
 
        ExecutorService executor = Executors.newCachedThreadPool();
        Future<String> future = executor.submit(() -> { //Lambda 是一个 callable， 提交后便立即执行，这里返回的是 FutureTask 实例
            System.out.println("running task");
            Thread.sleep(10000);
            return "return task";
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
        System.out.println("do something else");  //前面的的 Callable 在其他线程中运行着，可以做一些其他的事情
        try {
            System.out.println(future.get());  //等待 future 的执行结果，执行完毕之后打印出来
        } catch (InterruptedException e) {
        } catch (ExecutionException e) {
        } finally {
            executor.shutdown();
 
比起future.get()，其实更推荐使用get (long timeout, TimeUnit unit) 方法，设置了超时时间可以防止程序无限制的等待future的结果。
 
二. CompletableFuture介绍
 
2.1 Future模式的缺点
 
 
Future虽然可以实现获取异步执行结果的需求，但是它没有提供通知的机制，我们无法得知Future什么时候完成。
 
要么使用阻塞，在future.get()的地方等待future返回的结果，这时又变成同步操作。要么使用isDone()轮询地判断Future是否完成，这样会耗费CPU的资源。
 
2.2 CompletableFuture介绍
 
Netty、Guava分别扩展了Java 的 Future 接口，方便异步编程。
 
Java 8新增的CompletableFuture类正是吸收了所有Google Guava中ListenableFuture和SettableFuture的特征，还提供了其它强大的功能，让Java拥有了完整的非阻塞编程模型：Future、Promise 和 Callback(在Java8之前，只有无Callback 的Future)。
 
CompletableFuture能够将回调放到与任务不同的线程中执行，也能将回调作为继续执行的同步函数，在与任务相同的线程中执行。它避免了传统回调最大的问题，那就是能够将控制流分离到不同的事件处理器中。
 
CompletableFuture弥补了Future模式的缺点。在异步的任务完成后，需要用其结果继续操作时，无需等待。可以直接通过thenAccept、thenApply、thenCompose等方式将前面异步处理的结果交给另外一个异步事件处理线程来处理。
 
三. CompletableFuture特性
 
3.1 CompletableFuture的静态工厂方法
 
方法名
描述
runAsync(Runnable runnable)
使用ForkJoinPool.commonPool()作为它的线程池执行异步代码。
runAsync(Runnable runnable, Executor executor)
使用指定的thread pool执行异步代码。
supplyAsync(Supplier<U> supplier)
使用ForkJoinPool.commonPool()作为它的线程池执行异步代码，异步操作有返回值
supplyAsync(Supplier<U> supplier, Executor executor)
使用指定的thread pool执行异步代码，异步操作有返回值
 
runAsync 和 supplyAsync 方法的区别是runAsync返回的CompletableFuture是没有返回值的。
 
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("Hello");
        try {
            future.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        System.out.println("CompletableFuture");
 
而supplyAsync返回的CompletableFuture是由返回值的，下面的代码打印了future的返回值。
 
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello");
        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        System.out.println("CompletableFuture");
 
3.2 Completable
 
方法名
描述
complete(T t)
完成异步执行，并返回future的结果
completeExceptionally(Throwable ex)
异步执行不正常的结束
 
future.get()在等待执行结果时，程序会一直block，如果此时调用complete(T t)会立即执行。
 
        CompletableFuture<String> future  = CompletableFuture.supplyAsync(() -> "Hello");
        future.complete("World");
        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
执行结果：
 
World
 
可以看到future调用complete(T t)会立即执行。但是complete(T t)只能调用一次，后续的重复调用会失效。
 
如果future已经执行完毕能够返回结果，此时再调用complete(T t)则会无效。
 
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        future.complete("World");
        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
执行结果：
 
Hello
 
如果使用completeExceptionally(Throwable ex)则抛出一个异常，而不是一个成功的结果。
 
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello");
        future.completeExceptionally(new Exception());
        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
执行结果：
 
java.util.concurrent.ExecutionException: java.lang.Exception

作者： fengzhizi715 
链接：http://www.imooc.com/article/21654
来源：慕课网
本文原创发布于慕课网 ，转载请注明出处，谢谢合作！
 
https://www.jianshu.com/p/6f3ee90ab7d3
 
CompletableFuture类实现了CompletionStage和Future接口。Future是Java 5添加的类，用来描述一个异步计算的结果，但是获取一个结果时方法较少,要么通过轮询isDone，确认完成后，调用get()获取值，要么调用get()设置一个超时时间。但是这个get()方法会阻塞住调用线程，这种阻塞的方式显然和我们的异步编程的初衷相违背。
 为了解决这个问题，JDK吸收了guava的设计思想，加入了Future的诸多扩展功能形成了CompletableFuture。
 
CompletionStage是一个接口，从命名上看得知是一个完成的阶段，它里面的方法也标明是在某个运行阶段得到了结果之后要做的事情。
 
public <U> CompletionStage<U> thenApply(Function<? super T,? extends U> fn);
public <U> CompletionStage<U> thenApplyAsync(Function<? super T,? extends U> fn);
public <U> CompletionStage<U> thenApplyAsync(Function<? super T,? extends U> fn,Executor executor);
首先说明一下已Async结尾的方法都是可以异步执行的，如果指定了线程池，会在指定的线程池中执行，如果没有指定，默认会在ForkJoinPool.commonPool()中执行，下文中将会有好多类似的，都不详细解释了。关键的入参只有一个Function，它是函数式接口，所以使用Lambda表示起来会更加优雅。它的入参是上一个阶段计算后的结果，返回值是经过转化后结果。
 例如：
 
    @Test
    public void thenApply() {
        String result = CompletableFuture.supplyAsync(() -> "hello").thenApply(s -> s + " world").join();
        System.out.println(result);
hello world
public CompletionStage<Void> thenAccept(Consumer<? super T> action);
public CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action);
public CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action,Executor executor);
thenAccept是针对结果进行消耗，因为他的入参是Consumer，有入参无返回值。
 例如：
 
@Test
public void thenAccept(){    
       CompletableFuture.supplyAsync(() -> "hello").thenAccept(s -> System.out.println(s+" world"));
hello world
对上一步的计算结果不关心，执行下一个操作。
 
public CompletionStage<Void> thenRun(Runnable action);
public CompletionStage<Void> thenRunAsync(Runnable action);
public CompletionStage<Void> thenRunAsync(Runnable action,Executor executor);
thenRun它的入参是一个Runnable的实例，表示当得到上一步的结果时的操作。
 例如：
 
    @Test
    public void thenRun(){
        CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            return "hello";
        }).thenRun(() -> System.out.println("hello world"));
        while (true){}
hello world
4.结合两个CompletionStage的结果，进行转化后返回
 
public <U,V> CompletionStage<V> thenCombine(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn);
public <U,V> CompletionStage<V> thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn);
public <U,V> CompletionStage<V> thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn,Executor executor);
它需要原来的处理返回值，并且other代表的CompletionStage也要返回值之后，利用这两个返回值，进行转换后返回指定类型的值。
 例如：
 
    @Test
    public void thenCombine() {
        String result = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            return "hello";
        }).thenCombine(CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            return "world";
        }), (s1, s2) -> s1 + " " + s2).join();
        System.out.println(result);
hello world
结合两个CompletionStage的结果，进行消耗
 
public <U> CompletionStage<Void> thenAcceptBoth(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action);
public <U> CompletionStage<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action);
public <U> CompletionStage<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action,     Executor executor);
它需要原来的处理返回值，并且other代表的CompletionStage也要返回值之后，利用这两个返回值，进行消耗。
 例如：
 
    @Test
    public void thenAcceptBoth() {
        CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            return "hello";
        }).thenAcceptBoth(CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            return "world";
        }), (s1, s2) -> System.out.println(s1 + " " + s2));
        while (true){}
hello world
在两个CompletionStage都运行完执行。
 
public CompletionStage<Void> runAfterBoth(CompletionStage<?> other,Runnable action);
public CompletionStage<Void> runAfterBothAsync(CompletionStage<?> other,Runnable action);
public CompletionStage<Void> runAfterBothAsync(CompletionStage<?> other,Runnable action,Executor executor);
不关心这两个CompletionStage的结果，只关心这两个CompletionStage执行完毕，之后在进行操作（Runnable）。
 例如：
 
    @Test
    public void runAfterBoth(){
        CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            return "s1";
        }).runAfterBothAsync(CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            return "s2";
        }), () -> System.out.println("hello world"));
        while (true){}
hello world
6.两个CompletionStage，谁计算的快，我就用那个CompletionStage的结果进行下一步的转化操作。
 
public <U> CompletionStage<U> applyToEither(CompletionStage<? extends T> other,Function<? super T, U> fn);
public <U> CompletionStage<U> applyToEitherAsync(CompletionStage<? extends T> other,Function<? super T, U> fn);
public <U> CompletionStage<U> applyToEitherAsync(CompletionStage<? extends T> other,Function<? super T, U> fn,Executor executor);
我们现实开发场景中，总会碰到有两种渠道完成同一个事情，所以就可以调用这个方法，找一个最快的结果进行处理。
 例如：
 
    @Test
    public void applyToEither() {
        String result = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            return "s1";
        }).applyToEither(CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            return "hello world";
        }), s -> s).join();
        System.out.println(result);
hello world
两个CompletionStage，谁计算的快，我就用那个CompletionStage的结果进行下一步的消耗操作。
 
public CompletionStage<Void> acceptEither(CompletionStage<? extends T> other,Consumer<? super T> action);
public CompletionStage<Void> acceptEitherAsync(CompletionStage<? extends T> other,Consumer<? super T> action);
public CompletionStage<Void> acceptEitherAsync(CompletionStage<? extends T> other,Consumer<? super T> action,Executor executor);
    @Test
    public void acceptEither() {
        CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            return "s1";
        }).acceptEither(CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            return "hello world";
        }), System.out::println);
        while (true){}
hello world
两个CompletionStage，任何一个完成了都会执行下一步的操作（Runnable）。
 
public CompletionStage<Void> runAfterEither(CompletionStage<?> other,Runnable action);
public CompletionStage<Void> runAfterEitherAsync(CompletionStage<?> other,Runnable action);
public CompletionStage<Void> runAfterEitherAsync(CompletionStage<?> other,Runnable action,Executor executor);
    @Test
    public void runAfterEither() {
        CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            return "s1";
        }).runAfterEither(CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            return "s2";
        }), () -> System.out.println("hello world"));
        while (true) {
hello world
当运行时出现了异常，可以通过exceptionally进行补偿。
 
public CompletionStage<T> exceptionally(Function<Throwable, ? extends T> fn);
    @Test
    public void exceptionally() {
        String result = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            if (1 == 1) {
                throw new RuntimeException("测试一下异常情况");
            return "s1";
        }).exceptionally(e -> {
            System.out.println(e.getMessage());
            return "hello world";
        }).join();
        System.out.println(result);
java.lang.RuntimeException: 测试一下异常情况
hello world
当运行完成时，对结果的记录。这里的完成时有两种情况，一种是正常执行，返回值。另外一种是遇到异常抛出造成程序的中断。这里为什么要说成记录，因为这几个方法都会返回CompletableFuture，当Action执行完毕后它的结果返回原始的CompletableFuture的计算结果或者返回异常。所以不会对结果产生任何的作用。
 
public CompletionStage<T> whenComplete(BiConsumer<? super T, ? super Throwable> action);
public CompletionStage<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action);
public CompletionStage<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action,Executor executor);
    @Test
    public void whenComplete() {
        String result = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            if (1 == 1) {
                throw new RuntimeException("测试一下异常情况");
            return "s1";
        }).whenComplete((s, t) -> {
            System.out.println(s);
            System.out.println(t.getMessage());
        }).exceptionally(e -> {
            System.out.println(e.getMessage());
            return "hello world";
        }).join();
        System.out.println(result);
java.lang.RuntimeException: 测试一下异常情况
java.lang.RuntimeException: 测试一下异常情况
hello world
这里也可以看出，如果使用了exceptionally，就会对最终的结果产生影响，它没有口子返回如果没有异常时的正确的值，这也就引出下面我们要介绍的handle。
 
运行完成时，对结果的处理。这里的完成时有两种情况，一种是正常执行，返回值。另外一种是遇到异常抛出造成程序的中断。
 
public <U> CompletionStage<U> handle(BiFunction<? super T, Throwable, ? extends U> fn);
public <U> CompletionStage<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn);
public <U> CompletionStage<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn,Executor executor);
例如：
 出现异常时
 
    @Test
    public void handle() {
        String result = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            //出现异常
            if (1 == 1) {
                throw new RuntimeException("测试一下异常情况");
            return "s1";
        }).handle((s, t) -> {
            if (t != null) {
                return "hello world";
            return s;
        }).join();
        System.out.println(result);
hello world
未出现异常时
 
    @Test
    public void handle() {
        String result = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            return "s1";
        }).handle((s, t) -> {
            if (t != null) {
                return "hello world";
            return s;
        }).join();
        System.out.println(result);
上面就是CompletionStage接口中方法的使用实例，CompletableFuture同样也同样实现了Future，所以也同样可以使用get进行阻塞获取值，总的来说，CompletableFuture使用起来还是比较爽的，看起来也比较优雅一点。
 


 作者：数齐
 链接：https://www.jianshu.com/p/6f3ee90ab7d3
 来源：简书
 简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。
                    一. FutureJDK 5引入了Future模式。Future接口是Java多线程Future模式的实现，在java.util.concurrent包中，可以来进行异步计算。Future模式是多线程设计常用的一种设计模式。Future模式可以理解成：我有一个任务，提交给了Future，Future替我完成这个任务。期间我自己可以去做任何想做的事情。一段时间之后，我就便可以从Future那...
				
Java8InAction
 该存储库包含《 Java 8 in Action：Lambda，Streams和函数式编程》一书中的示例和测验的所有源代码。
 您可以在这里购买该书：  : 或在亚马逊上
所有示例的源代码都可以在目录
第1章：Java 8：您为什么要关心？
 第2章：通过行为参数化传递代码
第3章：Lambda表达式
第4章：使用流
第5章：使用流处理数据
第6章：使用流收集数据
第7章：并行数据处理和性能
第8章：重构，测试，调试
第9章：默认方法
第10章：使用Optional作为null的更好替代方法
第11章：CompletableFuture：可组合的异步编程
第12章：新的日期和时间API
 第十三章：功能性思考
第14章：函数式编程技术
第15章：混合OOP和FP：比较Java 8和Scala
 第16章：Java的结论和“下一步”
 附录A：其他语言更新
CompletableFuture
API是用于Java异步编程的高级API。
该API支持将多个异步计算流水线化（也称为链接或合并）成单个结果，而不会造成嵌套回调（“
callback
hell”）的混乱。
此API也是Java中Future
Promise并发构造的实现。
从Java
5开始，有一个用于异步编程的简单得多的API：
Future接口及其基础实现FutureTask类。
Future接口表示异步计算的结果，并且只有几种方法：
检查任务是否完成或取消
等待任务完成（如有必要）然后获得结果
Future接口在构建非平凡的异步计算时有很大的局限性：
无法为将来的比赛注册回叫
不可能以非阻塞的方式传递期货
不可能手动完成未来
为了克服这些限制，Java
8添加（并更新了Java
9和Java
CompletionStage接口及其基本实现CompletableFuture类。
这些类允许构建有效且流畅的多级异步计算。
但是，CompletableFutur
第 10 章：使用 Optional 作为 null 的更好替代品
第 11 章 CompletableFuture：可组合异步编程
第 12 章：新的日期和时间 API
 第13章：功能性思考
第 14 章：函数式编程技术
第 15 章：混合 OOP 和 FP：比较 Java 8 和 Scala
 第 16 章：Java 的结论和“下一步”
 附录 A：其他语言更新
附录 B：其他库更新
附录 C：在 St
1.1 概述
在上一篇文章《CompletionService使用与源码分析》中，已经介绍过了Future的局限性，它没法直接对多个任务进行链式、组合等处理，需要借助并发工具类才能完成，实现逻辑比较复杂。
而CompletableFuture是对Future的扩展和增强。CompletableFuture实现了Future接口，并在此基础上进行了丰富的扩展，完美弥补了Future的局限性，同时CompletableFuture实现了对任务编排的能力。借助这项能力，可以轻松地组织不同任务的运行顺序、
				
JDK8 异步编程方式 Completable
文章目录JDK8 异步编程方式 Completable一、Future二、使用步骤1.引入库2.读入数据总结
一、Future
JDK 5引入了Future模式。Future接口是Java多线程Future模式的实现，在java.util.concurrent包中，可以来进行异步计算。
Future模式是多线程设计常用的一种设计模式。Future模式可以理解成：我有一个任务，提交给了Future，Future替我完成这个任务。期间我自己可以去做任何想做的事
				
CompletableFuture是jdk8的新特性。CompletableFuture实现了CompletionStage接口和Future接口，前者是对后者的一个扩展，增加了异步会点、流式处理、多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利。
1. supplyAsync
supplyAsync是带有返回值的异步任务。它有如下两个方法，有一个是带有线程池的重载方法
// 带返回值异步请求，默认线程池
public static <U> Completa
				
文章目录一、Future的缺陷二、CompletableFuture简介和相关API三、CompletableFuture的简单使用
一、Future的缺陷
1、Future只提供了get方法来获取结果，并且是阻塞的。所以在并发情况下只能等待所有线程执行完后才能获取结果，除此之外别无它法；
2、无法对多个任务进行链式调用。也就是说不能让第二个任务获取第一个任务执行完成后的结果后再去执行，它的执行是无法指定先后顺序的；
3、无异常处理机制。Future接口中没有异常处理的方法，所以当Futrue中的任务