异步
Future 和 Promise   

Future 表示某种已经发生或未发生的行为的结果
Promise 表示某种已经发生或未发生的行为的写入端

A future represents the result of an action that may, or may not, have occurred yet.
A promise represents the writable side of an action that may, or may not, have occurred yet.

Promise  消息的生产者
Future   消息的消费者
很多时候会隐去 Promise，只使用 Future 来完成异步操作

Promise< String> promise = Promise.promise();
Future< String> future = promise.future();
promise.complete("Hello"); // 生产消息
future.onSuccess(msg -> System.out.println(msg)); // 消费消息
future.onSuccess(msg -> System.out.println(msg)); // 消费消息 第二次



Promise 和 Future 是两个接口，它们有共同的实现类，在运行时 Fromise 和与之关联的 Future 是同一个对象。
一个 Promise 对象整个生命周期只能够生产一条消息，与之关联的 Future 只能够消费一条消息，但可以多次消费这条消息。

往一个已经写入过内容的 promise 的对象中继续写入，会抛出 IllegalStateException。
除非使用以 "try" 开头的 方法 来写入消息，这类 方法 通过返回 boolean 值来判断写入是否成功，不抛出 IllegaStateException。


void complete(T result)	写入异步任务的结果
void complete()	同 complete(null)
void fail(Throwable cause)	写入一个异常
void fail(String message)	同 fail(new NoStackTraceThrowable(message))
boolean tryComplete(T result)	尝试写入一个异步任务的结果
boolean tryComplete()	同 tryComplete(null)
boolean tryFail(Throwable cause)	尝试写入一个异常
boolean tryFail(String message)	同 tryFail(new NoStackTraceThrowable(message))


Future 有两个状态，已完成（已完成 completed）或未完成两种状态。
按照 Promise 写入的结果类型，已完成状态分为 成功完成 和 失败完成 

isComplete()	true 表示 Future 已完成，false 表示未完成。
succeed()	true 表示 Future 已成功完成。此时可以读取正常结果。
failed()	true 表示 Future 已经失败。此时可以读取异常结果。

result()	读取正常结果。若异步操作未完成或异步操作失败，则返回 null；否则，返回异步操作的正常结果。
cause()	    读取异常结果。若异步操作未完成或异步操作成功，则返回 null；否则，返回异步操作的异常结果。

SucceedFuture 和 FailedFuture 在创建出来的时候状态就已经确定。
Future 提供了静态工厂方法来获取它们的实例，
这一类 Future 对象没有与之关联的 Promise，因为消息已经存在，不需要 Promise 来生产消息。


Future< Void> future = Future.succeedFuture();
Future< String> future1 = Future.succeedFuture("hello");
Future< Void> future2 = Future.failedFuture(e);



 Promise< String> promise = Promise.promise();

        new Thread(() -> {
            try {
                // String responseBody = httpClient.request("http://www.codefun007.xyz/hello");
                System.out.println("start," + LocalDateTime.now());
                // mock
                Thread.sleep(1000);
                System.out.println("promise.complete run ,"+ LocalDateTime.now());
                String responseBody = "responseBody mock";
                promise.complete(responseBody); // 写入正常消息

            } catch(Exception e) {
                promise.fail(e); // 写入异常
            }
        }).start();

        Future< String> future = promise.future();
        future.onSuccess(body -> System.out.println("获取到 Response Body:" + body)) // 成功时执行
                .onFailure(cause -> cause.printStackTrace()) // 失败时执行
                .onComplete(asyncResult -> { // 无论成功失败都执行
                    if (asyncResult.succeeded()) {
                        System.out.println("成功获取到 Reponse Body,"+asyncResult.result());
                    } else {
                        System.out.println("获取 Response Body 失败,"+asyncResult.cause());
                    }
                });



Future代表一个只读的结果的容器 , Promise是一次性可写的,并且实现了Future的接口。
Java 1.8 版本引入了 CompletableFuture ，
CompletableFuture 实现的 CompletionStage 接口定义了一系列的流畅的编程接口以支持灵活扩展异步计算。
CompletableFuture 支持写入结果，实现了 Promise 的写入语义。
CompletableFuture = Future + Promise

 CompletableFuture 实例