1 public class FutureTaskDemo {
 2     public static void main(String[]args)throws InterruptedException {
 3         FutureTask < Integer > ft = new FutureTask <  > (new Callable < Integer > () {
 4                  @Override 
 5                  public Integer call()throws Exception {
 6                     int num = new Random().nextInt(10);
 7                     TimeUnit.SECONDS.sleep(num);
 8                     return num;
 9                 }
10             });
11         Thread t = new Thread(ft);
12         t.start(); 
13         //这里可以做一些其它的事情，跟futureTask任务并行，等需要futureTask的运行结果时，可以调用get方法获取
14         try { 
15             //等待任务执行完成，获取返回值
16             Integer num = ft.get();
17             System.out.println(num);
18         } catch (Exception e) {
19             e.printStackTrace();
20         }
21     }
22 }

 1 public class FutureTask<V> implements RunnableFuture<V> { 
 2 /** * 当前任务的运行状态。 
 3 * 
 4 * 可能存在的状态转换 
 5 * NEW -> COMPLETING -> NORMAL（有正常结果） 
 6 * NEW -> COMPLETING -> EXCEPTIONAL（结果为异常） 
 7 * NEW -> CANCELLED（无结果） 
 8 * NEW -> INTERRUPTING -> INTERRUPTED（无结果） 
 9 */ 
10 private volatile int state; 
11 private static final int NEW = 0; //初始状态 
12 private static final int COMPLETING = 1; //结果计算完成或响应中断到赋值给返回值之间的状态。 
13 private static final int NORMAL = 2; //任务正常完成，结果被set 
14 private static final int EXCEPTIONAL = 3; //任务抛出异常 
15 private static final int CANCELLED = 4; //任务已被取消 
16 private static final int INTERRUPTING = 5; //线程中断状态被设置ture，但线程未响应中断 
17 private static final int INTERRUPTED = 6; //线程已被中断 
18 
19 //将要执行的任务 
20 private Callable<V> callable; //用于get()返回的结果，也可能是用于get()方法抛出的异常 
21 private Object outcome; // non-volatile, protected by state reads/writes //执行callable的线程，调用FutureTask.run()方法通过CAS设置 
22 private volatile Thread runner; //栈结构的等待队列，该节点是栈中的最顶层节点。 
23 private volatile WaitNode waiters; 
24 .... 

1 public interface RunnableFuture<V> extends Runnable, Future<V> {
2     void run();
3 }

 1 public interface Future<V> { 
 2     //取消任务 
 3     boolean cancel(boolean mayInterruptIfRunning); 
 4     //判断任务是否已经取消 
 5     boolean isCancelled(); 
 6     //判断任务是否结束（执行完成或取消） 
 7     boolean isDone(); 
 8     //阻塞式获取任务执行结果 
 9     V get() throws InterruptedException, ExecutionException; 
10     //支持超时获取任务执行结果 
11     V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException; 
12 }

 1 public void run() {
 2     //保证callable任务只被运行一次
 3     if (state != NEW || !UNSAFE.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread()))
 4         return;
 5     try {
 6         Callable < V > c = callable;
 7         if (c != null && state == NEW) {
 8             V result;
 9             boolean ran;
10             try { 
11                 //执行任务，上面的例子我们可以看出，call()里面可能是一个耗时的操作，不过这里是同步的
12                 result = c.call();
13                 //上面的call()是同步的，只有上面的result有了结果才会继续执行
14                 ran = true;
15             } catch (Throwable ex) {
16                 result = null;
17                 ran = false;
18                 setException(ex);
19             }
20             if (ran)
21                 //执行完了，设置result
22                 set(result);
23         }
24     }
25     finally {
26         runner = null;
27         int s = state;
28         //判断该任务是否正在响应中断，如果中断没有完成，则等待中断操作完成
29         if (s >= INTERRUPTING)
30             handlePossibleCancellationInterrupt(s);
31     }
32 }