FutureTask源码阅读

public class FutureTask<V> implements RunnableFuture<V> {    /**      * 内部状态可能得迁转过程:      * NEW -> COMPLETING -> NORMAL //正常完成      * NEW -> COMPLETING -> EXCEPTIONAL //发生异常      * NEW -> CANCELLED //取消      * NEW -> INTERRUPTING -> INTERRUPTED //中断      */      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;    /** 内部的callable，运行完成后设置为null */      private Callable<V> callable;    /** The result to return or exception to throw from get() */    private Object outcome; // 没有volatile修饰, 依赖state的读写来保证可见性    /** 执行内部callable的线程*/    private volatile Thread runner;    /** Treiber stack of waiting threads */    private volatile WaitNode waiters;    /**     * Returns result or throws exception for completed task.     *     * @param s completed state value     */    @SuppressWarnings("unchecked")    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);    }    public FutureTask(Callable<V> callable) {        if (callable == null)            throw new NullPointerException();        this.callable = callable;        this.state = NEW;       // ensure visibility of callable    }    public FutureTask(Runnable runnable, V result) {        this.callable = Executors.callable(runnable, result);        this.state = NEW;       // ensure visibility of callable    }    public boolean isCancelled() {        return state >= CANCELLED;    }    public boolean isDone() {        return state != NEW;    }    public boolean cancel(boolean mayInterruptIfRunning) {        if (!(state == NEW &&              UNSAFE.compareAndSwapInt(this, stateOffset, 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                    UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);                }            }        } finally {            finishCompletion();        }        return true;    }    public V get() throws InterruptedException, ExecutionException {        int s = state;        if (s <= 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);    }    protected void done() { }    protected void set(V v) {        //当前任务状态state从NEW改为COMPLETING        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {            outcome = v;            UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state            finishCompletion();//唤醒Treiber Stack中所有等待线程        }    }    protected void setException(Throwable t) {        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {            outcome = t;            UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state            finishCompletion();        }    }    public void run() {        //如果state不为NE或者尝试设置runner为当前线程，失败就退出        if (state != NEW ||            !UNSAFE.compareAndSwapObject(this, runnerOffset,                                         null, Thread.currentThread()))            return;        try {            Callable<V> c = callable;            if (c != null && state == NEW) {                V result;                boolean ran;                try {                    result = c.call();//执行任务                    ran = true;                } catch (Throwable ex) {                    result = null;                    ran = false;                    setException(ex);//如果发生异常，设置异常                }                if (ran)//如果正常执行完成，设置执行结果                    set(result);            }        } finally {            // runner必须在设置了state之后再置空，避免run方法出现并发问题            runner = null;            int s = state;            if (s >= INTERRUPTING)//处理可能发生的取消中断                handlePossibleCancellationInterrupt(s);        }    }    protected boolean runAndReset() {        if (state != NEW ||            !UNSAFE.compareAndSwapObject(this, runnerOffset,                                         null, Thread.currentThread()))            return false;        boolean ran = false;        int s = state;        try {            Callable<V> c = callable;            if (c != null && s == NEW) {                try {                    c.call(); // don't set result                    ran = true;                } catch (Throwable ex) {                    setException(ex);                }            }        } finally {            runner = null;            s = state;            if (s >= INTERRUPTING)                handlePossibleCancellationInterrupt(s);        }        return ran && s == NEW;    }    /**     * Ensures that any interrupt from a possible cancel(true) is only     * delivered to a task while in run or runAndReset.     */    private void handlePossibleCancellationInterrupt(int s) {        // 如果当前正在中断过程中，自旋等中断完成        if (s == INTERRUPTING)            while (state == INTERRUPTING)                Thread.yield(); // wait out pending interrupt    }    /**     * Simple linked list nodes to record waiting threads in a Treiber     * stack.  See other classes such as Phaser and SynchronousQueue     * for more detailed explanation.     */    static final class WaitNode {        volatile Thread thread;        volatile WaitNode next;        WaitNode() { thread = Thread.currentThread(); }    }    //移除Treiber Stack，并将Treiber Stack中所有等待获取任务结果的线程唤醒，然后回调下done钩子方法    private void finishCompletion() {        // assert state > COMPLETING;        for (WaitNode q; (q = waiters) != null;) {            //尝试将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();        callable = null;        // to reduce footprint    }    private int awaitDone(boolean timed, long nanos)        throws InterruptedException {        final long deadline = timed ? System.nanoTime() + nanos : 0L;        WaitNode q = null;        boolean queued = false;        for (;;) {            if (Thread.interrupted()) {                //如果当前线程被中断，移除等待节点q，然后抛出中断异常                removeWaiter(q);                throw new InterruptedException();            }            int s = state;            if (s > COMPLETING) {//如果任务已经执行完毕                 if (q != null)                    q.thread = null;//q不为null，将q中的thread置null                return s;//返回状态            }            else if (s == COMPLETING) // cannot time out yet                Thread.yield();//如果当前正在完成过程中，出让CPU            else if (q == null)                q = new WaitNode();//创建一个等待节点            else if (!queued)//将q(包含当前线程的等待节点)入队                queued = UNSAFE.compareAndSwapObject(this, waitersOffset,                                                     q.next = waiters, q);            else if (timed) {                nanos = deadline - System.nanoTime();                if (nanos <= 0L) {                    removeWaiter(q);//如果超时，移除等待节点q                     return state;                }                LockSupport.parkNanos(this, nanos);//超时的话，就阻塞给定时间            }            else                LockSupport.park(this);//没设置超时的话，就阻塞当前线程        }    }    private void removeWaiter(WaitNode node) {        if (node != null) {            node.thread = null;//将node的thread域置空            retry://下面过程中会将node从等待队列中移除，以thread域为null为依据            for (;;) {          // restart on removeWaiter race                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;            }        }    }}