AysncTask源码学习笔记一中讲到在workrunnable中返回postResult(result)那么我们看看这个函数的内部实现
private Result postResult(Result result) {
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
出现了Message和getHandler()，看来我们需要的从子线程切换到主线程的过程就在这里执行了。我们继续看看getHandler()的内部执行过程
private static Handler getHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
sHandler = new InternalHandler();
}
return sHandler;
}
}
看来sHandler是一个单例对象，并且由InternalHandler()初始化，看名字像是一个内部类，继续看InternalHandler()
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;
}
}
}
我们可以看到这是一个静态的内部类，且初始化的时候传入了Looper.getMainLooper()，这就要求sHandler对象必须在主线程中创建，由于sHandler是一个静态成员，
private static InternalHandler sHandler;
所以在加载类的时候进行初始化，这也就要求AsyncTask的类必须在主线程中加载。
我们看到handleMessage中有两个状态，一个是MESSAGE_POST_RESULT，另一个是MESSAGE_POST_PROGRESS看名称也能知道一个是后台执行完成，一个是更新进度。我们继续跟踪其中的finish()方法。
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
这里出现了两个模板方法，一个是我们非常眼熟的onPostExecute(result)，另一个则是我们取消时调用的onCancelled(result)方法。
这样整个AsyncTask的工作过程就完毕了。
其他细节
我们看到IntenalHandler是一个静态内部类，所以无法引用外部类AsyncTaskde的实例对象，也就是说无法使用外部类的方法。这样就需要一个类来持有外部类对象，这就是IntenalHandler中
AsyncTaskResult的作用。
private static class AsyncTaskResult<Data> {
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}
我们看到AsyncTaskResult的内部成员里有一个AsyncTask对象，而且在前文postResult()中创造了一个AsyncTaskResult对象，传递了this,也就是外部类对象的引用，这样Internalhandler中就可以调用外部类的方法了
- 并行或串行
从Android3.0开始，默认情况下是串行执行的
这是《Android开发艺术探索中》的原话，源码中的线程池是默认串行执行的。
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
/**
* An {@link Executor} that executes tasks one at a time in serial
* order. This serialization is global to a particular process.
*/
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
内部实现了SerialExecutor
private static class SerialExecutor implements Executor
我们调用execute()时默认使用串行的线程池
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
- 不能执行多次
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;
}
内部有个状态判断，当前要是有任务是RUNNING或FINISHED状态，会抛出异常。
参考文章
http://blog.csdn.net/guolin_blog/article/details/11711405
http://www.jianshu.com/p/b1574686faa3
《Android开发艺术探索》
