概述
AsyncTask 是一个轻量级的异步任务类，它可以在线程池中执行后台任务，然后把执行的进度和最终结果传递到主线程并在主线程中更新 UI 。从实现的角度来看呢， AsyncTask 对线程池和 Handler 进行了很好的封装。
基本使用
-
创建一个继承 AsyncTask
- 其中三个泛型参数的意义为， Params 表示执行后台任务方法的参数类型， Progress 表示更新后台任务进度方法的参数类型。Result 表示后台任务的返回结果类型。如果不需要指定类型参数则传入 void 就好。
-
AsyncTask 类对外提供了关键的四个核心方法：
- onPreExecute(): 此方法在后台任务之前调用，可以用此方法做一些准备方法。
- doInBackground(Params... params): 此方法在线程池中执行，用于执行异步耗时任务。可在此方法中调用 publishProgress() 方法来通知主线程更新UI或者任务进度。需要注意的就是此方法执行完毕，需返回一个结果给 onPostExecute() 方法。
- onProgressUpdate(Progress.. values):在主线程中执行，用于更新UI或者根据任务进度做些事。
- onPostExecute(): 此方法用于执行后台任务结束时返回的结果的处理，在主线程中调用。
AsyncTask 结构分析
我们首先从 AsyncTask 的入口开始分析。从 execute() 方法开始，然后呢此方法又调用了 executeOnExecutor() 方法，实现如下：
public final AsyncTask execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
public final AsyncTask 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 最终把参数传递给 mWorker ，mFuture 是 FutureTask 类为一个并发类。在这里充当了 Runnable 的作用，而这个类的 run() 方法最终会调用到 mWorker 的 call() 方法。AsyncTask 的 onPreExecute 方法会最先执行，然后再调用线程池执行后台任务，mFuture 最终会交于线程池来执行。线程池的执行过程分析如下：
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
private static class SerialExecutor implements Executor {
final ArrayDeque mTasks = new ArrayDeque();
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 类其实主要作用用于将任务插入 mTasks 队列中，如果没有正在运行的任务，则调用 THREAD_POOL_EXECUTOR 线程池来做事。一般情况下 AsyncTask 默认串行执行任务。
在 AsyncTask 中 有两个线程池(SerialExecutor 和 THREAD_POOL_EXECUTOR)和一个 Handler (InternalHandler)。SerialExecutor 线程池用于任务的排队， THREAD_POOL_EXECUTOR 线程池用于正真执行任务。InternalHandler 用于从线程池环境切换主线程。
这里再来看下 WorkerRunnable 类的定义，源码如下：
public AsyncTask() {
mWorker = new WorkerRunnable() {
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;
}
};
.....
}
以匿名内部类的形式定义，在 mWorker 的 call() 方法中，首先将 mTaskInvoked 设为 true ，表示任务已经调用。然后将对象的 mParams 传入 AsyncTask 的 doInBackground() 中开始执行任务，接着获取执行结果再调用 postResult(result), postResult() 方法实现如下：
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult(this, result));
message.sendToTarget();
return result;
}
从 postResult() 的代码中可以看出，此方法通过 AsyncTask 类的 Handler 发送一个 MESSAGE_POST_RESULT的消息，那么接下来应该看的就是 AsyncTask 类中的 Handler 类的 HandleMessage() 方法的实现了，代码如下：
private static class InternalHandler extends Handler {
public InternalHandler() {
super(Looper.getMainLooper());
}
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 类 在构造函数中就与主线程的 looper 绑定了，从 handleMessage() 中可以看出当收到 MESSAGE_POST_RESULT 时会继续调用 AsyncTask 类的 finish() 方法。然后我们再来看看 finish() 方法的代码：
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
finish() 方法的逻辑比较简单，首先判断 AsyncTask 的任务是否已经被取消，如取消则调用 onCancelled() , 没取消调用 onPostExecute() 来进行后台任务执行完毕的收尾工作。publishProgress() 更新进度的逻辑同上。至此呢 AsyncTask 的流程就基本分析完毕了。