上一節(jié)我們知道，想要啟動一個AsyncTask，首先需要創(chuàng)建一個AsyncTask對象然后調(diào)用execute方法。例如：
new DownloadFilesTask().execute();
DownloadFilesTask繼承自AsyncTask需要指定3個泛型參數(shù)：
private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
protected void onPreExecute() {
super.onPreExecute();
}
protected Long doInBackground(URL... urls) {
int count = urls.length;
long totalSize = 0;
for (int i = 0; i < count; i++) {
totalSize += Downloader.downloadFile(urls[i]);
publishProgress((int) ((i / (float) count) * 100));
// Escape early if cancel() is called
if (isCancelled()) break;
}
return totalSize;
}
protected void onProgressUpdate(Integer... progress) {
setProgressPercent(progress[0]);
}
protected void onPostExecute(Long result) {
showDialog("Downloaded " + result + " bytes");
}
}
一、AsyncTask構(gòu)造函數(shù)
首先先從AsyncTask的構(gòu)造函數(shù)說起：
/**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);
Binder.flushPendingCommands();
return postResult(result);
}
};
mFuture = new FutureTask<Result>(mWorker) {
@Override
protected void done() {
try {
postResultIfNotInvoked(get());
} catch (InterruptedException e) {
android.util.Log.w(LOG_TAG, e);
} catch (ExecutionException e) {
...
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};
}
在AsyncTask構(gòu)造函數(shù)中初始化了兩個對象：WorkerRunnable和FutureTask，分別賦值為mWorker、mFuture。這兩個對象初始化都實(shí)現(xiàn)了兩個回調(diào)方法，當(dāng)用戶執(zhí)行了execute方法的時候在特定情況下會觸發(fā)這兩個對象的回調(diào)方法，下面我們就開始詳細(xì)分析這兩個對象。
結(jié)論：doInBackground是在WorkerRunnable的call方法中被回調(diào)執(zhí)行的
WorkerRunnable【mWorker】
由于WorkerRunnable實(shí)現(xiàn)了Callable接口，所以在AsyncTask的構(gòu)造函數(shù)中實(shí)例化WorkerRunnable時，必須實(shí)現(xiàn)call()方法。其中還需要指定泛型參數(shù)Params和Result。這樣在回調(diào)了call方法之后，就能返回Result。
/** WorkerRunable類**/
private static abstrat class WorkerRunable<Params, Result> implements Callable<Result>
{
Params[] mParams;
}
/** Callable接口**/
public interface Callable<V>
{
V call() throws Exception;
}
現(xiàn)在我們暫時只需要知道當(dāng)執(zhí)行execute的時候會回調(diào)WorkerRunnable的call方法。
FutureTask【mFuture】
從上面的AsyncTask的構(gòu)造函數(shù)源碼中可以看到，在構(gòu)造FutureTask對象初始化時，mWorker是作為參數(shù)傳遞進(jìn)來的。從FutureTask的構(gòu)造函數(shù)也看出來了FutureTask需要一個Callable對象。
/** FutureTask的構(gòu)造函數(shù)**/
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}
【在這里不禁可以提前猜測出一個信息了，既然FutureTask把WorkerRunnable傳遞進(jìn)來了，那WorkerRunnable的回調(diào)方法call肯定是在FutureTask中調(diào)用的】
來看看FutureTask這個類：
可以看出，F(xiàn)utureTask是實(shí)現(xiàn)了RunnableFuture接口，而這個接口繼承了Runnable、以及Future。
通過上面兩個類，發(fā)現(xiàn)其實(shí)FutureTask中的get方法實(shí)現(xiàn)了Runnable的阻塞和返回執(zhí)行完畢的數(shù)據(jù)(泛型V)。
我們再來看FutureTask的run方法，豁然開朗，原來WorkerRunnable中的回調(diào)方法call果然是在這里調(diào)用的。
結(jié)論：WorkerRunnable中的回調(diào)方法call()是在執(zhí)行FutureTask的run方法后回調(diào)的。當(dāng)WorkerRunnable的call方法執(zhí)行完畢后將返回數(shù)據(jù)給FutureTask。
疑問：那么，F(xiàn)utureTask的run方法又是被誰調(diào)用的呢？
二、execute()方法
很顯然，F(xiàn)utureTask的run方法肯定需要AsyncTask執(zhí)行execute方法后才會執(zhí)行。
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
/** AsyncTask類的execute方法**/
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
當(dāng)執(zhí)行execute方法時，其實(shí)是調(diào)用的executeOnExecutor方法。這里傳遞了兩個參數(shù)，一個是sDefaultExecutor，一個是params。從上面的源碼可以看出，sDefaultExecutor其實(shí)是一個SerialExecutor對象。params其實(shí)最終會賦給doInBackground方法，就是用戶實(shí)現(xiàn)回調(diào)的方法，這個后面會看到。
executeOnExecutor
我們現(xiàn)在先來看executeOnExecutor方法。
/** AsyncTask類的executeOnExecutor方法**/
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
...
mStatus = Status.RUNNING;
onPreExecute();
mWorker.mParams = params;
exec.execute(mFuture);
return this;
}
看到木有？在這個方法中，最先先執(zhí)行了onPreExecute()方法，此時便會回調(diào)到用戶自定義AsyncTask的實(shí)現(xiàn)方法onPreExecute【看本文最頂部第一個例子的代碼】。onPreExecute可以用來做一些后臺任務(wù)執(zhí)行之前的準(zhǔn)備工作。
通過上面的代碼可以看出，執(zhí)行到exec.execute(mFuture)這里時傳遞進(jìn)去了一個mFuture，這個mFuture就是之前AsyncTask構(gòu)造初始化賦值的FutureTask。exec其實(shí)就是之前執(zhí)行AsyncTask.execute()方法時傳遞進(jìn)來的參數(shù)sDefaultExecutor，剛剛也說了這個sDefaultExecutor其實(shí)就是SerialExecutor對象。嗯，exec就是SerialExecutor對象。
SerialExecutor
我們可以看到，之前exec.execute(mFuture)執(zhí)行時，SerialExecutor將FutureTask作為參數(shù)執(zhí)行execute方法。在SerialExecutor的execute方法中，這里通過一個任務(wù)隊列mTasks把FutureTask插入進(jìn)了隊列中，執(zhí)行r.run，其實(shí)就是執(zhí)行FutureTask的run方法，因?yàn)閭鬟f進(jìn)來的r參數(shù)就是mFuture。
/** AsyncTask對象中的SerialExecutor成員變量【內(nèi)部類】 **/
private static class SerialExecutor implements Executor {
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
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) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
結(jié)論：FutureTask的run方法是在SerialExecutor的execute方法中執(zhí)行的。
其實(shí)在這里，SerialExecutor實(shí)現(xiàn)了一個任務(wù)的排隊算法。當(dāng)一個AsyncTask任務(wù)開始execute時，首先執(zhí)行FutureTask的run方法，然后finally執(zhí)行scheduleNext方法，然后執(zhí)行THREAD_POOL_EXECUTOR的execute方法。繼續(xù)往下，如果mActive為空，就會繼續(xù)調(diào)用scheduleNext方法執(zhí)行下一個AsyncTask任務(wù)，說白了就是當(dāng)mActive這個Runnable執(zhí)行完畢之后，才會繼續(xù)調(diào)用 THREAD_POOL_EXECUTOR.execute(mActive)。這樣SerialExecutor便實(shí)現(xiàn)了串行的任務(wù)隊列。
結(jié)論：SerialExecutor只是實(shí)現(xiàn)任務(wù)隊列，真正執(zhí)行線程池的是THREAD_POOL_EXECUTOR。
前面我們已經(jīng)知道，F(xiàn)utureTask的run方法在SerialExecutor的execute方法中執(zhí)行了，然后由 mTasks.offer 封裝成一個Runnable(mActive)給THREAD_POOL_EXECUTOR。
public static final Executor THREAD_POOL_EXECUTOR
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
到這里，F(xiàn)utureTask的run方法要開始回調(diào)WorkerRunable的call方法了。是不是已經(jīng)開始暈了，2333。撐住 !!!! 接下來我們還要看WorkerRunable的回調(diào)call方法：
oh my god ! 終于開始回調(diào)doInBackground方法了?？吹浆F(xiàn)在已經(jīng)很明白了，doInBackground的執(zhí)行不是在主線程中。
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
Result result = doInBackground(mParams);
Binder.flushPendingCommands();
return postResult(result);
}
};
doInBackground(mParams)執(zhí)行完后返回result，接著再繼續(xù)執(zhí)行postResult方法，并將返回的result作為參數(shù)傳遞進(jìn)去?，F(xiàn)在我們來看postResult方法，當(dāng)當(dāng)當(dāng)當(dāng)，Handler開始登場了。這里在執(zhí)行完doInBackground后直接發(fā)送了一個消息給Handler，那么這個Handler又是哪個呢？
private Result postResult(Result result) {
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
繼續(xù)看getHandler方法：
private static Handler getHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
sHandler = new InternalHandler();
}
return sHandler;
}
}
private static class InternalHandler extends Handler {
public InternalHandler() {
super(Looper.getMainLooper());
}
@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]);
break;
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}
之前執(zhí)行postResult的時候，obtainMessage傳遞的參數(shù)是：MESSAGE_POST_RESULT和AsyncTaskResult<Result>(this, result))，然后message.sendToTarget()開始發(fā)消息，并在InternalHandler的handleMessage中開始處理消息。
結(jié)論：doInBackground執(zhí)行完后立即發(fā)送了一個消息給InternalHandler
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
private static class AsyncTaskResult<Data> {
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}
由于傳遞的是MESSAGE_POST_RESULT，所以執(zhí)行mTask.finish方法。這個時候doInBackground已經(jīng)執(zhí)行完了并返回了result，便開始執(zhí)行onPostExecute方法，并將result傳遞進(jìn)去。因?yàn)镮nternalHandler是通過Looper.getMainLooper()獲得的，所以是在主線程，所以最后onPostExecute方法便又回到了主線程執(zhí)行。這個時候onPostExecute就可以拿到doInBackground異步執(zhí)行返回的result，直接更新UI。
