FutureTask源码2

@SuppressWarnings({"unchecked","restriction"})
public class FutureTask1<V> implements RunnableFuture<V> {

    /*
    任务可能出现的状态转换
    NEW新建 -> COMPLETING即将完成 -> NORMAL正常结束
    NEW新建 -> COMPLETING即将完成 -> EXCEPTIONAL异常
    NEW新建 -> CANCELLED被取消
    NEW新建 -> INTERRUPTING即将被中断 -> INTERRUPTED已经被中断

    第一种：初始化状态：NEW新建
    第二种：中间状态：COMPLETING即将完成，INTERRUPTING即将被中断
    第三种：终端状态：NORMAL正常结束，EXCEPTIONAL异常，CANCELLED被取消，INTERRUPTED已经被中断
    */
    private volatile int state;//任务当前状态，任务的状态可能被其他线程修改，所以要CAS。
    private static final int NEW = ;//新建
    private static final int COMPLETING = ;//即将完成。get(),finishCompletion(),awaitDone()使用这个状态。
    private static final int NORMAL = ;//正常结束，返回结果值。report()使用这个变量。
    private static final int EXCEPTIONAL = ;//异常，不返回结果值，抛出异常。没有使用这个状态。
    private static final int CANCELLED = ;//被取消，不返回结果值，抛出异常。report(),isCanceld()方法使用这个变量。
    private static final int INTERRUPTING = ;//即将被中断，不返回结果值，抛出异常。run()方法最后会使用这个状态。
    private static final int INTERRUPTED = ;//已经被中断，不返回结果值，抛出异常。没有使用这个状态。

    //FutureTask里面只能是callable，即使传进来Runnable也会转换为callable，
    //也就是FutureTask真正执行的任务。Thread里面只能丢Runnable，要想FutureTask丢到线程池里面去，也必须是Runnable。
    //finishCompletion()置为null
    private Callable<V> callable;
    private Object outcome;//get()返回的结果
    private volatile Thread runner;//执行callable任务的线程，它是CAS操作。run()的最后finally置为null。
    private volatile WaitNode waiters;//等待结果的线程集合

    //根据状态s决定是否返回结果
    private V report(int s) throws ExecutionException {
        Object x = outcome;//我们在set()方法的时候把结果写进outcome的
        if (s == NORMAL)//只有是正常才返回结果。其余
            return (V) x;
        if (s >= CANCELLED)//CANCELLED4被取消，INTERRUPTING5即将被中断，INTERRUPTED6已经被中断，
            throw new CancellationException();
        throw new ExecutionException((Throwable) x);
    }

    //把Callable封装为FutureTask1
    public FutureTask1(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;
    }

    //把Runnable封装为FutureTask1，result是预期值。
    public FutureTask1(Runnable runnable, V result) {
        this.callable = Executors1.callable(runnable, result);//runnbale封装为callable
        this.state = NEW;
    }

    //判断是否取消了，包括cancel(false);和cancel(true);
    public boolean isCancelled() {
        return state >= CANCELLED;//CANCELLED被取消，INTERRUPTING即将被中断，INTERRUPTED已经被中断
    }

    //任务是否结束，不一定是成功任务，取消了，出异常了，被中断了，也是结束，包括cancel(false);和cancel(true);run()，setException()，set()，
    public boolean isDone() {
        return state != NEW;
    }

    //取消任务。如果是false  NEW0->CANCELLED4     true: NEW ->INTERRUPTING5->中断线程->INTERRUPTED6
    public boolean cancel(boolean mayInterruptIfRunning) {
        //fasle&&：处于不是新建状态：返回fasle，状态不变。
        //true&&false：处于新建状态，但是状态设置失败：返回fasle，状态不变。
        if (!(state == NEW && UNSAFE.compareAndSwapInt(this, stateOffset, NEW, mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))//即将被中断5，被取消4
            return false;
        //true&&true：是新建状态，并且 状态设置成功（将其置为INTERRUPTING5或者CANCELLED4）：继续状态变为INTERRUPTED6
        try {
            if (mayInterruptIfRunning) {//true才继续变为INTERRUPTED
                try {
                    Thread t = runner;
                    if (t != null)
                        t.interrupt();//使用了线程中断的方法来达到取消任务的目的，设置中断标记=true
                } finally { // final 已经被中断6
                    UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);//
                }
            }
        } finally {
            finishCompletion();
        }
        return true;
    }

    //获取执行结果，阻塞，获得Callable的返回值
    public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)//COMPLETING1即将完成，NEW新建，如果任务还没执行完成，就等待任务先执行完成
            s = awaitDone(false, 0L);
        //s > COMPLETING:正常结束，异常，被取消，即将被中断，已经被中断
        return report(s);
    }

    //获取任务执行的结果，并且有超时机制
    public V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
        if (unit == null)
            throw new NullPointerException();
        int s = state;
         //带有超时时间的get()，如果超过指定时间，就会抛出一个TimeoutException
        if (s <= COMPLETING && (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
            throw new TimeoutException();
        return report(s);
    }

    protected void done() {
    }

    protected void set(V v) {//先设置即将完成，再设置正常结束
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {//即将完成1
            outcome = v;//把任务执行的结果写入到outcome当中，
            UNSAFE.putOrderedInt(this, stateOffset, NORMAL); //final 正常结束2
            finishCompletion();//唤醒等待结果的线程
        }
    }

    //修改当前任务的状态
    protected void setException(Throwable t) {//先设置即将完成，再设置异常
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {//即将完成1
            outcome = t;//把任务执行的结果写入到outcome当中，
            UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final 异常3
            finishCompletion();//唤醒等待结果的线程
        }
    }

    //任务起动就调这个方法。
    public void run() {
        //true||：不是新建，已经执行了，就不执行
        //fasle||true：是新建，runner设置当前线程失败了，就不执行
        if (state != NEW || !UNSAFE.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread()))//不能多线程进来
            return;
        //false||fasle：是新建，设置runner成功就进去
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();//Callable的call方法，如果是Runnable封装的Callable，call方法返回的是RunnableAdapter的期望值。
                    ran = true;
                } catch (Throwable ex) {//call()抛出了异常
                    result = null;
                    ran = false;
                    setException(ex);//状态不是NEW就不设置异常结果。先设置即将完成，再设置异常。设置1 3
                }
                if (ran)
                    set(result);//设置结果，状态不是NEW就不设置结果。先设置即将完成，再设置正常结束。设置1 2。
            }
        } finally {
            //在任务执行的过程中，可能会调用cancel()，这里主要是不想让中断操作逃逸到run()方法之外
            runner = null;//可以多线程进来了
            int s = state;
            if (s >= INTERRUPTING)//即将被中断5和已经被中断6。调用了cancel(true)现在s=5|6。调用cancel(false)=4不会进来。
                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 {
            //在任务执行的过程中，可能会调用cancel()，这里主要是不想让中断操作逃逸到run()方法之外
            runner = null;
            s = state;
            if (s >= INTERRUPTING)//INTERRUPTING5即将被中断，INTERRUPTED6已经被中断。调用了cancel(true)。
                handlePossibleCancellationInterrupt(s);
        }
        return ran && s == NEW;
    }

    private void handlePossibleCancellationInterrupt(int s) {
        if (s == INTERRUPTING)//5，如果cancel(true)并且现在是5
            while (state == INTERRUPTING)
                Thread.yield(); // 避免过多的CPU时间放在这个for循环的自旋上，让步等着变为INTERRUPTED6，等着runner线程被设置中断标记在退出，就是在收集cancel(true)的中断标记再出去。

        //         assert state == INTERRUPTED;
        // 清除cancel(true)的中断，中断是任务task和调用者通信的机制，
        // Thread.interrupted();   //重置中断状态为未中断=false；    isInterrupted不会重置中断状态；
    }

    static final class WaitNode {
        volatile Thread thread;
        volatile WaitNode next;//下一个

        WaitNode() {
            thread = Thread.currentThread();
        }
    }

    //成功|取消 完成任务后唤醒等待结果的线程。cancel()设置s=4|6后调用这个方法，run()正常完成设置s=2，run()异常完成设置s=3后调用这个方法。
    //awaitDone()唤醒的线程走if(s > COMPLETING1)返回状态值去get()获取结果。
    private void finishCompletion() {
         assert state > COMPLETING;//正常结束，异常，被取消，即将被中断，已经被中断
        for (WaitNode q; (q = waiters) != null;) {//从头开始唤醒

            //设置为null之后，其他get线程看到状态>1,直接获取结果，不加入waiters队列。
            //如果其他线程成功加入到了另一个新的waiters队列，此时唤醒失败，就要另一个线程他自己去退出。
            //这里准备开始清空等待队列了，就要阻止其他线程进到队列来（通过状态值），如果清空后还是进到队列去了，就要线程自己处理。
            if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
                for (;;) {
                    Thread t = q.thread;
                    if (t != null) {
                        q.thread = null;//thread属性置为null
                        LockSupport.unpark(t);//唤醒的是获取结果的awaitDone()阻塞的线程
                    }
                    WaitNode next = q.next;
                    if (next == null)
                        break;
                    q.next = null; //gc q，q.next不会回收，因为还有next指向在。
                    System.gc();
                    System.gc();
                    System.gc();
                    System.gc();
                    System.gc();
                    q = next;
                }
                break;
            }
        }
        //一个钩子方法，本类中，它是一个空实现，在子类中可以重写它。
        done();
        //最后把callable置为null.
        callable = null; // to reduce footprint
    }

    //等待任务完成，多线程进来，唤醒之后，返回状态去get获取结果。2个出口。
    private int awaitDone(boolean timed, long nanos) throws InterruptedException {
        final long deadline = timed ? System.nanoTime() + nanos : 0L;//超时时间，如果使用了超时的get()才起作用，否则这个值不起作用
        WaitNode q = null;
        boolean queued = false;
        for (;;) {
            if (Thread.interrupted()) {//等待结果的线程被中断了
                removeWaiter(q);//移除无效节点
                throw new InterruptedException();//就抛出一个中断异常
            }

            /*分为几部操作：每一步都在一个for循环里面，只有前面一步执行了才能在下一个循环里面执行下一步*/

            int s = state; 

            //如果当前状态大于COMPLETING，说明任务已经正常完成了或者取消完成了。就去拿结果。拿到的结果可能是null就抛出异常。
            //NORMAL正常结束，EXCEPTIONAL异常，CANCELLED被取消，INTERRUPTING即将被中断，INTERRUPTED已经被中断
            if (s > COMPLETING) {
                if (q != null)
                    q.thread = null;//回收q.thread
                return s;//返回任务的状态，等待结束。有可能是cancel()设置s=4|6后唤醒，有可能是run()设置s=2后唤醒，run()设置s=3后唤醒。

            // 正在完成，先等一会，下次循环去初始化节点--压栈--阻塞
            } else if (s == COMPLETING)
                Thread.yield();//避免过多的CPU时间放在这个for循环的自旋上。再次判断状态。

            else if (q == null)//初始化q节点，才能去压栈，才能去阻塞。（后面2步在下一个循环中处理，会跳过这个循环）
                q = new WaitNode();//再次判断状态。

            else if (!queued)//将q节点压入栈，它是一个cas操作。第一次是false，压栈成功变为true，再去阻塞。也就是说只有压栈了才能去阻塞。后来的在前面。
                //有可能唤醒不了：finishCompletion()已经执行完了，才加入到队列就不能唤醒，就加入到一个新的waiters里面去了，就要再次循环，通过状态退出。
                queued = UNSAFE.compareAndSwapObject(this, waitersOffset, q.next = waiters, q);
                //再次判断状态。
            else if (timed) {//如果有超时限制的话，判断是否超时，如果没有超时就重试，如果超时了，就把q节点从栈中遇除
                nanos = deadline - System.nanoTime();
                if (nanos <= 0L) {//超时了
                    removeWaiter(q);//移除无效节点，多线程进来
                    return state;//返回状态，去获取结果。
                }
                LockSupport.parkNanos(this, nanos);//LockSupport是一个并发工具，这里表示等待nanos秒后唤醒
            } else
                LockSupport.park(this);//开始阻塞线程，直到任务完成了才会再次唤醒了在finishCompletion()中唤醒
        }
    }

    /*
      将某个节点置为无效节点，并清除栈中所有的无效节点
     （通过前面的分析，应该可以推断出，无效的节点，其实就是指节点内部的thread ＝＝ null）
      那么产生无效节点的情况就有三种了
        (1):线程被中断了
        (2):s > COMPLETING，当前的任务状态> COMPLETING
        (3):超时
     */
    //如果在阻塞其间，任务被中断了，或者超时了，又或者任务已经完成了，都需要进行资源的回收。
    private void removeWaiter(WaitNode node) {
        if (node != null) {
            node.thread = null;//为了GC回收node节点中的thread成员变量
            retry:
                for (;;) {//从头到尾删除thread=null的。不仅仅删除node。

                    /* 多线程不会有影响，其他线程只是做了重复的事情，或者可以帮着其他线程做  */

                    for (WaitNode pred = null, q = waiters, s; q != null; q = s) {
                        s = q.next;
                        if (q.thread != null)
                            pred = q;//q不为null，pred只要被赋值了就不为null。
                        else if (pred != null) {
                            pred.next = s;
                            if (pred.thread == null)
                                continue retry;//如果前驱节点也是一个无效节点，则重新遍历，

                        //q.thread异常了，pred=null，说明pred没有被赋值过，第一个q就异常了。
                        } else if (!UNSAFE.compareAndSwapObject(this, waitersOffset, q, s))//修改头结点是多线程在修改。修改失败就重来。
                            continue retry;//调到外层循环再来。
                    }
                    break;
            }
        }
    }

    private static final sun.misc.Unsafe UNSAFE;
    private static final long stateOffset;//state
    private static final long runnerOffset;//runner
    private static final long waitersOffset;//waiters
    static {
        try {
            UNSAFE = java.security.AccessController
                    .doPrivileged(new java.security.PrivilegedExceptionAction<sun.misc.Unsafe>() {
                        public sun.misc.Unsafe run() throws Exception {
                            Class<sun.misc.Unsafe> k = sun.misc.Unsafe.class;
                            for (java.lang.reflect.Field f : k.getDeclaredFields()) {
                                f.setAccessible(true);
                                Object x = f.get(null);
                                if (k.isInstance(x))
                                    return k.cast(x);
                            }
                            throw new NoSuchFieldError("the Unsafe");
                        }
                    });
            Class<?> k = FutureTask1.class;
            stateOffset = UNSAFE.objectFieldOffset(k.getDeclaredField("state"));
            runnerOffset = UNSAFE.objectFieldOffset(k.getDeclaredField("runner"));
            waitersOffset = UNSAFE.objectFieldOffset(k.getDeclaredField("waiters"));
        } catch (Exception e) {
            throw new Error(e);
        }
    }

}