柏油

FutureTask源码分析

什么是Future?

从字面上来看，Future表示将来的意思，也就是说现在执行某个任务可能是不能立即拿到返回值，在将来的某个时间点当task执行完毕也就可以拿到了；那么这个返回值在哪呢？就封装在future中(实现类)

Future 最主要的作用是，比如当做一定运算的时候，运算过程可能比较耗时，有时会去查数据库，或是繁重的计算，比如压缩、加密等，在这种情况下，如果我们一直在原地等待方法返回，显然是不明智的，整体程序的运行效率会大大降低。我们可以把运算的过程放到子线程去执行，再通过 Future 去控制子线程执行的计算过程，最后获取到计算结果。这样一来就可以把整个程序的运行效率提高，是一种异步的思想

Future与FutureTask有何联系？

FutureTask是Future的一个实现，结合Callable并将任务执行的返回值封装在FutureTask中

FutureTask

FutureTask可以用做闭锁。(FutureTask实现了Future语义，表示一种抽象的可生成结果的计算)。
FutureTask表示的计算通过Callable来实现，相当于一种可生成结果的Runnable，可以处于以下3中状态

等待运行
正在运行
运行完成：表示计算的所有可能结束方式，包括正常结束，由于取消而结束和由于异常而结束；当进入完成状态后，它会永远停止在这个状态上

Future.get的行为取决于任务的状态，如果任务已经完成，那么get会立即返回结果，否则get将阻塞直到任务进入完成状态，然后返回结果或者抛出异常；

FutureTask实现

在JDK1.7及之前，FutureTask是基于AQS实现，状态字段state用来表示正在运行、已完成、已取消
JDK1.8, FutureTask不在依赖于AQS实现，并发控制通过CAS自旋方式更新状态字段"state"，通过一个简单的单向链表维护一个线程等待队列(想要获取返回值的线程)

FutureTask维护的一些额外的状态变量，用来保存计算结果或者抛出的异常，此外还维护了一个引用，指向正在执行计算任务的线程(如果它当前处于运行状态),
因而如果任务被取消，该线程就会中断

闭锁

闭锁是一种同步工具类，可以延迟线程的进度直到其到达终止状态，闭锁的作用相当于一扇门

当闭锁到达结束状态之前，这扇门一直是关闭的，并且没有任务线程能通过
当闭锁到达结束状态时，这扇门会打开并允许所有线程通过
当闭锁到达结束状态后，将不会再改变状态，因此这扇门将永远保持打开状态

Future.get的闭锁语义：如果发生了某个事件(由FutureTask表示的任务执行完成或者被取消)，那么线程就可以恢复执行，
否则这些线程将停留在队列中并直到该事件发生

如何使用FutureTask？

来看一个例子：

    public class OneFuture {
    
        public static void main(String[] args) {
            ExecutorService service = Executors.newFixedThreadPool(10);
            Future<Integer> future = service.submit(new CallableTask());
            try {
                System.out.println(future.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
            service.shutdown();
        }
    
        static class CallableTask implements Callable<Integer> {
    
            @Override
            public Integer call() throws Exception {
                Thread.sleep(3000);
                return new Random().nextInt();
            }
        }
    }

通过submit提交callable或者runnable都可以得到future，不同的是runnable的future返回值是空的

JDK版本

JDK1.8

FutureTask原理分析

在ThreadPoolExecutor源码分析中，未分析父类AbstractExecutorService相关实现(比如我们常见的submit方法)
这里来看看父类中submit方法

    public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
    }
    
    public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
    }    
    
    protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
        return new FutureTask<T>(runnable, value);
    }

可以看到submit方法返回了Future类型的参数，Future是一个接口，这里使用的是实现类FutureTask，封装了如何从future中取值(简单的理解就是，当某个线程执行的task，
如果已经结束并且将结果封装在了future，那我这会直接从future取就可以了；如果task未执行完毕，此时future中肯定没有执行结果，但是这个时候又想要取到该结果，那就只有通过阻塞的方式来等待task的执行完毕)

通过newTaskFor返回的就是FutureTask实例，看看FutureTask的实现关系

可以看到FutureTask最终实现了Future和Runnable接口，同时内部组合了Callable接口作为属性字段，
我们知道execute的参数是Runnable类型，因此可以使用execute来执行futureTask任务，
我们只需要在run方法中调用callable.call接口来执行task并得到结果，然后将结果封装在future即可

细心的你可能已经注意到了，submit的参数有两种类型，分别是Runnable和Callable；Callable就不说了本身就会返回结果，
Runnable是不会返回结果，FutureTask是如何如果给属性字段callable赋值，又如何通过callable.call接口来执行task并得到结果呢？来看看FutureTask的一个构造方法

    public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }

    public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
    }

    static final class RunnableAdapter<T> implements Callable<T> {
        final Runnable task;
        final T result;
        RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
        }
        public T call() {
            task.run();
            return result;
        }
    }

可以看到最终是通过实现了Callable接口的适配器RunnableAdapter来封装Runnable的task和result，
这样当调用callable.call接口来执行task并得到结果时，实际便会执行task.run(), 并返回指定的result(上面的例子result传入的是null, 也就是没有返回值)

来看看FutureTask的基本参数

    public class FutureTask<V> implements RunnableFuture<V> {
    // 状态
    private volatile int state;
    // 初始状态
    private static final int NEW          = 0;
    // 已经拿到结果，处于封装赋值futureTask阶段
    private static final int COMPLETING   = 1;
    // 正常已完成阶段
    private static final int NORMAL       = 2;
    // 异常完成阶段
    private static final int EXCEPTIONAL  = 3;
    // 取消阶段
    private static final int CANCELLED    = 4;
    
    private static final int INTERRUPTING = 5;
    private static final int INTERRUPTED  = 6;

    private Callable<V> callable;
    // 处理的结果
    private Object outcome; // non-volatile, protected by state reads/writes
    // 运行callable的线程，在run方法中会被初始化
    private volatile Thread runner;
    // 在future.get上等待结果的线程列表
    private volatile WaitNode waiters;

来看看state的流转