談談 Callable 任務是怎么運行的？它的執行結果又是怎么獲取的?

談談 Callable 任務是怎么運行的？它的執行結果又是怎么獲取的？

向線程池提交Callable任務，會創建一個新線程(執行任務的線程)去執行這個Callable任務，但是通過Future#get獲取任務的執行結果是在提交任務的調用者線程中，那問題一：調用者線程如何獲取執行任務的線程的結果？

在JDK中，有2種類型的任務，Runnable和Callable，但是具體到線程池執行任務的java.util.concurrent.ThreadPoolExecutor#execute(Runnable)方法，它只接收Runnable任務，那問題二：Callable任務是提交給線程池后是如何執行的呢？

Callable 任務是怎么運行的?

import java.util.concurrent.*;

public class FutureTest {
    public static void main(String[] args) {
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                //sleep 是為了調試方便
                TimeUnit.SECONDS.sleep(4);
                return 3;
            }
        };
		//創建一個 ThreadPoolExecutor 對象
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        
        Future<Integer> future = executorService.submit(callable);

        try {
            Integer i = future.get();
            System.out.println(i);
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

Future<Integer> future = executorService.submit(callable);

//java.util.concurrent.AbstractExecutorService#submit(java.util.concurrent.Callable<T>)    
public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
    	//FutureTask其實是個RunnableFuture, RunnableFuture其實是個Runnable
    	//重點是: Runnable#run方法的執行,其實就是 FutureTask#run方法的執行!!!
        RunnableFuture<T> ftask = newTaskFor(task);
    	//java.util.concurrent.ThreadPoolExecutor#execute
        execute(ftask);
        return ftask;
    }

RunnableFuture<T> ftask = newTaskFor(task);

//java.util.concurrent.AbstractExecutorService#newTaskFor(java.util.concurrent.Callable<T>)
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
        return new FutureTask<T>(callable);
    }

當submit一個Callable任務時，會生成一個RunnableFuture接口對象，默認情況下 RunnableFuture對象是一個FutureTask對象。看java.util.concurrent.AbstractExecutorService類的源碼注釋：我們也可以重寫 newTaskFor 方法生成我們自己的 RunnableFuture。一個具體的示例可參考ES源碼org.elasticsearch.common.util.concurrent.PrioritizedEsThreadPoolExecutor#newTaskFor(java.util.concurrent.Callable<T>)，它就重寫了 newTaskFor 方法，實現了執行優先級任務時，獲取任務執行結果的邏輯。

the implementation of submit(Runnable) creates an associated RunnableFuture that is executed and returned. Subclasses may override the newTaskFor methods to return RunnableFuture implementations other than FutureTask

然后再來看FutureTask這個類的run()方法：java.util.concurrent.FutureTask#run，它會觸發執行我們定義的Callable#call()方法。搞清楚java.util.concurrent.FutureTask#run方法是怎么被調用的，就搞清楚了線程池執行Callable任務的原理。該方法主要是做了2件事：

• 執行Callable#call方法，即：FutureTest.java中 我們定義的處理邏輯：返回一個Integer 3
• 設置任務的執行結果：set(result)

java.util.concurrent.AbstractExecutorService#submit(java.lang.Runnable) 中execute(ftask)提交任務（注意：FutureTask implements Runnable）

ThreadPoolExecutor是AbstractExecutorService具體實現類，因此最終會執行到：java.util.concurrent.ThreadPoolExecutor#execute提交任務。

//java.util.concurrent.ThreadPoolExecutor#execute， 重點看addWorker()實現
if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }

java.util.concurrent.ThreadPoolExecutor#addWorker 有2行代碼很關鍵：

//java.util.concurrent.ThreadPoolExecutor#addWorker
try {
            w = new Worker(firstTask);//關鍵代碼1, firstTask 本質上是 FutureTask對象
            final Thread t = w.thread;
            if (t != null) {
              //...省略非關鍵代碼
                if (workerAdded) {
                    t.start();//關鍵代碼 2
                    workerStarted = true;
                }
            }
        }

w = new Worker(firstTask)創建一個新線程！把Worker作為this對象傳進去，因為Worker implements Runnable，並且實現了java.lang.Runnable#run方法。

        Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;//
            this.thread = getThreadFactory().newThread(this);
        }

這意味着啥？執行java.lang.Runnable#run 就會去真正地執行 java.util.concurrent.ThreadPoolExecutor.Worker#run，那么java.lang.Runnable#run是被誰調用的呢？

聰明的你一定知道了，new Thread(Runnable).start()執行時，會由jvm去自動調用java.lang.Runnable#run

所以，上面java.util.concurrent.ThreadPoolExecutor#addWorker 中的關鍵代碼2 t.start();，觸發了java.util.concurrent.ThreadPoolExecutor.Worker#run的調用。

java.util.concurrent.ThreadPoolExecutor.Worker#run里面只是調用了runWoker(this)而已。

//java.util.concurrent.ThreadPoolExecutor.Worker#run
/** Delegates main run loop to outer runWorker. */
        public void run() {
            runWorker(this);
        }

重點來了！再跟進去看看runWoker是何方神聖：

//java.util.concurrent.ThreadPoolExecutor#runWorker
final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;//task 實際上是FutureTask類型的對象
        w.firstTask = null;
        try {
            while (task != null || (task = getTask()) != null) {
              //省略一些 非關鍵代碼....
                try {
                    beforeExecute(wt, task);//
                    try {
                        //重點代碼！觸發 java.util.concurrent.FutureTask#run 執行
                        task.run();
                        afterExecute(task, null);
                    } catch (Throwable ex) {
                        //去看看afterExecute方法注釋,無論線程執行過程中是否拋異常,afterExecute()都會 執行,看了源碼,明白為什么是這樣了,因為catch異常處理里面會執行afterExecute
                        afterExecute(task, ex);
                        throw ex;
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }

看懂了java.util.concurrent.ThreadPoolExecutor#runWorker幾乎就明白線程池執行任務時的beforeExecute、afterExecute方法的所起的作用了(比如經常在afterExecute方法里面做一些線程池任務運行時間的統計工作)。

總結以下點：

• Callable任務被submit時，會生成一個FutureTask對象，封裝Callable，在FutureTask的run方法里面執行Callable#call方法，並且調用java.util.concurrent.FutureTask#set設置Callable任務的執行結果(結果保存在一個FutureTask的Object類型的實例變量里面：private Object outcome; )。

• Future<Integer> future = executorService.submit(callable);返回一個Future，它實際上是一個FutureTask對象，通過java.util.concurrent.FutureTask#get()獲取Callable任務的執行結果。

• java.util.concurrent.FutureTask#run方法是由java.util.concurrent.ThreadPoolExecutor#runWorker觸發調用的；而java.util.concurrent.ThreadPoolExecutor#runWorker又是由java.util.concurrent.ThreadPoolExecutor.Worker#run觸發調用的；而java.util.concurrent.ThreadPoolExecutor.Worker#run又是由java.util.concurrent.ThreadPoolExecutor#addWorker里面的t.start();這條語句觸發調用的；而t.start();會觸發Runnable#run方法的執行。這就是前面提到的這個原理：new Thread(Runnable).start()會由jvm來調用Runnable#run。具體可參考：

  用一個詞表示就是多態。用一張圖表示就是：

  ​

• 繼承 ThreadPoolExecutor 實現自定義的線程池時，可重寫 afterExecute()方法做一些異常處理邏輯的實現，不管任務正常執行完成、還是拋出異常，都會調用afterExecute()，具體可看JDK源碼關於ThreadPoolExecutor#runWorker方法的注釋。有興趣可研究下ES SEARCH線程池源碼就使用afterExecute來統計提交給線程池的每個任務的等待時間、執行時間，從而根據Little's law 自動調整線程池任務隊列的長度：org.elasticsearch.common.util.concurrent.QueueResizingEsThreadPoolExecutor#afterExecute

最后，想說的是：Callable任務，到ThreadPoolExecutor線程池執行 層面，它實際上是一個Runnable任務在執行。因為，ExecutorService submit Callable時，其實是將Callable封裝到FutureTask/RunnableFuture中，而RunnableFuture implements Runnable，因此可以提交給線程池的java.util.concurrent.ThreadPoolExecutor#execute(Runnable command)執行，這就回答了本文開頭提出的第二個問題。

//java.util.concurrent.RunnableFuture
public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */
    void run();
}

用一張圖表示就是：

Callable任務的設置與獲取，則都是在FutureTask這個層面上完成，把Callable封裝到FutureTask中，而FutureTask implements Runnable，從而轉化成ThreadPoolExecutor#execute執行Runnable任務。

Callable任務的執行結果又是怎么獲取的?Future.get為什么會阻塞？

java.util.concurrent.FutureTask 的private volatile int state;變量：

//java.util.concurrent.FutureTask#run
public void run() {
        if (state != NEW ||
            !RUNNER.compareAndSet(this, null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    //Callable#call執行成功, ran=true
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                //ran=true,才會設置Callable任務的執行結果
                if (ran)
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

set方法設置Callable任務的執行結果時，會修改 FutureTask的 state 實例變量的值！

	//java.util.concurrent.FutureTask#set   
	protected void set(V v) {
        if (STATE.compareAndSet(this, NEW, COMPLETING)) {
            outcome = v;
            STATE.setRelease(this, NORMAL); // final state
            finishCompletion();
        }
    }

而java.util.concurrent.FutureTask#get()方法，也正是通過檢查 state 的值，來確定是否能夠拿到Callable任務的執行結果。

    //java.util.concurrent.FutureTask#get()
	public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)
            //如果 state 不是在 NORMAL 狀態，FutureTask#get()就會阻塞
            //這就是 java.util.concurrent.Future#get() 阻塞的原因
            s = awaitDone(false, 0L);//這里面會調用：Thread.yield()、LockSupport.park(this)
        return report(s);
    }

java.util.concurrent.FutureTask#awaitDone

//java.util.concurrent.FutureTask#awaitDone
private int awaitDone(boolean timed, long nanos)
        throws InterruptedException {
    	WaitNode q = null;
		//省略一些無關代碼...
        for (;;) {//for循環一直檢查任務的運行狀態....直到可以"結束"
            int s = state;
            //state的值大於 COMPLETING 說明已經有Callable任務的結果了
            //java.util.concurrent.FutureTask#set 設置了Callable任務的結果,修改了state的值
            if (s > COMPLETING) {
                if (q != null)
                    q.thread = null;
                return s;
            }
            //COMPLETING 任務的運行狀態是：正在執行中
            else if (s == COMPLETING)
                // We may have already promised (via isDone) that we are done
                // so never return empty-handed or throw InterruptedException
                Thread.yield();//掛起獲取執行結果的線程（這就是Futur#get阻塞的原因）
            else if (Thread.interrupted()) {
                removeWaiter(q);//任務可能被中斷了,當然就不需要等待獲取執行結果了
                throw new InterruptedException();
            }
            else if (q == null) {
                if (timed && nanos <= 0L)
                    return s;
                q = new WaitNode();
            }
            else if (!queued)
                queued = WAITERS.weakCompareAndSet(this, q.next = waiters, q);
            //java.util.concurrent.Future#get(long, java.util.concurrent.TimeUnit)超時阻塞的實現原理
            else if (timed) {
                final long parkNanos;
                if (startTime == 0L) { // first time
                    startTime = System.nanoTime();
                    if (startTime == 0L)
                        startTime = 1L;
                    parkNanos = nanos;
                } else {
                    long elapsed = System.nanoTime() - startTime;
                    if (elapsed >= nanos) {
                        removeWaiter(q);
                        return state;
                    }
                    parkNanos = nanos - elapsed;
                }
                // nanoTime may be slow; recheck before parking
                if (state < COMPLETING)
                    LockSupport.parkNanos(this, parkNanos);
            }
            else
                LockSupport.park(this);
        }
    }

總結一下：通過 state變量來判斷Callable任務的執行結果是否已經生成。如果已經生成了執行結果，那么 java.util.concurrent.FutureTask#set會把結果放到private Object outcome;outcome這個變量中。然后設置state的值為NORMAL，那么java.util.concurrent.FutureTask#get()通過檢查 state 的值，就能拿到執行結果了，當然了，如果執行結果還未生成，java.util.concurrent.FutureTask#awaitDone就會導致 get 阻塞。

將Happens-Before的程序順序規則與其他某個順序規則(監視器鎖規則或者volatile變量規則)結合起來，從而對某個未被鎖保護的變量的訪問操作進行排序。那么，正如本文所分析的，某個未被鎖保護的變量就是Callable任務的執行結果outcome，而state就是一個volation修飾的變量，通過修改/讀寫 volatile 變量的值(即任務的運行狀態變量state)，從而實現了設置任務執行結果與獲取任務執行結果的排序---當一個線程調用set保存結果並且另一個線程調用get獲取結果時，這2個線程是按照Happens-Before進行排序的，它們是基於volatile 修飾的state 變量實現的，背后的原理就是： volatile 變量規則 。

原理參考：《Java並發編程實戰》第14章

最后的最后，留一個問題：由於JDK里面Future#get都是阻塞的，那有沒有什么方法使得獲取 Callable 任務的執行結果不阻塞？

看看Netty的源碼？借鑒一下Listener回調機制。哈哈……