我们知道，Android的界面渲染都是在UI线程中执行的，但是还会有一些耗时操作，如果直接在UI线程中执行，会导致ANR。那么，就需要在子线程处理耗时操作，处理完成之后，再交给UI线程处理。
为了处理子线程ui线程的切换，Android为我们提供了Handler机制。Handler就是将子线程的内容传递到当前线程（Handler初始化的线程）。
为了使用Handler实现数据在不同线程间的切换，需要使用Handler+Thread的方式。其中比较麻烦，Android为了方便我们在UI与子线程之间的切换，提供了AsyncTask。接下来，我们分析一下AsyncTask的过程。
AsyncTask里面有一个静态内部类SerialExecutor,源码如下
private static class SerialExecutor implement Executor {
final ArrayDeque<Runnable> mTasks = new ArrayDeque();
Runnable mActive;
public synchronized void execute(final Runnable r) {
mTasks.offer(new Runnable(){
public void run() {
try{
r.run();
} finally{
scheduleNext();
}
}
});
if(mActive == null) {
sheduleNext();
}
}
protected synchronized void scheduleNext() {
if((mActive = mTasks.poll()) != null) {
THREAD_POLL_EXECUTOR.execute(mActive)
}
}
}
在上述代码中，THREAD_POOL_EXECUTOR是在静态代码块里面初始化的：
static {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
sPoolWorkQueue, sThreadFactory);
//核心线程，在空闲状态的时候，若时间超过KEEP_ALIVE_SECONDS，则会被杀死
threadPoolExecutor.allowCoreThreadTimeOut(true);
private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE_SECONDS = 30;
//将threadPoolExecutor赋值给THREAD_POOL_EXECUTOR
THREAD_POOL_EXECUTOR = threadPoolExecutor;
}
在上面的SerialExecutor的实现里面，我们可以看到，每一个任务，都会放到mTask队列里面，每次从mTask中获取一个任务，然后通过线程池去执行。 SerialExecutor的实例化方式为： public static final Executor sDefaultExecutor = new SerialExecutor();可知，sDefaultExecutor是在主线程中,并且只保存一份内存地址。
同时，THREAD_POOL_EXECUTOR的实例化，是在静态代码块中，在静态代码块中声明的内容，其是在主线程中的，并且保持一份内存地址。
因此，每次new 一个AsyncTask，但是对应一个线程池THREAD_POOL_EXECUTOR，因此，AsyncTask同时执行的任务不能太多，如果超过线程池规定的数据，任务就会执行失败。
AsyncTask提供了两种方式，执行任务，分别是
1、execute(Param... param),内部会调用executeOnExecutor execute(sDefaultExecutor, param) 使用串行下载，里面使用默认的SerialExecutor,这个里面维护了一个队列，一个一个下载
2、executeOnExecutor(Executor exec, Param... param) 可以构造自己的下载方式，比如使用串行下载或者并行下载
其中，sDefaultExecutor = new SerialExecutor(); 我们看一下executeOnExecutor源码：
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec, Param... params) {
mStatus = Status.RUNNING;
onPreExecute();
mWorker.mParams = params;
exec.execute(mFuture);
return this;
}
其中，上面的mWorker和mFuture是在构造函数里面创建的，代码如下：
public AsyncTask(Looper callbackLooper) {
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler()
: new Handler(callbackLooper);
mWorker = new WorkerRunnable<Param, Result>() {
public Result call() {
mTaskInvoked.set(true);
Result result = null;
try {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
result = doInBackground(mParams);
Binder.flushPendingCommands();
} catch (Throwable tr) {
mCancelled.set(true);
throw tr;
} finally {
//利用handler将消息发送到UI线程中（Handler创建的线程中）
//AsyncTask必须在UI线程中调用
postResult(result);
}
return result;
}
}
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);
}
}
};
}
从上面我们可以知道，AsyncTask里面使用了FutureTask，处理任务。 当任务执行完成之后，使用postResult，将执行完成之后的结果通过handler的sendMessage切换到Handler所在的线程中。
postResult方法里面是如下实现：
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
将执行结果通过sendMessgae发送到Handler所在的线程中。 Handler的handMessage接收到MESSAGE_POST_RESULT，会调用AsyncTask的finish方法，finish方法里面实现如下
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
我们可以看到，如果当前任务没有被cancle，则会调用onPostExecute，否则调用onCancelled
总结：
执行AsyncTask的execte方法之后，使用线程池ThreadPoolExector执行任务。每个任务是一个FutureTask,FutureTask构造函数里面传的是一个Callable，Callable执行里面的call方法，最终会调用doInBackGround方法，同时在finally里面执行postResult，任务执行完成之后，调用FutureTask里面的done方法，done最终会调用onPostExecutor()方法。
在上面我们看到postResult有两个地方都会调用，但是实际上，postResult只会执行一次。因为，如果在call中，正常执行doInBackGround，就会记一个flag，下次回调到done方法的时候，会先判断flag，如果flag为true，就不重新sendMessage。
由于线程池在静态代码块里面实例化，因此，整个app进程，只保留一份内存地址，因此，尽量避免同时new多个AsyncTask，因为ThreadPoolExector只有一份，里面的核心任务数量是一定的，如果AsyncTask任务过多，会导致一些任务运行失败。
