AsyncTask的执行流程及其细节点

AsyncTask的执行流程，完全根据developer在调用时的步骤进行分析。

       首先开发者会建立一个AsyncTask的实例

     AsyncTask asyncTask = new AsyncTaskImpl();

这个构造函数会调到AsyncTask的构造函数,在AsyncTask的构造函数中做了如下操作:

<span style="white-space:pre">	</span><span style="font-size:18px;">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);
                }
            }</span>
     <span style="font-size:18px;">   };</span>

主要就是初始化了mWorker(WorkerRunnable),mFuture(FutureTask)。并且把mWorker的值传递给了mFuture。

这两个变量在后面会用到，先记着。

     然后会在调用asyncTask.execute(Params,Progress,Result);

     这里面会执行如下代码:

    return executeOnExecutor(sDefaultExecutor, params);

   然后去执行上面的方法，这个方法前面先判断了一下当前这个AsyncTask的状态，如果mStatus!=Pending的话，就会抛异常，否则就把mStatus=Pending，执行onPreExecute()，然后会调用如下:

    exec.execute(mFuture);

     这个exec就是sDefaultExecutor,查看赋值，发现属于SerialExecutor类，内部类。

     那就查看这个类，会执行execute()方法

    public synchronized void execute(final Runnable r) {
            mTasks.offer(new Runnable() {
                public void run() {
                    try {
                        r.run();
                    } finally {
                        scheduleNext();
                    }
                }
            });
            if (mActive == null) {
                scheduleNext();
            }
        }

其中tasks是一个ArrayDaque<Runnable>。这个方法会执行runnable的run,而这个runnable就是mFuture.

        mFuture属于FutureTask implements RunnableFuture extends Runnable的。

查看mFuture的run方法，如下: 

        ....
       try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                   <span style="color:#ff0000;"> result = c.call();</span>
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }

其中会调用callable.call()方法，这个callable是在构造FutureTask时传递的,而FutureTask实例的构造就是之前提到的在AsyncTask的构造函数中进行的，其中是把mWorker作为callable传递了进去，本质上就是调用了mWorker.call()方法，而这个方法的定义也是在AsyncTask的构造函数中进行的。

mWorker是WorkerRunnable implements Callable.

mWorker的call()方法最关键的一句是最后一句，如下:

     return postResult(doInBackground(mParams));

       首先会回调doInBackground(),这个call方法是在非UI Thread进行的。执行完毕后，会在执行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机制，把消息传递给这个handler。就是InternalHandler。

     可见AsyncTask内部线程间的通信也是利用handler来进行的，ui-child通过callable来执行，从child-ui通过InternalHandler执行。

    下面看InternalHandler的代码:

   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;
            }
        }

如果msg.what = MESSAGE_POST_PROGRESS---此时一定是调用了publishProgress并且isCancelled()返回了false,则回调onProgressUpdate()方法。

         而postResult()中的msg.what = MESSAGE_POST_RESULT,因此会执行result.mTask.finish()方法，查看代码如下:

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

    会先判断是不是cancel()了,如果有就执行onCancelled()，否则回调到onPostExecute()方法,并且把状态设置为finished.

  一整套流程就结束了，基本就是

1)构造函数里

2)execute()--回调到executeOnExecutor()----判断status状态,然后设置为running

3)执行serialExecutor.run();

        4)也就是执行mFuture.run();

        5)也就是执行mWorker.call();

        6)回调到postResult(doInBackground())

        7)通过handler发消息，回调finish()

        8)判断是不是cancel了，是的话执行onCancelled()否则执行OnPostExecute()---设置status状态为finished.