AsyncTask机制原理解析

Android为我们提供了2种方便的异步处理方案，Handler和AsyncTask，两种方式适合的场景网上一搜就知道了，但是为什么呢？这篇分析将为你揭晓答案。前面分析了Handler的机制原理，还不熟悉的可以看下Handler机制原理。通过本篇的学习，来了解AsyncTask的工作原理。本篇内容较多，本着结论先行，分析在后的原则来看。

一，使用

使用呢是十分的简单，用一个类继承AsyncTask，拿着这个对象，执行execute就可以开始执行后台任务了。还是找个例子吧

* private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
*     protected Long doInBackground(URL... urls) {
*         int count = urls.length;
*         long totalSize = 0;
*         for (int i = 0; i < count; i++) {
*             totalSize += Downloader.downloadFile(urls[i]);
*             publishProgress((int) ((i / (float) count) * 100));
*             // Escape early if cancel() is called
*             if (isCancelled()) break;
*         }
*         return totalSize;
*     }
*
*     protected void onProgressUpdate(Integer... progress) {
*         setProgressPercent(progress[0]);
*     }
*
*     protected void onPostExecute(Long result) {
*         showDialog("Downloaded " + result + " bytes");
*     }
* }
*new DownloadFilesTask().execute(url1, url2, url3);

这个例子是AsyncTask源码中注释提到的例子。我们看到AsyncTask有3个泛型参数，分别代表什么意思呢

 *     <li><code>Params</code>, the type of the parameters sent to the task upon*     execution.</li>*     <li><code>Progress</code>, the type of the progress units published during*     the background computation.</li>*     <li><code>Result</code>, the type of the result of the background*     computation.</li>

简单来说，第一个参数（是个可变参数）是传给后台任务用的，第二个参数是后台任务执行过程中更新进度使用，第三个参数是后台任务执行完的返回结果。除此之外，还有几个方法介绍一下

 * <p>AsyncTask must be subclassed to be used. The subclass will override at least* one method ({@link #doInBackground}), and most often will override a* second one ({@link #onPostExecute}.)</p>

至少重写一个方法，doInBackground，这个方法用来执行后台任务的，运行在工作线程

    @WorkerThreadprotected abstract Result doInBackground(Params... params);

通常，我们还会重写一个onPostExecute，这个方法是将后台任务的结果post给UI线程，运行在UI线程

    @MainThreadprotected void onPostExecute(Result result) {}

其实，另外还有2个方法我们需要关注下，这里将4个方法的注释都贴出来

 * <p>When an asynchronous task is executed, the task goes through 4 steps:</p>* <ol>*     <li>{@link #onPreExecute()}, invoked on the UI thread before the task*     is executed. This step is normally used to setup the task, for instance by*     showing a progress bar in the user interface.</li>*     <li>{@link #doInBackground}, invoked on the background thread*     immediately after {@link #onPreExecute()} finishes executing. This step is used*     to perform background computation that can take a long time. The parameters*     of the asynchronous task are passed to this step. The result of the computation must*     be returned by this step and will be passed back to the last step. This step*     can also use {@link #publishProgress} to publish one or more units*     of progress. These values are published on the UI thread, in the*     {@link #onProgressUpdate} step.</li>*     <li>{@link #onProgressUpdate}, invoked on the UI thread after a*     call to {@link #publishProgress}. The timing of the execution is*     undefined. This method is used to display any form of progress in the user*     interface while the background computation is still executing. For instance,*     it can be used to animate a progress bar or show logs in a text field.</li>*     <li>{@link #onPostExecute}, invoked on the UI thread after the background*     computation finishes. The result of the background computation is passed to*     this step as a parameter.</li>* </ol>

onPreExecute，在任务开始前的准备工作，运行在UI线程，比如准备进度条

onProgressUpdate，一般用在后台任务进行时，更新进度等动作，运行在UI线程

二，原理分析

分析之前，我们先说结论，AsyncTask是对线程池和Handler的封装，任务只能执行一次，多次执行报错，任务可取消，默认串行执行。

2.1，成员分析

    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();// We want at least 2 threads and at most 4 threads in the core pool,// preferring to have 1 less than the CPU count to avoid saturating// the CPU with background workprivate static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;private static final int KEEP_ALIVE_SECONDS = 30;

这里能看到，通过获取CPU的核数，来确定核心池数量和最大池数量，这个池是啥，应该就是线程池吧。

    private static final ThreadFactory sThreadFactory = new ThreadFactory() {private final AtomicInteger mCount = new AtomicInteger(1);public Thread newThread(Runnable r) {return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());}};private static final BlockingQueue<Runnable> sPoolWorkQueue =new LinkedBlockingQueue<Runnable>(128);

这里有个ThreadFactory，其实就是生产线程的工厂嘛，BlockingQueue，看名字是个阻塞的队列，其实就是放我们要执行的任务的。

    /*** An {@link Executor} that can be used to execute tasks in parallel.*/public static final Executor THREAD_POOL_EXECUTOR;static {ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,sPoolWorkQueue, sThreadFactory);threadPoolExecutor.allowCoreThreadTimeOut(true);THREAD_POOL_EXECUTOR = threadPoolExecutor;}

先看Executor注释，可以用来执行并行任务。这里有个静态final的对象，看名字，没错，这就是线程池了。不过，这里不是说并行吗，别急，往下看

public static final Executor SERIAL_EXECUTOR = new 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();} finally {scheduleNext();}}});if (mActive == null) {scheduleNext();}}protected synchronized void scheduleNext() {if ((mActive = mTasks.poll()) != null) {THREAD_POOL_EXECUTOR.execute(mActive);}}}
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

这里还有个串行的Executor，是啥呢，看到关键的一行，通过THREAD_POOL_EXECUTOR去execute，到这我们似乎应该明白了，pool是默认用来执行异步任务的，那么这个SerialExecutor其实可以理解为一个容器，对接收到的任务暂存，串行交给pool去处理。这也验证了AsyncTask默认是串行执行的，当然了，你可以自己定制为并行执行。

    private static final int MESSAGE_POST_RESULT = 0x1;private static final int MESSAGE_POST_PROGRESS = 0x2;

2种类型的消息，不需要解释了吧。

    /*** Indicates the current status of the task. Each status will be set only once* during the lifetime of a task.*/public enum Status {/*** Indicates that the task has not been executed yet.*/PENDING,/*** Indicates that the task is running.*/RUNNING,/*** Indicates that {@link AsyncTask#onPostExecute} has finished.*/FINISHED,}

用这个枚举来标识任务的状态，看注释，每个任务只能执行一次。

private static InternalHandler sHandler;private static Handler getHandler() {synchronized (AsyncTask.class) {if (sHandler == null) {sHandler = new InternalHandler();}return sHandler;}}private static class InternalHandler extends Handler {public InternalHandler() {super(Looper.getMainLooper());}

到这里，知道了吧，AsyncTask内部有一个UI线程的Handler。

AsyncTask是可以取消任务的，其实是使用了FutureTask和Callable。这里介绍一下，Callable是个借口，与Runnable类似，不同的是Runnable没有返回值，Callable可以指定返回值。而关于FutureTask，看一下源码注释吧

 * <p>A {@code FutureTask} can be used to wrap a {@link Callable} or* {@link Runnable} object.  Because {@code FutureTask} implements* {@code Runnable}, a {@code FutureTask} can be submitted to an* {@link Executor} for execution.

意思是说，FutureTask可以封装Callable和Runnable，并且可以让Executor执行起来。FutureTask有两个关键方法，done，表示任务执行完，cacel，表示任务取消。AsyncTask之所以能取消，其实就是通过FutureTask来取消的

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

mWorker是实现了Callable的对象。看到这里，应该对AsyncTask的特点有了初步的认识，没关系，下面还会继续加深。

2.2，工作原理分析

先看一下AsyncTask的构造方法

public AsyncTask() {mWorker = new WorkerRunnable<Params, Result>() {public Result call() throws Exception {mTaskInvoked.set(true);Result result = null;try {Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);//noinspection uncheckedresult = doInBackground(mParams);Binder.flushPendingCommands();} catch (Throwable tr) {mCancelled.set(true);throw tr;} finally {postResult(result);}return result;}};mFuture = new FutureTask<Result>(mWorker) {@Overrideprotected 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);}}};}

这里初始化了2个成员，mWorker和mFuture，内部的方法并不会执行。那么就看看execute方法吧

    @MainThreadpublic final AsyncTask<Params, Progress, Result> execute(Params... params) {return executeOnExecutor(sDefaultExecutor, params);}

这里说明了，方法运行在UI线程。

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

一上来，先对status进行判断和初始化（这里是一个任务只能执行一次的实现），接下来，看到了onPreExecute，就是我们可能需要重写的方法。然后把params赋给了mWorker。exec.execute就是sDefaultExecutor执行execute。又因为

private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

所以也就是SERIAL_EXECUTOR的execute了。

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);}}}

这里我们前面分析过，是用了个容器，让任务串行执行。传给pool的是mActive，其实是对mFuture的封装，而mFuture初始化又是使用的mWorker，所以最终执行到了mWorker的call方法，也就构造方法中的第一个成员的方法。这里会执行doInbackground，这里是在工作线程执行的。执行完会得到一个result，在finally中post出去。

    private Result postResult(Result result) {@SuppressWarnings("unchecked")Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,new AsyncTaskResult<Result>(this, result));message.sendToTarget();return result;}

Handler前面已经介绍过了，这里知道封装完Message，发送给UI线程即可。AsyncTaskResult是一个内部类

    private static class AsyncTaskResult<Data> {final AsyncTask mTask;final Data[] mData;AsyncTaskResult(AsyncTask task, Data... data) {mTask = task;mData = data;}}

看一下handleMessage

        public void handleMessage(Message msg) {AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;switch (msg.what) {case MESSAGE_POST_RESULT:// There is only one resultresult.mTask.finish(result.mData[0]);break;case MESSAGE_POST_PROGRESS:result.mTask.onProgressUpdate(result.mData);break;}}

可以看到，POST_RESULT会调用finish方法

    private void finish(Result result) {if (isCancelled()) {onCancelled(result);} else {onPostExecute(result);}mStatus = Status.FINISHED;}

这里我们看到了熟悉的onPostExecute方法，参数是result。那么POST_PROGRESS是怎么处理的呢？我们知道，doInBackground可能需要较长的时间执行完，中间的过程想更新进度条怎么办呢？可以在doInbackground中调用publishProgress

    @WorkerThreadprotected final void publishProgress(Progress... values) {if (!isCancelled()) {getHandler().obtainMessage(MESSAGE_POST_PROGRESS,new AsyncTaskResult<Progress>(this, values)).sendToTarget();}}

如果任务没被取消，则通过Handler发送出去，那么接下来又到handleMessage了，看一下前面的代码，onProgressUpdate

    @MainThreadprotected void onProgressUpdate(Progress... values) {}

看到这里，工作原理分析就结束了，我们已经能知道AsyncTask是对线程池和Handler的封装，任务只能执行一次，任务可以取消，默认串行执行（注意理解为什么有这些特点）