AsyncTask 是 Android 中实现多线程方式之一，我们通常用 AsyncTask 来实现在耗时操作中对 UI 界面的更新。AsyncTask 提供了 onPreEcecute()、onProgressUpdate()、onPostExecute() 方法用于更新 UI，doInBackground() 方法用于实现耗时操作，如网络请求、I/O操作。
1. execute()
我们在使用 AsyncTask 时通常开启任务执行的入口就是 execute()，进入到 execute() 中，调用了 executeOnEcecutor() 方法开始执行任务，注意这两个方法都是在主线程调用的。
@MainThread
public final AsyncTask execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
@MainThread
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;
}
//状态标识
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,
}
- 任务的状态信息
PENDING 表示任务未被执行
RUNNING 表示任务正在执行
FINISHED 表示任务已执行
1）判断当前 AsyncTask 状态：
当开启一个 AsyncTask，如果当前任务正在执行或被执行过，程序会抛出异常，这表明:
一个 AsyncTask 在主线程中只能调用 execute() 或 ececuteOnExecutor() 一次。
2）更行状态信息，调用 onPreExecute() 方法处理任务执行前的准备工作；
3）exec.execute(mFuture) 开始执行任务，这里的 exec 是 AsyncTask 的一个线程池 sDefaultExecutor，AsyncTask 里 sDefaultExecutor 是由 SerialExecutor 的对象 SERIAL_EXECUTOR 赋值而来，用于顺序存储任务，同时并串行执行任务，看看 SerialExecutor 的具体实现：
2. SerialExecutor
SerialExecutor 是一个线程池，其中有一个队列用于存储任务，在 execute() 方法中还实现了任务串行执行。
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); //执行任务
}
}
}
1）mTasks 是一个存储任务的队列，基于队列先进先出原则保证了任务按进入队列的顺序可以被顺序执行，一个任务即是一个 Runnable 对象；
2）execute() 方法，首先将传入的 Runnable 对象 r 封装成 Runnable 对象加入任务队列，封装的 Runnable 对象实现了 run() 方法用于执行传入的任务，即 r.run()，接着调用 scheduleNext() 执行下一个任务；
3）mActivie == null，当前没有任务在执行，调用 scheduleNext() 执行任务队列中的下一个任务，按照步骤2中的逻辑，执行完当前任务后调用 scheduleNext() 继续执行任务队列中下一个任务，直到任务队列为空，这里可以看出来 AsyncTask 是默认串行执行任务；
4）scheduleNext() 方法，任务队列取出队头任务，不为空则通过 THREAD_POOL_EXECUTOR 调用 ececute() 执行任务。
3. THREAD_POOL_EXECUTOR
THREAD_POOL_EXECUTOR 也是一个线程池，它的作用是执行任务，来看看它的实现：
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;
}
这里主要是初始化了 THREAD_POOL_EXECUTOR 的相关参数，参数如下：
private 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;
1）CORE_POOL_SIZE 线程池最大核心线程数最小为2，最大为4且比 CPU 数少1；
2）MAXIMUM_POOL_SIZE 线程池最大线程数为 CPU 数的 2倍加1；
3）KEEP_ALIVE_SECONDS 线程数大于核心线程数是，线程终止之前最大等待时长 30s，大于了这个时间，等待中的线程则终止。
4. 构造方法
从 execute() 一路追踪下来，我们了解了一个任务是如何被放入任务队列中并执行的，AsyncTask 中的关键方法 doInBackground() 、onProgressUpdate()、onPostEcexute() 又是在哪儿调用的呢？回到最初调用 execute() 的地方，进入 AsyncTask 的构造方法来看看。
public AsyncTask() {
this((Looper) null);
}
public AsyncTask(@Nullable Handler handler) {
this(handler != null ? handler.getLooper() : null);
}
public AsyncTask(@Nullable Looper callbackLooper) {
mHandler =...;
mWorker = new WorkerRunnable() {
...
};
mFuture = new FutureTask(mWorker) {
...
};
}
1）构造函数中传入了 Looper，这里使用 Looper 是因为在 AsyncTask 中创建了 Handler，创建 Handler 时必须在有 Looper 的线程中创建；
2）接着在构造函数中依次实例化对象 mHandler、mWorker、mFuture，我们依次来看这三个对象的具体实现。
-
mHandler
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler()
: new Handler(callbackLooper);
private static Handler getMainHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
sHandler = new InternalHandler(Looper.getMainLooper());
}
return sHandler;
}
}
1）判断 callbackLooper 是否为空且是否是主线程的 Looper，为空则使用 调用 getMainHandler() 返回一个 Handler，否则调用 new Handler(callbackLooper) 新建一个 Handler。注意这里调用的是 Looper.getMainLooper()，这表明我们在 AsyncTask 中创建 Handler 时必须使用主线程的 Looper，即创建 Handler 的线程必须在主线程， 同理 AsyncTask 必须在主线程创建；
2）getMainHandler() ，mHandler 为空则在主线程为其创建一个 InternalHandler，InternalHandler 我们后面来看它的实现。
-
mWorker
mWorker = new WorkerRunnable() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Result result = null;
try {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
result = doInBackground(mParams);
Binder.flushPendingCommands();
} catch (Throwable tr) {
mCancelled.set(true);
throw tr;
} finally {
postResult(result);
}
return result;
}
};
private static abstract class WorkerRunnable implements Callable {
Params[] mParams;
}
mWorker 其实是一个 Callback，call() 方法中拿到 doInBackground() 方法的返回结果并传给了 posResult() 方法。
-
mFuture
mFuture = new FutureTask(mWorker) {
@Override
protected void done() {
try {
postResultIfNotInvoked(get());
}
...
}
};
mFuture 传入了 mWorker，在 execute() 方法中参数 params 存入了mWorker 中， mFuture 作为一个 Runnable 对象在线程池 sDefaultExecutor 中被保存在任务队列中，所以 mFuture 就是一个携带参数的任务。任务队列执行任务时调用 mFuture 的 run() 方法，run() 方法在 FutureTask 内部调用 mWorker 的 call()，call() 方法里调用了 doInBackground()，这里就实现了任务执行时对 AsyncTask 关键方法 doInBackground() 的调用。
-
postResult()
最后我们来看 mWorker 的 call() 中调用的 postResult() 方法：
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult(this, result));
message.sendToTarget();
return result;
}
postResult() 方法很简单，拿到我们在 doInBackground() 中返回的结果后，通过 Handler 发送了一条 MESSAGE_POST_RESULT 消息，InternalHandler 实现了消息的接受。
注意：我们在 execute() 中调用 exec.execute(mFuture) 执行任务时，线程池 THREAD_POOL_EXECUTOR 中的核心线程（也有可能是非核心线程）开始执行任务，这时候我们已经不是在主线程（UI线程了）所以可以很明显的知道这里调用的 doInBackground() 也是在我们的线程池中执行的，即 doInBackground() 里的耗时任务放入子线程中执行。 同样在子线程中使用 Handler 发送消息，在创建 Handler 的主线程（UI线程）中接受子线程发来的消息，实现了线程的切换。
5. InternalHandler
我们在构造方法中实例化的 mHandler 对象就是 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，任务执行完成后会收到，收到后调用 finish() 处理消息；一种是 MESSAGE_POST_RESULT，任务在执行过程中调用了 publishProgress() 方法时会收到，用于接受当前任务执行的进度，收到后调用 onProgressUpdate() 处理消息。
-
finish()
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
@MainThread
protected void onCancelled(Result result) {
onCancelled();
}
@MainThread
protected void onCancelled() {
}
isCancelled() 当前任务若是在执行完成前被取消了，则调用 onCancelled() 取消任务，取消任务的具体实现需要我们自己在 UI 线程实现；任务没有在执行过程中被取消则返回任务执行结果给 onPostExecute()。
到这里 AsyncTask 调用 execute() 执行一次任务的完整流程就走完了，附上完整流程：
execute()
→ executeOnExecutor() →onPreExecute()
→ SerialExecutor.execute()
→ SerialExecutor.scheduleNext()
→ THREAD_POOL_EXECUTOR.execute()
→ FutureTask.run()
→ WorkerRunnable.call() →doInBackground()→ publishProgress()
→ postResult()
→ InternalHandler.handleMessage()
① → finish() → onCancelled() /onPostExecute()
② →onProgressUpdate()
6. 总结
1）AsyncTask 是一个抽象泛型类，泛型 Params、Progress、Result 分别表示 doInBackground(Params ...) 的参数类型，onProgressUpdate(Progress ...)的参数类型，doInBackground()返回结果类型和 onPostExecute(Result result) 的参数类型；
2）AsyncTask 只能在主线程（UI线程）创建，execute() 和 executeOnExecutor() 方法同样也只能在主线程（UI线程）调用，即任务的开启只能在主线程。这里很好理解，我们实现 onPreExecute()、onProgressUpdate()、onPostExecute() 这些方法时基本都会更新我们的 UI，而要更新 UI 只能在主线程，所以 AsyncTask 的创建必然是只能在主线程；
3）AsyncTask 的 execute() 或 executeOnExecutor() 只能在主线程中被调用一次；
4）AsyncTask 有两个线程池和一个 Handler，线程池 SerialExecutor 用于按序存储任务（因为有一个队列）；线程池 THREAD_POOL_EXECUTOR 用于执行任务；InternalHandler 则用于接受来自子线程的消息，消息包括任务结束的消息和任务进度更新的消息；
5）运行在主线程（UI线程）的方法有 onPreEcecute()、onProgressUpdate()、onPostExecute()，运行在子线程的方法有 doInBackground()、publishProgress()；
6）onPostExecute() 方法不再被调用之后，我们应当手动调用 cancel() 结束当前任务。
疑问：
1）AsyncTask 也支持并行执行任务吗？怎么实现？
2）AsyncTask 是否会内存泄漏，为什么？怎么解决？
参考：
《Android 开发艺术探索》