源码分析-FutureTask

基本原理

首先FutureTask早期使用AQS来实现。目前的版本(java 7)是将所有状态用一个volatile的int来保存。并且使用unsafe的cas来进行修改。当然如果使用一个Atomic类也可以。但是使用unsafe效率更高。

状态介绍

    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。
只有在调用了set、setException、cancal方法之后才会变成terminal。
在完成的过程中，状态会变成COMPLETING（正在设置结果）或者INTERRUPTING（中断任务以尝试满足取消指令cancel(true)）。
从这些中间状态到达最终状态的过程使用有序/懒惰写因为这些值是唯一的而且不会被修改。

可能存在的状态转换

NEW -> COMPLETING -> NORMAL
NEW -> COMPLETING -> EXCEPTIONAL
NEW -> CANCELLED
NEW -> INTERRUPTING -> INTERRUPTED

内部域

    private volatile int state;
    private Callable<V> callable;//底层的callable，会在运行后清理
    private Object outcome; // 计算的结果或者需要抛出的异常，不使用volatile，而是使用状态读写
    private volatile Thread runner;//运行callable的线程。在run()方法中使用cas设置
    private volatile WaitNode waiters;//等待节点的集合

意义都比较的明确。

WaitNode内部静态类

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

WaitNode比较简单就是一个单向链表。这里还想说一下。关于内部类的问题。之前我一直纠结何种情况下应该用内部类何种情况下应该用内部静态类。不过前段时间看到effectivejava中间有一段说的比较好。简单的说。应该优先使用内部静态类，因为这样更安全，而且也不会绑定外部类的实例。也就是说只要内部类没有必要访问外部类实例的内容就应该使用静态的类。具体的可以书上的内容。

主要方法

构造器

首先构造器没什么好说的，就是设置以下callable和state。这里有一个包装的方法，可以将runnable和result包装成callable。

this.callable = Executors.callable(runnable, result);

get()方法

    public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)//当前状态为COMPLETING以下的状态就运行awaitDone等待计算完成或者
            s = awaitDone(false, 0L);
        return report(s);
    }

其次这两个方法awaitDone和report还是要看一下：

awaitDone

    private int awaitDone(boolean timed, long nanos)
        throws InterruptedException {
        final long deadline = timed ? System.nanoTime() + nanos : 0L;//根据参数计算可能存在的延时，预留WaitNode引用和入列标志位。
        WaitNode q = null;
        boolean queued = false;
        for (;;) {
            if (Thread.interrupted()) {//如果执行任务的线程中断了则需要移除Waiter并且抛出中断异常。
                removeWaiter(q);
                throw new InterruptedException();
            }

            int s = state;
            if (s > COMPLETING) {//状态大于COMPLETING则说明任务完成或中断则返回状态，还需要注意将WaitNode的可能存在的thread置为null以防止可能存在的意外操作。
                if (q != null)
                    q.thread = null;
                return s;
            }
            else if (s == COMPLETING) // cannot time out yet//正在运行期间则等待。Thread.yield()为了避免过度的自旋。
                Thread.yield();
            else if (q == null)//设置新的WaitNode()而不是在整个方法开始之前是为了防止计算提前结束。这样就不用构造可以直接返回了。运行到这里说明之前已经让渡了，但是依然未完成所以需要准备入列。
                q = new WaitNode();
            else if (!queued)//使用cas去设置waitersOffset
                queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                     q.next = waiters, q);
            else if (timed) {//根据条件进行带时间限的阻塞。
                nanos = deadline - System.nanoTime();
                if (nanos <= 0L) {
                    removeWaiter(q);
                    return state;
                }
                LockSupport.parkNanos(this, nanos);
            }
            else
                LockSupport.park(this);
        }
    }

removeWaitNode
这上面有一个removeWaitNode方法
这里也用到了java版本的goto语句。语义标签。配合循环使用。
这里需要注意这个removeWaitNode是用来删除超时或者被中断你的节点的。这里使用了便利的操作，如果节点非常多的话这里会

    private void removeWaiter(WaitNode node) {
        if (node != null) {
            node.thread = null;
            retry:
            for (;;) {//第一个for循环其实没什么意义，这里只是为了使用retry：标签而使用的。为的是当出现重试的情况的时候goto到这里重试。
                for (WaitNode pred = null, q = waiters, s; q != null; q = s) {//第二个循环才是正体。
                    s = q.next;
                    if (q.thread != null)
                        pred = q;
                    else if (pred != null) {
                        pred.next = s;
                        if (pred.thread == null) // check for race
                            continue retry;
                    }
                    else if (!UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                          q, s))
                        continue retry;
                }
                break;
            }
        }
    }

第二个循环体到底干了什么。这里看简单分析下。
pred记录的实际上是上一个thread不为null的有效节点，q是指向当前节点的指针，循环会从头到尾的遍历节点直到节点末尾。s是q的后继可能是节点可能是null。

从当前节点来看只有两种情况一种是当前节点q的thread为null，也就是说当前节点无效，这时候如果存在pred节点就使得pred的next为s也就是跳过当前节点。进入下一个循环（这里实际上还进行了竞争的判断就是确保pred的thread不为null。如果不满足条件则需要重头节点重新开始，这当然是非常耗时的。所以这里实际上是假设节点不会太多而且竞争不会太激烈，这个在源码中有介绍。）当然如果pred为null就说明在当前节点之前都没有有效的节点，则需要设置waitersOffset为当前的s。如果失败则重头开始。

当前节点q的thread如果不为null则尝试设置pred为当前节点，进入下一个循环。

removeWaiter的工作实际上就是将所有thread为null的节点全部扔掉。

report
此外还有一个report方法。这个就很简单了就是根据当前状态返回结果或者抛出异常。

    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);
    }

其实这里有一个我觉得略微有些可以讨论的问题。就是为什么把抛出的异常放到outcome中。我觉得完全可以新定义一个域比较合适。。

run()

    public void run() {
        if (state != NEW ||//这判断是为了防止并发错误。状态不为new说明已经启动了。当前线程设置失败说明已经有有线程开始执行这个任务了。
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;//ran作为运行完成的标志，根据这个决定是调用set还是setException。
                try {
                    result = c.call();//在当前线程中调用c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;//runner必须设置用来保证不会并发的调用run。
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)//在设置runner为null之后重读state防止遗漏中断。
                handlePossibleCancellationInterrupt(s);
        }
    }

run方法比较简单。这里还是看一下set、setException和handlePossibleCancellationInterrupt几个方法：

set

    protected void set(V v) {
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = v;
            UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
            finishCompletion();
        }
    }

CAS设置state成功后设置输出，然后在CAS设置为正常终止状态NORMAL。

finishCompletion
这个方法主要用来唤醒所有的等待线程。
这个方法比removeWaitNode要简单的多就是把所有有效的节点全部解锁。

    private void finishCompletion() {
        // assert state > COMPLETING;
        for (WaitNode q; (q = waiters) != null;) {
            if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
                for (;;) {
                    Thread t = q.thread;
                    if (t != null) {
                        q.thread = null;
                        LockSupport.unpark(t);
                    }
                    WaitNode next = q.next;
                    if (next == null)
                        break;
                    q.next = null; // unlink to help gc
                    q = next;
                }
                break;
            }
        }

        done();//一个hook方法。

        callable = null;        // to reduce footprint
    }

handlePossibleCancellationInterrupt

这个方法比较有意思。只有在调用了cancel(true)的时候才会调用这个方法。这个方法是为了配合cancel使用的。

    private void handlePossibleCancellationInterrupt(int s) {
        if (s == INTERRUPTING)//如果状态为INTERRUPTING说明调用了cancel并且成功取消。这时候会有一个另一个线程尝试终止当前的线程。但是我们知道在java中中断不是立刻有效的，所以调用Thread.yield()来尝试让当前线程让步。直到取消当前线程的任务为INTERRUPTED程序才会继续往下跑。
            while (state == INTERRUPTING)
                Thread.yield(); // wait out pending interrupt
    }

setException
和set一样只不过是将状态设置为Exception。

cancel

    public boolean cancel(boolean mayInterruptIfRunning) {
        if (state != NEW)//任务一旦开始就没办法取消。
            return false;
        if (mayInterruptIfRunning) {
            if (!UNSAFE.compareAndSwapInt(this, stateOffset, NEW, INTERRUPTING))//尝试设置当前状态为尝试中断。
                return false;
            Thread t = runner;
            if (t != null)//如果已经设置了线程则尝试中断他。
                t.interrupt();
            UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED); //此状态为最终状态。
        }
        else if (!UNSAFE.compareAndSwapInt(this, stateOffset, NEW, CANCELLED))//如果输入参数为false则说明不需要中断状态，而直接尝试进入取消状态。
            return false;
        finishCompletion();
        return true;
    }