Android中從源碼分析關於AsyncTask的使用

Android在架構層提供了非同步任務類，AysncTask，用於執行背景工作，並將執行結果更新到UI線程。為什麼要用非同步任務呢？這是因為如果某個任務太耗時間的話，會阻塞UI主線程，而我們知道UI線程如果阻塞5秒的話，就會發生ANR（Application No Response）錯誤 ，就算沒有發生，主介面上看起來也會卡卡的，這顯然使用者體驗就不太好了。

而AsyncTask類則在不影響UI線程的情況下，另起子線程去做那些耗時比較久的任務，比如我們在TodoList中去讀取圖片這種情況，然後將處理後的結果再更新到UI線程，從而達到更好的使用者體驗。

下面是AsyncTask類的定義：

public abstract class AsyncTask<Params, Progress, Result> {    private static final String LOG_TAG = "AsyncTask";    ...

從上面的代碼可以看出，AsyncTask是一個抽象類別，所以在使用AsyncTask的時候，我們要繼承它，實現一個子類，並實現其中一個方法，如下：

class LoadImageTask extends AsyncTask<String, Void, ImageView>{@Overrideprotected 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的吧，代碼如下：

@Overrideprotected 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<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;    }

在這個方法中，我們可以發現，AsynctTask定義了一個mStatus的成員變數，來表示非同步任務的運行狀態，分別是pending，running和finished，但只有處於pending狀態的AsnycTask才能被執行。當狀態是Pending的時候，就會繼續執行，將狀態變成running，這樣能夠保證AsyncTask只會被執行一次。

接著會調用onPreExecute方法做一些處理工作，這個方法其實我們也可以在子類中自己實現，如果有什麼需要處理的話，一般不用。

然後我們發現，我們傳進來的參數params會被傳給mWorker，然後會有一個executor來執行execute的方法，並且執行的參數是一個mFuture對象。那麼這兩個東西是什麼呢？

接著看如下代碼：

    public AsyncTask() {        mWorker = new WorkerRunnable<Params, Result>() {            public Result call() throws Exception {                mTaskInvoked.set(true);                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);                //noinspection unchecked                return postResult(doInBackground(mParams));            }        };        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 occured while executing doInBackground()",                            e.getCause());                } catch (CancellationException e) {                    postResultIfNotInvoked(null);                }            }        };    }

mWorker是一個WorkerRunnable對象，而實際上WorkerRunnable是AsyncTask的一個抽象內部類，實現了Callable介面，如下：

    private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {        Params[] mParams;    }

而在上面的賦值過程，通過匿名類實現了WorkerRunnable，並其call方法中將線程優先順序調整為後台線程，然後會執行 doInBackground方法，不過現在還沒執行，咱們再看看FutureTask對象，下面是它的建構函式：

    public FutureTask(Callable<V> 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<Runnable> mTasks = new ArrayDeque<Runnable>();        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<Result>(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<Data> {        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的基本原理到這裡也就結束了。