【源码分析】AsyncTask源码分析
AsyncTask类在早期的开发中占的比重非常重，因为它可以方便的将耗时工作与UI线程连接在一起，随着android版本的更新、业务的复杂度增加AsyncTask的越来越不能满足业务的需求，比如它不能取消一个正在执行的任务。但是AsyncTask中将耗时线程和UI线程工作组合在一起的思想还是值得我们好好学习借鉴一下的，那么我们就来分析一下AsyncTask这个经典类的源码。
按照AsyncTask的功能我们从两个方面来分析一下源码：耗时线程如何工作、UI线程如何工作。
耗时线程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 static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}WorkerRunnbale是个抽象类实现了Callable接口，同时添加mParams变量用来接收参数，mWorker实现了一个匿名的WorkerRunnable类，并且把所有需要处理的任务都封装在call方法中，doInBackground方法表示我们需要的耗时任务，postResult方法表示更新UI的操作。mFuture变量则是一个FutureTask的变量，我们把上面定义的mWorker封装在mFuture中，这样就方便我们的线程池调用。所以在构造方法中，封装了所有的任务到一个mFuture变量中。接着往下看executor方法。
@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;
}在executor方法中，调用了executeOnExecutor方法，并且传递了一个Executor变量sDefaultExecutor，这个变量其实是一个线程池变量，后面我们介绍。在executeOnExecutor方法中首先判断了一下当前AsyncTask的状态，如果是RUNNING或者是FINISHED则说明当前的状态不对，不能执行新增的任务。检查之后，首先设置状态为RUNNING状态，然后执行onPreExecute方法，所以这个方法也是在UI线程中执行的同样不能做一些耗时操作。 紧接着用mWorker.mParams变量来接收exexutor传递过来的参数，最后一步就是用调用了线程池的execute方法把mFuture添加到了线程池中。终上所述，调用exexutor方法之后，会把mFuture这个我们定义好的任务添加到sDefaultExexutor这个预先定义好的线程池中。
UI线程调用executor方法之后，任务会在线程池中得到执行。也就是doBackground方法会在线程池中执行，那么在任务执行完成之后，如何调用到了UI线程呢？mWorker的call方法最后返回的是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;
}
...
private static Handler getHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
sHandler = new InternalHandler();
}
return sHandler;
}
}
...在postResult方法中，首先通过getHandler方法获取到了一个Handler对象，从getHandler中可以看到这个Handler是一个InternalHandler的实例。获取handler之后，通过obtainMessage方法获取一个关联到InternalHandler类的Message对象，然后将AsyncTask和doBackground计算的结果封装到AsyncTaskResult中，发送给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;
}
}
}从InternalHandler的定义中可以看到，它在构造方法中关联了UI线程的mainLooper，那么这个Handler也就是在UI线程中处理事务。所以在postResult中将result结果发送给了一个关联UI线程的Handler来处理。如果是任务完成，传递的message.what就是MESSAGE_POST_RESULT，它最后会调用AsyncTask的finish方法。
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}最后也就是调用到了onPostExecute这个方法上来了。
最后说说sDefaultExecutor这个线程池。其实sDefaultExecutor并不是一个线程池，它只是实现了Executor接口的一个类SerialExecutor ，看源码
public static final Executor THREAD_POOL_EXECUTOR
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
...
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);
}
}
}调用execute方法时，会重新封装一下runnbale，并且将封装后的runnbale添加到阻塞队列ArrayDeque中，同时检查mActive是否为空，如果为空的话，从ArrayDeque中取出一个runnable，放到线程池THREAD_POOL_EXECUTOR中执行这个runnable。