FutureTask

public interface Future<V> {
    
    // 取消任务 可中断的方式取消
    boolean cancel(boolean mayInterruptIfRunning);
    
    // 判断任务是否处于取消状态 
    boolean isCancelled();
    
    // 判断异步任务是否执行完成      ==这里使用轮训的方式监听==
    boolean isDone();
    
    // 获取异步线程的执行结果，如果没有执行完成，则一直阻塞到有结果返回；
    V get() throws InterruptedException, ExecutionException;
    
    // 获取异步线程的执行结果，如果没有执行完成，则一直阻塞到设置的时间，有结果返回，没有结果则抛出异常；
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

public class FutureTest implements Callable<Integer> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    @Override
    public Integer call() throws Exception {
        System.err.println("start call method...");
        Thread.sleep(3000);
        return 1111;
    }


    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.err.println("main method start....");
        FutureTest futureTest = new FutureTest();
        Future1Test future1Test = new Future1Test();
        long time = System.currentTimeMillis();
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        Future<String> future = executorService.submit(future1Test);
        if (!future.isDone()) {
            System.err.println("future not done !");
        }
        Future<Integer> future1 = executorService.submit(futureTest);
        // submit提交多个任务时，只有所有任务都完成后，才能使用get按照任务的提交顺序得到返回结果
        // 这里先提交了future1Test，休眠了4s, futureTest休眠了3s，但是等我们get到结果的时候，是消耗的4s时间的；
        System.err.println("cost time: " + (System.currentTimeMillis() - time));
        System.err.println("future: " + future.get());
        System.err.println("future1: " + future1.get());
        System.err.println("main method end....");
        executorService.shutdown();
    }
}

main method start....
future not done !
// 说明了第一 get()方法是阻塞，第二线程池任务都执行完成之后，按提交任务顺序get结果返回值
cost time: 4
start call method...
future: future 2 test
future1: 1111
main method end....

public class FutureTask<V> implements RunnableFuture<V> {...}
// 下面是RunnableFuture接口的继承关系

public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */
    void run();
}

/** The underlying callable; nulled out after running */
private Callable<V> callable;

/** The result to return or exception to throw from get() */
//任务执行结果或者任务异常
private Object outcome; // non-volatile, protected by state reads/writes

/** The thread running the callable; CASed during run() */
//执行任务的线程
private volatile Thread runner;

/** Treiber stack of waiting threads */
//等待节点，关联等待线程
private volatile WaitNode waiters;

private static final sun.misc.Unsafe UNSAFE;
//state字段的内存偏移量     这个在线程池执行任务的时候进行状态判断的时候会用到
private static final long stateOffset;
//runner字段的内存偏移量
private static final long runnerOffset;
//waiters字段的内存偏移量
private static final long waitersOffset;

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;

/**
    * 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 void run() {
     // 如果状态 state 不是 NEW，或者设置 runner 值失败
     // 表示有别的线程在此之前调用 run 方法，并成功设置了 runner 值
     // 保证了只有一个线程可以运行 try 代码块中的代码。
     if (state != NEW ||
             !UNSAFE.compareAndSwapObject(this, runnerOffset,
                     null, Thread.currentThread()))
         return;
     //以上state值变更的由CAS操作保证原子性
     
     try {
         Callable<V> c = callable;
         //只有c不为null且状态state为NEW的情况
         if (c != null && state == NEW) {
             V result;
             boolean ran;
             try {
                 //调用callable的call方法，并获得返回结果
                 result = c.call();
                 //运行成功
                 ran = true;
             } catch (Throwable ex) {
                 result = null;
                 ran = false;
                 setException(ex);
             }
             if (ran)
                 //设置结果
                 set(result);
         }
     } finally {
         // runner must be non-null until state is settled to
         // prevent concurrent calls to run()
         runner = null;
         // state must be re-read after nulling runner to prevent
         // leaked interrupts
         int s = state;
         if (s >= INTERRUPTING)
             handlePossibleCancellationInterrupt(s);
     }
 }

public V get() throws InterruptedException, ExecutionException {
    int s = state;
    if (s <= COMPLETING)
        s = awaitDone(false, 0L);
    return report(s);
}

private int awaitDone(boolean timed, long nanos)
        throws InterruptedException {
        final long deadline = timed ? System.nanoTime() + nanos : 0L;
        WaitNode q = null;
        boolean queued = false;
        // CPU轮转
        for (;;) {
            // 如果线程中断了，将线程移除等待队列，抛出中断异常
            if (Thread.interrupted()) {
                removeWaiter(q);
                throw new InterruptedException();
            }

            int s = state;
            // 如果任务状态大于完成，则直接返回；
            if (s > COMPLETING) {
                if (q != null)
                    q.thread = null;
                return s;
            }
            // 如果任务完成，但是返回值outcome还没有设置，可以先让出线程执行权，让其他线程执行
            else if (s == COMPLETING) // cannot time out yet
                Thread.yield();
            // 下面是任务还没有执行完成的状态，将线程添加到等待队列
            else if (q == null)
                q = new WaitNode();
            else if (!queued)
                queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                     q.next = waiters, q);
            // 判断get方法是否设置了超时时间
            else if (timed) {
                nanos = deadline - System.nanoTime();
                // 如果超出设置的时间，线程移除等到队列
                if (nanos <= 0L) {
                    removeWaiter(q);
                    return state;
                }
                LockSupport.parkNanos(this, nanos);
            }
            // 没有设置超时时间，线程直接阻塞，直到任务完成
            else
                LockSupport.park(this);
        }
    }
    

@Param mayInterruptIfRunning 是否中断
public boolean cancel(boolean mayInterruptIfRunning) {
    /*
     * 在状态还为NEW的时候，根据参数中的是否允许传递，
     * 将状态流转到INTERRUPTING或者CANCELLED。
     */
        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;
    }
    

private void finishCompletion() {
    for (WaitNode q; (q = waiters) != null;) {
        // 必须将栈顶CAS为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;
                // 将next域置为null，这样对GC友好。
                q.next = null; 
                q = next;
            }
            break;
        }
    }

    /*
     * done方法是暴露给子类的一个钩子方法。
     *
     * 这个方法在ExecutorCompletionService.QueueingFuture中的override实现是把结果加到阻塞队列里。
     * CompletionService谁用谁知道，奥秘全在这。
     */
    done();

    /* 
     * callable置为null主要为了减少内存开销,
     * 更多可以了解JVM memory footprint相关资料。
     */
    callable = null;
}