AsyncTask的使用和工作原理

简介

AsyncTask是一个轻量级的异步任务类，封装了Handler和Thread，可以方便的在线程池里执行后台任务，并把进度和结果发送到主线程并在主线程中更新UI。AsyncTask应该用来执行比较短的后台任务，一般是以秒为单位的。如果需要保持线程长期运行，建议用线程池进行。

一个AsyncTask是一个抽象的泛型类，通过继承的方式来使用。AsyncTask需要指定三个三个泛型参数的类型，重写四个回调方法。

三个泛型

三个泛型参数分别是Params, Progress and Result。

• Params：初始化AsyncTask时传入的参数类型，用来定义传递给后台任务的参数类型。
• Progress：后台任务执行进度的类型。
• Result：后台任务执行完成返回的结果类型。

当不需要相应的参数的时候，也可定义成Void类型。

四个方法

• onPreExecute()，后台任务执行前在UI线程中调用，一般用来做一些初始化工作，比如显示progress bar等。
• doInBackground(Params…)，在onPreExecute()方法执行之后，在后台线程中调用，用来处理耗时的后台任务，执行完成之后将结果return。在这个方法中可以调用publishProgress(Progress…)将执行进度发送到主线程的回调方法onProgressUpdate(Progress…)。
• onProgressUpdate(Progress…)，在调用publishProgress(Progress…)方法之后会在主线程中回调这个方法。主要用来更新后台任务的执行进度。
• onPostExecute(Result)，在后台任务执行完成之后在UI线程中调用。后台任务执行结果会作为一个参数传递到这个方法中，一般用来更新UI。

取消任务

AsyncTask可以调用cancel(boolean)方法取消执行，该方法调用之后，调用isCancelled()方法会返回true，后台任务执行完成后，不再调用onPostExecute(Object)，而是调用onCancelled(Object)。为了尽快的取消任务，应该在doInBackground(Object[])方法中尽可能的调用isCancelled()判断任务是否被取消。

使用方法

AsyncTask必须通过继承的方式使用。子类至少复写onInBackground(Params…)方法，一般还会复写onPostExecute(Result)方法。如下使用一个模拟下载文件的例子：

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 calledif (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类必须在UI线程中加载。在Android4.1之后由系统自动完成。
• AsyncTask实例必须在UI线程中创建。
• execute(Params…)方法必须在UI线程中调用。
• 不要手动调用提供的四个回调方法。
• 每个AsyncTask实例只能执行一次。

版本演化

AsyncTask类经过几次的版本演化，一开始的AsyncTask是顺序执行的，从Android1.6开始，改成了线程池，允许多个AsyncTask并行执行。直到Android3.0开始，为了避免并发引起的错误，AsyncTask又改成默认为顺序执行，但可以通过executeOnExecutor()方法并发执行。

AsyncTask的工作原理

为了分析AsyncTask的工作原理，从execute(Params… params)方法入手。

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

execute(Params… params)方法又调用了executeOnExecutor(Executor exec, Prams… params)方法。

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

从上面的源码可以看到，在AsyncTask执行的时候，就调用了onPreExecute()方法，然后将params参数封装成FutureTask对象，调用了线程池sDefaultExecutor的execute(mFuture)方法。线程池sDefaultExecutor实际就是一个串行的线程池，我们来看一下sDefaultExecutor线程池的实现。

private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
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);}}}

从这里可以看到，在SerialExecutor中，FutureTask作为Runnable对象传进来之后，会把FutureTask插入任务队列mTasks中，如果当前没有正在活动的AsyncTask，就会调用sheduleNext()方法，如果有正在活动的AsyncTask，则在执行结束之后调用sheduleNext()方法，直到所有的任务执行完成。可以看得出来SerialExecutor是串行执行的。而真正执行的线程池为THREAD_POOL_EXECUTOR，SerialExecutor是对THREAD_POOL_EXECUTOR的封装。

在THREAD_POOL_EXECUTOR的execute()方法中最后调用了run方法。

public void run() {...try {Callable<V> c = callable;if (c != null && state == NEW) {V result;boolean ran;try {result = c.call();ran = true;...
}

而在FutureTask执行run方法时，会执行Callable的call()方法，从AsyncTask的构造方法中可以发现，对应的是mWorker的call()方法。

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) {
...

在call()方法中，执行了doInBackground(mParams)方法，然后将返回值传递给postResult(result)中。

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

而在postResult(Result)方法中，将result包装成Message，发送给Handler，跟踪getHandler()找到对应的Handler为InternalHandler。

private static class InternalHandler extends Handler {public InternalHandler(Looper looper) {super(looper);}@SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})@Overridepublic 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;}}
}

InternalHandler收到MESSAGE_POST_RESULT消息之后，调用AsyncTask的finish()方法。

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

如果AsyncTask取消执行了，就调用onCancelled()方法，否则调用onPostExecute()方法。