使用AsyncTask的一般步驟是：
- 定義一個類繼承自
AsyncTask狠怨，實現(xiàn)抽象方法
- new 一個
AsyncTask對象 - 調(diào)用
execute()方法執(zhí)行任務
那么就一步一步來分析AsyncTask的實現(xiàn)原理侦厚，首先看構造函數(shù)
/** * Creates a new asynchronous task. This constructor must be invoked on the UI thread. */
public AsyncTask() {
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); //noinspection unchecked
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) {
throw new RuntimeException("An error occurred while executing doInBackground()", e.getCause());
}
catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
}}
構造函數(shù)很簡單盯质，就是初始化了2個全局的變量mWorker和mFuture括眠，并在創(chuàng)建mFuture的時候把mWorker作為參數(shù)傳遞進去彪标。其中mWorker實現(xiàn)了Callable，mFuture是一個FutureTask掷豺。關于Callable和FutureTask請參考
然后執(zhí)行execute()方法
@MainThreadpublic final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
調(diào)用了executeOnExecutor(sDefaultExecutor, params);捞烟，params就是execute()傳入的參數(shù)，這個sDefaultExecutor是在哪里定義的呢当船？
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
原來sDefaultExecutor是AsyncTask內(nèi)部的一個常量指向的是SerialExecutor题画。繼續(xù)跟進executeOnExecutor().
@MainThreadpublic 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;
}
從這個函數(shù)可以看出，AsyncTask一共有三種狀態(tài)德频，并且非PENDING狀態(tài)下調(diào)用execute()都會拋出異常
- PENDING 初始狀態(tài)
- RUNNING 執(zhí)行狀態(tài)
- FINISHED 完成狀態(tài)
第一次調(diào)用execute()會把狀態(tài)置為RUNNING苍息，任務完成時會把狀態(tài)置為FINISHED。這就要求一個AsyncTask只能執(zhí)行一次execute()只能完成一個后臺任務，如果需要處理多個任務竞思，只有重新創(chuàng)建一個AsyncTask表谊。
回到上面的函數(shù)，可以看到 onPreExecute()被最先調(diào)用盖喷，所以我們可以在這個回調(diào)中做一些初始化操作比如開始加載動畫（這就是execute()一般都會在UI線程調(diào)用的原因）爆办。然后把execute(Parem... param)傳遞過來的param賦值給在構造中初始化好的mWorker的mParams變量。
再執(zhí)行exec.execute(mFuture)课梳，其中exec是上文可以知道指向的是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就是mFuture
r.run();
}
finally {
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
可以看到這里調(diào)用了mFuture的run()方法，在來看看這個方法
public void run() {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
//這個的c就是mFuture創(chuàng)建時候暮刃，傳遞的參數(shù)mWorker
result = c.call();
ran = true;
}
}
注意c.call()跨算，這個c什么呢？其實就是在AsyncTask構造中創(chuàng)建mFuture的參數(shù)mWorker沾歪，轉了一大圈其實就是調(diào)用了mWorker.call()方法
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//調(diào)用doInBackground（）做后臺任務,mParams就是調(diào)用execute()時傳遞的參數(shù)
Result result = doInBackground(mParams);
Binder.flushPendingCommands();
return postResult(result);
}
};
可以看到在這個方法中回調(diào)了doInBackground(mParams)漂彤，而參數(shù)就是我們調(diào)用execute()時傳遞的參數(shù)。因為WorkerRunnable是實現(xiàn)Runnable接口的所以doInBackground的確是在子線程中執(zhí)行的灾搏。
在doInBackground(mParams)完成我們自己的后臺邏輯之后挫望，把結果作為參數(shù)傳遞給了postResult(result)
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
private static Handler getHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
sHandler = new InternalHandler();
} return sHandler;
}
}
private static class InternalHandler extends Handler {
public InternalHandler() {
//獲取主線程Looper來構造Handler
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;
}
}
}
這里代碼比較簡單，就是后臺任務返回結果后狂窑，把結果封裝進message發(fā)送媳板，Handler接受到消息后，根據(jù)消息類型執(zhí)行不同的邏輯泉哈。我們看到有2種消息類型,MESSAGE_POST_RESULT就是后臺任務完成了蛉幸，而MESSAGE_POST_PROGRESS看命名也大概知道了，沒錯丛晦，就是我們調(diào)用publishProgress()更新進度的時候就會發(fā)送這個類型的消息
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
注意 : 3.0 以后奕纫，默認會使用主線程的Looper來構造handler，所以不管AsyncTask在那個線程創(chuàng)建或者execute()在那個線程調(diào)用烫沙，
onPostExecute(result)匹层，publishProgress()都是在主線程執(zhí)行
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
finish()中判斷后臺任務時候取消過，是锌蓄，onPostExecute(result)就不再調(diào)用升筏，而是回調(diào)onCancelled(result)。并且設置狀態(tài)瘸爽，保證AsyncTask只能執(zhí)行一次您访。
3.0之后，AsyncTask默認是串行執(zhí)行任務的剪决，來看看是怎么實現(xiàn)串行的
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就是mFuture
r.run();
}
finally {
//上一個任務執(zhí)行完畢后灵汪，才會從隊列中取出下一個任務
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
//取出隊列頭部的任務
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
調(diào)用AsyncTask.execute()后會調(diào)用SerialExecutor.execute()檀训，這是AsyncTask中維護的一個靜態(tài)串行控制器，不管創(chuàng)建多少個AsyncTask都會使用同一個SerialExecutor來完成串行控制识虚。
ArrayDeque是一個線性雙向隊列肢扯，每一次調(diào)用SerialExecutor.execute()都會把傳進來的任務（FutureTask）加入到這個隊列中。首先判斷mActive是否為空第一次肯定是null担锤，調(diào)用schecduleNext()會從隊列中取出頭部任務蔚晨，交給AsyncTask維護的線程池去執(zhí)行，第二次mActive肛循！=null铭腕，schecduleNext()就執(zhí)行不到，那如果第二個任務怎么執(zhí)行呢多糠？注意try..finally中的邏輯累舷，在前一個.run執(zhí)行完之后，才會又一次schecduleNext()被執(zhí)行夹孔。這就實現(xiàn)了任務的串行控制
SerialExecutor是一個串行控制器被盈，他會把加入的任務按順序加入到任務隊列中，給任務排序搭伤，然后一個一個去處交給AsyncTask中維護的線程池執(zhí)行只怎。
AsyncTask中維護的線程池是一個ThreadPoolExecutor，這是一個并發(fā)線程池怜俐，3.0以前默認同一時刻運行的線程數(shù)是5個身堡，最大線程數(shù)是128個，3.0以后根據(jù)CPU配置而定拍鲤。
所以贴谎，在3.0以后我們也是可以讓AsyncTask并行執(zhí)行的，就是不讓SerialExecutor來控制任務的串行季稳，即調(diào)用AsyncTask.executeOnExcutor(THREAD_POOL_EXECUTOR)擅这，參數(shù)參入線程池的引用，這樣任務就跳過了排序景鼠，被直接交給了線程池去執(zhí)行蕾哟。
AsyncTask的缺點
AsyncTask我們肯定都用過，優(yōu)點就不說了莲蜘，使用簡單，簡化代碼帘营，過程可控票渠。我們來說一說它的缺點
使用不當可能造成內(nèi)存泄漏。因為涉及到異步操作芬迄，非靜態(tài)內(nèi)部類/匿名內(nèi)部類AsyncTask都有可能引起activity的泄漏
任務有沒有正確取消導致nullPointer问顷。AsyncTask并不會隨著創(chuàng)建它的activity的生命周期的結束而結束，相反它會一直執(zhí)行直到
doInBackground()方法執(zhí)行完畢，如果我們的Activity銷毀之前杜窄，沒有取消 AsyncTask肠骆，就有可能引起Crash，因為它想要處理的view已經(jīng)不存在了塞耕。并且蚀腿，就算調(diào)用cancle(true)來取消任務，也不一定保證成功扫外，因為這個方法是調(diào)用Thread.interrupt()莉钙，如果正在做一個IO操作，還會拋出ClosedByInterruptException異常結果丟失筛谚。屏幕旋轉或Activity在后臺被系統(tǒng)殺掉等情況會導致Activity的重新創(chuàng)建磁玉，之前運行的AsyncTask會持有一個之前Activity的引用，這個引用已經(jīng)無效驾讲，這時調(diào)用
onPostExecute()再去更新界面將不再生效蚊伞。
的確以上都是在使用AsnycTask過程中可能遇到的問題，但是我認為這些都不是AsyncTask自身的缺陷吮铭，而是程序猿代碼設計的問題时迫，因為使用
Thread+handler或者相似的類庫都可能出現(xiàn)同樣的問題。比如內(nèi)存泄漏沐兵，我們完全可以用靜態(tài)內(nèi)部類+弱引用别垮、或者是用MVP解耦來解決。對于cancle()可能不正常取消扎谎，那也是Thread的問題碳想。
** AsyncTask真正的缺點是處理多個任務和控制串行、并行**
- 多任務處理毁靶，通過源碼我們知道一個AsyncTask調(diào)用一次execute()處理一次后臺任務胧奔，如果有多個任務的時候只能多次創(chuàng)建，就像這樣的代碼
task1.execute()
task2.execute()
task3.execute()
我們還得關心每個task的回調(diào)预吆，每一個任務的cancle處理龙填，并且如果每個任務需要的泛型參數(shù)不同的話，就的寫多個AsyncTask拐叉。
-
串行岩遗、并行控制。AsyncTask內(nèi)部維護了一個靜態(tài)并發(fā)線程池THREAD_POOL_EXECUTOR和一個靜態(tài)串行任務執(zhí)行器**SERIAL_EXECUTOR **凤瘦，這個執(zhí)行器中實現(xiàn)了串行控制宿礁，會循環(huán)的取出一個個任務交給并發(fā)線程池去執(zhí)行 。也就是說同時有多個
Task.execute的時候蔬芥，其實也是按順序一個一個串行執(zhí)行的梆靖。如果確實需要并行執(zhí)行的時候控汉，就需要手動調(diào)用AsyncTask.executeOnExecutor(THREAD_POOL_EXECUTOR, Params... params)傳入上述靜態(tài)并發(fā)線程池。所以返吻，AsyncTask在處理串并行的時候還是顯得比較尷尬
總結
AsyncTask的內(nèi)部封裝線程池和Handler姑子，暴露不同的執(zhí)行在不同線程的回調(diào)函數(shù)，大大簡化程序猿寫子線程處理耗時任務--主線程刷新UI的邏輯测僵。
常常在網(wǎng)上或者面試的時候被問到為什么AsyncTask必須在主線程創(chuàng)建或者execute()必須在主線程執(zhí)行街佑？
我覺得這種說法至少不準確的，的分版本恨课，3.0以前舆乔，創(chuàng)建AsyncTask的時候會根據(jù)當前線程創(chuàng)建一個Handler，如果是子線程而我們又沒有手動初始化Looper剂公，程序會直接crash（而3.0以后會默認用主線程Looper創(chuàng)建Handler）onPostExecute()希俩，publishProgress()等回調(diào)都會執(zhí)行在AsyncTask創(chuàng)建的的線程，execute()中會回調(diào)onPreExecute()纲辽，如果我們在這些回調(diào)中更新UI就一定會拋出異常颜武。
所以，3.0以前創(chuàng)建AsynacTask必須在主線程拖吼，而3.0以后只要不在
onPreExecute()鳞上，publishProgress()，onPostExecute()回調(diào)中更新UI吊档，AsyncTask完全可以不在主線程創(chuàng)建篙议。但是這明顯跟我們?nèi)粘５氖褂孟嚆?/p>
