FutureTask

1.概念

一个可以取消的异步计算，当前线程都会阻塞在get阻塞，直到任务执行完毕，返回结果。

2.类图

3.源码分析

3.1 参数分析

 //表示当前task状态
    private volatile int state;
    //当前任务尚未执行
    private static final int NEW          = 0;
    //当前任务正在结束，稍后完全结束，一种临界状态
    private static final int COMPLETING   = 1;
    //当前任务正常结束
    private static final int NORMAL       = 2;
    //当前任务执行过程中发生了异常。 内部封装的 callable.run() 向上抛出异常了
    private static final int EXCEPTIONAL  = 3;
    //当前任务被取消
    private static final int CANCELLED    = 4;
    //当前任务中断中..
    private static final int INTERRUPTING = 5;
    //当前任务已中断
    private static final int INTERRUPTED  = 6;

        //submit(runnable/callable)   runnable 使用 装饰者模式 伪装成 Callable了。
    private Callable<V> callable;

    //正常情况下：任务正常执行结束，outcome保存执行结果。 callable 返回值。
    //非正常情况：callable向上抛出异常，outcome保存异常
    private Object outcome; // non-volatile, protected by state reads/writes

    //当前任务被线程执行期间，保存当前执行任务的线程对象引用。
    private volatile Thread runner;
 
    //因为会有很多线程去get当前任务的结果，所以 这里使用了一种数据结构 stack 头插 头取 的一个队列。
    private volatile WaitNode waiters;

3.2 构造函数分析

  public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        //callable就是程序员自己实现的业务类
        this.callable = callable;
        //设置当前任务状态为 NEW
        this.state = NEW;      
    }

  public FutureTask(Runnable runnable, V result) {
        //使用装饰者模式将runnable转换为了 callable接口，外部线程 通过get获取
        //当前任务执行结果时，结果可能为 null 也可能为 传进来的值。
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }   

3.3 任务执行的入口run方法

1.首先判断当前task 是否被消费，如果已经被消费或者当task已经被其他线程抢占，直接返回
2. 当task为new，，并且当前现在通过cas抢占到了任务，调用自己重写的runnable或者calleble，如果程序猿自己写的代码没有抛出异常，正常返回结果，并将当前任务状态
改为normal，并且将那些get操作阻塞在此的线程唤醒。

 //任务执行入口
    public void run() {
        //条件一：state != NEW 条件成立，说明当前task已经被执行过了 或者 被cancel 了，总之非NEW状态的任务，线程就不处理了。
        //条件二：!UNSAFE.compareAndSwapObject(this, runnerOffset,null, Thread.currentThread())
        //       条件成立：cas失败，当前任务被其它线程抢占了...
        if (state != NEW ||
                !UNSAFE.compareAndSwapObject(this, runnerOffset,
                        null, Thread.currentThread()))
            return;

        //执行到这里，当前task一定是 NEW 状态，而且 当前线程也抢占TASK成功！

        try {
            //callable 就是程序员自己封装逻辑的callable 或者 装饰后的runnable
            Callable<V> c = callable;
            //条件一：c != null 防止空指针异常
            //条件二：state == NEW 防止外部线程 cancel掉当前任务。
            if (c != null && state == NEW) {

                //结果引用
                V result;
                //true 表示callable.run 代码块执行成功 未抛出异常
                //false 表示callable.run 代码块执行失败 抛出异常
                boolean ran;

                try {
                    //调用程序员自己实现的callable 或者 装饰后的runnable
                    result = c.call();
                    //c.call未抛出任何异常，ran会设置为true 代码块执行成功
                    ran = true;
                } catch (Throwable ex) {
                    //说明程序员自己写的逻辑块有bug了。
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    //说明当前c.call正常执行结束了。
                    //set就是设置结果到outcome
                    set(result);
            }
        } finally {
            runner = null;
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }


    protected void set(V v) {
        //使用CAS方式设置当前任务状态为 完成中..
        //有没有可能失败呢？ 外部线程等不及了，直接在set执行CAS之前 将  task取消了。  很小概率事件。
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {

            outcome = v;
            //将结果赋值给 outcome之后，马上会将当前任务状态修改为 NORMAL 正常结束状态。
            UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state

            //最起码得把get() 再此阻塞的线程 唤醒..
            finishCompletion();
        }
    }   

  private void finishCompletion() {
        //q指向waiters 链表的头结点。
        for (WaitNode q; (q = waiters) != null;) {

            //使用cas设置 waiters 为 null 是因为怕 外部线程使用 cancel 取消当前任务 也会触发finishCompletion方法。 小概率事件。
            if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
                for (;;) {
                    //获取当前node节点封装的 thread
                    Thread t = q.thread;
                    //条件成立：说明当前线程不为null
                    if (t != null) {

                        q.thread = null;//help GC
                        //唤醒当前节点对应的线程
                        LockSupport.unpark(t);
                    }
                    //next 当前节点的下一个节点
                    WaitNode next = q.next;

                    if (next == null)
                        break;

                    q.next = null; // unlink to help gc
                    q = next;
                }

                break;
            }
        }
        done();
        //将callable 设置为null helpGC
        callable = null;        // to reduce footprint
    }    

3.4 get方法

1. 判断当前任务的状态，如果当前任务的状态小于COMPLETING，说明当前还没有完成，将当前线程封装成waitnode节点，使用头插法插入等待队列，park当前get线程。
2. 如果当前任务已经完成，并且没有抛出异常返回当前任务结果,unpark当前get线程。

 //场景：多个线程等待当前任务执行完成后的结果...
    public V get() throws InterruptedException, ExecutionException {
        //获取当前任务状态
        int s = state;
        //条件成立：未执行、正在执行、正完成。 调用get的外部线程会被阻塞在get方法上。
        if (s <= COMPLETING)
            //返回task当前状态，可能当前线程在里面已经睡了一会了..
            s = awaitDone(false, 0L);

        return report(s);
    }


      private int awaitDone(boolean timed, long nanos)
            throws InterruptedException {
        //0 不带超时
        final long deadline = timed ? System.nanoTime() + nanos : 0L;
        //引用当前线程 封装成 WaitNode 对象
        WaitNode q = null;
        //表示当前线程 waitNode对象 有没有 入队/压栈
        boolean queued = false;
        //自旋
        for (;;) {

            //条件成立：说明当前线程唤醒 是被其它线程使用中断这种方式喊醒的。interrupted()
            //返回true 后会将 Thread的中断标记重置回false.
            if (Thread.interrupted()) {
                //当前线程node出队
                removeWaiter(q);
                //get方法抛出 中断异常。
                throw new InterruptedException();
            }

            //假设当前线程是被其它线程 使用unpark(thread) 唤醒的话。会正常自旋，走下面逻辑。

            //获取当前任务最新状态
            int s = state;
            //条件成立：说明当前任务 已经有结果了.. 可能是好 可能是 坏..
            if (s > COMPLETING) {

                //条件成立：说明已经为当前线程创建过node了，此时需要将 node.thread = null helpGC
                if (q != null)
                    q.thread = null;
                //直接返回当前状态.
                return s;
            }
            //条件成立：说明当前任务接近完成状态...这里让当前线程再释放cpu ，进行下一次抢占cpu。
            else if (s == COMPLETING) 
                Thread.yield();
                //条件成立：第一次自旋，当前线程还未创建 WaitNode 对象，此时为当前线程创建 WaitNode对象
            else if (q == null)
                q = new WaitNode();
                //条件成立：第二次自旋，当前线程已经创建 WaitNode对象了，但是node对象还未入队
            else if (!queued){
                //当前线程node节点 next 指向 原 队列的头节点   waiters 一直指向队列的头！
                q.next = waiters;
                //cas方式设置waiters引用指向 当前线程node， 成功的话 queued == true 否则，可能其它线程先你一步入队了。
                queued = UNSAFE.compareAndSwapObject(this, waitersOffset, waiters, q);
            }
            //第三次自旋，会到这里。
            else if (timed) {
                nanos = deadline - System.nanoTime();
                if (nanos <= 0L) {
                    removeWaiter(q);
                    return state;
                }
                LockSupport.parkNanos(this, nanos);
            }
            else
                //当前get操作的线程就会被park了。  线程状态会变为 WAITING状态，相当于休眠了..
                //除非有其它线程将你唤醒  或者 将当前线程 中断。
                LockSupport.park(this);
        }
    }