Android面試收集錄7 AsyncTask詳解
1.Android中的線程
在操作系統中，線程是操作系統調度的最小單元，同時線程又是一種受限的系統資源，即線程不可能無限制地產生，
並且 **線程的創建和銷毀都會有相應的開銷。**當系統中存在大量的線程時，
系統會通過會時間片輪轉的方式調度每個線程，因此線程不可能做到絕對的並行。
如果在一個進程中頻繁地創建和銷毀線程，顯然不是高效的做法。
正確的做法是采用線程池，一個線程池中會緩存一定數量的線程，
通過線程池就可以避免因為頻繁創建和銷毀線程所帶來的系統開銷。
2.AsyncTask簡介
AsyncTask是一個抽象類，它是由Android封裝的一個輕量級異步類（輕量體現在使用方便、代碼簡潔），
它可以在線程池中執行後臺任務，然後把執行的進度和最終結果傳遞給主線程並在主線程中更新UI。
AsyncTask的內部封裝了兩個線程池(SerialExecutor和THREAD_POOL_EXECUTOR)和一個Handler(InternalHandler)。
其中SerialExecutor線程池用於任務的排隊，讓需要執行的多個耗時任務，按順序排列，
THREAD_POOL_EXECUTOR線程池才真正地執行任務，InternalHandler用於從工作線程切換到主線程。
1.AsyncTask的泛型參數
AsyncTask的類聲明如下：
public abstract class AsyncTask<Params, Progress, Result>
AsyncTask是一個抽象泛型類。
其中，三個泛型類型參數的含義如下：
**Params：**開始異步任務執行時傳入的參數類型；
**Progress：**異步任務執行過程中，返回下載進度值的類型；
**Result：**異步任務執行完成後，返回的結果類型；
如果AsyncTask確定不需要傳遞具體參數，那麽這三個泛型參數可以用Void來代替。
有了這三個參數類型之後，也就控制了這個AsyncTask子類各個階段的返回類型，
如果有不同業務，我們就需要再另寫一個AsyncTask的子類進行處理。
2.AsyncTask的核心方法
onPreExecute()
這個方法會在**後臺任務開始執行之間調用，在主線程執行。
**用於進行一些界面上的初始化操作，比如顯示一個進度條對話框等。
doInBackground(Params...)
這個方法中的所有代碼都會在子線程中運行，我們應該在這裏去處理所有的耗時任務。
任務一旦完成就可以通過return語句來將任務的執行結果進行返回，如果AsyncTask的第三個泛型參數指定的是Void，就可以不返回任務執行結果。註意，在這個方法中是不可以進行UI操作的，如果需要更新UI元素，比如說反饋當前任務的執行進度，可以調用publishProgress(Progress...)方法來完成。
onPostExecute(Result)
當doInBackground(Params...)執行完畢並通過return語句進行返回時，這個方法就很快會被調用。返回的數據會作為參數傳遞到此方法中，可以利用返回的數據來進行一些UI操作，在主線程中進行，比如說提醒任務執行的結果，以及關閉掉進度條對話框等。
上面幾個方法的調用順序：
onPreExecute() --> doInBackground() --> publishProgress() --> onProgressUpdate() --> onPostExecute()
如果不需要執行更新進度則為onPreExecute() --> doInBackground() --> onPostExecute(),
3.AsyncTask的簡單使用
class DownloadTask extends AsyncTask<Void, Integer, Boolean> { @Override protected void onPreExecute() { progressDialog.show(); } @Override protected Boolean doInBackground(Void... params) { try { while (true) { int downloadPercent = doDownload(); publishProgress(downloadPercent); if (downloadPercent >= 100) { break; } } } catch (Exception e) { return false; } return true; } @Override protected void onProgressUpdate(Integer... values) { progressDialog.setMessage("當前下載進度：" + values[0] + "%"); } @Override protected void onPostExecute(Boolean result) { progressDialog.dismiss(); if (result) { Toast.makeText(context, "下載成功", Toast.LENGTH_SHORT).show(); } else { Toast.makeText(context, "下載失敗", Toast.LENGTH_SHORT).show(); } } }
這裏我們模擬了一個下載任務，在doInBackground()方法中去執行具體的下載邏輯，
在onProgressUpdate()方法中顯示當前的下載進度，在onPostExecute()方法中來提示任務的執行結果。
如果想要啟動這個任務，只需要簡單地調用以下代碼即可：
new DownloadTask().execute();
4.使用AsyncTask的註意事項
①異步任務的實例必須在UI線程中創建，即AsyncTask對象必須在UI線程中創建。
②execute(Params... params)方法必須在UI線程中調用。
③不要手動調用onPreExecute()，doInBackground(Params... params)，
onProgressUpdate(Progress... values)，onPostExecute(Result result)這幾個方法。
④不能在doInBackground(Params... params)中更改UI組件的信息。
⑤一個任務實例只能執行一次，如果執行第二次將會拋出異常。
3.AsyncTask的源碼分析
先從初始化一個AsyncTask時，調用的構造函數開始分析。
public AsyncTask() { mWorker = new WorkerRunnable<Params, Result>() { public Result call() throws Exception { mTaskInvoked.set(true); Result result = null; try { Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); //noinspection unchecked result = doInBackground(mParams); Binder.flushPendingCommands(); } catch (Throwable tr) { mCancelled.set(true); throw tr; } finally { postResult(result); } return 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) { throw new RuntimeException("An error occurred while executing doInBackground()", e.getCause()); } catch (CancellationException e) { postResultIfNotInvoked(null); } } }; }
這段代碼雖然看起來有點長，但實際上並沒有任何具體的邏輯會得到執行，只是初始化了兩個變量，mWorker和mFuture，並在初始化mFuture的時候將mWorker作為參數傳入。mWorker是一個Callable對象，mFuture是一個FutureTask對象，這兩個變量會暫時保存在內存中，稍後才會用到它們。 FutureTask實現了Runnable接口。
mWorker中的call()方法執行了耗時操作，即result = doInBackground(mParams);,然後把執行得到的結果通過postResult(result);,傳遞給內部的Handler跳轉到主線程中。在這裏這是實例化了兩個變量，並沒有開啟執行任務。
那麽mFuture對象是怎麽加載到線程池中，進行執行的呢？
接著如果想要啟動某一個任務，就需要調用該任務的execute()方法，因此現在我們來看一看execute()方法的源碼，
如下所示：
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
調用了executeOnExecutor()方法,具體執行邏輯在這個方法裏面：
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
if (mStatus != Status.PENDING) {
switch (mStatus) {
case RUNNING:
throw new IllegalStateException("Cannot execute task:"
+ " the task is already running.");
case FINISHED:
throw new IllegalStateException("Cannot execute task:"
+ " the task has already been executed "
+ "(a task can be executed only once)");
}
}
mStatus = Status.RUNNING;
onPreExecute();
mWorker.mParams = params;
exec.execute(mFuture);
return this;
}
可以 看出，先執行了onPreExecute()方法，然後具體執行耗時任務是在exec.execute(mFuture)，
把構造函數中實例化的mFuture傳遞進去了。
exec具體是什麽？
從上面可以看出具體是sDefaultExecutor，再追溯看到是SerialExecutor類，具體源碼如下：
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);
}
}
}
終於追溯到了調用了SerialExecutor 類的execute方法。SerialExecutor 是個靜態內部類，是所有實例化的AsyncTask對象公有的，SerialExecutor 內部維持了一個隊列，通過鎖使得該隊列保證AsyncTask中的任務是串行執行的，即多個任務需要一個個加到該隊列中，然後執行完隊列頭部的再執行下一個，以此類推。
在這個方法中，有兩個主要步驟。 ①向隊列中加入一個新的任務，即之前實例化後的mFuture對象。
②調用 scheduleNext()方法，調用THREAD_POOL_EXECUTOR執行隊列頭部的任務。
由此可見SerialExecutor 類僅僅為了保持任務執行是串行的，實際執行交給了THREAD_POOL_EXECUTOR。
THREAD_POOL_EXECUTOR又是什麽？
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
sPoolWorkQueue, sThreadFactory);
threadPoolExecutor.allowCoreThreadTimeOut(true);
THREAD_POOL_EXECUTOR = threadPoolExecutor;
實際是個線程池，開啟了一定數量的核心線程和工作線程。
。然後調用線程池的execute()方法。執行具體的耗時任務，即開頭構造函數中mWorker中call()方法的內容。
先執行完doInBackground()方法，又執行postResult()方法，下面看該方法的具體內容：
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
該方法向Handler對象發送了一個消息，下面具體看AsyncTask中實例化的Hanlder對象的源碼：
private static class InternalHandler extends Handler {
public InternalHandler() {
super(Looper.getMainLooper());
}
@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]);
break;
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}
在InternalHandler 中，如果收到的消息是MESSAGE_POST_RESULT，
即執行完了doInBackground()方法並傳遞結果，那麽就調用finish()方法。
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
如果任務已經取消了，回調onCancelled()方法，否則回調 onPostExecute()方法。
如果收到的消息是MESSAGE_POST_PROGRESS，回調onProgressUpdate()方法，更新進度。
InternalHandler是一個靜態類，為了能夠將執行環境切換到主線程，因此這個類必須在主線程中進行加載。
所以變相要求AsyncTask的類必須在主線程中進行加載。
到此為止，從任務執行的開始到結束都從源碼分析完了。
從上述源碼分析中分析得到，默認情況下AsyncTask的執行效果是串行的，
因為有了SerialExecutor類來維持保證隊列的串行。
如果想使用並行執行任務，那麽可以直接跳過SerialExecutor類，使用executeOnExecutor()來執行任務。
4.AsyncTask使用不當的後果
1.)生命周期
AsyncTask不與任何組件綁定生命周期，所以在Activity/或者Fragment中創建執行AsyncTask時，
最好在Activity/Fragment的onDestory()調用 cancel(boolean)；
2.)內存泄漏
如果AsyncTask被聲明為Activity的非靜態的內部類，那麽AsyncTask會保留一個對創建了AsyncTask的Activity的引用。
如果Activity已經被銷毀，AsyncTask的後臺線程還在執行，它將繼續在內存裏保留這個引用，導致Activity無法被回收，
引起內存泄露。
3.) 結果丟失
屏幕旋轉或Activity在後臺被系統殺掉等情況會導致Activity的重新創建，
之前運行的AsyncTask（非靜態的內部類）會持有一個之前Activity的引用，這個引用已經無效，
這時調用onPostExecute()再去更新界面將不再生效。
5.參考文章
https://github.com/LRH1993/android_interview/blob/master/android/basis/asynctask.md
Android面試收集錄7 AsyncTask詳解