1. 如果不是始狀態(tài)或者 cas 設(shè)置運(yùn)行線程是當(dāng)前線程不成功，直接返回，防止多個(gè)線程重復(fù)執(zhí)行。
2. 執(zhí)行 Callable 的 call()，即提交執(zhí)行任務(wù)（這里做了catch，會(huì)捕獲執(zhí)行任務(wù)的異常封裝到 outcome 中）。
3. 如果成功執(zhí)行 set 方法，封裝結(jié)果。

set 方法

protected void set(V v) {
    //cas方式設(shè)置成completing狀態(tài)，防止多個(gè)線程同時(shí)處理
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        outcome = v; // 封裝結(jié)果
        UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // 最終設(shè)置成normal狀態(tài)

        finishCompletion();
    }
}

解析如下：

1. cas方式設(shè)置成completing狀態(tài)，防止多個(gè)線程同時(shí)處理
2. 封裝結(jié)果到outcome，然后設(shè)置到最終狀態(tài)normal
3. 執(zhí)行finishCompletion方法。

finishCompletion方法

// state > COMPLETING; 不管異常，中斷，還是執(zhí)行完成，都需要執(zhí)行該方法來(lái)喚醒調(diào)用get方法阻塞的線程
private void finishCompletion() {
    // assert state > COMPLETING;
    for (WaitNode q; (q = waiters) != null;) {
        // cas 設(shè)置waiters為null，防止多個(gè)線程執(zhí)行。
        if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
            // 循環(huán)喚醒所有等待結(jié)果的線程
            for (;;) {
                Thread t = q.thread;
                if (t != null) {
                    q.thread = null;
                    //喚醒線程
                    LockSupport.unpark(t);
                }
                WaitNode next = q.next;
                if (next == null)
                    break;
                q.next = null; // unlink to help gc
                q = next;
            }
            break;
        }
    }
   //該方法為空，可以被重寫(xiě)
    done();
    callable = null;        // to reduce footprint
}

解析如下：

遍歷waiters中的等待節(jié)點(diǎn)，并通過(guò) LockSupport 喚醒每一個(gè)節(jié)點(diǎn)，通知每個(gè)線程，該任務(wù)執(zhí)行完成（可能是執(zhí)行完成，也可能 cancel，異常等）。

以上就是執(zhí)行的過(guò)程，接下來(lái)分析獲取結(jié)果的過(guò)程->get。

get 方法

public V get() throws InterruptedException, ExecutionException {
    int s = state;
    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;
        if (s <= COMPLETING &&
            (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
            throw new TimeoutException();
        return report(s);
    }

解析如下：

以上兩個(gè)方法，原理一樣，其中一個(gè)設(shè)置超時(shí)時(shí)間，支持最多阻塞多長(zhǎng)時(shí)間。
狀態(tài)如果小于 COMPLETING，說(shuō)明還沒(méi)到最終狀態(tài)，（不管是否是成功、異常、取消）。
調(diào)用 awaitDone 方法阻塞線程，最終調(diào)用 report 方法返回結(jié)果。

awaitDone 方法

private int awaitDone(boolean timed, long nanos)
        throws InterruptedException {
        final long deadline = timed ? System.nanoTime() + nanos : 0L;
        WaitNode q = null;
        boolean queued = false;
        for (;;) {
            //線程可中斷，如果當(dāng)前阻塞獲取結(jié)果線程執(zhí)行interrupt()方法，則從隊(duì)列中移除該節(jié)點(diǎn)，并拋出中斷異常
            if (Thread.interrupted()) {
                removeWaiter(q);
                throw new InterruptedException();
            }
            int s = state;
            // 如果已經(jīng)是最終狀態(tài)，退出返回
            if (s > COMPLETING) {
                if (q != null)
                    q.thread = null;
                return s;
            }
            //這里做了個(gè)優(yōu)化，competiting到最終狀態(tài)時(shí)間很短，通過(guò)yield比掛起響應(yīng)更快。
            else if (s == COMPLETING) // cannot time out yet
                Thread.yield();
            // 初始化該阻塞節(jié)點(diǎn)
            else if (q == null)
                q = new WaitNode();
            // cas方式寫(xiě)到阻塞waiters棧中
            else if (!queued)
                queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                     q.next = waiters, q);
            // 這里做阻塞時(shí)間處理。
            else if (timed) {
                nanos = deadline - System.nanoTime();
                if (nanos <= 0L) {
                    removeWaiter(q);
                    return state;
                }
                // 阻塞線程，有超時(shí)時(shí)間
                LockSupport.parkNanos(this, nanos);
            }
            else
                // 阻塞線程
                LockSupport.park(this);
        }
    }

解析如下：

整體流程已寫(xiě)到注解中，整體實(shí)現(xiàn)是放在一個(gè)死循環(huán)中，唯一出口，是達(dá)到最終狀態(tài)。
然后是構(gòu)建節(jié)點(diǎn)元素，并將該節(jié)點(diǎn)入棧，同時(shí)阻塞當(dāng)前線程等待運(yùn)行主任務(wù)的線程喚醒該節(jié)點(diǎn)。

report 方法

private V report(int s) throws ExecutionException {
    Object x = outcome;
    if (s == NORMAL)
        return (V)x;
    if (s >= CANCELLED)
        throw new CancellationException();
    throw new ExecutionException((Throwable)x);
}

然后是report方法，如果是正常結(jié)束，返回結(jié)果，如果不是正常結(jié)束（取消，中斷）拋出異常。

最后分析下取消流程。

cancel 方法

public boolean cancel(boolean mayInterruptIfRunning) {
    if (!(state == NEW &&
          UNSAFE.compareAndSwapInt(this, stateOffset, NEW,
              mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
        return false;
    try {    // in case call to interrupt throws exception
        if (mayInterruptIfRunning) {
            try {
                Thread t = runner;
                if (t != null)
                    t.interrupt();
            } finally { // final state
                UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
            }
        }
    } finally {
        finishCompletion();
    }
    return true;
}