AsyncTask为Android封装的轻量级异步类，用法简单。但是在这个简单的异步类里面其实包含了很多的知识点，本文主要是从设计模式 -- 模板方法来简单分析其在AsyncTask中的使用。先说一下模板方法的定义：
模板方法：针对一个特定问题，它的解决步骤是已知、并且是固定的，但是步骤中的具体的解决方式，由于不同需求可能不同，所以出现了模板方法（固定，不可改变），在该方法中定义了步骤（方法），子类只需要根据需要重写相应步骤方法即可。
我们先看下AsyncTask的简单使用：
//创建异步任务并执行
new AsyncTask<Void,Void,Void>(){
@Override
protected Void doInBackground(Void... params) {
return null;
}
}.execute();
首先我们来看一下的AsyncTask构造函数：
/**
* AsyncTask构造，必须在UI线程调用本构造，创建异步任务
*/
public AsyncTask() {
//WorkerRunnable为Callable<Result>接口实现类
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
...省略几行代码
//调用doInBackground
result = doInBackground(mParams);
...省略几行代码
} ...省略异常捕获
finally {
//将使用Hanlder发送结果到主线程
postResult(result);
}
return result;
}
};
//可以简单认为就是一个Runnable子实现类
mFuture = new FutureTask<Result>(mWorker) {
@Override
protected void done() {
try {
//判断是否执行过，未执行的话会调用postResult
postResultIfNotInvoked(get());
} ...省略异常捕获
}
};
}
可以看出，在AsyncTask的构造函数中主要是构造了两个对象，mWorker 和mFuture ，mWorker 为Callable接口实现类，主要是重写call方法，一会在线程池执行的时候会调用；mFuture为FutureTask接口实现类，重写run方法，FutureTask为Runnable的子类。
执行异步任务一共有两个方法execute和executeOnExecutor，不过两者实际上是一样的，因为execute也会调用executeOnExecutor，所以我们直接看executeOnExecutor方法：
/**
* 执行异步任务，需要在UI线程调用，会返回异步任务引用
*/
@MainThread
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
...省略几行代码
//执行该方法，可以做初始化操作（在UI线程）
onPreExecute();
...省略几行代码
//线程池开始执行任务（会将mFuture添加到当前队列的尾部），会调用mFuture的run方法。
//在线程池中每次执行完毕都会从队列中获取第一个任务元素来执行，直到全部执行完毕
exec.execute(mFuture);
return this;
}
executeOnExecutor中使用exec，即线程池来执行execute，我们就以默认的SerialExecutor来分析：
public synchronized void execute(final Runnable r) {
mTasks.offer(new Runnable() {
public void run() {
try {
//调用传递进来的Runnable的run方法（实际上为mFuture的run方法）
r.run();
} finally {
//获取下一个任务来执行
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
在SerialExecutor的execute方法中我们看到它调用例如r.run,r即为我们前面传递进去的mFuture，我们看下构造中的mFuture的run方法：
public void run() {
...省略几行代码
//调用Callable的call方法（实际上就是AsyncTask构造中所初始化的mWorker）
result = c.call();
...省略几行代码
}
c即为我们传递进去的mWorker实例，mWorker的call方法为：
public Result call() throws Exception {
...省略几行代码
//调用doInBackground
result = doInBackground(mParams);
...省略几行代码
} ...省略异常捕获
finally {
//将使用Hanlder发送结果到主线程
postResult(result);
}
return result;
}
可以看到这里调用了doInBackground，最后还会调用postResult方法，postResult会使用基于UI线程的Handler对象（InternalHandler 实例），将结果发送到UI线程：
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
//使用Handler获取缓存Message对象，有则直接使用，没有则新建（Message使用了享元模式，防止大量创建Message从而消耗性能）
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
自定义Hanlder类：
private static class InternalHandler extends Handler {
//定义UI线程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:
// 执行完毕，回调finish
result.mTask.finish(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
//回调进度刷新(需要注意的是这个方法要回调，需要调用publishProgress才会触发)
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}
AsyncTask的finish方法
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
从以上流程就可以看出AsyncTask.execute的执行流程：onPreExecute() --> doInBackground() --> publishProgress() --> onProgressUpdate() --> onPostExecute()。这整个流程都是从execute/executeOnExecutor开始的，它们被定义为final类型，原因就是异步任务的步骤是固定的，就是以上几个步骤，但是具体这个异步任务要做什么，就需要子类根据自身需求来确定，只要重写相应的方法即可。这就是模板方法模式的一个简单分析，在Android中其实还有很多使用到了模板设计模式，只是我们没有去在意，比如：Activity/Fragment的生命周期等。如果有什么不足之处还请指出，一起进步。
