AsyncTask 是一个安卓开发中很常用的类，毕竟有太多地方需要做异步处理，而 AsyncTask 做了很好的封装。正好最近在看 Java 并发，看了下 AsyncTask的源码，里面也涉及到了这部分的内容，正好一起学习一下。
本文先从 AsyncTask 中涉及到的并发的基础部分讲起，之后再分析 AsyncTask 源码，这样看起来会清晰很多。本文不会介绍AsyncTask的基本用法，只讲底层实现。会包括以下内容：
- Executor
- Callable、Future 和 FutureTask
- AsyncTask 源码分析
注：下面源码中出现的 Params, Progress, Result，Data都是泛型参数，注意一下，以免引起理解困难
1. Excutor
开启一个子线程最简单也最常见的方法就是用 Thread 去驱动一个 Runnable 对象。这种方法大家都很熟悉了这里就不再举例。但其实 Java 类库中还提供了一种更加强大的开启多线程任务的方法，那就是 Excutor。从这个名字就可以直观的理解，它是一个用来执行任务的工具。
public interface Executor {
void execute(Runnable command);
}
Executor 是一个只有一个方法的接口。一般使用的是 ExecutorService ，是一个继承了 Executor 的接口，文档中对 ExecutorService 的概述是这样的：
An Executor that provides methods to manage termination and methods that can produce a Future for tracking progress of one or more asynchronous tasks.
简单的说就是一个带有生命周期管理的 Executor，并且可以追踪其执行的任务的状态。这里涉及到 Future 和 Callable 两个接口，稍后会介绍。
说了这么半天，那么实现类怎么来？当然不用自己写了，Java 已经提供了一个工厂类 Excutors，可以方便的构造出多种 ExecutorService 的实现类，满足各种场景的应用。这里列举几个 Excutors 里常用的静态方法：
public static ExecutorService newCachedThreadPool()public static ExecutorService newFixedThreadPool(int nThreads)public static ExecutorService newSingleThreadExecutor()
从函数名就可以猜出来，这三个方法构造的 ExecutorService 都维护着一个线程池，CachedThreadPool 线程的数量没有上限，FixedThreadPool的线程数量的上限由用户指定，而 SingleThreadExecutor 的线程数量为1，即所有任务都串行执行。
查看源码可以发现这几个工厂方法最终都调用了 ThreadPoolExecutor 这个类的构造方法，只是传入的不同的配置参数，从而构造出了具有不同特性的线程池。
构造好了线程池，接下来的事情就简单了，直接把 Runnable 对象丢进去，即调用
void execute(Runnable command);
任务就会自动在子线程执行了，简直不能更简单了。
总结一下就是，通过 Excutors 类的工厂方法获得一个 ExcutorService 的实例，然后调用 ExecutorService 的 execute 方法执行 Runnable 任务。
2. Callable 、Future 以及 FutureTask
上一节介绍的 execute 方法，虽然简单好用，但是有一个缺点就是任务执行一旦开始，就无法获知任务的执行情况，也无法在任务执行完成后得到一个返回值。要想实现这样的功能，就需要 Callable 和 Future 了。
Callable 和 Runnable 很像，也是一个接口：
public interface Callable<V> {
V call() throws Exception;
}
除了函数名的变化，主要的不同是多了一个泛型返回，这个就是我们希望得到的返回值的类型。那么要执行一个实现了 Callable 的任务， ExecutorService 里面也有对应的方法：
<T> Future<T> submit(Callable<T> task);
当调用 submit 方法后，我们会得到一个 Future 对象。准确的来说，Future也是个接口，它定义了几个方法，用来查询当前任务执行的状态，以及控制任务的执行：
-
boolean cancel( boolean mayInterruptIfRunning)：用来取消任务，取消成功返回true，否则返回false 。mayInterruptIfRunning表示是否可以中断正在执行的任务。 -
boolean isCancel(): 查询任务是否在完成前被成功取消 -
boolean isDone()：查询任务是否执行完成 -
T get()：得到任务的返回值，需要注意如果任务还没完成，那么get()方法将会阻塞，直到任务完成。
Future 接口最常用的一个子类是 FutureTask，后面在AsyncTask 源码分析时会见到。FutureTask 不仅实现了 Future 接口，也实现了 Runnable 接口，所以它可以通过 Executor 的 execute 方法执行。
3. AsyncTask 初探
基本概念介绍完了，现在可以来看 AsyncTask 了。先介绍几个重要的成员变量，代码看上去有点长，不要被吓到，其实很简单：
//删掉了一些暂时无需关注的成员变量和方法
public abstract class AsyncTask<Params, Progress, Result> {
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE = 1;
public static final Executor THREAD_POOL_EXECUTOR
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
private final WorkerRunnable<Params, Result> mWorker;
private final FutureTask<Result> mFuture;
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 abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}
}
下面逐个说明一下：
-
THREAD_POOL_EXECUTOR: 一个指定了最大线程数量的 Executor。最大线程数是MAXIMUM_POOL_SIZE, 可以看到其值取决于 CPU 的核心数，如果是4核，那么最大线程数就是9个。但是这个线程池并没有直接用来执行异步任务，后面会看到。 -
SERIAL_EXECUTOR: 从名字可以看出是一个串行执行任务的 Executor，其具体实现在由下面的SerialExecutor类定义。实现方式也很简单。维护了一个队列mTasks，mTasks.offer在队尾插入任务，mTasks.poll()从队首取出任务。怎么实现一个任务执行后接着执行下一个呢？这里很巧妙的，在插入任务的时候做了一层包装，用一个 Runnable 包住一个 Runnable，有点代理模式的感觉。外层的Runnable 在执行完内层的Runnable之后，最终一定会执行 finally 中进行取下一个任务并执行的操作，这样就实现了一个不断线性执行任务的调度队列。 -
sDefaultExecutor: 这个就是默认的执行异步任务的 Executor 了，其值被指定为SERIAL_EXECUTOR。所以我们知道了所有的 AsyncTask 最终会按照先后顺序依次执行，而并不是并发的执行。 -
mWorker: 就是一个 Callable 接口多了一个保存参数的数组而已 -
mFuture: 是一个FutureTask 对象， 正是前面提到的 Future 接口的一个实现类
至此，我们看到了前面介绍到的 ExecutorService，Callable，Future， FutureTask 都已经悉数登场，有了前面两节的铺垫，再看这些类应该毫无压力了。接下来就是如何组织运用它们了。
4. AsyncTask 的构造函数
AsyncTask 的构造函数并不复杂，但是可以说 AsyncTask 架构的关键部分都在这里定义了。上源码：
public AsyncTask() {
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
Result result = doInBackground(mParams);
Binder.flushPendingCommands();
return postResult(result);
}
};
mFuture = new FutureTask<Result>(mWorker) {
@Override
protected 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);
}
}
};
}//构造函数到此结束，下面只是涉及到的方法和类
private void postResultIfNotInvoked(Result result) {
final boolean wasTaskInvoked = mTaskInvoked.get();
if (!wasTaskInvoked) {
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;
}
//一个用来封装数据的类，mData 字段，可以封装任务的执行结果数据
//也可以封装任务的执行进度数据
private static class AsyncTaskResult<Data> {
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}
可以看到主要是完成 mWorker 和 mFuture 两个变量的初始化。
-
mWorker：call方法内部，调用了doInBackground方法，这个太熟悉了，就是我们使用AsyncTask必须要实现的方法，执行我们需要在子线程执行的业务逻辑。执行完之后的返回值调用postResult方法。postResult方法里面的操作我们也很熟悉，就是通过一个 Handler 把结果发送出去，这个Handler 对象后面再讲。注意 mTaskInvoked.set(true)，这里mTaskInvoked 是一个提供了原子操作的布尔型对象，用来标记任务已经被调用 -
mFuture：只实现了一个 done 方法，这个方法会在任务终止（正常执行完或被取消）的时候调用。这里的postResultIfNotInvoked逻辑有点奇怪，明明只要任务一开始执行，mWorker的call方法就会被调用，mTaskInvoked就肯定被设置为 true 了，怎么会有等于 false 的情况出现呢？最后答案在这里 ，是为了修复一个bug，这里就不深究了，我们只要知道绝大多数情况下，wasTaskInvoked都会被设为 ture 就好了。
4. AsyncTask 里的 Handler
上一节中的 postResult 里我们看到了一个 getHandler() 方法，现在就来研究这个 Handler 有什么特别了 （其实真的没什么特别的...）：
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());
}
@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;
}
}
}
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
getHandler() 返回了一个 InternalHandler。InternalHandler 处理两种消息，一种是任务执行结果的消息 MESSAGE_POST_RESULT，一种是任务执行进度的消息 MESSAGE_POST_PROGRESS。
收到任务执行结果的消息会调用 AsyncTask 的 finish 方法，在这个方法里面，我们看到了熟悉的 onPostExecute(Result result) 。而收到任务执行进度的消息，会调用 onProgressUpdate(Progress... values) ，这个消息是在调用 publishProgress(Progress... values) 方法的时候发送的。
这里的关键是在 InternalHandler 的构造函数里，传入的 Looper 是通过 Looper.getMainLooper() 方法得到的，这正是 UI 线程的 Looper，因而也就确保了 onPostExecute 和 onProgressUpdate 方法都在 UI 线程执行。
至此，我们已经在源码中见到了通常使用 AsyncTask会用到的方法：
doInBackground 在子线程执行异步任务， publishProgress 在子线程发布任务执行进度，onProgressUpdate、onPostExecute 在 UI 线程接收任务执行进度和结果。好像还差了一个没见到，onPreExecute，别着急，下面马上就来
5. 最后一步，让 AsyncTask 运转起来
一切准备工作已经就绪，当我们定义好一个 AsyncTask，最终要执行的时候，就要调用 execute 方法：
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, 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;
}
execute 方法会调用到 executeOnExecutor(Executor exec, Params... params)，传入的 Executor 就是第二节介绍的 SerialExecutor。在这个方法里看到了 onPreExecute()确实是在任务执行前调用 。最后exec.execute(mFuture); 终于到了任务执行的地方。
6. 总结 AsyncTask = Executor + Handler
经过一番分析，理解了 AsyncTask 的内部实现，发现它主要就是封装了一个可以串行执行任务的 Executor 以及处理线程间消息传递的 Handler，极大的简化了异步任务的处理。不过这里并没有涉及到并发访问资源的同步问题，因为所有的任务都被串行化执行了。其实在3.0之前的几个版本里任务曾经是并发执行的，但是这时候我们在 doInBackgroud 里面就要小心了，对于共享的资源访问必须要考虑同步问题。大概Google考虑到多数情况下程序员们不会意识到这个问题，所以最终还是改为串行执行了吧。
