J.U.C FutureTask之源码解析

通过直接继承Thread， 实现Runnable接口来创建线程。但这两种方式都有一种缺陷：在执行完任务之后无法获得执行结果。

如果需要获得执行结果，就必须通过共享变量或者使用线程通信的方式来达到效果，这样使用起来比较麻烦，而jdk中Callable和Future，通过他们可以在任务执行完毕之后得到任务执行结果。先看看他们之间的组织关系：

Callable：

public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

源码可知,它也是个一个接口，在他里面也只是申明一个方法，只不过这个方法为call(),call方法返回的就是该泛型传递进来的V类型，他怎么使用呢？就是结合之前的ExecuteService:

    <T> Future<T> submit(Callable<T> task);

    <T> Future<T> submit(Runnable task, T result);

    Future<?> submit(Runnable task);

第一个submit方法里面的参数类型就是Callable。

Future：

Future就是对于具体的Runnable或者Callable任务的执行进度的查看，取消，查询是否完成，获取结果（正确完成时的结果，或异常）。必要时可以通过get方法获取执行的结果，该方法会阻塞直到任务返回结果，或通过指定阻塞时间的版本。

public interface Future<V> {

    boolean cancel(boolean mayInterruptIfRunning);

    boolean isDone();

    V get() throws InterruptedException, ExecutionException;

    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

其中cancel()方法用来取消任务，如果取消任务成功则返回true, 如果取消任务失败则返回false。 参数mayInterruptIfRunning表示是否允许取消真在执行去没有执行完毕的任务，如果设置true, 则表示可以取消正在执行过程的任务。 当任务已经完成，或者已经被取消过了，或者因为别的原因不能取消， 则返回false。 当取消时，该任务还没有开始执行，则该任务不会执行，并且总是返回true。

FutureTask:

public class FutureTask<V> implements RunnableFuture<V>

FutureTask类实现了RunnableFuture接口，看一下RunnableFuture接口的定义：

public interface RunnableFuture<V> extends Runnable, Future<V>

RunnableFuture接口接触了Runnable接口和Future接口, 而FutureTask实现了RunnableFuture接口，所以它既可作为Runnable被线程执行，也可以作为Future得到Callable的返回值。

构造器定义：

 public FutureTask(Callable<V> callable)
 public FutureTask(Runnable runnable, V result) {

再来看看第二个构造器中的参数怎么变身Callable的：

this.callable = Executors.callable(runnable, result);

调用Executors.callable方法：

 public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
    }

简单实现Callable：

static final class RunnableAdapter<T> implements Callable<T> {
        final Runnable task;
        final T result;
        RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
        }
        public T call() {
            task.run();
            return result;
        }
    }

流程：

下面结合完整具体流程走一下FutureTask过程，并解析源码，草图如下：

实例代码如下：

 public class Test {
     public static void main(String[] args) {
         //第一种方式
         ExecutorService executor = Executors.newCachedThreadPool();
         Task task = new Task();
         FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
         executor.submit(futureTask);
         executor.shutdown();

         try {
             Thread.sleep(1000);
         } catch (InterruptedException e1) {
             e1.printStackTrace();
         }

         System.out.println("主线程在执行任务");

         try {
             System.out.println("task运行结果"+futureTask.get());
         } catch (InterruptedException e) {
             e.printStackTrace();
         } catch (ExecutionException e) {
             e.printStackTrace();
         }

         System.out.println("所有任务执行完毕");
     }
 }
 class Task implements Callable<Integer>{
     @Override
     public Integer call() throws Exception {
         System.out.println("子线程在进行计算");
         Thread.sleep(3000);
         int sum = 0;
         for(int i=0;i<100;i++)
             sum += i;
         return sum;
     }
 }

分析过程之前，先准备前准备知识，首先看一下FutureTask内部状态，以及之间的转变：

    private volatile int state; // volatile 内存可见性
    private static final int NEW          = 0; //该状态为new FutureTask（）时设定，同时也表示内部成员callable已经成功赋值，一直到worker thread完成FutureTask中run().
    private static final int COMPLETING   = 1; //该状态位worker thread完成task时设定的中间状态，处于该状态下，说明worker thread 真正准备设置result.
    private static final int NORMAL       = 2;  //当设置result结果完成后，FutureTask处于该状态，代表过程结果，该状态为最终状态final state,(正确完成的最终状态)
    private static final int EXCEPTIONAL  = 3;  // 同上，只不过task执行过程出现异常，此时结果设值为exception,也是final state
    private static final int CANCELLED    = 4;  //final state, 表明task被cancel（task还没有执行就被cancel的状态）.
    private static final int INTERRUPTING = 5;  // 中间状态，task运行过程中被interrupt时，设置的中间状态；
    private static final int INTERRUPTED  = 6;   // final state, 中断完毕的最终状态，几种情况，下面具体分析。

下面是状态之间的转变,贯穿主线：

   * Possible state transitions:
     1* NEW -> COMPLETING -> NORMAL
     2* NEW -> COMPLETING -> EXCEPTIONAL
     3* NEW -> CANCELLED
     4* NEW -> INTERRUPTING -> INTERRUPTED
     */

其他重要的变量：

 /** The underlying callable; nulled out after running */
    private Callable<V> callable;   // 具体run运行时会调用其方法call()，并获得结果，结果时置为null.
    /** The result to return or exception to throw from get() */
    private Object outcome; // non-volatile, protected by state reads/writes   没必要为votaile,因为其是伴随state 进行读写，而state是FutureTask的主导因素。
    /** The thread running the callable; CASed during run() */
    private volatile Thread runner;   //具体的worker thread.
    /** Treiber stack of waiting threads */
    private volatile WaitNode waiters;     //Treiber stack 并发stack数据结构，用于存放阻塞在该futuretask#get方法的线程。

OK，构造new FutureTask开始：

  public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable; //底层callable赋值
        this.state = NEW;       // 初始状态NEW，同时也标志了callable的赋值，可见性
    }

ThreadPoolExecutor.submit(Runnable)，ThreadPoolExecutor里面具体细节请见这里，这里就假设它直接new a thread来处理该任务了，因为FutureTask为Runnable的子类，所以worker thread调用该类的run()方法：

        public void run() {
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))   //状态检测，和当前worker Thread的cas原子赋值，有一个不成立，就直接返回。什么情况下还没run()呢？就不是NEW状态了呢？
            return;                                                       //caller调用cancel了，此时状态为Interrupting,也说明了上面的cancel方法说明，task没运行时，就interrupt，task得不到运行。总是返回
        try {                                                               //true。
                                                                           //再来看看这里worker thread赋值为什么要用cas操作，有竞争racing? 竞争哪里来？难道threadPoolExecutor线程池多个线程可能抢同一个
            Callable<V> c = callable;                                      //任务？不可能 1：线程数 < coreThreadPool 时， 直接new thread, 2 : 大于 coreThreadpool时，放在blockingqueue里，取的话只能一
            if (c != null && state == NEW) {                               //线程。能想到就是caller那边了，即多callers(多线程)提交同一FutureTask.
                V result;                                                  //多线程同时提交同一FutureTask，确保该FutureTask的run()只被调用一次，
                boolean ran;
                try {
                    result = c.call();                                      //此处的if,1：当state == NEW(task没完成，中断) 并且 worker Thread为null时，才会得到运行
                    ran = true;                                             // 2: task已经完成了 或者 该任务已经有worker thread来执行时，直接返回不会运行。
                } catch (Throwable ex) {                                //调用callable的call方法
                    result = null;                                     //执行task时有异常
                    ran = false;                                        //附异常
                    setException(ex);
                }
                if (ran)                                               //正常完成，则赋值
                    set(result);
            }
        } finally {
                                                                       //注意！！什么这里吧runner置为null，此时run（）方法还没运行完呢啊！现在置为null,不怕并发调用run()吗？注意此时state已经变化了（Comple
            runner = null;                                             //teing或者interrupting了，run()一开始state != NEW 直接return,不会运行。可以说通过state和 worker thread来一起控制并发调用run
            int s = state;                                            //必须再读一次，防止worker thread == null后,遗漏的interrup信号,底下具体分析中断的情况。
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);              //如果caller中断信号有的话，则处理该interrupt.
        }                                                            //另外该任务是一致性任务，即state只要不为NEW，该任务就不会在运行，运行结束或cancel后，就不能在运行了，因为state状态在那不变哦！
    }

请看下例子，三个提交线程（提交同一个FutureTask）：

public class Test {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        Task task = new Task();
        CountDownLatch latch = new CountDownLatch(1);
        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
        for (int i = 0 ; i < 3; i++) {
            new Thread(new Submit(executor,  futureTask, latch)).start();
        }
        try {
            Thread.sleep(3000);
            latch.countDown();
            Thread.sleep(20000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        System.out.println("所有任务执行完毕");
        executor.shutdown();
    }

}

class Submit implements Runnable {
    private CountDownLatch latch ;
    private ExecutorService es ;
    private FutureTask<Integer> task;
    public Submit(ExecutorService es, FutureTask<Integer> task, CountDownLatch latch) {
         this.latch = latch;
         this.es = es;
         this.task = task;
    }
    public void run() {

        try {
            latch.await();
            Future<?> future = (Future<?>) es.submit(task);
            System.out.println("Thread name : " + Thread.currentThread().getName() + "go!");
            future.get(3000, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e1) {
            e1.printStackTrace();
        } catch (TimeoutException e2) {
            System.err.println("Thread name : " + Thread.currentThread().getName()  + " " + e2);
        }
    }
}

class Task implements Callable<Integer>{

    public Integer call() throws Exception {
        System.out.println("thread name : " + Thread.currentThread().getName() + "do the work!");
        Thread.sleep(6000);
        int sum = 0;
        for(int i=0;i<100;i++)
            sum += i;
        return sum;
    }
}

显示如下：

Thread name : Thread-1go!
Thread name : Thread-0go!
Thread name : Thread-2go!
thread name : pool-1-thread-1do the work!
Thread name : Thread-1 java.util.concurrent.TimeoutException
所有任务执行完毕

结果很显然，同一个任务多次提交（并发提交），FutureTask保证只是启一个线程来运行。

想运行多次(只要不cancel,和throw exception,因为他set(result),正常运行结束，state还是new)，用这个：

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 {

            runner = null;
            s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
        return ran && s == NEW;
    }

再来看看setException()和set(result)：

 protected void set(V v) {
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) { // cas原子操作，失败直接返回，成功的前提之前的状态必须为NEW.
            outcome = v;                                                    //可能和什么冲突呢？ caller已经cancel该task,状态位Interrupting或者Interrpted(这次Interrupted代表interrupt完成，这set()
            UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state  // 不是在worker thread中调用的嘛，怎么intterupt都完成了，怎么worker thread还在运行呢？worker thread运行的代码中没有响
            finishCompletion();                                              //应interrupt的代码。所以客户端cancel操作，对运行中的worker thread,并不一定让它停下来，不过此时即使运行完毕，也不能赋值。
        }
    }                                                                        //new -> Completing-> NORMAL 或者NEW ->Interrupting->Intterrpted.

    protected void setException(Throwable t) {
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = t;    //同上，不过附异常。
            UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
            finishCompletion();
        }                                                                   //new ->completing ->exception 或者 同上
    }

finishCompletion()等会细聊，主要是没说到get()阻塞呢！看看caller端线程调用cancel()和workerThread的handlePossibleCancellationInterrupt(int s)协调：

   public boolean cancel(boolean mayInterruptIfRunning) {
        if (state != NEW)
            return false; //1：已经cancel(cancelled,Interruping, Interrupted)过了 2：正常完成 Completing(Completed) 3:异常完成completing（exception） 直接返回false;
        if (mayInterruptIfRunning) { // flag : worker thread 已经启动运行了，是否可以中断
            if (!UNSAFE.compareAndSwapInt(this, stateOffset, NEW, INTERRUPTING)) //再次检查state状态，完成的话（上面的三种），直接返回false;
                return false;
            Thread t = runner;
            if (t != null)       // t == null对应Future task还没启动， 跳过thread.interrupt()，直接由interrpting -> interrupted,成功的话
                t.interrupt();   //调用worker thread的 interrupt() //mayInterrptIfRunning 为true ，interrupt 状态转变 new -> interrupting -> interrupted.
            UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED); // final state
        }
        else if (!UNSAFE.compareAndSwapInt(this, stateOffset, NEW, CANCELLED)) //mayInterruptIfRunning 为false，interrupt成功的 状态转变 new -> Cancelled
            return false;
        finishCompletion();
        return true;
    }

由上面可知，客户端cancel()中不少cas操作，主要来自两方面的racing, 1：线程池worker Thread的完成（异常，正常）状态设置； 2：同一futuretask，不同客户端线程callers的cancel操作。

 private void handlePossibleCancellationInterrupt(int s) {
        // It is possible for our interrupter to stall before getting a
        // chance to interrupt us.  Let's spin-wait patiently.
        if (s == INTERRUPTING)
            while (state == INTERRUPTING)
                Thread.yield(); // wait out pending interrupt

        // assert state == INTERRUPTED;

        // We want to clear any interrupt we may have received from
        // cancel(true).  However, it is permissible to use interrupts
        // as an independent mechanism for a task to communicate with
        // its caller, and there is no way to clear only the
        // cancellation interrupt.
        //
        // Thread.interrupted();
    }

当state处于Interrupting, 即caller即将调用worker thread.interrupt(), 所以worker thread自旋会，等会interrupt方法的调用，保留interrupt标志。

再来看看get()和带参数的get(timeout):

 public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)  //结果未设定的情况下
            s = awaitDone(false, 0L); //无条件等待
        return report(s);
    }

    /**
     * @throws CancellationException {@inheritDoc}
     */
    public V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException {
        if (unit == null)
            throw new NullPointerException();
        int s = state;
        if (s <= COMPLETING &&
            (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING) //等到timeout时间内，没完成，throws TimeoutException
            throw new TimeoutException();
        return report(s);
    }

awaitDone():

   private int awaitDone(boolean timed, long nanos)
        throws InterruptedException {
        final long deadline = timed ? System.nanoTime() + nanos : 0L; //计算出等待时间。
        WaitNode q = null;
        boolean queued = false;  //是否加入阻塞队列的标志
        for (;;) {
            if (Thread.interrupted()) { //阻塞该caller线程之前，caller线程被中断，直接throw 异常
                removeWaiter(q);    //在阻塞队列中移除该线程的封装node.此处无意义
                throw new InterruptedException();
            }

            int s = state; //读取state,阻塞前 recheck一下 是否完成？
            if (s > COMPLETING) { //完成了，直接返回，不要阻塞了
                if (q != null)
                    q.thread = null;
                return s;
            }
            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); //设为当前FutureTask阻塞链表（stack结构）的栈顶。
            else if (timed) {
                nanos = deadline - System.nanoTime(); //计算当前要阻塞的等待时间
                if (nanos <= 0L) {
                    removeWaiter(q); //小于0 直接返回，当前REMOVEWaiter无意义，并没有加入stack中。
                    return state;
                }
                LockSupport.parkNanos(this, nanos);本地native方法，阻塞当前线程。
            }
            else
                LockSupport.park(this); //无时间条件阻塞
        }
    }

无时间限制阻塞，有时间阻塞（阻塞时间大于task完成时间）会等到任务完成而给通知，唤醒该线程，即finishCompletion();而有时间阻塞（阻塞时间在task完成之间就已经结束的）会通过for()退出（退出前，删除等待队列中的节点）。

WaiterNode定义：

  static final class WaitNode {
        volatile Thread thread;
        volatile WaitNode next;
        WaitNode() { thread = Thread.currentThread(); } //当前阻塞线程的引用
    }

结合awaitDone()中的新阻塞节点加入顺序，其定位stack结构（Treiber stack）;

removeWaiter()：

 private void removeWaiter(WaitNode node) {
        if (node != null) {
            node.thread = null;
            retry:
            for (;;) {          // restart on removeWaiter race
                for (WaitNode pred = null, q = waiters, s; q != null; q = s) {
                    s = q.next;
                    if (q.thread != null)
                        pred = q;
                    else if (pred != null) {
                        pred.next = s;
                        if (pred.thread == null) // 检测竞争
                            continue retry; //发生重试
                    }
                    else if (!UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                          q, s))
                        continue retry;
                }
                break;
            }
        }
    }

finishCompletion():

 private void finishCompletion() {
        // assert state > COMPLETING;
        for (WaitNode q; (q = waiters) != 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;
                    q.next = null; // unlink to help gc
                    q = next;
                }
                break;
            }
        }

        done();

        callable = null;        // to reduce footprint
    }

其实，前面的分析可知，多个caller线程并发提交同一个FutureTask, 并且所谓调用get()阻塞的话(阻塞在该FutureTask上)，实际上也就一个caller线程阻塞，其他线程在调用该FutureTask的run()开始条件检查时，就直接return了，实际情况：三个并发线程提交同一个future task，对应生成三份FutureTask(不同于之前),三份FutureTask中对应三分Callable，而这三份Callable含有相同的FutureTask(所谓的相同任务) ，向ThreadPoolExecutor.submit(Runnable)实际上提交了三份Runnable(即生成的三分FutureTask)， FutureTask实现了Runnable接口， 然后ThreadPoolExecutor生成三个线程来执行这所谓的三个任务，这三个任务run()中都是调用对应内部的callable的call(), 而callable的call方法调用的是他们共同引用的FutureTask(同一个对像)的run()方法，而run方法， 我们上面解析过了,通过cas和状态检测，只运行一个worker thread 调用run()（见上），另外两个线程直接从共同底层FutureTask的run方法开始直接返回。

晕了？从头再来看看提交的过程：

1：submit(FutureTask(Runnable)):AbstractExecutorService

  public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
    }

 protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
        return new FutureTask<T>(runnable, value);
    }

2:生成三个FutureTask(其中runnable就是同一个底层FutureTask任务)：

    public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }

3:调用Executors.callable():

public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
    }

 static final class RunnableAdapter<T> implements Callable<T> {
        final Runnable task;
        final T result;
        RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
        }
        public T call() { //直接调用底层同一个FutureTask的run();
            task.run();
            return result;
        }
    }

即三次提交，生成三份FutureTask，每份FutureTask调用Executors.callable()为自己底层的callable赋值，而Executors.callable方法生成简单的Callable实现,其中call()，调用底层共同FutureTask的run(), 也就受共同futureTask内部状态（state, runThread）限制。所以，阻塞在底层共同FutureTask阻塞队列中的只有一个线程，看下例：

public class Test {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        Task task = new Task();
        int waitTime = 4000;
        CountDownLatch latch = new CountDownLatch(1);
        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
        for (int i = 0 ; i < 3; i++) {
            new Thread(new Submit(executor,  futureTask, latch, waitTime)).start();
        }
        try {
            Thread.sleep(3000);
            latch.countDown();
            Thread.sleep(8000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        System.out.println("所有任务执行完毕");
        executor.shutdown();
    }

}

class Submit implements Runnable {
    private CountDownLatch latch ;
    private ExecutorService es ;
    private FutureTask<Integer> task;
    private int waitTime ;
    public Submit(ExecutorService es, FutureTask<Integer> task, CountDownLatch latch, int waitTime) {
         this.latch = latch;
         this.es = es;
         this.task = task;
         this.waitTime = waitTime;
    }
    public void run() {
        try {
            latch.await();
            Future<?> future =  es.submit(task);
            System.out.println("Thread name : " + Thread.currentThread().getName() + " go!");
            waitTime = new Random().nextInt(waitTime);
            System.out.println("Thread name : " + Thread.currentThread().getName() + " , The wait time : =  " + waitTime );
            future.get(waitTime, TimeUnit.MILLISECONDS);
            System.out.println("Thread name : " + Thread.currentThread().getName() + " run over!");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e1) {
            e1.printStackTrace();
        } catch (TimeoutException e2) {
            System.err.println("Thread name : " + Thread.currentThread().getName()  + " " + e2);
        }
    }
}

class Task implements Callable<Integer>{

    public Integer call() throws Exception {
        System.out.println("thread name : " + Thread.currentThread().getName() + " do the work!");
        Thread.sleep(4000);
        int sum = 0;
        for(int i=0;i<20;i++)
            sum += i;
        return sum;
    }
}

class Task1 implements Runnable{
    int sum = 0;
    @Override
    public void run() {
        System.out.println("Thread Name : " + Thread.currentThread().getName() + "do the work!");
        try {
            Thread.sleep(6000);

            for(int i=0;i<100;i++)
                sum += i;
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

显示结果：

Thread name : Thread-2 go!
Thread name : Thread-0 go!
Thread name : Thread-0 , The wait time : =  2738
thread name : pool-1-thread-1 do the work!
Thread name : Thread-1 go!
Thread name : Thread-2 , The wait time : =  284
Thread name : Thread-1 , The wait time : =  678
Thread name : Thread-2 run over!
Thread name : Thread-0 run over!
Thread name : Thread-1 java.util.concurrent.TimeoutException
所有任务执行完毕

三个线程都是阻塞一段时间，但是只有一个超时，另外两个运行完毕，（他两实际工作那部分没运行，处理各自FutureTask那部分代码，所以只能看到线程池只有一个线程处理底层FutureTask）;

但，如果直接并发提交Callable,或者Runnable，线程池会启动三个线程来分别处理这三个不同任务，朋友可以自行试验demo下。而FutureTask是自己的自身的限制。

后话，一般调用ThreadPoolExecutor.submit()提交的是Callable<T>和Runnable, 返回的Future<T>, Future<?>(返回Null，或者不要求返回值)，提交FutureTask用不着，所以实际中不会遇见这种情况。

另外，本文源码基于jdk1.7，与网上1.7之前源码不同（1.6通过AQS实现）。