前言
Android为了提高运行流程性不允许主线程阻塞，所以耗时操作都要在子线程执行，耗时操作完成后再通知主线程完成回调。而AsyncTask就是google官方封装好的一个轻量级异步框架。AsyncTask也用了很久了，这几天在做些网络、线程池相关的东西时又回过来重新学习了下AsyncTask源码，记录一下。
使用方法
Android的异步回调一般都是通过创建worker线程执行任务，完成后通过handler通知主线程完成后续操作。其实不用AsyncTask而直接用Handler也是一样的，不过通过AsyncTask可以简化代码，让代码结构变得更加清晰。
先来看看AsyncTask的定义：
public abstract class AsyncTask<Params, Progress, Result> {
三种泛型类型分别代表“启动任务执行的输入参数”、“后台任务执行的进度”、“后台计算结果的类型”。在特定场合下，并不是所有类型都被使用，如果没有被使用，可以用java.lang.Void类型代替。
一个异步任务的执行一般包括以下几个步骤：
1.execute(Params... params)，执行一个异步任务，需要我们在代码中调用此方法，触发异步任务的执行。
2.onPreExecute()，在execute(Params... params)被调用后立即执行，一般用来在执行后台任务前对UI做一些标记。
3.doInBackground(Params... params)，在onPreExecute()完成后立即执行，用于执行较为费时的操作，此方法将接收输入参数和返回计算结果。在执行过程中可以调用publishProgress(Progress... values)来更新进度信息。
4.onProgressUpdate(Progress... values)，在调用publishProgress(Progress... values)时，此方法被执行，直接将进度信息更新到UI组件上。
5.onPostExecute(Result result)，当后台操作结束时，此方法将会被调用，计算结果将做为参数传递到此方法中，直接将结果显示到UI组件上。
实现原理
- 线程池：
作为异步请求框架，创建线程肯定是毫无疑问的，android2.3以上AsyncTask有两个线程池：
先来看看第一个并行线程池
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 ThreadFactory sThreadFactory = new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);
public Thread newThread(Runnable r) {
return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
}
};
private static final BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(128);
/**
* An {@link Executor} that can be used to execute tasks in parallel.
*/
public static final Executor THREAD_POOL_EXECUTOR
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
这里google对不同性能的手机做了适配，根据cpu核数的不同线程池的coreSize和MaxSize值不同，在线程数达到coreSize之前，添加到线程池的任务会立即执行，而线程数到达coreSize后会被添加到阻塞队列sPoolWorkQueue 中，如果队列满才会开启新的线程，直到线程数达到maxSize且队列也满了后线程池就会拒绝接受任务（调用RejectedExecutionHandler来处理），当然任务数一般也很难达到这个上限。
而调用execute（）执行asynctask则使用的是串行线程池，源码如下：
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);
}
}
}
可以看出来，SerialExecutor 其实也是执行在并行线程池上，这里用了一个数组实现的双端队列，当一个任务执行完了再取队列尾的任务执行，这样就实现了串行执行的功能。
2.任务的执行
AsyncTask的执行是通过execute（）和executeonexecutor（）两个方法，execute（）在Android2.3之后是串行的，而在Android2.3之前（包括2.3）是并行的。而execute其实也是调用的executeonexecutor（），只不过worker线程池是SerialExecutor 罢了。先来看看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;
}
上面大部分代码是一些异常判定和状态设置，而倒数第三行才是真正的执行部分，那mFuture是什么呢？
public AsyncTask() {
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);
}
};
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);
}
}
};
}
private void postResultIfNotInvoked(Result result) {
final boolean wasTaskInvoked = mTaskInvoked.get();
if (!wasTaskInvoked) {
postResult(result);
}
}
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
由上面的代码可以看到，mWoker是对doInBackground（）中任务的封装，而mFuture 则是实现了Future和Runnable的，Future接口主要的以下功能：
1）判断任务是否完成；
2）能够中断任务；
3）能够获取任务执行结果。
上面的三个功能正是我们对AsyncTask的一些需求，所以选用FutureTask的确是很好的选择。
上面的代码最后是走到了postResult（）方法这里，其实就是简单的通过Handler把result发送到主线程并执行onPostExecute（）方法。来看看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是一个使用了主线程的mainlooper的静态handler，而且是单例的（其实可以通过双重校验锁来减小点同步的范围的），注意：在4.1以前这个handler并没有设置mainlooper，而是在第一次实例化AsyncTask的线程初始化的，所以初始化的现成必须是主线程。
结语
虽然AsyncTask只是很简单的框架，不过也能学到很多源码的细节，如线程池的设置、atomicboolean实现原子性、Future类实现任务的控制等等。