#### 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方法的作用