FutureTask源码简单解析

首先说一下任务与线程。并发编程使我们将程序划分成多个分离的、独立运行的任务，而线程可以驱动任务。一般情况下任务通常就是实现了Runnable或Callable接口的类。

FutureTask在jdk11中的定义是一个可取消的异步计算。也就是说FutureTask对象是一个任务。不过FutureTask实现的是RunnableFuture接口，该接口继承自Runnable和Future。FutureTask类简单实现了这些接口中的方法，其中run()方法的操作是由你传给它的Runnable或Callable的对象决定的。

FutureTask的域

1、代表任务状态的state（int），每个任务有7个状态，用数字0~6表示。

    private volatile int state;
    private static final int NEW          = 0;//任务的最初状态。
    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;//已被中断

个人认为状态大概可以分成三个部分，第一部分是NEW，第二部分是COMPLETING，第三部分是从NORMAL到INTRRUPTED。状态之间所有可能的转换方式如图，至于何时进行转换看后面的代码详解。

 

2、域的第二部分是表示具体任务的callable ，表示任务运行结果的outcome，线程的引用runner以及结点waiters，这个waiters表示首节点（栈顶）。

    /** The underlying callable; nulled out after running */
    private Callable<V> callable;
    /** The result to return or exception to throw from get() */
    private Object outcome; // non-volatile, protected by state reads/writes
    /** The thread running the callable; CASed during run() */
    private volatile Thread runner;
    /** Treiber stack of waiting threads */
    private volatile WaitNode waiters;

这里的结点类，包含Thread域和指向下一个结点的引用，这里是用链表的方式实现栈。先简单说一下这个栈是干嘛的，假如任务在线程B中运行，而在线程A中调用了任务的某个方法，例如get()，这时可能该任务还没有运行结束而无法返回结果，那么A线程就有可能被放到这个栈中。也就是说这个栈是用来管理线程的，注意管理的是A线程而不是驱动任务的线程。由于这个栈使用了重试和CAS，被称为Treiber stack。Treiber stack原理很简单具体可以百度。后面会简单的提一下CAS。

static final class WaitNode {
        volatile Thread thread;
        volatile WaitNode next;
        WaitNode() { thread = Thread.currentThread(); }
    }

3、第三部分是三个句柄（Varhandle），他们可以指向某个FutureTask对象的state、runner和waiter。简单的理解就是通过这三个句柄，可以直接更改state、runner和waiter的值。使用句柄来更改主要是为了使用CAS。

// VarHandle mechanics
    private static final VarHandle STATE;
    private static final VarHandle RUNNER;
    private static final VarHandle WAITERS;
    static {
        try {
            MethodHandles.Lookup l = MethodHandles.lookup();
            STATE = l.findVarHandle(FutureTask.class, "state", int.class);
            RUNNER = l.findVarHandle(FutureTask.class, "runner", Thread.class);
            WAITERS = l.findVarHandle(FutureTask.class, "waiters", WaitNode.class);
        } catch (ReflectiveOperationException e) {
            throw new ExceptionInInitializerError(e);
        }

        // Reduce the risk of rare disastrous classloading in first call to
        // LockSupport.park: https://bugs.openjdk.java.net/browse/JDK-8074773
        Class<?> ensureLoaded = LockSupport.class;
    }

CAS是Compare And Swap的缩写，意思就是比较和替换。比较和替换原本是两个操作，也就是说可以被中断，但是CAS使得这两个操作变成一个原子操作，它的底层实现具体可以百度。实现了CAS的方法通常包括三个值：当前值、预期值和新值，作用是如果当前值等于预期值则把当前值设置为新值。

FutureTask的方法

按照任务执行的步骤来讲解方法。

1、首先要创建一个任务，所以先看构造方法，构造方法有两个，在构造方法中将任务的状态设置为了NEW。

（1）使用Callable对象初始化

 public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // 将任务状态设置为NEW
    }

（2）使用Runnable对象初始化，Excutors.callable()方法是使用适配器模式将Runnable对象转化为Callable对象。

 public FutureTask(Runnable runnable, V result) {//result任务完成后表示的结果
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }

2、开始运行任务，执行run()方法。

 public void run() {
        //如果任务状态不为NEW或者将runner设置为当前线程失败则返回。
        if (state != NEW ||
            !RUNNER.compareAndSet(this, null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;//用来判断任务是否抛出了异常
                try {
                    result = c.call();//执行call函数
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);//如果抛出异常则调用此方法将任务设置为EXCEPTION状态
                }
                if (ran)
                    set(result);//如果没有异常则调用此方法将任务设置为NORMAL状态
            }
        } finally {
            //只要run()方法结束都要将runner设置为空，不管是异常结束还是正常结束
            runner = null;
            int s = state;
            //这里检查是否在正在中断状态的原因是在上面运行过程中可能调用了cancle()方法
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

然后看看上面代码中提到的几个方法，实现很简单。

protected void set(V v) {
       if (STATE.compareAndSet(this, NEW, COMPLETING)) {//任务设置为COMPLETING状态
            //if语句后也可能被中断
            outcome = v;
            STATE.setRelease(this, NORMAL); // 最终设置为NORMAL状态
            finishCompletion();
        }
    }

protected void setException(Throwable t) {
        if (STATE.compareAndSet(this, NEW, COMPLETING)) {
            outcome = t;
            STATE.setRelease(this, EXCEPTIONAL); // final state
            finishCompletion();
        }
    }

private void handlePossibleCancellationInterrupt(int s) {
        if (s == INTERRUPTING)
            while (state == INTERRUPTING)
                Thread.yield(); //
    }

3、再看看cancle()方法，在Future接口中对cancle()方法的描述是，如果任务没有开始，那么就不再开始任务；如果任务已经开始那么根据传给cancle方法的参数决定是否中断任务；如果任务已经完成，那么cancle方法无作用。而从代码我们可以看出，只要任务到了COMPLETING状态，那么cancle方法就不起作用了。

//cancle方法根据mayInterrupteIfRunning来决定是否中断。
public boolean cancel(boolean mayInterruptIfRunning) {
        //只有任务状态为NEW并且修改任务状态为INTERRUPTING或CANCLE成功时才继续执行cancle
        if (!(state == NEW && STATE.compareAndSet
              (this, NEW, mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
            return false;
        try {    // in case call to interrupt throws exception
            if (mayInterruptIfRunning) {
                try {
                    Thread t = runner;
                    if (t != null)
                        t.interrupt();//将线程中断
                } finally { // final state
                    STATE.setRelease(this, INTERRUPTED);//设置为INTERRUPTED状态
                }
            }
        } finally {
            finishCompletion();
        }
        return true;
    }

4、如果我们想获取任务运行的结果，那么需要调用get()方法，但是调用get()方法是我们无法确定任务是否运行结束，那么如何处理各种情况呢？

首先看一下get()方法

    /*此方法没有设置超时，调用此方法的线程会等待到该方法返回结果*/
    public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)//小于等于COMPLETING表示没有运行结束
            s = awaitDone(false, 0L);
        return report(s);
    }

    
    /*此方法设置了超时等待，在规定时间能得到结果则返回结果，否则返回超时异常*/
    public V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException {
        if (unit == null)
            throw new NullPointerException();
        int s = state;
        if (s <= COMPLETING &&
            (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
            throw new TimeoutException();
        return report(s);
    }
    
     //此方法用来返回结果
     private V report(int s) throws ExecutionException {
        Object x = outcome;
        if (s == NORMAL)//正常结束
            return (V)x;
        if (s >= CANCELLED)//被取消
            throw new CancellationException();
        throw new ExecutionException((Throwable)x);//其他情况
    }

get()方法有设置了超时和未设置超时两种，他们都调用了awaitDone()方法，所以主要看awaitDone()是如何处理的。

/* 先假设调用get()方法的线程为线程T */
private int awaitDone(boolean timed, long nanos)
        throws InterruptedException {
        long startTime = 0L;    //用来表示超时的开始时间
        WaitNode q = null;
        boolean queued = false;
        for (;;) {
            int s = state;
            if (s > COMPLETING) { //如果任务已经运行结束
                if (q != null)
                    q.thread = null;
                return s;
            }
            else if (s == COMPLETING)//如果任务正在运行
                Thread.yield();
            else if (Thread.interrupted()) {//如果T线程已经被中断
                //将结点出栈，由于使用链表实现的栈，所以是可以将处于中间位置的结点出栈的
                removeWaiter(q);
                throw new InterruptedException();
            }
            else if (q == null) {
                if (timed && nanos <= 0L)//如果设置了超时但是超时时间小于等于0
                    return s;
                q = new WaitNode();//新建一个结点，该节点中的线程是T线程
            }
            else if (!queued)//如果没有入栈
                //把新建的结点压入栈中（链表的头插法），并将waiters指向栈顶
                queued = WAITERS.weakCompareAndSet(this, q.next = waiters, q);
            else if (timed) {//如果设置了超时，并且超时时间大于0
                final long parkNanos;
                if (startTime == 0L) {
                    startTime = System.nanoTime();
                    if (startTime == 0L)
                        startTime = 1L;//这里设置成1的原因是与startTime的初值进行区分
                    parkNanos = nanos;
                } else {
                    long elapsed = System.nanoTime() - startTime;//从开始到现在的时间间隔
                    if (elapsed >= nanos) {//如果时间间隔到了设置的时间
                        removeWaiter(q);
                        return state;
                    }
                    parkNanos = nanos - elapsed;//parkNanos表示还要多久才到超时时间
                }
                if (state < COMPLETING)//将T线程阻塞前进行一次确认，确认任务没完成
                    LockSupport.parkNanos(this, parkNanos);//将线程T阻塞parkNanos纳秒
            }
            else//表示没有设置超时，并且已经将结点压入栈中
                LockSupport.park(this);//将线程T阻塞
        }
    }

awaitDone的算法如下，以下几点循环往复：

（1）如果任务已经结束则返回

（2）如果任务正在进行（COMPLETING）那么仅调用yield()方法

（3）如果线程T被中断，那么抛出异常

（4）如果任务还没开始

    ①如果开启了超时等待但是等待时间小于等于0，那么直接返回就好，如果没开启那么新建结点

    ②如果还没将结点压入栈中则将结点压入栈，之后线程T就要被阻塞了

    ③如果开启了超时等待，那么将线程T阻塞一段时间

    ④如果没有开启超时等待，那么将线程阻塞

在上面的有些方法中有的调用了finishCompletion()方法，通过观察我们可以发现它是在set、setException、get、cancle方法的最后调用的，这些方法的共同点是一旦到了这些方法的最后，那么任务也就运行完成了。所以之前由于获取任务结果而被阻塞的线程都可以被唤醒了。finishCompletion()就是用来唤醒那些被阻塞的线程。

//将结点一个一个的删除
private void finishCompletion() {
        // assert state > COMPLETING;
        for (WaitNode q; (q = waiters) != null;) {
            if (WAITERS.weakCompareAndSet(this, q, null)) {//把waiters设为null
                for (;;) {
                    Thread t = q.thread;
                    if (t != null) {
                        q.thread = null;
                        LockSupport.unpark(t);//唤醒结点中的线程
                    }
                    //下面就是将q指向下一个结点的算法
                    WaitNode next = q.next;
                    if (next == null)//删除完毕
                        break;
                    q.next = null; // 帮组垃圾回收
                    q = next;
                }
                break;
            }
        }
        done();
        callable = null;        // to reduce footprint
    }

主要的内容就是这些了，轻喷。