編輯：關於Android編程
上篇分析AsyncTask的一些基本用法以及不同android版本下的區別，接著本篇我們就來全面剖析一下AsyncTask的工作原理。在開始之前我們先來了解一個多線程的知識點——Callable
Callable的接口定義如下:
public interface Callable{ V call() throws Exception; }
??Callable接口聲明了一個名稱為call()的方法，該方法可以有返回值V，也可以拋出異常。Callable也是一個線程接口，它與Runnable的主要區別就是Callable在線程執行完成後可以有返回值而Runnable沒有返回值，Runnable接口聲明如下：
public interface Runnable {
public abstract void run();
}
??那麼Callable接口如何使用呢，Callable需要和ExcutorService結合使用，其中ExecutorService也是一個線程池對象繼承自Executor接口，對於線程池的知識點不了解可以看看我的另一篇文章,這裡就不深入了，接著看看ExecutorService提供了那些方法供我們使用：
submit(Callable task)，傳遞一個實現Callable接口的任務，並且返回封裝了異步計算結果的Future。 submit(Runnable task, T result)，傳遞一個實現Runnable接口的任務，並且指定了在調用Future的get方法時返回的result對象。 submit(Runnable task)，傳遞一個實現Runnable接口的任務，並且返回封裝了異步計算結果的Future。Future submit(Callable task); Future submit(Runnable task, T result); Future submit(Runnable task);
??因此我們只要創建好我們的線程對象（實現Callable接口或者Runnable接口），然後通過上面3個方法提交給線程池去執行即可。Callable接口介紹就先到這，再來看看Future時什麼鬼。
??Future接口是用來獲取異步計算結果的，說白了就是對具體的Runnable或者Callable對象任務執行的結果進行獲取(get()),取消(cancel()),判斷是否完成等操作。其方法如下：
public interface Future{ //取消任務 boolean cancel(boolean mayInterruptIfRunning); //如果任務完成前被取消，則返回true。 boolean isCancelled(); //如果任務執行結束，無論是正常結束或是中途取消還是發生異常，都返回true。 boolean isDone(); //獲取異步執行的結果，如果沒有結果可用，此方法會阻塞直到異步計算完成。 V get() throws InterruptedException, ExecutionException; // 獲取異步執行結果，如果沒有結果可用，此方法會阻塞，但是會有時間限制， //如果阻塞時間超過設定的timeout時間，該方法將返回null。 V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException; }
總得來說Future有以下3點作用：
能夠中斷執行中的任務 判斷任務是否執行完成 獲取任務執行完成後額結果。??但是Future只是接口，我們根本無法將其創建為對象，於官方又給我們提供了其實現類FutureTask，這裡我們要知道前面兩個接口的介紹都只為此類做鋪墊，畢竟AsncyTask中使用到的對象是FutureTask。
先來看看FutureTask的實現：
public class FutureTaskimplements RunnableFuture {
顯然FutureTask類實現了RunnableFuture接口，我們再看一下RunnableFuture接口的實現：
public interface RunnableFutureextends Runnable, Future { void run(); }
??從接口實現可以看出，FutureTask除了實現了Future接口外還實現了Runnable接口，因此FutureTask既可以當做Future對象也可是Runnable對象，當然FutureTask也就可以直接提交給線程池來執行。接著我們最關心的是如何創建FutureTask對象，實際上可以通過如下兩個構造方法來構建FutureTask
public FutureTask(Callablecallable) { } public FutureTask(Runnable runnable, V result) { }
??從構造方法看出，我們可以把一個實現了Callable或者Runnable的接口的對象封裝成一個FutureTask對象，然後通過線程池去執行，那麼具體如何使用呢？簡單案例，CallableDemo.java代碼如下：
package com.zejian.Executor; import java.util.concurrent.Callable; /** * Callable接口實例 計算累加值大小並返回 */ public class CallableDemo implements Callable{ private int sum; @Override public Integer call() throws Exception { System.out.println("Callable子線程開始計算啦！"); Thread.sleep(2000); for(int i=0 ;i<5000;i++){ sum=sum+i; } System.out.println("Callable子線程計算結束！"); return sum; } }
CallableTest.java測試代碼如下：
package com.zejian.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
public class CallableTest {
public static void main(String[] args) {
//第一種使用方式
// //創建線程池
// ExecutorService es = Executors.newSingleThreadExecutor();
// //創建Callable對象任務
// CallableDemo calTask=new CallableDemo();
// //提交任務並獲取執行結果
// Future future =es.submit(calTask);
// //關閉線程池
// es.shutdown();
//第二中使用方式
//創建線程池
ExecutorService es = Executors.newSingleThreadExecutor();
//創建Callable對象任務
CallableDemo calTask=new CallableDemo();
//創建FutureTask
FutureTask futureTask=new FutureTask<>(calTask);
//執行任務
es.submit(futureTask);
//關閉線程池
es.shutdown();
try {
Thread.sleep(2000);
System.out.println("主線程在執行其他任務");
if(futureTask.get()!=null){
//輸出獲取到的結果
System.out.println("futureTask.get()-->"+futureTask.get());
}else{
//輸出獲取到的結果
System.out.println("futureTask.get()未獲取到結果");
}
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("主線程在執行完成");
}
}
??代碼非常簡單，注釋也很明朗，這裡我們分析一下第2種執行方式，先前聲明一個CallableDemo類，該類實現了Callable接口，接著通過call方法去計算sum總值並返回。然後在測試類CallableTest中，把CallableDemo實例類封裝成FutureTask對象並交給線程池去執行，最終執行結果將封裝在FutureTask中，通過FutureTask#get()可以獲取執行結果。第一種方式則是直接把Callable實現類丟給線程池執行，其結果封裝在Future實例中，第2種方式執行結果如下：
Callable子線程開始計算啦！ 主線程在執行其他任務 Callable子線程計算結束！ futureTask.get()-->12497500 主線程在執行完成
??ok~，到此我們對Callable、Future和FutureTask就介紹到這，有了這個知識鋪墊，我們就可以愉快的撩開AsyncTask的內部工作原理了。
??在上篇中，使用了如下代碼來執行AsyncTask的異步任務：
new AysnTaskDiff("AysnTaskDiff-1").execute("");
??從代碼可知，入口是execute方法，那我們就先看看execute的源碼：
@MainThread
public final AsyncTask execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
??很明顯execute方法只是一個殼子，直接調用了executeOnExecutor(sDefaultExecutor, params)，其中sDefaultExecutor是一個串行的線程池，接著看看sDefaultExecutor內部實現：
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
/**
* An {@link Executor} that executes tasks one at a time in serial
* order. This serialization is global to a particular process.
*/
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
//串行線程池類，實現Executor接口
private static class SerialExecutor implements Executor {
final ArrayDeque mTasks = new ArrayDeque();
Runnable mActive;
public synchronized void execute(final Runnable r) {
mTasks.offer(new Runnable() { //插入一個Runnble任務
public void run() {
try {
r.run();
} finally {
scheduleNext();
}
}
});
//判斷是否有Runnable在執行,沒有就調用scheduleNext方法
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
//從任務隊列mTasks中取出任務並放到THREAD_POOL_EXECUTOR線程池中執行.
//由此也可見任務是串行進行的。
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
??從源碼可以看出，ArrayDeque是一個存放任務隊列的容器（mTasks），任務Runnable傳遞進來後交給SerialExecutor的execute方法處理，SerialExecutor會把任務Runnable插入到任務隊列mTasks尾部，接著會判斷是否有Runnable在執行,沒有就調用scheduleNext方法去執行下一個任務，接著交給THREAD_POOL_EXECUTOR線程池中執行，由此可見SerialExecutor並不是真正的線程執行者，它只是是保證傳遞進來的任務Runnable（實例是一個FutureTask）串行執行，而真正執行任務的是THREAD_POOL_EXECUTOR線程池，當然該邏輯也體現AsyncTask內部的任務是默認串行進行的。順便看一下THREAD_POOL_EXECUTOR線程池的聲明：
//CUP核數
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
//核心線程數量
private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
//最大線程數量
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
//非核心線程的存活時間1s
private static final int KEEP_ALIVE = 1;
//線程工廠類
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);
public Thread newThread(Runnable r) {
return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
}
};
//線程隊列，核心線程不夠用時，任務會添加到該隊列中，隊列滿後，會去調用非核心線程執行任務
private static final BlockingQueue sPoolWorkQueue =
new LinkedBlockingQueue(128);
/**
* An {@link Executor} that can be used to execute tasks in parallel.
* 創建線程池
*/
public static final Executor THREAD_POOL_EXECUTOR
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
??ok~，關於sDefaultExecutor，我們先了解到這，回到之前execute方法內部調用的executeOnExecutor方法的步驟，先來看看executeOnExecutor都做了些什麼事？其源碼如下：
