一.前言
AsyncTask 异步任务，是 Android 中用于异步执行耗时任务的类，封装了 Hanlder ，Message 和 线程池。AsyncTask 的封装使得开发者在开发过程中不用再自己编写相应的 Handler 或者线程执行的方法。
二.简介
public abstract class AsyncTask<Params, Progress, Result> {
...
@WorkerThread
protected abstract Result doInBackground(Params... params);
...
}
AsyncTask 是一个抽象类,使用的时候需要实现 doInBackground 这个方法，同时需要指三个泛型参数，从名字就基本可以看出这三个参数的作用：
- Params，用于指定传递给 AsyncTask 的参数类型 。
- Progress ，用于在任务进行中返回的任务进度的类型 。
- Result，用于指定任务执行完成后返回的类型。
AsyncTask 的执行从开始到结束主要有下面的几个方法：
- execute，传递这个 Params 参数并开始执行任务，注意每一个 AsyncTask 对象只能执行一次，如果需要重复的任务就需要重复的创建这个对象。
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
- onPreExecute，在任务执行之前调用（Pre 之前），运行在 主线程，可以对 UI 做一些任务前的处理比如提示加载框等。
@MainThread
protected void onPreExecute() {
}
- doInBackground，在工作线程执行，也就是在子线程执行，接收参数 Params 执行完成后就将 Result 类型的结果返回。
@WorkerThread
protected abstract Result doInBackground(Params... params);
- publishProgress,在工作线程执行，可以在 doInBackground 方法中调用，用于在任务进行的过程中不断更新 UI ,传入的参数就是之前指定的 Progress 类型。
@WorkerThread
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
....
}
}
- onProgressUpdate 工作在主线程，在 publishProgress 调后，具体的 UI 的更新操作就是在 onProgressUpdate 这里执行，接收从 publishProgress 传过来的 参数并执行相应的更新操作。
@MainThread
protected void onProgressUpdate(Progress... values) {
}
- onPostExecute，运行在主线程，在任务执行完成后（Post 之后），任务完成后会返回一个 Result 类型的值，可以在这里获取并执行 Ui 操作。
@MainThread
protected void onPostExecute(Result result) {
}
- onCancelled，取消任务的时候会执行，运行在住线程，对 UI 做一些状态的恢复工作。
@MainThread
protected void onCancelled(Result result) {
onCancelled();
}
@MainThread
protected void onCancelled() {
}
三.原理
AsyncTask 暴露出来的方法的生命期就是上面所介绍的，下面就具体看看 AsyncTask 是如何处理异步操作的。
1.创建
public AsyncTask() {
this((Looper) null);
}
public AsyncTask(@Nullable Handler handler) {
this(handler != null ? handler.getLooper() : null);
}
public AsyncTask(@Nullable Looper callbackLooper) {
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler()
: new Handler(callbackLooper);
可以看到刚开始 new AsyncTask 的时候如果没有指定 Looper 或者指定的 Looper 是主线程的 Looper 就是使用 AsyncTask 封装的 Hanlder ( InternalHandler ) ，否则就根据 指定的 Looper 创建一个 Hander.
public AsyncTask(@Nullable Looper callbackLooper) {
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler()
: new Handler(callbackLooper);
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
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 {
postResult(result);
}
return result;
}
};
mFuture = new FutureTask<Result>(mWorker) {
@Override
protected void done() {
try {
postResultIfNotInvoked(get());
...
}
}
};
}
在创建的过程中会初始化一个 WorkerRunnable ，这是一个封装的 Runnable 对象，在这个对象中首先会所处的线程的优先级设置为 Process.THREAD_PRIORITY_BACKGROUND 后台线程，然后就是将 doInBackground 方法封装在这个 workerRunnable ，然后再将这个 Runable 封装到一个 FutureTask 这是一个可以有返回值的线程任务，相对于的 Runable 就是一个 没有返回值的线程任务。
2.execute 开始执行
这里首先先介绍几个重要的对象
- sPoolWorkQueue,阻塞队列，使用的是 LinkedBlockingQueue 的阻塞队列。
- THREAD_POOL_EXECUTOR ，执行任务的线程池，与线程池配套的是 上面的阻塞队列。
- SERIAL_EXECUTOR，任务排队的线程池
- sDefaultExecutor，默认的线程池，默认为 SERIAL_EXECUTOR
- sHandler，封装的 InternalHandler ，也就是 Hanlder .
private static final BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(128);
public static final Executor THREAD_POOL_EXECUTOR;
static {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
sPoolWorkQueue, sThreadFactory);
threadPoolExecutor.allowCoreThreadTimeOut(true);
THREAD_POOL_EXECUTOR = threadPoolExecutor;
}
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
private static InternalHandler sHandler;
这里看一下 SerialExecutor 。
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);
}
}
}
可以看到这里使用的 ArrayDeque ，这是一种先进先出的队列，所以在 AsyncTask 任务执行就是一个接一个的执行。在任务执行的线程池中不会产生并发执行的过程。
回到 execute 方法
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
@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;
}
可以看到 execute 方法执行后会调用 executeOnExecutor，在里面就会先进行一个些判断，如果当前任务是 RUNNING 即运行状态或者 FINISHED 即终止状态就抛出异常，否则就将状态设置为 RUNNING 并开始执行 onPreExecute 方法，最一些任务执行前的操作，最后就将任务提交的 SerialExecutor 线程池。在 SerialExecutor 中
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);
}
}
}
前面也说过 提交的任务在这里会添加的 ArrayDeque 的 mTasks 队列中，然后再去 THREAD_POOL_EXECUTOR 中做真正的执行。保证了 任务的执行是串行的过程。
在 THREAD_POOL_EXECUTOR 执行完成后 WorkerRunnable 的 方法后最后就会调用 postResult
mWorker = new WorkerRunnable<Params, Result>() {
...
result = doInBackground(mParams);
...
postResult(result);
};
跳转到 postResult
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
这里就使用 message 和 getHandler 发送消息，直接看 InternalHandler
private static class InternalHandler extends Handler {
public InternalHandler(Looper looper) {
super(looper);
}
@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;
}
}
}
可以看到最后调用的就是 result.mTask.finish(result.mData[0]); ，这个 result.mTask 就是一个封装了最后的结果和 AsyncTask 的对象，也就是将执行的结果 传递给了finish 方法，而且也从工作线程回到了 主线程。
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
在finish 就会调用 onPostExecute 方法执行最后的显示操作，并将 状态设置为 FINISHED ，一旦设置为 FINISHED 就说明这个 AsyncTask 对象不能再执行 任务。
对于任务的更新操作也是类是的过程，首先通过 getHandler 发送 Message.
@WorkerThread
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
最后就是在 Handler 里面进行处理调用 result.mTask.onProgressUpdate(result.mData); 方法。 同样从工作线程回到了主线程 ，然后就是进度的更新方法 onProgressUpdate 。 就这样 AsyncTask 的原理就介绍到此。