FutureTask 源码分析

FutureTask 源码分析，这个类的原理与我分析android当中的FutureTask类差不多[http://www.cnblogs.com/daxin/p/3802392.html]

public class FutureTask<V> implements RunnableFuture<V> {
    /** 所有的方法全部委托sync */
    private final Sync sync;

    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        sync = new Sync(callable);
    }

    public FutureTask(Runnable runnable, V result) {
        sync = new Sync(Executors.callable(runnable, result));
    }

    public boolean isCancelled() {
        return sync.innerIsCancelled();
    }

    public boolean isDone() {
        return sync.innerIsDone();
    }

    public boolean cancel(boolean mayInterruptIfRunning) {
        return sync.innerCancel(mayInterruptIfRunning);
    }

    public V get() throws InterruptedException, ExecutionException {
        return sync.innerGet();
    }

    public V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException {
        return sync.innerGet(unit.toNanos(timeout));
    }

    protected void done() { }

    protected void set(V v) {
        sync.innerSet(v);
    }

    protected void setException(Throwable t) {
        sync.innerSetException(t);
    }

    public void run() {
        sync.innerRun();
    }

    protected boolean runAndReset() {
        return sync.innerRunAndReset();
    }

    private final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -7828117401763700385L;

        /** State value representing that task is ready to run */
        /** 代表起始状态 */
        private static final int READY     = 0;
        /** State value representing that task is running */
        /** 代表正在运行中状态 */
        private static final int RUNNING   = 1;
        /** State value representing that task ran */
        /** 代表运行完成的状态 */
        private static final int RAN       = 2;
        /** State value representing that task was cancelled */
        /** 代表被取消的状态 */
        private static final int CANCELLED = 4;

        /** The underlying callable */
        private final Callable<V> callable;
        /** The result to return from get() */
        private V result;
        /** The exception to throw from get() */
        private Throwable exception;

        /**
         * The thread running task. When nulled after set/cancel, this
         * indicates that the results are accessible.  Must be
         * volatile, to ensure visibility upon completion.
         */
        private volatile Thread runner;

        Sync(Callable<V> callable) {
            this.callable = callable;
        }

        /**
        *  判断是否完成或者是否取消
        *  传入0或者1 都返回0 说明任务没有完成 也没有取消
        */
        private boolean ranOrCancelled(int state) {
            return (state & (RAN | CANCELLED)) != 0;
        }

        /**
         * AbstractQueuedSynchronizer的模板方法
         * 返回1可以获取锁 返回-1说明获取锁失败
         * 调用innerIsDone 返回TRUE 说明任务已经执行完毕
         * 返回FALSE 说明任务没有执行完毕
         */
        protected int tryAcquireShared(int ignore) {
            return innerIsDone() ? 1 : -1;
        }

        /**
         * 释放锁 将执行当前任务的线程设置为null
         */
        protected boolean tryReleaseShared(int ignore) {
            runner = null;
            return true;
        }

        //判断任务是否被取消
        boolean innerIsCancelled() {
            return getState() == CANCELLED;
        }

        //判断任务是否完成(取消也算完成)
        boolean innerIsDone() {
            return ranOrCancelled(getState()) && runner == null;
        }

        //获取结果
        V innerGet() throws InterruptedException, ExecutionException {
            //首先调用AbstractQueuedSynchronizer的方法，这个方法会调用子类方法tryAcquireShared 上面有讲
            //如果当前任务已经完成，那么当前线程可以向下运行，否则把当前线程加入队列阻塞.
            acquireSharedInterruptibly(0);
            //判断状态 如果取消了就抛CancellationException异常.
            if (getState() == CANCELLED)
                throw new CancellationException();
            //如果任务执行过程中出现异常，这里包装一下抛出ExecutionException.
            if (exception != null)
                throw new ExecutionException(exception);
            return result;
        }

        //获取结果
        V innerGet(long nanosTimeout) throws InterruptedException, ExecutionException, TimeoutException {
            //调用AbstractQueuedSynchronizer里的方法
            // return tryAcquireShared(arg) >= 0 ||doAcquireSharedNanos(arg, nanosTimeout);
            // 首先tryAcquireShared调用它获取锁，也就是看任务完事没，如果任务完事了就返回TRUE，那么执行逻辑同上。
            // 如果获取不到锁，那么就阻塞当前线程给定的时间，如果时间到了再次任务还没完成则抛出异常。
            if (!tryAcquireSharedNanos(0, nanosTimeout))
                throw new TimeoutException();
            if (getState() == CANCELLED)
                throw new CancellationException();
            if (exception != null)
                throw new ExecutionException(exception);
            return result;
        }

        void innerSet(V v) {
            for (;;) {
                int s = getState();
                if (s == RAN)
                    return;
                if (s == CANCELLED) {
                    // aggressively release to set runner to null,
                    // in case we are racing with a cancel request
                    // that will try to interrupt runner
                    releaseShared(0);
                    return;
                }
                //正常完成 设置状态为RAN
                if (compareAndSetState(s, RAN)) {
                    result = v;
                    releaseShared(0);
                    done(); //通知子类
                    return;
                }
            }
        }

        void innerSetException(Throwable t) {
            for (;;) {
                int s = getState();
                if (s == RAN)
                    return;
                if (s == CANCELLED) {
                    // aggressively release to set runner to null,
                    // in case we are racing with a cancel request
                    // that will try to interrupt runner
                    releaseShared(0);
                    return;
                }
                //设置异常
                if (compareAndSetState(s, RAN)) {
                    exception = t;
                    releaseShared(0);
                    done();//通知子类
                    return;
                }
            }
        }

        //取消任务
        boolean innerCancel(boolean mayInterruptIfRunning) {
            for (;;) {
                int s = getState();
                //如果任务已经结束，则返回FALSE
                if (ranOrCancelled(s))
                    return false;
                //设置任务的状态为CANCELLED
                if (compareAndSetState(s, CANCELLED))
                    break;
            }
            //如果参数mayInterruptIfRunning=TRUE,那么设置线程的终端状态
            if (mayInterruptIfRunning) {
                Thread r = runner;
                if (r != null)
                    r.interrupt();
            }
            //释放锁
            releaseShared(0);
            //调用子类方法，通知状态改变
            done();
            return true;
        }

        void innerRun() {
            //如果任务不是初始状态则直接结束
            if (!compareAndSetState(READY, RUNNING))
                return;

            runner = Thread.currentThread();
            if (getState() == RUNNING) { // recheck after setting thread
                V result;
                try {
                    result = callable.call();
                } catch (Throwable ex) {
                    //我们写的任务方法里如果出现异常则调用setException
                    setException(ex);
                    return;
                }
                //设置结果
                set(result);
            } else {
                //释放锁
                releaseShared(0); // cancel
            }
        }

        boolean innerRunAndReset() {
            if (!compareAndSetState(READY, RUNNING))
                return false;
            try {
                runner = Thread.currentThread();
                if (getState() == RUNNING)
                    callable.call(); // don't set result
                runner = null;
                return compareAndSetState(RUNNING, READY);
            } catch (Throwable ex) {
                setException(ex);
                return false;
            }
        }
    }
}