zoukankan      html  css  js  c++  java
  • 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;
                }
            }
        }
    }
  • 相关阅读:
    Python学习笔记(2)
    Python学习笔记(1)
    2020年5月记于博茨瓦纳
    20145208 蔡野 《网络对抗》免考项目 MSF学习
    20145208 蔡野 《网络对抗》Exp9 web安全基础实践
    20145208 蔡野 《网络对抗》Exp8 Web基础
    20145208 蔡野 《网络对抗》Exp7 网络欺诈技术防范
    20145122 《Java程序设计》课程总结
    20145122《 Java网络编程》实验五实验报告
    20145122 《Java程序设计》第十周学习总结
  • 原文地址:https://www.cnblogs.com/daxin/p/3969864.html
Copyright © 2011-2022 走看看