深入了解AsyncTask工作原理
一、 AsyncTask简介
AsyncTask是一种轻量级的异步任务类，它可以在线程池中执行后台的任务，然后把执行的进度和最终结果传递给主线程并在主线程中更新UI。
private abstract class AsyncTask<Params, Progress, Result>
它提供了Params、Progress和Result这三个泛型参数，其中Params表示参数的类型，Progress表示后台任务执行进度的类型，而Result则表示后台任务的返回结果的类型。
AsyncTask提供了4个核心方法：
- preExecute() 主线程中执行，异步任务执行前会被调用
- doInBackground(Params...params) 线程池中执行，用于执行异步任务
- onProgressUpdate(Progress..values) 主线程执行，当后台任务执行进度发生改变时调用
- onPostExecute(Result result) 主线程执行，异步任务执行之后被调用
除了上述四个方法，AsyncTask还提供了onCancelled()方法，同样在主线程中执行，当异步任务被取消时，onCancelled()方法被调用。
下面提供一个实例：
private class DownloadFilesTask extends AsyncTask<URL, Integer, Long>{
@Override
protected Long doInBackground(URL... urls) {
// 执行下载任务
int count = urls.length;
long totalSize = 0;
for (int i=0; i<count; i++){
totalSize += Downloader.downloadFile(urls[i]);
// 当publishProgress被调用时，onProgressUpdate就被被调用，更新界面中的下载进度
publishProgress((int)((i/(float)count)*100));
// 判断下载任务是否被外部中断
if (isCancelled()) break;
}
return totalSize;
}
@Override
protected void onProgressUpdate(Integer... progress) {
// 更新界面中的下载进度
setProgressPercent(progress[0]);
}
@Override
protected void onPostExecute(Long result) {
// 当下载任务执行完成后执行
showDialog("Downloaded" + result + "bytes");
}
}
ps：doInBackground和onProgressUpdate方法它们的参数中均包含...的字样，在Java中表示参数的数量不定
当要执行上述下载任务是，可通过以下方式来完成：
new DownloadFilesTask().execute(url01, url02, url03);
使用AsyncTask需要注意：
- AsyncTask的类必须在主线程中加载
- AsyncTask的对象必须在主线程中创建
- execute必须在UI线程被调用
- 不要再程序中直接调用onPreExecute、onPostExecute、doInBackground、onProgressUpdate等方法
- 一个AsyncTask对象只能执行一次，即只调用一次excute方法，否则会报运行时异常
二、 AsyncTask的工作原理
为了分析AsyncTask，我们得从AsyncTask的源码入手，首先从它的execute方法开始分析：
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
execute方法又会执行executeOnExecutor方法
@MainThread
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
if (mStatus != Status.PENDING) {
switch (mStatus) {
case RUNNING:
throw new IllegalStateException("Cannot execute task:"
+ " the task is already running.");
case FINISHED:
throw new IllegalStateException("Cannot execute task:"
+ " the task has already been executed "
+ "(a task can be executed only once)");
}
}
mStatus = Status.RUNNING;
onPreExecute();
mWorker.mParams = params;
exec.execute(mFuture);
return this;
}
在executeOnExecutor方法中首先会判断此AsyncTask是否已经在执行或者已经执行完毕，这就是为什么一个AsyncTask对象只能执行一次，即只调用一次excute方法，否则会报运行时异常
如果可以运行，则onPreExecute()方法会首先被调用，然后线程池exec（sDefaultExecutor）开始执行mFuture
mFuture一个FutureTask对象，在new AsyncTask()方法中系统会将AsyncTask的Params参数封装成FutureTask对象，FutureTask是一个并发类，这里充当Runnable的作用
接下来看sDefaultExecutor的execute()方法：
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);
}
}
}
AsyncTask有两个线程池（SerialExecutor和THREAD_POOL_EXECUTOR）和一个Handler
（InternalHandler），其中线程池SerialExecutor用于任务的排队，而线程池THREAD_POOL_EXECUTOR用于真正地执行任务，InternalHandler用于将执行环境从线程池切换到主线程
从源码可以看出，SerialExecutor的execute方法首先把FutureTask对象插入到任务队列mTasks中，如果这个时候没有正在活动的AsyncTask任务，那么就会调用SerialExecutor的scheduleNext方法来执行下一个AsyncTask任务。当一个AsyncTask任务执行完后，AsyncTask会继续执行其他任务直到所有任务都被执行为止，从这一点可以看出，在默认情况下，AsyncTask是串行执行的。
接下里，要看FutureTask的run()方法，run()的方法里会调用mWorker的call()方法，因此mWoker的call()方法最终会在线程池执行：
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
Result result = doInBackground(mParams);
Binder.flushPendingCommands();
return postResult(result);
}
};
这样就一目了然了，在mWorker的call方法中，首先将mTaskInvoked设为true，表示当前任务已经被调用过了，然后执行Async的doInBackground方法，接着将其返回值传递给postResult方法，它的实现如下：
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
在上面代码中，postResult方法会通过Handler发送一个MESSAGE_POST_RESULT的消息，这个Handler的定义如下：
private static Handler getHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
sHandler = new InternalHandler();
}
return sHandler;
}
}
private static class InternalHandler extends 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:
// There is only one result
result.mTask.finish(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}
可以发现，这里的Handler对象是一个静态的Handler对象，为了能够将执行环境切换到主线程，这就要求这个Handler必须在主线程中创建。由于静态成员会在加载类的时候进行初始化，因此这就要求AsyncTask的类必须在主线程中加载，否则同一个进程中的AsyncTask都将无法正常工作。Handler收到MESSAGE_POST_RESULT消息后会调用AsyncTask的finish方法：
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
如果AsyncTask被取消执行了，那么就调用onCancelled方法，否则就调用onPostExecute方法，可以看到doInBackground的返回结果会传递给onPostExecute方法，到这里AsyncTask的整个工作过程就分析完毕了。
最后附上自己画的一副粗糙的图，into指进入函数内部，next代表下一个方法
源于《Android开发艺术探索》
三、 AsyncTask思考
多个AsyncTask任务是串行还是并行？
根据我们上面的源码，多个AsyncTask任务是串行执行的（Android3.0版本过后）。
如果需要并行执行，则只需要调用executeOnExecutor(Executor)函数，并把参数设置为并行执行即可。即创建一个单独的线程池(Executors.newCachedThreadPool())。或者最简单的方法法就是使用
executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR)，这样起码不用等到前面的都结束了再执行了。 executeOnExecutor(AsyncTask.SERIAL_EXECUTOR)则与execute()是一样的。
AsyncTask容易引发内存泄漏
如果AsyncTask被声明为Activity的非静态的内部类，那么AsyncTask会保留一个对创建了AsyncTask的Activity的引用。如果Activity已经被销毁，AsyncTask的后台线程还在执行，它将继续在内存里保留这个引用，导致Activity无法被回收，引起内存泄露。
