@Test
public void testSubmit() throws ExecutionException, InterruptedException {
    // 創(chuàng)建一個核心線程數(shù)為5的線程池
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 30, TimeUnit.SECONDS, new ArrayBlockingQueue<>(50));

    // 創(chuàng)建一個計算任務
    Callable<Integer> myTask = new Callable<Integer>() {

        @Override
        public Integer call() throws Exception {
            int result = 0;
            for (int i = 0; i < 10000; i++) {
                result += i;
            }
            Thread.sleep(1000);
            return result;
        }
    };

    log.info("start submit task .....");
    Future<Integer> future = threadPoolExecutor.submit(myTask);

    Integer sum = future.get();
    log.info("get submit result: [{}]", sum);

    // use sum do other things
}

// AbstractExecutorService#submit
public <T> Future<T> submit(Callable<T> task) {
    // 判空處理
    if (task == null) throw new NullPointerException();
    // 將提交的任務包裝成RunnableFuture
    RunnableFuture<T> ftask = newTaskFor(task);
    // 最終還是調用execute方法執(zhí)行任務
    execute(ftask);
    return ftask;
}

// AbstractExecutorService#newTaskFor
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
    // 調用FutureTask的構造方法返回RunnableFuture對象
    return new FutureTask<T>(callable);
}

// 存儲當前任務運行狀態(tài)
private volatile int state;
// 當前任務尚未執(zhí)行
private static final int NEW          = 0;
// 當前任務正在結束，尚未完全結束，一種臨界狀態(tài)
private static final int COMPLETING   = 1;
// 當前任務正常結束
private static final int NORMAL       = 2;
// 當前任務執(zhí)行過程中發(fā)生了異常
private static final int EXCEPTIONAL  = 3;
// 當前任務被取消
private static final int CANCELLED    = 4;
// 當前任務中斷中
private static final int INTERRUPTING = 5;
// 當前任務已中斷
private static final int INTERRUPTED  = 6;

// 存放真正提交的原始任務
private Callable<V> callable;

返回的結果或從get()中拋出的異常
private Object outcome;

//當前任務被線程執(zhí)行期間，保存當前任務的線程對象引用
private volatile Thread runner;

//因為會有很多線程去get當前任務的結果，所以這里使用了一種stack數(shù)據(jù)結構來保存
private volatile WaitNode waiters;

static final class WaitNode {
        volatile Thread thread;
        volatile WaitNode next;
        WaitNode() { thread = Thread.currentThread(); }
    }

public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        // 設置要執(zhí)行的任務
        this.callable = callable;
        // 初始化時任務狀態(tài)為NEW
        this.state = NEW;       
}

public void run() {
    // 狀態(tài)機不為NEW表示執(zhí)行完成或任務被取消了，直接返回
    // 狀態(tài)機為NEW，同時將runner設置為當前線程，保證同一時刻只有一個線程執(zhí)行run方法，如果設置失敗也直接返回
    if (state != NEW ||
        !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                     null, Thread.currentThread()))
        return;
    try {
        Callable<V> c = callable;
        // 取出原始的任務檢測不為空 且 再次檢查狀態(tài)為NEW(雙重校驗)
        if (c != null && state == NEW) {
            // 任務運行的結果
            V result;
            // 任務是否運行是否正常， true：正常， false-異常
            boolean ran;
            try {
                // 任務執(zhí)行，將結果返回給result
                result = c.call();
                // 設置任務運行正常
                ran = true;
            } catch (Throwable ex) {
                // 任務運行報錯的情況
                // 設置結果為空
                result = null;
                // 設置任務運行異常標記
                ran = false;
                // 任務執(zhí)行拋出異常時，保存異常信息，而不直接拋出
                setException(ex);
            }
            // 執(zhí)行成功則保存結果
            if (ran)
                set(result);
        }
    } finally {
        // runner must be non-null until state is settled to
        // prevent concurrent calls to run()
        // 執(zhí)行完成后設置runner為null
        runner = null;
        // state must be re-read after nulling runner to prevent
        // leaked interrupts
        // 獲取任務狀態(tài)
        int s = state;
        // 如果被置為了中斷狀態(tài)則進行中斷的處理
        if (s >= INTERRUPTING)
            handlePossibleCancellationInterrupt(s);
    }
}

protected void set(V v) {
    // 將狀態(tài)由NEW更新為COMPLETING
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        // 保存任務的結果
        outcome = v;
       // 更新狀態(tài)的最終狀態(tài)-NORMAL
        UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
        // 通用的完成操作，主要作用就是喚醒阻塞在waiters隊列中請求get的線程
        finishCompletion();
    }
}

// FutureTask#setException
protected void setException(Throwable t) {
    // 將狀態(tài)由NEW更新為COMPLETING
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        // 將異常信息保存到輸出結果中
        outcome = t;
        // 更新狀態(tài)機處理異常的最終狀態(tài)-EXCEPTIONAL
        UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
        // 通用的完成操作，主要作用就是喚醒阻塞在waiters隊列中請求get的線程
        finishCompletion();
    }
}

// 阻塞獲取任務結果
public V get() throws InterruptedException, ExecutionException {
    int s = state;
    // 任務還沒有執(zhí)行完成，通過awaitDone方法進行阻塞等待
    if (s <= COMPLETING)
        s = awaitDone(false, 0L);
    // 返回結果
    return report(s);
}

// 超時阻塞獲取任務結果
public V get(long timeout, TimeUnit unit)
    throws InterruptedException, ExecutionException, TimeoutException {
    // 判空處理
    if (unit == null)
        throw new NullPointerException();
    int s = state;
    // 任務還沒有執(zhí)行完成，通過awaitDone方法進行阻塞等待
    if (s <= COMPLETING &&
        // 如果awaitDone返回的結果還是小于等于COMPLETING，表示運行中，那么直接拋出超時異常
        (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
        throw new TimeoutException();
    // 返回結果
    return report(s);
}

// 線程阻塞等待方法， timed等于 true表示阻塞等待有時間限制nanos, false表示沒有，一直阻塞
private int awaitDone(boolean timed, long nanos) throws InterruptedException {
    // 計算阻塞超時時間點
    final long deadline = timed ? System.nanoTime() + nanos : 0L;
    WaitNode q = null;
    // 表示q是否添加到waiters棧中，默認false
    boolean queued = false;
    // 自旋操作
    for (;;) {
        // 如果阻塞線程被中斷則將當前線程從阻塞隊列中移除
        if (Thread.interrupted()) {
            // 從waiters棧中移除WaitNode，
            removeWaiter(q);
            // 返回中斷移除
            throw new InterruptedException();
        }

        // 獲取任務的狀態(tài)
        int s = state;
        // 如果任務的狀態(tài)大于COMPLETING，表示線程運行結束了，直接返回
        if (s > COMPLETING) { 
            // 任務已經完成時直接返回結果
            if (q != null)
                q.thread = null;
            // 返回狀態(tài)
            return s;
        }
        // 如果任務狀態(tài)是COMPLETING     
        else if (s == COMPLETING) 
            // 如果任務執(zhí)行完成，但還差最后一步最終完成，則讓出CPU給任務執(zhí)行線程繼續(xù)執(zhí)行
            Thread.yield();
        // 如果任務狀態(tài)小于COMPLETING，說明任務還在運行中
        // 如果q為空的情況    
        else if (q == null)
            // 新進來的線程添加等待節(jié)點
            q = new WaitNode();
        // 如果任務還在運行中并且當前線程節(jié)點還不在waiters棧中，那么就加入   
        else if (!queued)
            // 上一步節(jié)點創(chuàng)建完，還沒將其添加到waiters棧中，因此在下一個循環(huán)就會執(zhí)行此處進行入棧操作，并將當前線程的等待節(jié)點置于棧頂
            queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                 q.next = waiters, q);
        // 如果任務還在運行中并且timed為true，表示有超時限制
        else if (timed) {
            // 如果設置了阻塞超時時間，則進行檢查是否達到阻塞超時時間，達到了則刪除當前線程的等待節(jié)點并退出循環(huán)返回，否則繼續(xù)阻塞
            nanos = deadline - System.nanoTime();
            // 如果nanos小于等于0
            if (nanos <= 0L) {
                // 從waiters棧中移除
                removeWaiter(q);
                //返回狀態(tài)
                return state;
            }
            // 超時阻塞當前線程，超過時間，就會恢復
            LockSupport.parkNanos(this, nanos);
        }
        // 如果任務還在運行中并且timed為false，沒有有超時限制
        else
            // 一直阻塞當前線程
            LockSupport.park(this);
    }
}

// 獲取任務結果方法：正常執(zhí)行則直接返回結果，否則拋出異常
private V report(int s) throws ExecutionException {
    Object x = outcome;
    // 如果狀態(tài)是正常情況
    if (s == NORMAL)
        // 直接返回
        return (V)x;
    // 如果狀態(tài)是取消了，拋出異常
    if (s >= CANCELLED)
        throw new CancellationException();
    throw new ExecutionException((Throwable)x);
}

private void finishCompletion() {
    // 遍歷waiters棧中的每個元素;
    for (WaitNode q; (q = waiters) != null;) {
        // cas設置waiters中q節(jié)點數(shù)據(jù)為null，成功的話，進入到if中
        if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
            // 自選操作
            for (;;) {
                // 獲取節(jié)點中的線程
                Thread t = q.thread;
                if (t != null) {
                    q.thread = null;
                    // 喚醒線程
                    LockSupport.unpark(t);
                }
                // 獲取下一個節(jié)點
                WaitNode next = q.next;
                if (next == null)
                    break;
                q.next = null; // unlink to help gc
                q = next;
            }
            break;
        }
    }
	//鉤子方法，有子類去實現(xiàn)
    done();
    // 設置原來的任務callable為null
    callable = null;        // to reduce footprint
}

// 取消任務，參數(shù)mayInterruptIfRunning為true，會中斷運行中的線程，false不會
public boolean cancel(boolean mayInterruptIfRunning) {
    // 如果FutureTask的狀態(tài)不是NEW或者CAS設置失敗時，直接返回false
    if (!(state == NEW &&
          UNSAFE.compareAndSwapInt(this, stateOffset, NEW,
              mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
        return false;
    try {   
        // 如果參數(shù)mayInterruptIfRunning為true,中斷
        if (mayInterruptIfRunning) {
            try {
                Thread t = runner;
                if (t != null)
                    t.interrupt();
            } finally { // final state
                //cas修改狀態(tài)為INTERRUPTED
                UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
            }
        }
    } finally {
        // 喚醒其他等待的線程
        finishCompletion();
    }
    return true;
}