概述
AsyncTask 是一种轻量级的异步任务类，它可以在线程池中处理后台任务，然后将执行结果传到主线程中对UI进行操作，适合于不是特别耗时的任务
参数与方法
- 参数
AsyncTask是一个泛型类，提供了Params、Progress、Result三个参数。类的声明如下
public abstract class AsyncTask
Params表示参数的类型，Progress表示后台任务执行进度的类型，Result表示后台执行结果的类型，如果不需要确切的传递参数，可用Void代替
- 方法
AsyncTask是个抽象类，使用时需要继承这个类并重写doInBackground(Params...params)方法，AsyncTask有四个核心方法
- onPreExecute(),这个方法在主线程中执行，调用于异步任务执行前，用于做一些准备工作。
- doInBackground(Params...params)在线程池中执行，用于执行异步任务。params参数表示异步任务的输入参数，...表示参数的数量不定，是一个数组型参数，也就意味着我们可以传入多个参数。在这个方法中可以通过publishProgress方法更新任务进度，这方法会调用onProgressUpdate方法。，另外此方法需要返回计算结果给onPostExecute方法。
- onProgressUpdate(Progress...value)在主线程中执行，当任务的执行进度被改变时调用，可用于刷新UI展示当前任务进度
- onPostExecute(Result result)在主线程中执行，当doInBackground方法执行完毕时会调用此方法。result是doInBackground的返回值，这个方法一般用于后台任务执行完毕后对UI的操作。
AsyncTask的工作原理
启动AsyncTask的方式很简单
new MyAsyncTask().execute(url);
我们看一下execut方法是怎么执行的
public final AsyncTask execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
public final AsyncTask 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(Executor exec, Params... params)。
可见先执行了onPreExecute();然后exec.execute(mFuture)，这时任务才正式被执行。
我们看一下sDefaultExecutor的类是怎么回事
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
private static class SerialExecutor implements Executor {
final ArrayDeque 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) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
系统会把AsyncTask的Params参数封装为FutureTask对象，FutureTask交给SerialExecutor的execute方法处理，execute把FutureTask对象插入mTask中，如果这时没有正在活动的任务，就会调用scheduleNext来执行下个任务，同时当一个任务执行完后，AsyncTask会继续执行其他任务直至所有任务都被执行完。可见默认情况下AsyncTask是串行执行的。
AsyncTask有两个线程池，一个是SerialExecutor，用于任务的排队，一个是THREAD_POOL_EXECUTOR，用于执行任务。
AsyncTask中使用了Handler来更新UI。我们看一下是如何操作的
mWorker = new WorkerRunnable() {
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);
}
};
AsyncTask构造方法中实例化了worker，由于FutureTask的run方法调用了worker的call方法，所以postResult方法被执行，也就执行了doInBackground方法。
看一下postResult方法
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult(this, result));
message.sendToTarget();
return result;
}
可见通过发送一则消息，将result传给Handler处理。看一下handler的代码
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;
}
}
}
finish方法是什么样呢,想必已经可以猜出个大概了
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
finish调用了onPostExecute方法。这里还有个判断，假如任务被取消了， onCancelled(result)就会被调用，我们可以重写这个方法。
上面的handler还case了MESSAGE_POST_PROGRESS，可以推出publishProgress发送了消息通知handler处理onProgressUpdate方法。
AsyncTask的特点
- 由于AsyncTask采用了Handler刷新UI，所以我们必须在主线程中实例化AsyncTask，execut方法也必须在UI线程中调用。
- 不要手动去调用AsyncTask四个核心方法
- 一个AsyncTask对象只能执行一次，也就是只能调用一次execute方法。
- AsyncTask默认是串行执行的，若想并行执行，则调用executeOnExecutor方法。即
new MyAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,url);
以上内容主要整理自《安卓开发艺术探索》，想了解更仔细请翻阅原书