前言
AsyncTask的分析会用到线程池的相关知识，如果没有了解过，可以先看一下我的笔记：线程池笔记
基础
AsyncTask是Android中用于异步处理的辅助类，十分的有用，能够让我们简单的在工作线程中进行耗时操作（比如I/O，网络请求），然后在UI线程进行更新操作等。
AsyncTask的用法就不说了，相信大家都用了几次了，主要的方法有：
- onPreExecute
- doInBackground
- onProgressUpdate
- onPostExecute
其中doInBackgroud运行在子线程中，其他均运行在主线程。
源码分析
其实AsyncTask是对线程池的一种封装，那么接下来就从源码来看看AsyncTask吧~
我们一般是通过execute方法进行开启任务：
new MyAsyncTask().execute("#1");
在new一个对象时，会调用用AsyncTask类中的构造方法，会初始化一个mWorker对象，在其中的call方法中会调用result = doInBackground(mParams)，完成后调用postResult(result)，并将mWorker对象传给mFuture对象，mFuture对象的run()方法会调用mWorker对象的call()方法。那么谁调用这个mFuture的run()方法呢？
那么我们看看execute方法：
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
....
mStatus = Status.RUNNING;
onPreExecute();
mWorker.mParams = params;
exec.execute(mFuture);
return this;
}
可以看到execute方法也是调用了executeOnExecutor方法，先执行了onPreExecute()，再执行exec.execute(mFuture)
从上面可以发现exec是sDefaultExecutor对象，那么这个sDefaultExecutor是怎样的呢？我们看看声明：
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>();
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);
}
}
}
我来解释解释上面的代码：
-
sDefaultExecutor是SerialExecutor的一个对象 -
SerialExecutor的execute方法是新创建一个Runnable对象，并在run方法中执行将作为参数传入的Runnable对象的run方法，并在run方法运行完成之后调用scheduleNext方法(finally代码块)。offer方法是将新创建的Runnable对象加入到mTasks的队尾（mTasks是一个双向队列） - 如果
mActive为空，即当前没有任务在运行就执行scheduleNext方法 -
scheduleNext是将Runnable对象加入到THREAD_POOL_EXECUTOR线程池运行并执行 - 所以
execute方法并没有执行传入，而只是作为一个任务调度者，真正的执行者是THREAD_POOL_EXECUTOR。 - 这是一个
static对象，所以创建多个MyAsyncTask对象的时候，任务排队排的是同一个队伍，所以会一个一个执行。
例如，当我们如下开启任务的时候：
new MyAsyncTask().execute("1");
new MyAsyncTask().execute("2");
new MyAsyncTask().execute("3");
new MyAsyncTask().execute("4");
我在doInBackground中sleep了3秒，然后打印传入的参数。执行结果如下图所示，
可以看到明显是隔了3秒才执行一个任务：
所以SerialExecutor是一个串行的调度器，让新加入的任务排队，通过加入到THREAD_POOL_EXECUTOR来执行任务。
再来看看THREAD_POOL_EXECUTOR的定义：
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE = 1;
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);
这是一个线程池，其中核心线程数为CPU数量+1，最大线程数为CPU_COUNT * 2 + 1，队列最大容量为128
所以通过execute()方法启动AsyncTask，默认情况下是串行执行的。(从Android3.0开始)
要想并行执行，需调用executeOnExecutor方法，并直接传入THREAD_POOL_EXECUTOR对象：
new MyAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"1");
new MyAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"2");
new MyAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"3");
new MyAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"4");
这样就不会是串行调度了，而是并行调度：
任务几乎是同时执行完毕的。
后记
好了，上面就是我看完开发探索之后，自己慢慢琢磨了一下源码，然后总结的笔记啦，你可以看看AsyncTask的源码，应该会有新的收获哟~
