Java Future

Outline

1. 什么是Java Future
2. 为什么要使用Java Future （好处？）
3. 如何使用Java Future

一、什么是Java Future

1. 古老的Runnable

长久以来，程序员熟知的Java多线程是以Thread和Runnable为代表的，不必关心执行结果的异步操作。这也是JDK从一开始（JDK1.0）就支持的异步模式，这种异步操作的使用时序一般如下：

runnable时序

这种模式中，我们不关心耗时操作的结果是什么，甚至不关心耗时操作要执行多久；可能在返回客户端后耗时操作都没有执行完毕。那么客户端请求执行的时间，近乎完全是工作线程”其他操作“的耗时。

伪代码如下：

Object foo() {
    // logic operation
    new Thread().start(() - {
        try {
            // time-consuming operation.
        } catch (PossibleException e) {
            // deal exception in the thread;
        }
    });
    // other logic operation
    return value;
}

这种不关心结果的异步操作设计，约定了run 方法不能抛出检查异常，而且线程必须自己处理执行过程中的异常。其实这也是个合情合理的约定，假设现在现在允许抛出异常到线程外部，试问在这种不关心结果的"shoot but don't care"的处理方式下，哪个时机处理线程抛出的异常合适呢？答案是只能线程自己内部处理。

2. 现在要关心结果了

如果要关心异步操作的结果，该怎么办呢？ 瞬间涌上脑门的想法是，工作线程和耗时任务线程共享变量，工作线程通过轮询不断检查共享变量的方式来判断任务是否完成。结果就是以下的复杂时序：

关心结果时序

注意工作线程检查结果与耗时任务线程设置结果并无先后关系

可能的伪代码如下：

Object sharedVar;
Object bar() {
    // logic operation
    new Thread(() -> {
        try {
            // time-consuming operation.
            sharedVar = value;
        } catch (PossibleException e) {
            // deal exception in the thread;
        }  
    }).start(); 
    // other logic operation
    while(!sharedVar ready);
    return sharedVar;
}

当然伪代码并没有考虑同步操作。

这样客户端请求的耗时就是工作线程的执行时长和耗时线程任务时长中较长的那个。现在想要更多的功能，比如：

1. 因为一些情况，工作线程在耗时任务线程没有执行完的情况下不关心结果了，想要取消；
2. 工作线程不想一直轮询来查询结果是否准备好，想要一个超时方法来指定轮询的时间。

当然这些合理的需求都是可以实现的，因此，从JDK 5开始Java为程序员准备了 Future 特性。

3. Java Future

正如以上，java future主要为异步操作提供了获取结果的途径。然后我们上面想要的，它都有。有了JDK的future特性，以上时序可以简化为：

future时序

JKD提供java.util.concurrent.Future 来支持future特性， JDK对其的介绍是：

Future 表示异步计算的结果。 并提供检查异步计算是否完成的方法，等待完成的方法，以及检索计算结果的方法。结果只能使用get 在计算完成之后获取，如果计算没有完成，get的调用将会阻塞。调用cancle 方法可以取消异步计算。也提供额外的方法来检查任务是否正常完成，或是被取消了。一旦计算完成，就不可取消了。如果想要使用Future 异步任务可取消的特性，而不关心返回值，可以声明为Futre 类型，并在异步方法中返回null 。

二、为什么要使用Java Future

在我最开始几年的业务编程历史中，从未使用过JDK Future，所有的异步操作场景都是使用不关心结果的Thread+Runnable，因为似乎完全没有使用Future特性的需求。

我的想法是这样的： 即使用了Future，那我也是想要获取结果才会用的，之后还得调用阻塞方法get 来获取结果，可能的编码是这样的：

void bar() {
    ExecutorService service = Executors.newFixedThreadPool(1);
    Future future = service.submit(() -> {
            // time-consuming operation
            return value;
    });
    // blocking invoke
    Object result = future.get();
    // use result to do something...
}

那么这样做跟直接同步调用耗时操作有什么区别：

var bar() {
    // time-consuming operation, get value;
   Object value = doTimeConsuming();
   // use result to do something...
}

诚然，本质上看来，如果是这种使用方式的话，这两种方法的耗时并没有差别，使用Future可能会更慢，还更复杂。
这个业务场景，其实是依赖耗时操作的结果，来做一些事情，这种场景下使用future意义不大，用单个线程完全可以胜任。

来杯咖啡提提神

但是啊，成年人的世界都是多线程的。

现实生活中，这样的场景随处可见。比如去咖啡馆泡吧看书，首先点一杯咖啡，咖啡制作过程中，我们也不可能在吧台闲着等咖啡做好；而是找到一个有插座的位置，摆好电脑，插上电源，启动电脑，打开idea，开始撸代码。做一个极端的假设，服务员不通知我们咖啡做好了，而是我们实在困得不行需要咖啡刺激一下的时候，自然会去吧台看看咖啡做好了没；没有做好就一直等（没办法，需要咖啡的刺激才能有精神继续撸代码啊），或者不是很困的话，等一会儿发现还没做好，那就再回去撸两行代码，再来吧台看看。

抽象一下这个业务场景，首先明确存在两个耗时操作：

1. 制作咖啡
2. 看书学习敲代码

操作2，在某一时刻（困得不行的时候）需要操作1的结果才能进行下去，但不是在一开始就需要依赖操作1的结果。在某一段时间两个操作需要并行，可能的时序如下：

喝咖啡

那么总结一下future的使用场景：

1. 多个在某个时间段可并行的耗时操作，并且存在任务结果依赖
2. Future类的jdk说明中提到的，如果想使用future异步任务可取消的特性，也可以使用。

三、如何使用Java Future

虽然JDK提供了多种途径使用Java Future，但是它们本质相同，使用相当简单，主要提供两种方式：

1. Callable + ExecutorService方式
2. FutureTask + (ExecutorService/Thread)方式

1. Callable + ExecutorService

这种方法通过不同的方式创建Callable 实例， 然后依赖ExecutorService 的 submit 方法获得Future 返回，最后调用返回的Future 实例get 方法获取结果。

Callable 接口：

public interface Callable {
    /**
    *  计算结果，计算失败时抛出异常
    */
    V call() throws Exception;
}

JDK对于Callable的描述：

Callable是一个会返回结果或者抛出异常的任务。实现类定义一个无参的，名为call 的方法。与Runnable 接口类似，都是为可能在其他线程中执行的类实例设计的。但是Runnableb不返回结果，也不抛出异常。 Executors 类提供将其他一般形式转换为Callable类的工具方法。

其实jdk对Callable的描述清楚阐述了创建Callable实例的方法：

1. 实现Callable接口

   class CallableTask implements Callable