Android在框架層提供了異步任務類，AysncTask，用於執行後台任務，並將執行結果更新到UI線程。為什麼要用異步任務呢？這是因為如果某個任務太耗時間的話，會阻塞UI主線程，而我們知道UI線程如果阻塞5秒的話，就會發生ANR（Application No Response）錯誤 ，就算沒有發生，主界面上看起來也會卡卡的，這顯然用戶體驗就不太好了。
而AsyncTask類則在不影響UI線程的情況下，另起子線程去做那些耗時比較久的任務，比如我們在TodoList中去讀取圖片這種情況，然後將處理後的結果再更新到UI線程，從而達到更好的用戶體驗。
下面是AsyncTask類的定義：
public abstract class AsyncTask {
private static final String LOG_TAG = "AsyncTask";
...
從上面的代碼可以看出，AsyncTask是一個抽象類，所以在使用AsyncTask的時候，我們要繼承它，實現一個子類，並實現其中一個方法，如下：
class LoadImageTask extends AsyncTask{
@Override
protected ImageView doInBackground(String... params) {
String photoImagePath = params[0];
Bitmap bitmap = BitmapReader.readBigBitmapFromFile(photoImagePath,REQ_WIDTH);
ImageView imageView = Helper.createImageViewFromBitmap(DetailActivity.this, bitmap);
return imageView;
}
protected void onPostExecute(ImageView result) {
imageViews.add(result);
refreshGallery();
}
}
對照 AsyncTask的三個參數，Params, Progress和Result，是泛型參數。
1）Params ：參數，比如例子中定義的String類型，指向一個Image的路徑，這是傳給AysncTask的doInBackground方法。
2）Progress：這是在執行過程中會用到的一個參數，一般在顯示進度的時候會用到，在例子中不會用到，所以可以在這裡指定為Void。
3）Result：這是執行的結果對象，會作為onPostExecute方法的參數，在UI線程中處理。
由上面的例子也可以看到，一般我們實現的這個子類，要實現其中的兩個方法
1）doInBackground：這個方法，其實是在另外一個線程中執行的。
2）onPostExecute：而這個方法卻已經回到UI線程中來執行，所以可以在這裡將上一個方法中執行所得的結果在這裡更新到UI線程中。
那麼這裡面的機制是怎麼樣的呢，我們就來深入地看一下，也學習一下吧。
首先我們來看一下在Activity中，我們是怎麼樣來使用我們這個AsyncTask的吧，代碼如下：
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data){
if (requestCode == REQUEST_FOR_CAMERA) {
if(resultCode == RESULT_OK){
isPhotoTaken = true;
photoFileNames.add(tempPhotoFileName);
}
} else if (requestCode == REQUEST_FOR_GALLERY) {
if(resultCode == RESULT_OK){
isPhotoTaken = true;
ContentResolver resolver = getContentResolver();
Uri uri = data.getData();
tempPhotoFileName = Helper.getImagePath(resolver, uri);
photoFileNames.add(tempPhotoFileName);
}
}
new LoadImageTask().execute(tempPhotoFileName);//調用其execute方法
}
在TodoList的小demo中，在相機或者圖庫返回來圖片的路徑之後，我們就會調用AsynctTask的execute方法了，那麼這裡就是入口了。
進入AsyncTask類中，找到execute方法，如下：
public final AsyncTask execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
可以看到，這裡調用的是executeOnExecutor方法，我們繼續找：
public final AsyncTask 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;
}
在這個方法中，我們可以發現，AsynctTask定義了一個mStatus的成員變量，來表示異步任務的運行狀態，分別是pending，running和finished，但只有處於pending狀態的AsnycTask才能被執行。當狀態是Pending的時候，就會繼續執行，將狀態變成running，這樣能夠保證AsyncTask只會被執行一次。
接著會調用onPreExecute方法做一些處理工作，這個方法其實我們也可以在子類中自己實現，如果有什麼需要處理的話，一般不用。
然後我們發現，我們傳進來的參數params會被傳給mWorker，然後會有一個executor來執行execute的方法，並且執行的參數是一個mFuture對象。那麼這兩個東西是什麼呢？
接著看如下代碼：
public AsyncTask() {
mWorker = new WorkerRunnable() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
return postResult(doInBackground(mParams));
}
};
mFuture = new FutureTask(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 occured while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};
}
mWorker是一個WorkerRunnable對象，而實際上WorkerRunnable是AsyncTask的一個抽象內部類，實現了Callable接口，如下：
private static abstract class WorkerRunnable implements Callable {
Params[] mParams;
}
而在上面的賦值過程，通過匿名類實現了WorkerRunnable，並其call方法中將線程優先級調整為後台線程，然後會執行 doInBackground方法，不過現在還沒執行，咱們再看看FutureTask對象，下面是它的構造函數：
public FutureTask(Callable callable) {
if (callable == null)
throw new NullPointerException();
sync = new Sync(callable);
}
而FutureTask是Java多線程模型的一部分，其間接地實現了Runnable（線程屬性）接口和Future（異步任務）接口，而在上面的executeOnExecutor方法中，正是將mWorker（實現了Callable接口）對象傳給它了，並被其封裝到成員變量sync中，這樣它們就共同表示了一個異步任務，到這裡，一個異步任務也就創建完成了。
從上面executeOnExecutor的方法，也可以看到，真正執行execute是一個Executor，而在AsyncTask中，其實是SerialExecutor，我們看看其構造函數：
private static class SerialExecutor implements Executor {
final ArrayDeque mTasks = new ArrayDeque();
Runnable mActive;
public synchronized void execute(final Runnable r) {
mTasks.offer(new Runnable() {
public void run() {
try {
r.run();//在新線程中調用了我們上面傳進來的FutureTask的run方法
} finally {
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
從上面，我們可以看到execute方法的參數就是一個Runnable，其實也就是FutrueTask了，在這裡，它會被封裝到一個新的線程中作為一個任務添加到mTasks隊列中，至於下面如何在THREAD_POOL_EXECUTOR中去執行mTasks我們就不再深入下去了，我們就來看看FutureTask的run方法，如下：
public void run() {
sync.innerRun();
}
我們發現，它調用的是sync.innerRun()，那麼Sync的innerRun方法又干了什麼呢？
void innerRun() {
if (!compareAndSetState(READY, RUNNING))
return;
runner = Thread.currentThread();
if (getState() == RUNNING) { // recheck after setting thread
V result;
try {
result = callable.call();
} catch (Throwable ex) {
setException(ex);
return;
}
set(result);
} else {
releaseShared(0); // cancel
}
}我們發現，它調用了callable的call方法，啊，我們終於來到了mWorker的call方法，回過頭看，不就是在那裡調用了doInBackground方法的嗎？所以，我們可以確定，doInBackground的確是在一個新的線程中執行的，並且是一個後台線程。
但同時我們發現，其執行完之後，是作為一個參數傳遞給postResult的，繼續看下去：
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult(this, result));
message.sendToTarget();
return result;
}可以看到，在這裡是利用了sHandler來發送異步消息的，而sHandler是在AsynctTask中定義的，如下：
private static final InternalHandler sHandler = new InternalHandler();
InternalHandler定義如下
private static class InternalHandler extends Handler {
@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;
}
}
}
我們可以在這裡發現，如果是MESSAGE_POST_RESULT，則會調用mTask的finish方法，然後就結束了，而如果是MESSAGE_POST_PROGRESS，則會調用 onProgressUpdate方法，那麼，很顯然這個mTask應該就是我們定久的AsyncTask了吧。我們看看AsyncTaskResult是什麼先，
@SuppressWarnings({"RawUseOfParameterizedType"})
private static class AsyncTaskResult {
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}
}我們發現，在上面傳進來的AsyncTaskResult的參數task的正好就是this，而它又賦值給了mTask的，所以說明，這個mTask就是我們在Activity中定義的LoadImageTask了，而它是在主線程中定義的，那麼很顯然，它的finish方法也是在主線程，也就是UI線程中執行的了，再來看看這個finish方法：
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}在這裡，我們終於看到了onPostExecute方法的調用了，這說明了，onPostExecute就是在UI線程中干活的了。最後mStatus也被設計成FIINISHED了，這個異步任務也就結束了。
嗯，關於AsyncTask的基本原理到這裡也就結束了。
