1. AsyncTask 框架圖
a. 線程相關(guān)接口
Callable 表示的任務(wù)可以拋出受檢查的或未受檢查的異常族檬，異常被封裝為ExecutionException中施无，并在Future::get()中重新拋出夫凸；
Future 表示一個任務(wù)的生命周期骗随，并提供了相應(yīng)的方法來判斷是否已經(jīng)完成或取消般码，以及獲取任務(wù)的結(jié)果和取消任務(wù)担锤。
RunnableFuture 是接口類，繼承Runnable儿礼、Future, 既包含抽象業(yè)務(wù)接口run,又添加監(jiān)控線程生命周期方法咖杂；
b. 線程實現(xiàn)類
FutureTask 表示一種抽象的可生成結(jié)果的計算；可以處于等待運(yùn)行蚊夫、正在運(yùn)行诉字、運(yùn)行完成；
運(yùn)行完成 表示計算的所有可能結(jié)束方式知纷，包括正常結(jié)束壤圃、由于取消、異常結(jié)束結(jié)束琅轧；
WorkerRunnable 保存AsyncTask execute傳遞的的具體業(yè)務(wù)的參數(shù), 重寫Callable call方法伍绳，調(diào)用doBackground執(zhí)行業(yè)務(wù)處理；
c. 線程池相關(guān)類
Executor 線程池接口
SerialExecutor是AsyncTask默認(rèn)的線程池類乍桂，作用使用ArrayDeque排隊任務(wù)冲杀，具體由ThreadPoolExecutor處理業(yè)務(wù)；
d. 消息處理類
InternalHandler 持有主線程的消息隊列
2.1 AsyncTask初始化
AsyncTask構(gòu)造函數(shù)
public AsyncTask() {
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
Result result = doInBackground(mParams); // a. 業(yè)務(wù)處理睹酌，并返回結(jié)果 b. 調(diào)用publishProgress返回實時進(jìn)度
Binder.flushPendingCommands();
return postResult(result); // 通過InternalHandler發(fā)送消息 MESSAGE_POST_RESULT 通知并更新UI主線程 參考2.7
}
};
mFuture = new FutureTask<Result>(mWorker) {
@Override
protected void done() {
try {
postResultIfNotInvoked(get()/*2.8 參考FutureTask::get()*/); // 先get結(jié)果权谁，然后通過postResult更新UI
} catch (InterruptedException e) {
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};
}
a. 創(chuàng)建WorkerRunnable用于保存任務(wù)的參數(shù)（params）；
b. FutureTask封裝WorkerRunable, 可獲取任務(wù)的生命周期
2.2 AsyncTask::execute()
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR; // 2.4 AsyncTask::SerialExecutor
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params); // 2.3
}
其中忍疾，sDefaultExecutor為SerialExecutor闯传， SerialExecutor中ArrayDeque保存當(dāng)前AsyncTask的任務(wù)隊列；
2.3 AsyncTask::executeOnExecutor
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
if (mStatus != Status.PENDING) {
switch (mStatus) {
case RUNNING:
case FINISHED:
} // 檢查線程所處的執(zhí)行狀態(tài)卤妒，只有PENDING才可以向下執(zhí)行
}
mStatus = Status.RUNNING;
onPreExecute(); // 任務(wù)執(zhí)行前業(yè)務(wù)邏輯
mWorker.mParams = params;
exec.execute(mFuture); // 2.4 AsyncTask::SerialExecutor::execute()
return this;
}
2.4 AsyncTask::SerialExecutor
private static final BlockingQueue<Runnable> sPoolWorkQueue = new LinkedBlockingQueue<Runnable>(128);
THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(.., sPoolWorkQueue, .. );
private static class SerialExecutor implements Executor {
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>(); // 保存任務(wù)
Runnable mActive;
public synchronized void execute(final Runnable r) {
mTasks.offer(new Runnable() {
public void run() {
try {
r.run();
} finally {
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) { // 業(yè)務(wù)邏輯的處理交給線程池ThreadPoolExecutor處理
THREAD_POOL_EXECUTOR.execute(mActive); // 2.5 FutureTask::run()
}
}
}
2.5 FutureTask::run()
public void run() {
if (state != NEW ||
!U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call(); // 回調(diào)WorkerRunnable::run(),參考2.1 AsyncTask初始化 ,
// 從此處可分析：業(yè)務(wù)執(zhí)行是由doInBackground完成
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if (ran)
set(result); // 保存結(jié)果甥绿，通過 get->report 可獲取
}
} 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);
}
}
2.6 InternalHandler
private static class InternalHandler extends Handler {
public InternalHandler() {
super(Looper.getMainLooper()); // 獲取UI主線程MessageQueue
}
@SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
@Override
public void handleMessage(Message msg) {
AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
switch (msg.what) {
case MESSAGE_POST_RESULT:
// There is only one result
result.mTask.finish(result.mData[0]); // 任務(wù)執(zhí)行完成，調(diào)用當(dāng)前AsyncTask的finish方法
break;
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData); // 更新UI
break;
}
}
}
2.7 通知并更新消息 postResult
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this/*當(dāng)前AsyncTask對象*/, result));
message.sendToTarget();
return result;
}
2.8 AsyncTask::get()
public final Result get() throws InterruptedException, ExecutionException {
return mFuture.get();
}
FutureTask回調(diào)call執(zhí)行完成之后则披，將結(jié)果保存在outcome, FutureTask的get取得此結(jié)果
