通过阅读本篇文章你将了解到：CompletableFuture的使用

//方法一
public static CompletableFuture runAsync(Runnable runnable) {
return asyncRunStage(asyncPool, runnable);
}
//方法二
public static CompletableFuture runAsync(Runnable runnable, Executor executor) {
return asyncRunStage(screenExecutor(executor), runnable);
}
结果的获取： 对于结果的获取CompltableFuture类提供了四种方式

//方式一
public T get()
//方式二
public T get(long timeout, TimeUnit unit)
//方式三
public T getNow(T valueIfAbsent)
//方式四
public T join()
说明：

示例：

get()和get(long timeout, TimeUnit unit) => 在Future中就已经提供了，后者提供超时处理，如果在指定时间内未获取结果将抛出超时异常
getNow => 立即获取结果不阻塞，结果计算已完成将返回结果或计算过程中的异常，如果未计算完成将返回设定的valueIfAbsent值
join => 方法里不会抛出异常
public class AcquireResultTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//getNow方法测试
CompletableFuture cp1 = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(60 * 1000 * 60 );
} catch (InterruptedException e) {
e.printStackTrace();
}

      return "hello world";
  });

  System.out.println(cp1.getNow("hello h2t"));

  //join方法测试
  CompletableFuture<Integer> cp2 = CompletableFuture.supplyAsync((()-> 1 / 0));
  System.out.println(cp2.join());

  //get方法测试
  CompletableFuture<Integer> cp3 = CompletableFuture.supplyAsync((()-> 1 / 0));
  System.out.println(cp3.get());

}
}
说明：

第一个执行结果为hello h2t，因为要先睡上1分钟结果不能立即获取
join方法获取结果方法里不会抛异常，但是执行结果会抛异常，抛出的异常为CompletionException
get方法获取结果方法里将抛出异常，执行结果抛出的异常为ExecutionException
异常处理： 使用静态方法创建的CompletableFuture对象无需显示处理异常，使用new创建的对象需要调用completeExceptionally方法设置捕获到的异常，举例说明：
CompletableFuture completableFuture = new CompletableFuture();
new Thread(() -> {
try {
//doSomething，调用complete方法将其他方法的执行结果记录在completableFuture对象中
completableFuture.complete(null);
} catch (Exception e) {
//异常处理
completableFuture.completeExceptionally(e);
}
}).start();
同步方法Pick异步方法查询所有店铺某个商品价格
店铺为一个列表：

private static List shopList = Arrays.asList(
new Shop("BestPrice"),
new Shop("LetsSaveBig"),
new Shop("MyFavoriteShop"),
new Shop("BuyItAll")
);
同步方法：

private static List findPriceSync(String product) {
return shopList.stream()
.map(shop -> String.format("%s price is %.2f",
shop.getName(), shop.getPrice(product))) //格式转换
.collect(Collectors.toList());
}
异步方法：

private static List findPriceAsync(String product) {
List<CompletableFuture> completableFutureList = shopList.stream()
//转异步执行
.map(shop -> CompletableFuture.supplyAsync(
() -> String.format("%s price is %.2f",
shop.getName(), shop.getPrice(product)))) //格式转换
.collect(Collectors.toList());

return completableFutureList.stream()
        .map(CompletableFuture::join)  //获取结果不会抛出异常
        .collect(Collectors.toList());

}
性能测试结果：

Find Price Sync Done in 4141
Find Price Async Done in 1033
异步执行效率提高四倍

为什么仍需要CompletableFuture
在JDK1.8以前，通过调用线程池的submit方法可以让任务以异步的方式运行，该方法会返回一个Future对象，通过调用get方法获取异步执行的结果：

private static List findPriceFutureAsync(String product) {
ExecutorService es = Executors.newCachedThreadPool();
List<Future> futureList = shopList.stream().map(shop -> es.submit(() -> String.format("%s price is %.2f",
shop.getName(), shop.getPrice(product)))).collect(Collectors.toList());

return futureList.stream()
        .map(f -> {
            String result = null;
            try {
                result = f.get();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }

            return result;
        }).collect(Collectors.toList());

}
既生瑜何生亮，为什么仍需要引入CompletableFuture？对于简单的业务场景使用Future完全没有，但是想将多个异步任务的计算结果组合起来，后一个异步任务的计算结果需要前一个异步任务的值等等，使用Future提供的那点API就囊中羞涩，处理起来不够优雅，这时候还是让CompletableFuture以声明式的方式优雅的处理这些需求。而且在Future编程中想要拿到Future的值然后拿这个值去做后续的计算任务，只能通过轮询的方式去判断任务是否完成这样非常占CPU并且代码也不优雅，用伪代码表示如下：

while(future.isDone()) {
result = future.get();
doSomrthingWithResult(result);
}
但CompletableFuture提供了API帮助我们实现这样的需求

其他API介绍
whenComplete计算结果的处理：
对前面计算结果进行处理，无法返回新值 提供了三个方法：

//方法一
public CompletableFuture whenComplete(BiConsumer<? super T,? super Throwable> action)
//方法二
public CompletableFuture whenCompleteAsync(BiConsumer<? super T,? super Throwable> action)
//方法三
public CompletableFuture whenCompleteAsync(BiConsumer<? super T,? super Throwable> action, Executor executor)
说明：

BiFunction<? super T,? super U,? extends V> fn参数 => 定义对结果的处理
Executor executor参数 => 自定义线程池
以async结尾的方法将会在一个新的线程中执行组合操作
示例：

public class WhenCompleteTest {
public static void main(String[] args) {
CompletableFuture cf1 = CompletableFuture.supplyAsync(() -> "hello");
CompletableFuture cf2 = cf1.whenComplete((v, e) ->
System.out.println(String.format("value:%s, exception:%s", v, e)));
System.out.println(cf2.join());
}
}
thenApply转换：
将前面计算结果的的CompletableFuture传递给thenApply，返回thenApply处理后的结果。可以认为通过thenApply方法实现CompletableFuture至CompletableFuture的转换。白话一点就是将CompletableFuture的计算结果作为thenApply方法的参数，返回thenApply方法处理后的结果 提供了三个方法：

public static Integer randomInteger() {
    return 10;
}

public static List<String> getList() {
    return Arrays.asList("a", "b", "c");
}

private static int getInteger() {
    return 666;
}

private static int expandValue(int num) {
    return num * 10;
}

    System.out.println(result.get());
}

public static Integer randomInteger() {
    return random.nextInt(100);
}