CompletableFuture

Future

Future接口(FutureTask实现类)定义了操作异步任务执行一些方法，如获取异步任务的执行结果、取消任务的执行、判断任务是否被取消、判断任务执行是否完毕等。（异步：可以被叫停，可以被取消）
Future接口可以为主线程开一个分支任务，专门为主线程处理耗时和费力的复杂业务。
Future接口中方法

作用

Future 是 Java5 新加的一个接口，它提供了一种异步并行计算的功能。比如主线程需要执行一个很耗时的计算任务，可以通过future把这个任务放到异步线程中执行，主线程就去做其他事情了，过了一会才去获取子任务的执行结果。举个例子：我在打游戏但是我现在饿了我肯定不能自己去否则就会坑队友会被骂，所以我让朋友帮我带份饭，我可以继续游戏，这就实现了异步任务。

目的

异步多线程任务执行且有返回结果，三个特点：多线程/有返回/异步任务（朋友作为我去买饭作为新启动的异步多线程任务且买到饭有结果返回）

FutureTask实现类

上面所说的三个特点在 FutureTasks 类上可以满足

实现了多线程且有异步任务
构造器注入 callable 实现了有返回

多线程/有返回/异步操作

public class FutureTaskTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 异步任务
        FutureTask<String> futureTask = new FutureTask<>(new MyThread());

        Thread thread = new Thread(futureTask, "thread");
        thread.start();

        // 接收返回值 hello callable
        System.out.println(futureTask.get());
    }
}

class MyThread implements Callable<String> {

    @Override
    public String call() {
        System.out.println("com in call()");
        return "hello callable";
    }
}

多线程/有返回/异步结果

Future 到 CompletableFuture

completableFuture 是由 future 演变而来的，所以我们再来看看 Future 的优缺点

Future 优点

future+线程池异步多线程任务配合，能显著提高程序的执行效率。
方案一：3个任务 1 个main线程处理，大概1130ms

public static void main(String[] args) {

    long startTime = System.currentTimeMillis();

    // 暂停毫秒
    try {TimeUnit.MILLISECONDS.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}
    try {TimeUnit.MILLISECONDS.sleep(300);} catch (InterruptedException e) {e.printStackTrace();}
    try {TimeUnit.MILLISECONDS.sleep(300);} catch (InterruptedException e) {e.printStackTrace();}

    long endTime = System.currentTimeMillis();
    System.out.println("消耗时长：" + (endTime - startTime) + " 毫秒");
}

方案二：3个任务，两个 futureTask 执行，一个 main 线程执行，利用线程池（假如每次new一个Thread，太浪费资源，会有GC这些工作），大概400毫秒。

public static void main(String[] args) {

    // 构建指定数量线程池
    ExecutorService threadPool = newFixedThreadPool(3);

    long startTime = System.currentTimeMillis();

    FutureTask<String> futureTask1 = new FutureTask<>(() -> {
        try {TimeUnit.MILLISECONDS.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}
        return "task1 over";
    });
    threadPool.submit(futureTask1);

    FutureTask<String> futureTask2 = new FutureTask<>(() -> {
        try {TimeUnit.MILLISECONDS.sleep(300);} catch (InterruptedException e) {e.printStackTrace();}
        return "task2 over";
    });
    threadPool.submit(futureTask2);

    try {TimeUnit.MILLISECONDS.sleep(300);} catch (InterruptedException e) {e.printStackTrace();}

    long endTime = System.currentTimeMillis();
    System.out.println("消耗时长：" + (endTime - startTime) + " 毫秒");

    threadPool.shutdown();
}

Future 缺点

get() 阻塞

下面模仿阻塞情况，例如在任务中阻塞了五秒，运行会发现最后一段出输出会等待 get() 阻塞完成后才会执行。说白了就是一旦你调用 get() 方法出现了无法计算阻塞时间太长就会导致整个程序无法运行

public static void main(String[] args) throws ExecutionException, InterruptedException {

    FutureTask<String> futureTask = new FutureTask<>(() -> {
        System.out.println(Thread.currentThread().getName() + "\t come in");
        try {TimeUnit.SECONDS.sleep(5);} catch (InterruptedException e) {e.printStackTrace();}
        return "task over";
    });

    Thread thread = new Thread(futureTask, "thread");
    thread.start();

    System.out.println(futureTask.get());

    System.out.println(Thread.currentThread().getName() + "\t 忙其他任务了");
}

针对上方的问题有一种解决方案就是将 get 设置超时时间如果超过指定秒就抛出异常，然后系统再补货异常及时止损。

System.out.println(futureTask.get(3, TimeUnit.SECONDS))

isDone() 轮询

上方使用 get 超时时间直接抛异常不太美观。可以利用if(futureTask.isDone())的方式使得他在结束之后才get()，但是也会消耗cpu

public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {

    FutureTask<String> futureTask = new FutureTask<>(() -> {
        System.out.println(Thread.currentThread().getName() + "\t come in");
        try {TimeUnit.SECONDS.sleep(5);} catch (InterruptedException e) {e.printStackTrace();}
        return "task over";
    });

    Thread thread = new Thread(futureTask, "thread");
    thread.start();

    while (true) {
        if (futureTask.isDone()) {
            System.out.println(futureTask.get());
            break;
        } else {
            // 暂停500毫秒, 要不然会一直刷屏
            TimeUnit.MILLISECONDS.sleep(500);
            System.out.println("正在处理中......");
        }
    }

    System.out.println(Thread.currentThread().getName() + "\t 忙其他任务了");
}

总结

Future对于结果的获取不是很友好，只能通过阻塞或轮询的方式得到任务的结果。

Future 应用现状

对于简单的业务场景使用Future完全OK
回调通知
- 应对Future的完成时间，完成了可以告诉我，也就是我们的回调通知
创建异步任务
- Future+线程池配合
多个任务前后依赖可以组合处理（水煮鱼）
- 想将多个异步任务的计算结果组合起来，后一个异步任务的计算结果需要前一个异步任务的值，将两个或多个异步计算合成一个异步计算，这几个异步计算相互独立，同时后面这个又依赖前一个处理的结果
- 比如买鱼-调料-下锅
- 比如 linux 命令 ps -ef | grep tomcat
对计算速度选最快完成的（并返回结果）
- 当Future集合中某个任务最快结束时，返回结果，返回第一名处理结果。