简介
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 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类必须在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 unchecked
result = 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"})
@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;
}
}
}
InternalHandler收到MESSAGE_POST_RESULT消息之后，调用AsyncTask的finish()方法。
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
如果AsyncTask取消执行了，就调用onCancelled()方法，否则调用onPostExecute()方法。
