AsyncTask是什么
AsyncTask是一个系统为我们封装好的异步任务类。通过这个类，我们可以很方便地在后台执行耗时操作，执行完毕后在UI线程更新UI。AsyncTask自动帮我们完成了线程切换，我们只需要实现该类中的方法就行。
AsyncTask内部由两个线程池和一个Handler组成（你还不清楚Handler的原理，请看我这篇博客一张图学习安卓的消息机制，两个线程池中一个负责存储任务，另一个负责执行任务，Handler负责切换线程。
AsyncTask怎么用
AsyncTask是一个抽象类，他提供了Params、Progress、Result三个泛型和onPreExecute()、doInBackground(Param)、onProgressUpdate(Progress)、onPostExecute(Result)四个抽象方法组成。
三个泛型
AsyncTask中有三个泛型Params、Progress、Result，分别表示AsyncTask输入的参数类型，进度条更新的参数类型，返回结果的参数类型。如果不需要输入、进度条、返回值，直接将泛型定义为void。
四个抽象方法
onPreExecute()
在主线程中执行，在异步任务执行之前，onPreExecute()先会被调用，我们可以在该函数中实现一些初始化操作。
doInBackground(Params)
在线程池中运行，用于执行异步任务。这个函数有一个输入值，Params，也就是任务需要输入的参数。在该任务中，我们可以调用publishProgress(Progress)方法来更新进度条，publishProgress(Progress)方法会调用onProgressUpdate(Progress)方法。
onProgressUpdate(Progress)
在该方法中更新进度。该方法运行在主线程中，有一个输入参数Progress，是当前的进度。
onPostExecute(Result)
在主线程中执行，用于显示执行结果，在异步任务执行完毕后会调用该方法。
通常用法
private class DownloadFilesTask extends AsyncTask<URL,Integer,Long>{
protected void onPreExecute(){
//执行初始化任务
}
protected Long doInBackground(URL urls){
//TODO 执行下载任务
。。。。。。。
publishProgress(20);//更新进度
}
protected void onProgressUpdate(Integer){
//显示进度
}
protected void onPostExecutor(Result){
//显示执行结果
}
}
new DownloadFilesTask ().execute(URL);
AsyncTask的实现原理
AsyncTask中的异步任务在子线程中完成，更新进度和显示结果在主线程中调用。所以，它内部肯定有一个Handler。此外，AsyncTask中还有两个线程池，一个线程池叫SERIAL_EXECUTOR，用于将所以的异步任务保存在一个队列中，另一个线程池叫做THREAD_POOL_EXECUTOR，在该线程池中队列中的任务会串行执行。
首先看AsyncTask的初始化
//CPU_COUNT为手机中的CPU核数
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
//将手机中的CPU核数加1作为AsyncTask所使用的线程池的核心线程数的大小
private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
//将CPU_COUNT * 2 + 1作为AsyncTask所使用的线程池的最大线程数的大小
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE = 1;
//实例化线程工厂ThreadFactory，sThreadFactory用于在后面创建线程池
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
//mCount为AtomicInteger类型，AtomicInteger是一个提供原子操作的Integer类，
//确保了其getAndIncrement方法是线程安全的
private final AtomicInteger mCount = new AtomicInteger(1);
//重写newThread方法的目的是为了将新增线程的名字以"AsyncTask #"标识
public Thread newThread(Runnable r) {
return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
}
};
//实例化阻塞式队列BlockingQueue，队列中存放Runnable，容量为128
private static final BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(128);
//根据上面定义的参数实例化线程池
public static final Executor THREAD_POOL_EXECUTOR
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
上面的程序中定义了线程池中线程数的最大值，创建了一个队列用于保存待执行的任务，创建了一个叫THREAD_POOL_EXECUTOR的线程池。
而后又会执行下面的代码，创建了一个SERIAL_EXECUTOR的线程池。
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
//SerialExecutor实现了Executor接口中的execute方法，该类用于串行执行任务，
//即一个接一个地执行任务，而不是并行执行任务
private static class SerialExecutor implements Executor {
//mTasks是一个维护Runnable的双端队列，ArrayDeque没有容量限制，其容量可自增长
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
//mActive表示当前正在执行的任务Runnable
Runnable mActive;
public synchronized void execute(final Runnable r) {
//execute方法会传入一个Runnable类型的变量r
//然后我们会实例化一个Runnable类型的匿名内部类以对r进行封装，
//通过队列的offer方法将封装后的Runnable添加到队尾
mTasks.offer(new Runnable() {
public void run() {
try {
//执行r的run方法，开始执行任务
//此处r的run方法是在线程池中执行的
r.run();
} finally {
//当任务执行完毕的时候，通过调用scheduleNext方法执行下一个Runnable任务
scheduleNext();
}
}
});
//只有当前没有执行任何任务时，才会立即执行scheduleNext方法
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
//通过mTasks的poll方法进行出队操作，删除并返回队头的Runnable，
//将返回的Runnable赋值给mActive，
//如果不为空，那么就让将其作为参数传递给THREAD_POOL_EXECUTOR的execute方法进行执行
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
在SERIAL_EXECUTOR线程池中，会将待执行的任务放进队列中保存起来，并且提供了一个叫做scheduleNext的方法，该方法中从队列取出任务，交给THREAD_POOL_EXECUTOR来执行。
所以我们得知，SERIAL_EXECUTOR用于保存和调度任务，THREAD_POOL_EXECUTOR真正执行了异步任务。
当任务执行完以后，会调用postResult方法。我们接着看postResult方法。
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
//通过getHandler获取InternalHandler，InternalHandler绑定主线程
//根据InternalHandler创建一个Message Code为MESSAGE_POST_RESULT的Message
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
//将该message发送给InternalHandler
message.sendToTarget();
return result;
}
postResult方法中，使用getHandler().obtainMessage发送了一个消息。我们接着看这个Handler
private static class InternalHandler extends Handler {
public InternalHandler() {
//Looper类的getMainLooper方法是个静态方法，该方法返回主线程的Looper
//此处用主线程的Looper初始化InternalHandler，表示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:
//发布最后结果
result.mTask.finish(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
//发布阶段性处理结果
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}
在这个Handler的构造方法中，获取的是Looper.getMainLooper()，所以这个Handle运行在主线程中。然后handleMessage处理两个消息，一个是处理最后结果，一个是处理进度的更新。
一张图总结
到这里AsyncTask的工作原理就水落石出了。结合下面一张图来总结一下。
1.先在主线程中调用AsyncTask的preExecutor方法。
2.线程池SERIAL_EXECUTOR将待执行的AsyncTask放入队列中
3.线程池THREAD_POOL_EXECUTOR从队列中取出任务，执行任务的doInBackground方法。执行完任务的doInBackground的方法后，向InternalHandler发送消息。
4.InternalHandler接收消息，显示结果或者更新进度。
