public class Test {
    //計算結果
    int count=0;
    @Test
    public void test(){
        try{  
            FutureTask<Integer> futureTask=new FutureTask<>(new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    return 1;
                }
            });
            //把FutureTask放入線程中,線程會運行FutureTask的run()代碼塊
            Thread t1=new Thread(futureTask);
            t1.start();
            //獲取計算的結果,是一個阻塞等待返回的方法
            count+=futureTask.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        //最后結果: 1
        System.out.println(count);    
    }
}

/**
    執(zhí)行結果(全局變量), 有2種情況:
    1. 順利完成返回的結果
    2. 執(zhí)行run()代碼塊過程中拋出的異常
*/
private Object outcome; 
//正在執(zhí)行run()的線程, 內存可被其他線程可見
private volatile Thread runner;
???????public void run() {
    /**
        FutureTask的run()僅執(zhí)行一次的原因：
        1. state != NEW表示任務正在被執(zhí)行或已經完成, 直接return
        2. 若state==NEW, 則嘗試CAS將當前線程 設置為執(zhí)行run()的線程,如果失敗,說明已經有其他線程 先行一步執(zhí)行了run(),則當前線程return退出
    */
    if (state != NEW ||!UNSAFE.compareAndSwapObject(this, runnerOffset,null, Thread.currentThread()))
        return;
    try {
        //持有Callable的實例,后續(xù)會執(zhí)行該實例的call()方法
        Callable<V> c = callable;
        if (c != null && state == NEW) {
            V result;
            boolean ran;
            try {
                result = c.call();
                ran = true;
            }catch (Throwable ex) {
                result = null;
                ran = false;
                //執(zhí)行中拋的異常會放入outcome中保存
                setException(ex);
            }
            if (ran)
                //若無異常, 順利完成的執(zhí)行結果會放入outcome保存
                set(result);
        }
    }finally {
        // help GC 
        runner = null;
        int s = state;
        if (s >= INTERRUPTING)
            handlePossibleCancellationInterrupt(s);
    }
}

public V get() throws InterruptedException, ExecutionException {    
       int s = state;
       //COMPLETING: 正在完成的狀態(tài);  s <= COMPLETING就是未完成
    if (s <= COMPLETING)
        //不計時等待,結束等待的條件只有【完成】、【被中斷】、【被取消】、【拋其他異常(不包括中斷異常、取消異常)】
        s = awaitDone(false, 0L);
    return report(s);    
}

private volatile int state;
//線程創(chuàng)建狀態(tài)
private static final int NEW = 0;
//完成(**一個瞬時的標記**)   
private static final int COMPLETING = 1;
//正常完成狀態(tài)
private static final int NORMAL = 2;
//執(zhí)行過程出現異常
private static final int EXCEPTIONAL = 3;
//執(zhí)行過程中被取消
private static final int CANCELLED = 4;
//線程執(zhí)行被中斷(**一個瞬時的標記**)
private static final int INTERRUPTING = 5;
//線程執(zhí)行被中斷的狀態(tài)
private static final int INTERRUPTED = 6;

/**
    @param timed 若是true則為定時等待,超時后會結束等待,并返回當前狀態(tài)state
    @param nanos 如果是定時等待即第一個入參timed=true的話,會設置對應的等待時長
*/
private int awaitDone(boolean timed, long nanos) throws InterruptedException {
    //等待的最后期限
    final long deadline = timed ? System.nanoTime() + nanos : 0L;
    WaitNode q = null;
    boolean queued = false;
    //進入無限循環(huán)的等待狀態(tài),只有【完成】、【被取消】、【異?！俊ⅰ局袛唷?、【超時】這五種情況才會結束等待
    for (;;) {
        if (Thread.interrupted()) {
            //線程執(zhí)行被中斷,則移除等待結點并拋出異常
            removeWaiter(q);
            throw new InterruptedException();
        }
         int s = state;
        //【完成】、【被取消】、【拋其他異?！康臓顟B(tài)都會 在這 結束等待
        if (s > COMPLETING) {
            if (q != null)
                q.thread = null;
            return s;
        }
        //子線程處于任務完成的瞬時狀態(tài),要等一會才能拿到執(zhí)行結果
        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);
        else if (timed) {
            //設置定時等待并且已經超時了
            nanos = deadline - System.nanoTime();
            if (nanos <= 0L) {
                removeWaiter(q);
                return state;
            }
            LockSupport.parkNanos(this, nanos);
        }
        else
            LockSupport.park(this);       
    }
}

/*正常的計算結果 or 拋出的異常 都會作為outcome*/
private Object outcome;
private V report(int s) throws ExecutionException {
    Object x = outcome;
    //正常完成
    if (s == NORMAL)
        return (V)x;
    //執(zhí)行的過程中【被取消】
    if (s >= CANCELLED)
        throw new CancellationException();
    /**
        這里拋的是執(zhí)行過程中發(fā)生的其他異常,既不是【中斷異?！?也不是【被取消異常】
        比如發(fā)生了RuntimeException之類的就會在這拋
    */    
    throw new ExecutionException((Throwable)x);
}

public class FutureTask<V> implements RunnableFuture<V> {
    //執(zhí)行任務并返回結果
    private Callable<V> callable;
    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        //新建狀態(tài)
        this.state = NEW;
    }
}