写作原因：AsyncTask是Android中轻量级异步操作的方案之一，这篇文章我们不谈其使用过程，我们要谈论的是其实现过程及背后相关的设计思想，这有利于提高我们的代码能力。
源码分析
入口：
new DownloadTask().execute(url);
AsyncTask是从execute()方法作为执行入口的，我们看看execute()方法。
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
它返回了executeOnExecutor(sDefaultExecutor, params);的结果，这里分两条线索，一条是sDefaultExecutor，另一条就是executeOnExecutor()。先看看后者，我们继续深入探究：
@MainThread
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;
}
首先看到有一个mStatus枚举对象，一共有三种状态：PENDING、RUNNING和FINISHED。我们查看声明该变量的地方发现：private volatile Status mStatus = Status.PENDING;，即一开始时状态为等待。现在我们可以大胆猜测这段代码的作用：查看一个AsyncTask对象是否是等待运行的状态（一开始时是等待），如果不是则分为两种情况（Running和Finished）分别抛出异常，如果是则切换为Running状态。然后调用onPreExecute()方法。下面有两行代码：
mWorker.mParams = params;
exec.execute(mFuture);
暂时还难以看出它们的作用，不过应该跟线程的执行相关。这时我们先去看看另外一条路：sDefaultExecutor，sDefaultExecutor实际上是一个静态的SerialExecutor对象。我们看看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是一个线程池（有关线程池的基本知识参见前面一篇博文），内部成员包括一个用于储存Runnable的双端队列对象mTasks和一个Runnable对象mActive。在executeOnExecutor()方法中我们调用了execute()方法，理解一下这个方法的作用。首先它在双端队列中插入一个新的线程，这个线程包括mFuture的run()方法和执行scheduleNext()方法。此外当mActive对象为null时也会执行scheduleNext()方法。而scheduleNext()方法作用又是什么呢？它用于将mTasks中的对象取出然后传递给mActive对象，如果不为null则让THREAD_POOL_EXECUTOR调用execute()方法去执行mActive。
源码这样写，我们结合前面的理解一下：
每次启动一个AsyncTask对象时，Android首先会判断它的状态，只有等待时会将该对象状态切换成Running。这样可以防止一个对象多次启动。然后会调用onPreExecute()方法，接着将mFuture对象压入线程池sDefaultExecutor中。这个线程池实际上是一个任务管理器，在这个任务管理器中系统将接收到的mFuture对象的run()方法剥离出来导入自己创建的一个Runnable对象之中，然后通知mActive去从双端队列中取出一个Runnable对象执行。具体执行过程是在THREAD_POOL_EXECUTOR线程池中实现的。到这里又有两个地方有疑问了，其一，mFuture是什么？其二，THREAD_POOL_EXECUTOR怎么运行？下面继续，先看看THREAD_POOL_EXECUTOR怎么运行。
public static final Executor THREAD_POOL_EXECUTOR
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
这个线程池通过标准的线程池类创建，具体实现也就与ThreadPoolExecutor一致了。所以这里就不多费笔墨了，不过可以看出AsyncTask一次执行任务数为CPU核心数+1。
再看看mFuture的来源实现：
博主找到了mFuture的声明和实现：
private final FutureTask<Result> mFuture;
在AsyncTask构造方法中：
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);
}
}
};
这是一个FutureTask对象。有关FutureTask相关知识点击此处：Java并发编程：Callable、Future和FutureTask
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);
}
}
};
这里重写了done()方法，表示当该子线程任务完成后回调，将结果传递给以下方法，下面几段源码实现了从子线程中将结果传给主线程的功能，通过InternalHandler来实现：
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
查看getHandler()方法，有：
private static Handler getHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
sHandler = new InternalHandler();
}
return sHandler;
}
}
继续查看InternalHandler类有：
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;
}
}
}
在InternalHandler中将mWorker得到的结果在主线程中处理，直接结果就是调用了finish方法间接调用onPostExecute(result)，从而实现了从子线程到主线程的结果传递的逻辑。到这里我们大概分析了AsyncTask的基本运行流程。
总结
总体流程
现在整理一下整体逻辑。创建一个AsyncTask对象首先根据参数Params创建mWorker，然后用mFuture去包装它，这个mFuture会被丢到任务线程池sDefaultExecutor中进行待命，轮到他时会进入THREAD_POOL_EXECUTOR线程池中执行。mWorker中会执行doInBackground()方法，执行后结果会通过sHandler传递主线程的Handler，在onPostExecute()中即可拿到结果。
收获
阅读源码是一个逆向推导的过程，需要耐得住性子。有些地方可能存在疑问，这时尚未见到整体难以推出其作用，可能需要到后面一些代码的推导下才能发现作用。有时可能需要借助API来参阅源码中用到的相关的类的作用。此外在源码中存在许多优秀的规范性的东西或者有价值的思想，这些需要慢慢研究总结。
