FutureTask 深度解析

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

public void run() {
        /**
        *首先判断任务的状态 如果任务的状态不是new 说明任务的状态已经改变（说明他已经走了4种可能变化的一种）
        * 如果状态是new就会把 当前执行任务的线程付给runner, 这里用的cmpandset如果runner不为空 说明已经有线程在执行
   	* 任务也会退出执行,如果状态是new并且runner为空并且把当前的线程付给了runner那么就继续执行任务(runner state 都是 volatile
        *类型的变量是一个很轻量机的线程安全操作)
        *引起state状态变化的原因 就是调用了cancel 或是 run
        **/
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return;
        
        //开始执行任务
        try {
            Callable<V> c = callable;
            /**
            * 如果 要执行的任务不为空 并且状态 new 就执行
   
            ***/
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                	//执行任务
                    result = c.call();
                    //如果没有意外发生就执行成功了
                    ran = true;
                } catch (Throwable ex) {
                		//有异常
                    result = null;
                    ran = false;
                    //设置异常
                    setException(ex);
                }
                //如果转型成功了 设置结果
                if (ran)
                    (result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            //不管是否执行成功了 都把runner设置成null
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

  protected void set(V v) {
    	 	/**
    	 	*如过state是new 把state设置成 COMPLETING
    	 	*
    	 	**/
    	 	
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = v;
            //将任务设置成NORMAL   over the task
            UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
            finishCompletion();
        }
    }

protected void setException(Throwable t) {
     /**
    	 	*如过state是new 把state设置成 COMPLETING
    	 	*
    	 	**/
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = t;
             //将任务设置成EXCEPTIONAL 
            UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
            finishCompletion();
        }
    }

/这个方法有一个参数 是否中断running
     public boolean cancel(boolean mayInterruptIfRunning) {
     	  /**
     	  * 这个有点晕啊逻辑关系是
     	  * 等价与 if(state!=new || !UNSAFE.compareAndSwapInt(this, stateOffset, NEW, mayInterruptIfRunning ? INTERRUPTING : CANCELLED))
     	  * 这个意思是 如果state不是new 那么就退出方法，这时的任务任务坑是已经完成了 或是被取消了 或是被中断了
     	  * 如果是state 是new 就设置state 为中断状态 或是取消状态
     	  *
     	  **/
        if (!(state == NEW &&
              UNSAFE.compareAndSwapInt(this, stateOffset, NEW,
                  mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
            return false;
        try {    // in case call to interrupt throws exception
        	//如果是可中断 那么就 调用系统中断方法 然后把状态设置成INTERRUPTED
            if (mayInterruptIfRunning) {
                try {
                    Thread t = runner;
                    if (t != null)
                        t.interrupt();
                } finally { // final state
                    UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
                }
            }
        } finally {
            finishCompletion();
        }
        return true;
    }