FutureTask 深度解析

转自：http://blog.csdn.net/liulipuo/article/details/39029643

先看下FutureTask的注释吧

FutureTask一个可取消的异步计算，FutureTask 实现了Future的基本方法，提空 start cancel 操作，可以查询计算是否已经完成，

并且可以获取计算的结果。结果只可以在计算完成之后获取，get方法会阻塞当计算没有完成的时候，一旦计算已经完成，

那么计算就不能再次启动或是取消。

一个FutureTask 可以用来包装一个 Callable 或是一个runnable对象。因为FurtureTask实现了Runnable方法，所以一个 
FutureTask可以提交(submit)给一个Excutor执行(excution).

FutureTask 有两个很重要的属性 分别是 state  runner ，futureTask之所以可以支持cancel操作 就是因为这两个属性
其中 state为 枚举值：
NEW                            新建            0
COMPLETING             执行中        1
NORMAL                    正常            2
EXCEPTIONAL            异常            3
CANCELLED                取消            4
INTERRUPTING        中断中        5
INTERRUNPED            被中断        6
state的状态变化可以有四种方式
NEW->COMPLETING->NORMAL                            正常完成的流程
NEW->COMPLETING->EXCEPTIONAL                出现异常的流程
NEW->CANCELED                                                  被取消
NEW->INTERRUNPING->INTERRRUNPTED        被中断

我们研究下Task的状态变化也就是一个任务的生命周期:

我们创建一个FutureTask 首先会调用构造方法:

[java]  view plain  copy

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

在我们构造Task的时候会把状态 设置成 NEW 也就是所有 状态变化路径的起始状态

我们创建完一个Task 会提交给Executes来执行(当然我们也可以自己启动Thread来执行 效果基本是一样，只是交给线程池执行Task可能会延迟执行）。

在之后的Task生命周期的变化 主要取决于 run()方法先被调用还是cancel ()方法会被调用，这两个方法的执行顺序决定了Task的生命周期的四种走向

我们先分析run方法先被调用的情况，为了能对run()方法能更加详细的理解我在run方法中加了增加了些注释

[java]  view plain  copy

1. public void run() {  
2.         /** 
3.         *首先判断任务的状态 如果任务的状态不是new 说明任务的状态已经改变（说明他已经走了4种可能变化的一种） 
4.         * 如果状态是new就会把 当前执行任务的线程付给runner, 这里用的cmpandset如果runner不为空 说明已经有线程在执行 
5.     * 任务也会退出执行,如果状态是new并且runner为空并且把当前的线程付给了runner那么就继续执行任务(runner state 都是 volatile 
6.         *类型的变量是一个很轻量机的线程安全操作) 
7.         *引起state状态变化的原因 就是调用了cancel 或是 run 
8.         **/  
9.         if (state != NEW ||  
10.             !UNSAFE.compareAndSwapObject(this, runnerOffset,  
11.                                          null, Thread.currentThread()))  
12.             return;  
13.           
14.         //开始执行任务  
15.         try {  
16.             Callable<V> c = callable;  
17.             /** 
18.             * 如果 要执行的任务不为空 并且状态 new 就执行 
19.     
20.             ***/  
21.             if (c != null && state == NEW) {  
22.                 V result;  
23.                 boolean ran;  
24.                 try {  
25.                     //执行任务  
26.                     result = c.call();  
27.                     //如果没有意外发生就执行成功了  
28.                     ran = true;  
29.                 } catch (Throwable ex) {  
30.                         //有异常  
31.                     result = null;  
32.                     ran = false;  
33.                     //设置异常  
34.                     setException(ex);  
35.                 }  
36.                 //如果转型成功了 设置结果  
37.                 if (ran)  
38.                     (result);  
39.             }  
40.         } finally {  
41.             // runner must be non-null until state is settled to  
42.             // prevent concurrent calls to run()  
43.             //不管是否执行成功了 都把runner设置成null  
44.             runner = null;  
45.             // state must be re-read after nulling runner to prevent  
46.             // leaked interrupts  
47.             int s = state;  
48.             if (s >= INTERRUPTING)  
49.                 handlePossibleCancellationInterrupt(s);  
50.         }  
51.     }  

 Task执行后如果成功会调用set()方法,如果有异常会调用setException()方法。

我们先看下set方法 ：

[java]  view plain  copy

1. protected void set(V v) {  
2.         /** 
3.         *如过state是new 把state设置成 COMPLETING 
4.         * 
5.         **/  
6.           
7.       if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {  
8.           outcome = v;  
9.           //将任务设置成NORMAL   over the task  
10.           UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state  
11.           finishCompletion();  
12.       }  
13.   }  

如果现在的状态是NEW 就把状态设置成COMPLETING 然后设置成NORMAL。 这个执行流程导致的状态变化就是

NEW->COMPLETING->NORMAL    

执行步骤是 首先执行 run() 并且Task正常完成而且在这其间没有调用cancel()

上边是任务正常执行完成的状态变化，我们在看下有异常的情况。有异常的话会调用setException()方法:

[java]  view plain  copy

1. protected void setException(Throwable t) {  
2.      /** 
3.             *如过state是new 把state设置成 COMPLETING 
4.             * 
5.             **/  
6.         if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {  
7.             outcome = t;  
8.              //将任务设置成EXCEPTIONAL   
9.             UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state  
10.             finishCompletion();  
11.         }  
12.     }  

如果现在的状态是NEW 就把状态设置成COMPLETING 然后设置成EXCEPTIONAL。 这个执行流程导致的状态变化就是

NEW->COMPLETING->EXCEPTIONAL  
执行步骤是 首先执行 run() 并且Task抛出异常而且在这其间没有调用cancel()。

上文所分析的场景只是run()方法被调用了而在run()方法执行的过程中 调用cancel()并没有分析，两个方法有时间交集的情况我们稍后分析。

现在我们分析下cancel()方法先被调用的情况

上cancel()代码吧

[java]  view plain  copy

1. /这个方法有一个参数 是否中断running  
2.      public boolean cancel(boolean mayInterruptIfRunning) {  
3.           /** 
4.           * 这个有点晕啊逻辑关系是 
5.           * 等价与 if(state!=new || !UNSAFE.compareAndSwapInt(this, stateOffset, NEW, mayInterruptIfRunning ? INTERRUPTING : CANCELLED)) 
6.           * 这个意思是 如果state不是new 那么就退出方法，这时的任务任务坑是已经完成了 或是被取消了 或是被中断了 
7.           * 如果是state 是new 就设置state 为中断状态 或是取消状态 
8.           * 
9.           **/  
10.         if (!(state == NEW &&  
11.               UNSAFE.compareAndSwapInt(this, stateOffset, NEW,  
12.                   mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))  
13.             return false;  
14.         try {    // in case call to interrupt throws exception  
15.             //如果是可中断 那么就 调用系统中断方法 然后把状态设置成INTERRUPTED  
16.             if (mayInterruptIfRunning) {  
17.                 try {  
18.                     Thread t = runner;  
19.                     if (t != null)  
20.                         t.interrupt();  
21.                 } finally { // final state  
22.                     UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);  
23.                 }  
24.             }  
25.         } finally {  
26.             finishCompletion();  
27.         }  
28.         return true;  
29.     }  

这个方法很简单 ：

1.如果是cancel(false) 那么Task的状态变化就是

 NEW->=CANCELLED

2.如果是cancel(true)那么Task的状态化就是

 NEW->INTERRUPTING ->INTERRUPTED

至此Task的四种状态变化我们都看到了，不过这都是在两个方法都是单独执行的情况。

我们在分析下两个方法交叉执行的情况( run()->cancel() )：

1.如果Task已经执行然后再调用cancel():

     A：调用cancel(false)情况
           a：如果Task已经在执行而callable.call()没有返回 或是 call()已经返回但是state状态还没有改变
              那么任务调用cancel(false) 不会对任务的执行造成影响 只会影响task的状态 
           

           b：如果callable.call()已经返回并且状态已经变成COMPLETING或是 COMPLED 那么对任务执行 和任务状态都没有影响
    
    B：调用cancel(true)

          a：如果任务已经在执行而callable.call()没有返回 会把state设置成 INTERRUPTING然后调用执行线程的中断请求 然后把状态设置成INTERRUPTED,这里 如果
                callable.call()方法可以响应中断 可能对任务执行产生影响，如果方法不会响应中断不会对任务运行产生影响。影响任务的状态
      
          b：.如果任务已经在执行并且 call()已经返回但是state状态还没有改变  不会对任务的执行造成影响 只会影响任务的状态 。

2。调用cancel()后 在执行任务 ( cancel() -> run() )

      先调用cancel()无论是那种调用方式都会引起state状态的变化。在run()方法执行的时候发现state已经不是new了 就会放弃任务的执行