深入探索AsyncTask

關於AsyncTask，相信大家都不陌生。由於Android UI線程的不安全性，所以如果想要在子線程中更新UI，就必須使用異步消息處理的方式。之前研究了Handler的處理機制（http://blog.csdn.net/u010429311/article/details/51288479），對於AsyncTask的理解還是挺有幫助的。在這裏，我們繼續深入的理解AsnycTask的工作原理。在此之前，我們可以先寫一個簡單的例子，然後循序漸進地去理解它。

public class MainActivity extends Activity {
    private Button btnExecute, btnCancel;
    private ProgressBar bar;
    private MyTask task;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        btnExecute = (Button) findViewById(R.id.start);
        btnCancel = (Button) findViewById(R.id.cancel);
        bar = (ProgressBar) findViewById(R.id.progressBar);

        btnExecute.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                task = new MyTask(); //創建任務
                task.execute();  //執行任務
            }
        });
        btnCancel.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (!task.isCancelled())
                    task.cancel(true);  //中斷任務
            }
        });

    }

    class MyTask extends AsyncTask<Void, Integer, Void> {
        @Override
        protected void onPreExecute() { //在任務開始之前在執行，可進行一些UI的顯示處理
            bar.setProgress(0);
            btnExecute.setEnabled(false);
            btnCancel.setEnabled(true);
        }

        @Override
        protected Void doInBackground(Void... params) { //任務開始執行
            for (int i = 1; i <= 100; i++) {
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    task.cancel(true);
                }
                publishProgress(i); //不斷地更新ProgressBar的數據
            }
            return null;
            }
        }
        @Override
        protected void onPostExecute(Void aVoid) { //任務結束後執行
            btnExecute.setEnabled(true);
            btnCancel.setEnabled(false);
        }

        @Override
        protected void onProgressUpdate(Integer... values) { //調用publishProgress方法後執行
            bar.setProgress(values[0]);   //更新數據
        }

        @Override
        protected void onCancelled(Void aVoid) {  //任務被中斷後執行
            bar.setProgress(0);
            btnExecute.setEnabled(true);
            btnCancel.setEnabled(false);
        }
}

結果：

上面實現了簡單的操作，既然要了解AsyncTask的工作原理，我們首先要看看第一步創建MyTask對象時發生了哪些事情，因此，就要去找AsyncTask的構造函數了：

 public AsyncTask() {
        //創建一個WorkerRunable對象
        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);
            }
        };

        //創建FutureTask對象
        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);
                }
            }
        };
    }

在構造函數中，只創建了兩個對象，而且不知道他們具體的作用是什麼。細心留意，我們會發現doInBackground(mParams)這條語句。說明mWorker 的call()方法會在某一時刻被執行，我們就暫且放着不管。繼續研究下一個重要的方法execute()。當執行task.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();   //從這裏可以看到最先執行的是onPreExecute()方法
        mWorker.mParams = params; //設置mWorker的參數
        exec.execute(mFuture);  //在線程池中執行mFuture任務
        return this;
    }

我們發現在execute方法中調用executeOnExecutor方法並傳入了sDefaultExecutor參數，用來執行exec.execute(mFuture)。那麼sDefaultExecutor這個線程池在哪裏定義了？我們可以在AsyncTask的數據域中找到：

 public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
 private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

可以看到，sDefaultExecutor 是一個SerialExecutor對象，我們具體看看SerialExecutor類以及它的execute方法：

private static class SerialExecutor implements Executor {
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();  //任務隊列
        Runnable mActive;  //將要執行的任務

        public synchronized void execute(final Runnable r) {  //傳入的參數爲mFuture，即FutureTask對象
            mTasks.offer(new Runnable() {  //任務的線程入隊，此處把任務放在了子線程處理
                public void run() {
                    try {
                        r.run();   //調用MFuture的run()方法
                    } finally {
                        scheduleNext();  //無論發生什麼，都會執行下一任務
                    }
                }
            });
            if (mActive == null) {  //第一次運行爲null
                scheduleNext();
            }
        }

        //使用線程池THREAD_POOL_EXECUTOR來執行下一任務mActive
        protected synchronized void scheduleNext() {
            if ((mActive = mTasks.poll()) != null) {
                THREAD_POOL_EXECUTOR.execute(mActive);  //執行任務，會調用任務中的run方法,即r.run()
            }
        }
    }

看到這裏，我們會發現 已經出現了兩個線程池，所以先區別一下：

THREAD_POOL_EXECUTOR 用來真正地去執行任務
sDefaultExecutor 用來保存當前地任務，以實現任務的入隊

從上述代碼可以看出，每當執行任務時，都會調用run()方法，那麼run()方法在FutureTask這個類中是如何實現的？之前我們創建了一個mFuture對象：

 public void run() {
        if (state != NEW ||
            !U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable; //此處的callable正是在創建AsyncTask時所創建的mWorker對象
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();  //調用了call()方法
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            runner = null;
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

在run()方法中，我們看到調用了mWorker的call()方法，之前AsyncTask的構造函數中的mWorker對象在這裏終於用上了，此時調用了doInBackground()方法，並且我們會發現這個時候任務處於子線程中！所以，這個時候，我們就可以用doInBackground()方法去處理一些耗時的操作。

//創建一個WorkerRunable對象
        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);
            }
        };

在完成doInBackground()方法後緊接着就執行了postResult()方法：

private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        //MESSAGE_POST_RESULT代表任務即將結束，發送結果
        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT, 
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;
    }

看到這裏，就已經進入了熟悉的畫面了，這裏顯然是Handler的處理機制，既然發送了消息，那麼在Handler的實例中一定重寫了handleMessage方法，我們通過 getHandler()方法中可以看到返回的是一個sHandler，sHandler是AsyncTask類的一個靜態的成員變量，由於最終要切換到主線程進行UI操作，所以sHandler必須在類初始化時就定義，因此決定了AsyncTask的實例必須在主線程創建，否則會報錯。它是InternalHandler的實例：

private static class InternalHandler extends Handler {
        public InternalHandler() {
            super(Looper.getMainLooper());  //對應一個Looper
        }
        @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); //調用我們實現的onProgressUpdate()方法，實現進度的更新
                    break;
            }
        }
    }

我們發現MESSAGE_POST_PROGRESS這個值並沒有出現過，它執行的操作是onProgressUpdate()，這讓我們很容易就聯想到了publishProgress()方法，在源碼中尋找這個方法：

protected final void publishProgress(Progress... values) {
        if (!isCancelled()) {
            //MESSAGE_POST_PROGRESS 代表了更新數據，所以執行了publishProgress()方法就可以更新當前的進度了
            getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                    new AsyncTaskResult<Progress>(this, values)).sendToTarget();
        }
    }

上面在結束時還調用finish()方法：

private void finish(Result result) {
        //如果取消了任務，如task.cancel(true)，就會執行onCancelled()方法，否則執行onPostExecute()方法
        if (isCancelled()) {  
            onCancelled(result);
        } else {
            onPostExecute(result);
        }
        mStatus = Status.FINISHED;  //無論哪種形式，當前的任務都在此結束了
    }

看到這裏，AsyncTask的工作原理就非常清晰了，真的是一波三折，讓我不得不感嘆工程師們的邏輯思維是多麼的強大(╯﹏╰)