AsyncTask的相关结论
下面是AsyncTask的相关结论，相关结论都会在下面的源码分析中一一印证。
- onPreExecute()是在异步任务执行之前调用的，它是在主线程中运行。
- doInBackground()是在子线程中运行，该方法执行的耗时的异步任务。
- onPostExecute(Result result)是执行完doInBackground之后被调用，参数result就是doInBackground计算的结果。
- 1，2，3以上3个方法不用手动调用，它们的调用都是AsyncTask自己去调用的。
- onProgressUpdate(Progress...values)在UI线程中执行，用于时时的更新UI，以进度条的方式，增加用户体验。
- protected final void publishProgress(Progress... values) 该方法一般会在doInBackground中执行，将计算的数据时时通过该方法传递给onProgressUpdate方法。该方法是final类型的。
- 异步任务就是能执行耗时耗时操作，并且将操作结果通知到UI线程中，完成此操作就需要使用到Handler消息机制，在AsyncTask中是通过InternalHandler去实现的。
- AsyncTask通过线程池去维护多个异步任务的创建和运行。
- AsyncTask实例需要在主线程中去实例化，因为postExecute是AsyncTask的方法，AsyncTask若是在子线程中运行，那么该方法也是在非UI线程调用，那么达不到刷新UI的效果了。
- AsyncTask#execute()需要在主线程调用，若在子线程中调用，那么在onPreExecute就会在子线程中运行，那么操作UI相关的操作就会出问题。
- AsyncTask异步任务不可以被执行多次，每一个异步任务都会有一个状态标记，分别为PENDDING,RUNING,FINISH，只要状态不是为PENDING都会抛出异常。
- AsyncTask#cancel(boolean)设置取消异步任务，设置之后会调用onCancelled()通知用户。
- AsyncTask#onCancelled()在finish()中判断当前状态是否为取消状态，取消状态的话则调用onCancelled(Result)方法。
- AsyncTask默认是串行执行的，需要并行执行异步任务的话则需要在executeOnExecutor方法传递一个Executor就可以实现并行执行。
1. AsyncTask构造方法
实例化对象中，实例化了mWorker,mFuture对象，具体实现待会具体分析。
public AsyncTask() {
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception{
...
}
};
mFuture = new FutureTask<Result>(mWorker) {
@Override
protected void done() {
...
}
};
}
2.WorkerRunnable&FutureTask
从类的定义可以知道mWorker是Callable的子类对象，mFuture是Runnabel的子类对象。
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}
public interface RunnableFuture<V> extends Runnable, Future<V> {}
public class FutureTask<V> implements RunnableFuture<V> {}
3.AsyncTask#execute(Params... params)
有了AsyncTask实例之后，怎样去开始执行一个异步任务？可以通过execute方法开启一个异步任务。有一个疑问？params是什么？我们看源码得出去找params用来干嘛。execute会通过executeOnExecutor(Executor exec,Params... params) 去执行任务。
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
4.AsyncTask#executeOnExecutor(Executor exec,Params... params)
从源码中可知道execute传递的params原来是会被赋值给mWorker.params，具体什么作用，我们先不分析，待会用到再说。现在我们看到一个熟悉的方法，那就是onPreExecute()，这证实了AsyncTask的第(1)条结论，那就是onPreExecute()是在主线程中运行（前提：AsyncTask是在主线程创建的），然后是在异步任务执行之前调用，通常用于准备工作。
@MainThread
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,Params... params) {
...
onPreExecute();//异步执行之前调用。
mWorker.mParams = params;
exec.execute(mFuture);//将任务放到线程池的，开始异步任务。
return this;
}
疑问1：exec是什么？
它是一个线程池，从传入的参数sDefaultExecutor可以看出，它是一个默认的线程池，内部维护一个ArrayDeQue队列。AsyncTask里默认维护了一个静态的线程池，不管有多少个AsyncTask调用execute方法都会去共享这个静态的线程池，该线程池只允许一次运行一个任务，多余的任务需要等待，这印证了第(8)点结论。SerialExecutor内部只是维护了一个队列，真正执行任务还是THREAD_POOL_EXECUTOR 去执行。代码如下：
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;//默认的线程池就是它
private static class SerialExecutor implements Executor {
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();//内部维护一个队列
public synchronized void execute(final Runnable r) {
...
//真正执行任务还是THREAD_POOL_EXECUTOR 去执行,代码暂时不贴。
}
...
}
疑问2：怎么体现异步任务在子线程执行？
答案就在SerialExecutor#execute怎么去执行Runnbale的?mTasks.offer将一个Runnabel添加到mTask中，这样做的目的就是按顺序地去执行任务，具体的实现就在scheduleNext()中。现在所处就是在子线程中了
private static class SerialExecutor implements Executor {
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();//不支持并发访问，是一个Collection数据结构，不安全
Runnable mActive;
public synchronized void execute(final Runnable r) {
mTasks.offer(new Runnable() {//插入一个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);
}
}
}
5.FuturnTask#run()
execute方法的最终会调用Runnable中run方法被执行，也就是说mFuture#run会被执行，接下来看看run怎么实现的
public void run() {
Callable<V> c = callable;//就是 mWorker 对象
...
V result;
result = c.call();//开始计算
...
if (ran)
set(result);
}
疑问1：callable是什么？
callable实际上就是在AsyncTask构造中传递给mFuture的构造参数(mWorker对象)
public FutureTask(Callable<V> callable) {
if (callable null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}
疑问2：result又是什么？
分析：result = c.call()将子线程中运行的结果赋值给result。result的类型就是Callable<V>的泛型类型。在mFuture初始化的时候已经被指定Result类型，也就是在AscnycTask异步任务执行结果返回值类型。接下来看看call怎么去计算异步结果的。
6.计算异步结果WorkerRunnable#call()
标记postResult方法调用的标记，这句话的作用现暂时放着，待会再解释。这时候我们又看到熟悉的身影了（doInBackground），这段代码实在子线程中执行的，也就印证了第(2)条结论。将返回结果传递给postResult，接下来看看postResult的实现
public Result call() throws Exception {
mTaskInvoked.set(true);//标记postResult为被调用
Result result = doInBackground(mParams);
return postResult(result);
};
7.AsyncTask#postResult
大家看到这里相信应该都有点眉目了，刚才call方法是在子线程中运行的，现在出现的Message和Handler的身影，那么100%就将异步结果放到主线程中去。我们看看怎么实现：
private Result postResult(Result result) {
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
8.InternalHandler消息机制实现消息的放松
既然需要更新UI，那么就需要将消息发送到主线程中去，那么就得拿到主线程中的Looper轮训器，在InternalHandler中的构造可以看到，获取到的Looper是主线程中的。
在这里可以看到两个case:MESSAGE_POST_RESULT是在postResult中调用，MESSAGE_POST_PROGRESS是在publishProgress中调用的
然后在onProgressUpdate中去调用，该方法是在需要子类去实现处理的，在该方法中将数据回调在主线程去。 印证了第(7)点结论
public InternalHandler() {
super(Looper.getMainLooper());
}
@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);//印证第(5)结论
break;
}
}
}
@WorkerThread
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
9.AsyncTask#finish(Result result)
在该方法中我又看到一个熟悉的身影那就是onPostExecute，由于finish是在handleMessage中调用的，所以它也是在主线程中调用，并且有Result结果，可以更新UI。 这里就印证了第(3)条结论 。
private void finish(Result result) {
if (isCancelled()) {//判断是否取消
onCancelled(result);
} else {//没有取消
onPostExecute(result);//将结果传递给该方法，主线程更新UI
}
mStatus = Status.FINISHED;//更新标记为完成
}
10.FuturnTask#set(result)
在call方法将结果计算之后，就需要将该结果保存起来，set方法就是做这件事的，在set中将result结果赋值给outcome，并且调用FutureTask#done(),看到这里我们会有点印象，那就是在 AsyncTask构造中实例化mFuture时重写了done()方法，这个方法就是在这里回调的 。下面我们看看done做了什么事？
protected void set(V v) {
if (U.compareAndSwapInt(this, STATE, NEW, COMPLETING)) {
//将计算的结果保存到 outcome 中。
outcome = v;
U.putOrderedInt(this, STATE, NORMAL); // final state
finishCompletion();
}
}
11.FutureTask#done()
该方法由子类去实现，当异步任务执行完毕之后会调用。该方法被调用表示Callable#call()方法的计算结果已经被保存在outcome中了，在需要的地方取出即可。done()除了在finishCompletion()中调用外，还有innerCancel(boolean)中调用，这个接下来再分析。
mFuture = new FutureTask<Result>(mWorker) {
@Override
protected void done() {
...
postResultIfNotInvoked(get());
...
};
get()是什么？可以源码直到，它实质上返回就是我们刚才说的call方法计算返回的值（outcome）。该值传递给postResultIfNotInvoked(Result result)又做了什么事呢？
12.postResultIfNotInvoked(Result result)
当看到这个wasTaskInvoked这个值的时候，我们应该有一丢丢印象，那就是在call方法执行的该标记被置为true了。这时候被取出来也是为true，那么接下来的代码就没执行了。现在有一个疑问，if条件在什么情况会成立呢？请看异步任务取消的代码就直到了。
private void postResultIfNotInvoked(Result result) {
final boolean wasTaskInvoked = mTaskInvoked.get();
if (!wasTaskInvoked) {//wasTaskInvoked这个标记唯一被赋值的地方就是call方法，标记为true表示postResult被调用，那么就不要再调用postResultIfNotInvoked方法了，除非cancel了该任务，导致在call方法没有对该标记赋值，所以该方法就会被调用。
postResult(result);
}
}
13.AsyncTask#postResult()
private Result postResult(Result result) {
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
14.取消异步任务AsyncTask#cancel(boolean)
将取消标记为true，并且调用mFuture#cancel取消任务。
public final boolean cancel(boolean mayInterruptIfRunning) {
mCancelled.set(true);
return mFuture.cancel(mayInterruptIfRunning);
}
15.FutureTask#cance(boolean)
在该方法中也执行了done()方法，该方法在AsyncTask构造中已经可以看到，直接回到先前的代码查阅，它会去调用postResultIfNotInvoked(Result),这就解释了为什么这个方法的命名，当异步任务没有执行完毕，它是不会去执行设置mTaskInvoked.set(true)的，因此该方法就可以顺利成章的执行了。代码最终会去执行postResult。
boolean innerCancel(boolean mayInterruptIfRunning) {
...
done();
return true;
}
