标签：Android AsyncTask 源码解析
1.关于AsyncTask
1.1 什么是AsyncTask?
根据Google的官方文档
This class allows you to perform background operations and publish results on the UI thread without having to manipulate threads and/or handlers.
AsyncTask允许我们执行后台操作并在UI线程中更新结果，而不用去操作threads或handlers。这句解释很明显的告诉了我们：AsyncTask是一个thread和handler的封装。
1.2 为什么使用AsyncTask?
既然AsyncTask只是一个封装，那它到底帮我们解决了哪些细节上的问题呢？除了提供更简明的接口之外，当我们单纯的使用thread+handler的组合时，其实我们忽略了线程所带来的一系列问题，比如创建线程的开销、如何管理线程等等，特别是当多任务情况下，情况会更加复杂。
2.源码解析
*注：源码基于api-24
源码点进去一大堆，我们这里直接从任务被执行开始看起。同时为了避免深入细节无法自拔的情况，我先大体看一下整个的调用顺序，而不去太纠结具体实现。
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
可以看到子类直接调用了父类的execute()方法。该方法又调用了executeOnExecutor() 方法。同时将sDefaultExecutor这个静态变量传递给了executeOnExecutor方法。那这个sDefaultExecutor又是什么鬼呢？
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
//省略...
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
原来sDefaultExecutor只是一个Executor接口，而它的实现则是SerialExecutor这样一个内部类。我们先把这个类的具体实现放下，不过从类的名字就可以猜出个大概来，这是一个用来顺序执行任务的线程池类。OK这个坑我们先迈过去，回头再来继续填它。再看看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;
}
5-17行先判断当mStatus的值，即前任务的状态，只有没有运的任务才能够被运行，否则将会抛出异常。再往下看，在将mStatus的值置为RUNNING之后，我看到了一个十分熟悉的方法onPreExecute()，而这个方法是个空实现，具体在执行任务之前要做些什么，是由我们自己去实现的。23-24行突然冒出两个新变量，mWorker和mFuture，回到变量声明和构造函数处看看他们的实质。
//变量声明
private final WorkerRunnable<Params, Result> mWorker;
private final FutureTask<Result> mFuture;
...
//构造函数，变量初始化
public AsyncTask() {
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
//...省略部分代码
}
};
mFuture = new FutureTask<Result>(mWorker) {
@Override
protected void done() {
//...省略部分代码
};
}
可以看到mWorker为一个WorkRunnale类，该类为一个静态抽象内部类，包含了一个初始化参数Params[]，并继承了Callable接口（待实现）。
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}
而mFuture为FutureTask的一个实例，FutureTask是Java并发编程中一个十分常见的类，主要用来异步执行任务，并返回结果。很显然，这些特点都是我们需要，但单纯的Thread所不具备的。FutureTask需要一个Callable接口来进行初始化，而这里我们使用了mWorker这个变量。
介绍了这么多，我们再捋一下思路：我们自己实现多XXXTask执行了execute()方法，再调用了我们重写多onPreExecute()方法后，该方法最终把一个任务(mFuture)交给了一个串行执行任务的线程池(sDefaultExecutor)去执行。那么剩下的问题就只有以下几个了：
1.任务(mFuture)具体做了些什么？
2.任务(mFuture)执行完后，如何通知UI线程的？
再回头看看mWork中Callable的实现：
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);
}
};
在这里我们发现一个十分熟悉的方法——doInBackground()，而该方法的签名是protected abstract Result doInBackground(Params... params)。是我们在子类中必须去实现的，因此mFuture具体做的事情就是我们在doInBackground()中的具体实现。再看看最后一行postResult()（此时任务有可能并未完成）：
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
再看看任务执行结束后，mFuture中done()方法的具体实现：
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);
}
}
可见，任务结束后同样也调用了postResult()方法。而该方法又是如何将结果传递给UI线程的呢？答案也很简单——通过Handler，这里的getHandler()方法返回一个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;
}
}
}
可以看到，构造器通过Looper.getMainLooper()来初始化了Hanlder，这也就是为什么hanlderMessage的具体执行是在UI线程（主线程）中的原因。最后判断消息的种类，如果为MESSAGE_POST_PROGRESS就调用我们自己实现的onProgress方法；如果为MESSAGE_POST_RESULT就调用finish方法，而finish()方法又会判断当前任务是否执行完成。若执行完成就交给我们实现的onPostExecute()方法，若还未执行完成就就给我们实现的onCancelled()方法。这样一来整个AsyncTask的大致流程我们就走完了～
再次整理一下流程：
1.我们自己实现的xxxTask(继承AsyncTask)执行了execute()方法；
2.execute方法调用了executeOnExecutor()方法，为我们的异步任务指定了一个串行执行任务的线程池；
3.该线程池调用了mFuture的call()方法，在子线程执行了我们重写的doInBackground()方法，最终发送一个消息给handler(用主线程的looper初始化);
4.该handler根据消息类型的不同，执行结束任务onPostExecute()或更新进度的操作onProgressUpdate()；
到此，我们常用的AsyncTask的方法，是不是不用再去翻文档我们也能写出先后顺序了呢，成就感满满哒～
3.细节问题
---待更新---
Todo-List
-
细节问题
- [x] 线程池相关
- [x] 线程池顺序执行任务的实现
- [x] 部分细节代码
- [x] WorkerRunnable 和 AsyncTaskResult
