从源代码理解AsyncTask的工作原理

首先，我们以AsyncTask的构造器和execute()方法作为研究的切入口；

一.

AsyncTask的构造器主要做了一些准备工作：

public AsyncTask() {
        mWorker = new WorkerRunnable<Params, Result>() {          
         public Result call() throws Exception {
               mTaskInvoked.set(true);

               Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
               //noinspection unchecked
               return postResult(doInBackground(mParams));
           }
       };

        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 occured while executing doInBackground()",
                            e.getCause());
                } catch (CancellationException e) {
                    postResultIfNotInvoked(null);
                }
            }
        };
    }

可以看到，在构造器中就给mWorker和mFuture进行了赋值，这里值得注意的是

1.mWorker中有一个call()方法

2.mWorker的call()中有

postResult(doInBackground(mParams))

2.mWorker作为参数传进mFuture的构造方法中，两者建立了联系

3.mWorker和mFuture中的方法都还没有被调用的

知道这些就可以了

二.

我们看execute(Params...params)方法：

 public final AsyncTask<Params, Progress, Result> execute(Params... params) {
       return executeOnExecutor(sDefaultExecutor, params);
  }

注意这里executeOnExecutor的参数传入的是sDefaultExecutor；

显然我们接着看executeOnExecutor(Executor exec , Params...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;
    }

这里就可以知道onPreExecutor()是在这里被调用的；

然后设置mWorker 的Params参数； 

最后调用线程池exec(sDefaultExecutor)来execute(mFuture);   最最重要的部分来了，真正的执行在于这个sDefaultExecutor的execute之中

三.

我们来看这个sDefaultExecutor:

 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方法中，就执行了前面构造器中赋值了的mFuture（也就是这里的Runnable r.run()）中的方法；

又因为mWorker是作为参数传进了mFuture中，于是乎mWorker的call这时也被调用了，换言之，就是call中的postResult（）和DoInBackground（）被调用了；

注意这里有两个线程池，SerialExecutor只是负责任务的排队，而THREAD_POOL_EXECUTOR才是真正的执行任务；

四.

我们知道在上面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；

五.

然后我们看发送了消息后，Handler做了什么：

 private static class InternalHandler extends Handler {
        public InternalHandler() {
           super(Looper.getMainLooper());
       }
       @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
       @Override
       public void More ...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;
            }
        }
    

原来就是根据消息内容来调用finish（）方法或者调用onProgressUpdate（）；

    private void finish(Result result) {
        if (isCancelled()) {
            onCancelled(result);
        } else {
            onPostExecute(result);
        }
        mStatus = Status.FINISHED;
    }

而finish（）中由会调用onPostExecute（Result result）方法，到这里，asyncTask的四个核心的方法全部出现被调用了；

最后，我们来总结一下整个流程：

1.execute（Params...params）调用executeOnExecutor（Executor exec ， Params...params）

2.调用了onPreExecute（）方法；

3.sDefaultExecutor执行execute（）使得mWorker的call（）被调用，这时doInBackground（）被调用，然后postResult（）被调用；

4.在postResult（）中发送消息，Handler根据消息调用了onProgressUpdate（）或者onPostExecute（）；