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开发艺术探索》