#### 11.2.2 AsyncTask的工作原理 為了分析AsyncTask的工作原理，我們從它的execute方法開始分析，execute方法又會調用executeOnExecutor方法，它們的實現如下所示。 ``` @MainThread public final AsyncTask<Params, Progress, Result> execute(Params... params) { return executeOnExecutor(sDefaultExecutor, params); } @MainThread 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; } ``` 在上面的代碼中，**sDefaultExecutor實際上是一個串行的線程池，一個進程中所有的AsyncTask全部在這個串行的線程池中排隊執行**，這個排隊執行的過程后面會再進行分析。 **在executeOnExecutor方法中，AsyncTask的onPreExecute方法最先執行，然后線程池開始執行**。 下面分析**線程池的執行過程**，如下所示。 ``` private final WorkerRunnable<Params, Result> mWorker; private final FutureTask<Result> mFuture; 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); } } }; } public static final Executor SERIAL_EXECUTOR = new SerialExecutor(); private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR; 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的實現可以分析AsyncTask的排隊執行的過程。首先系統會把AsyncTask的Params參數封裝為FutureTask對象`mFuture = new FutureTask<Result>(mWorker) {}`，**FutureTask是一個并發類，在這里它充當了Runnable的作用` exec.execute(mFuture);`**。 接著這個FutureTask會交給SerialExecutor的execute方法去處理，**SerialExecutor的execute方法首先會把FutureTask對象添加到任務隊列mTasks中，通過`mTasks.offer方法`，如果這個時候沒有正在活動的AsyncTask任務，那么就會調用SerialExecutor的`scheduleNext()`方法來執行下一個AsyncTask任務。同時當一個AsyncTask任務執行完后，AsyncTask會繼續執行其他任務直到所有的任務都被執行為止**，從這一點可以看出，在默認情況下，**AsyncTask是串行執行的**。 AsyncTask中有兩個線程池（`SerialExecutor`和`THREAD_POOL_EXECUTOR`）和一個Handler（`InternalHandler`），其中 * 線程池**SerialExecutor用于任務的排隊**， * 而線程池**THREAD_POOL_EXECUTOR用于真正地執行任務**， * **InternalHandler用于將執行環境從線程池切換到主線程**， 關于**線程池**的概念將在第11.3節中詳細介紹，其**本質仍然是線程的調用過程**。 在AsyncTask的構造方法中有如下這么一段代碼，由于**FutureTask的run方法會調用mWorker的call方法，因此mWorker的call方法最終會在線程池中執行**。 ``` 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); } }; ``` 在mWorker的call方法中，首先將mTaskInvoked設為true，表示當前任務已經被調用過了，然后執行AsyncTask的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; } private static Handler getHandler() { synchronized (AsyncTask.class) { if (sHandler == null) { sHandler = new InternalHandler(); } return sHandler; } } ``` 在上面的代碼中，**postResult方法會通過sHandler發送一個`MESSAGE_POST_RESULT`的消息**，這個sHandler的定義如下所示。 ``` 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; } } } ``` 可以發現，**sHandler是一個靜態的Handler對象，為了能夠將執行環境切換到主線程，這就要求sHandler這個對象必須在主線程中創建。由于靜態成員會在加載類的時候進行初始化，因此這就變相要求AsyncTask的類必須在主線程中加載，否則同一個進程中的AsyncTask都將無法正常工作。sHandler收到`MESSAGE_POST_RESULT`這個消息后會調用AsyncTask的finish方法**，如下所示。 ``` private void finish(Result result) { if (isCancelled()) { onCancelled(result); } else { onPostExecute(result); } mStatus = Status.FINISHED; } ``` AsyncTask的finish方法的邏輯比較簡單，**如果AsyncTask被取消執行了，那么就調用onCancelled方法，否則就會調用onPostExecute方法，可以看到doInBackground的返回結果會傳遞給onPostExecute方法**，到這里AsyncTask的整個工作過程就分析完畢了。 通過分析AsyncTask的源碼，可以進一步確定，**從Android 3.0開始，默認情況下AsyncTask的確是串行執行的**，在這里通過一系列實驗來證實這個判斷。 請看如下實驗代碼，代碼很簡單，就是**單擊按鈕的時候同時執行5個AsyncTask任務，每個AsyncTask會休眠3s來模擬耗時操作，同時把每個AsyncTask執行結束的時間打印出來，這樣我們就能觀察出AsyncTask到底是串行執行還是并行執行**。 @Override public void onClick(View v) { if (v == mButton) { new MyAsyncTask("AsyncTask#1").execute(""); new MyAsyncTask("AsyncTask#2").execute(""); new MyAsyncTask("AsyncTask#3").execute(""); new MyAsyncTask("AsyncTask#4").execute(""); new MyAsyncTask("AsyncTask#5").execute(""); } } private static class MyAsyncTask extends AsyncTask<String, Integer, String> { private String mName = "AsyncTask"; public MyAsyncTask(String name) { super(); mName = name; } @Override protected String doInBackground(String... params) { try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } return mName; } @Override protected void onPostExecute(String result) { super.onPostExecute(result); SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); Log.e(TAG, result + "execute finish at " + df.format(new Date())); } } 分別在Android 4.1.1和Android 2.3.3的設備上運行程序，按照本節前面的描述，AsyncTask在4.1.1上應該是串行的，在2.3.3上應該是并行的，到底是不是這樣呢？請看下面的運行結果。 **Android 4.1.1上執行**：如圖11-1所示，**5個AsyncTask共耗時15s且時間間隔為3s，很顯然是串行執行的**。 :-:  圖11-1 AsyncTask在Android 4.1.1上的執行順序 **Android 2.3.3上執行**：如圖11-2所示，**5個AsyncTask的結束時間是一樣的，很顯然是并行執行的**。 :-:  圖11-2 AsyncTask在Android 2.3.3上的執行順序 **為了讓AsyncTask可以在Android 3.0及以上的版本上并行，可以采用AsyncTask的executeOnExecutor方法**，需要注意的是**executeOnExecutor這個方法是Android 3.0新添加的方法，并不能在低版本上使用**，如下所示。 @TargetApi(Build.VERSION_CODES.HONEYCOMB) @Override public void onClick(View v) { if (v == mButton) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) { new MyAsyncTask("AsyncTask#1"). executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, ""); new MyAsyncTask("AsyncTask#2"). executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, ""); new MyAsyncTask("AsyncTask#3"). executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, ""); new MyAsyncTask("AsyncTask#4"). executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, ""); new MyAsyncTask("AsyncTask#5"). executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, ""); } } } private static class MyAsyncTask extends AsyncTask<String, Integer, String> { private String mName = "AsyncTask"; public MyAsyncTask(String name) { super(); mName = name; } @Override protected String doInBackground(String... params) { try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } return mName; } @Override protected void onPostExecute(String result) { super.onPostExecute(result); SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); Log.e(TAG, result + "execute finish at " + df.format(new Date())); } } 在Android 4.1.1的設備上運行上述程序，日志如圖11-3所示，很顯然，我們的**目的達到了，成功地讓AsyncTask在4.1.1的手機上并行起來了**。 :-:  圖11-3 AsyncTask的executeOnExecutor方法的作用