Android AsyncTask(2)-原理与源码解析

上一节我们知道，想要启动一个AsyncTask，首先需要创建一个AsyncTask对象然后调用execute方法。例如：

new DownloadFilesTask().execute();

DownloadFilesTask继承自AsyncTask需要指定3个泛型参数：

private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
  
      protected void onPreExecute() {
        super.onPreExecute();
      }
        
      protected Long doInBackground(URL... urls) {
          int count = urls.length;
          long totalSize = 0;
          for (int i = 0; i < count; i++) {
              totalSize += Downloader.downloadFile(urls[i]);
              publishProgress((int) ((i / (float) count) * 100));
              // Escape early if cancel() is called
              if (isCancelled()) break;
          }
          return totalSize;
      }

      protected void onProgressUpdate(Integer... progress) {
          setProgressPercent(progress[0]);
      }

      protected void onPostExecute(Long result) {
          showDialog("Downloaded " + result + " bytes");
      }
}

AsyncTask构造函数

首先先从AsyncTask的构造函数说起：

/**
 * AsyncTask的构造函数源码片段
 **/
public AsyncTask() {

    mWorker = new WorkerRunnable<Params, Result>() {
        public Result call() throws Exception {

            mTaskInvoked.set(true);
            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);

            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) {
               ...
                e.getCause());
            } catch (CancellationException e) {
                postResultIfNotInvoked(null);
            }
        }
    };
}

在AsyncTask构造函数中初始化了两个对象：WorkerRunnable和FutureTask，分别赋值为mWorker、mFuture。这两个对象初始化都实现了两个回调方法，当用户执行了execute方法的时候在特定情况下会触发这两个对象的回调方法，下面我们就开始详细分析这两个对象。

结论：doInBackground是在WorkerRunnable的call方法中被回调执行的 （见代码12行）

WorkerRunnable【mWorker】

由于WorkerRunnable实现了Callable接口，所以在AsyncTask的构造函数中实例化WorkerRunnable时，必须实现call()方法。其中还需要指定泛型参数Params和Result。这样在回调了call方法之后，就能返回Result。

/** WorkerRunable类**/
private static abstrat class WorkerRunable<Params, Result> implements Callable<Result> {
	Params[] mParams;
}

/** Callable接口**/
public interface Callable<V> {
	V call() throws Exception;
}

现在我们暂时只需要知道当执行execute的时候会回调WorkerRunnable的call方法。

FutureTask【mFuture】

从上面的AsyncTask的构造函数源码中可以看到，在构造FutureTask对象初始化时，mWorker是作为参数传递进来的。从FutureTask的构造函数也看出来了FutureTask需要一个Callable对象。

/** FutureTask的构造函数**/
public FutureTask(Callable<V> callable) {
    if (callable == null)
        throw new NullPointerException();
    this.callable = callable;
    this.state = NEW;       // ensure visibility of callable
}

【在这里不禁可以提前猜测出一个信息了，既然FutureTask把WorkerRunnable传递进来了，那WorkerRunnable的回调方法call肯定是在FutureTask中调用的】

来看看FutureTask这个类：

可以看出，FutureTask是实现了RunnableFuture接口，而这个接口继承了Runnable、以及Future。

通过上面两个类，发现其实FutureTask中的get方法实现了Runnable的阻塞和返回执行完毕的数据(泛型V)。

我们再来看FutureTask的run方法，豁然开朗，原来WorkerRunnable中的回调方法call果然是在这里调用的。

**结论：WorkerRunnable中的回调方法call()是在执行FutureTask的run方法后回调的。当WorkerRunnable的call方法执行完毕后将返回数据给FutureTask。
疑问：那么，FutureTask的run方法又是被谁调用的呢？

---

execute方法

很显然，FutureTask的run方法肯定需要AsyncTask执行execute方法后才会执行。

private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

/** AsyncTask类的execute方法**/
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
    return executeOnExecutor(sDefaultExecutor, params);
}

当执行execute方法时，其实是调用的executeOnExecutor方法。这里传递了两个参数，一个是sDefaultExecutor，一个是params。从上面的源码可以看出，sDefaultExecutor其实是一个SerialExecutor对象。params其实最终会赋给doInBackground方法，就是用户实现回调的方法，这个后面会看到。

executeOnExecutor方法

我们现在先来看executeOnExecutor方法。

/** AsyncTask类的executeOnExecutor方法**/
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
        Params... params) { 
    ...
    mStatus = Status.RUNNING;

    onPreExecute();

    mWorker.mParams = params;
    exec.execute(mFuture);

    return this;
}

看到木有？在这个方法中，最先先执行了onPreExecute()方法，此时便会回调到用户自定义AsyncTask的实现方法onPreExecute【看本文最顶部第一个例子的代码】。onPreExecute可以用来做一些后台任务执行之前的准备工作。

通过上面的代码可以看出，执行到exec.execute(mFuture)这里时传递进去了一个mFuture，这个mFuture就是之前AsyncTask构造初始化赋值的FutureTask。exec其实就是之前执行AsyncTask.execute()方法时传递进来的参数sDefaultExecutor，刚刚也说了这个sDefaultExecutor其实就是SerialExecutor对象。嗯，exec就是SerialExecutor对象。

SerialExecutor

我们可以看到，之前exec.execute(mFuture)执行时，SerialExecutor将FutureTask作为参数执行execute方法。在SerialExecutor的execute方法中，这里通过一个任务队列mTasks把FutureTask插入进了队列中，执行r.run，其实就是执行FutureTask的run方法，因为传递进来的r参数就是mFuture。

/** AsyncTask对象中的SerialExecutor成员变量【内部类】 **/
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);
        }
    }
}

结论：FutureTask的run方法是在SerialExecutor的execute方法中执行的。

其实在这里，SerialExecutor实现了一个任务的排队算法。当一个AsyncTask任务开始execute时，首先执行FutureTask的run方法，然后finally执行scheduleNext方法，然后执行THREAD_POOL_EXECUTOR的execute方法。继续往下，如果mActive为空，就会继续调用scheduleNext方法执行下一个AsyncTask任务，说白了就是当mActive这个Runnable执行完毕之后，才会继续调用 THREAD_POOL_EXECUTOR.execute(mActive)。这样SerialExecutor便实现了串行的任务队列。

结论：SerialExecutor只是实现任务队列，真正执行线程池的是THREAD_POOL_EXECUTOR。

从上面的代码块我们已经知道，FutureTask的run方法在SerialExecutor的execute方法中执行了，然后由 mTasks.offer 封装成一个Runnable(mActive)给THREAD_POOL_EXECUTOR。

到这里，FutureTask的run方法就要开始回调WorkerRunable的call方法了。是不是已经开始晕了，2333。撑住 !!!!

接下来我们还要看WorkerRunable的回调call方法：

mWorker = new WorkerRunnable<Params, Result>() {
        public Result call() throws Exception {
            mTaskInvoked.set(true);    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
        Result result = doInBackground(mParams);
        Binder.flushPendingCommands();
        return postResult(result);
    }
};

oh my god ! 看第4行，终于开始回调doInBackground方法了。结合上面两段代码，现在已经很明白了，doInBackground的执行不是在主线程中，而是在Runnable的run方法里面执行的。

doInBackground(mParams)执行完后返回result，接着再继续执行postResult方法，并将返回的result作为参数传递进去。现在我们来看postResult方法，当当当当，Handler开始登场了。这里在执行完doInBackground后直接发送了一个消息给Handler，那么这个Handler又是哪个呢？

private Result postResult(Result result) {
	
	Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,new AsyncTaskResult<Result>(this, result));
	message.sendToTarget();
	return result;
}

继续看getHandler方法：

private static Handler getHandler() {
    synchronized (AsyncTask.class) {
        if (sHandler == null) {
            sHandler = new InternalHandler();
        }
        return sHandler;
    }
}
    
private static class InternalHandler extends Handler {
    public InternalHandler() {
        super(Looper.getMainLooper());
    }

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

之前执行postResult的时候，obtainMessage传递的参数是：MESSAGE_POST_RESULT和AsyncTaskResult(this, result))，然后message.sendToTarget()开始发消息，并在InternalHandler的handleMessage中开始处理消息。

结论：doInBackground执行完后立即发送了一个消息给InternalHandler

private void finish(Result result) {
    if (isCancelled()) {
        onCancelled(result);
    } else {
        onPostExecute(result);
    }
    mStatus = Status.FINISHED;
}
	
private static class AsyncTaskResult<Data> {
    final AsyncTask mTask;
    final Data[] mData;

    AsyncTaskResult(AsyncTask task, Data... data) {
        mTask = task;
        mData = data;
    }
}

由于传递的是MESSAGE_POST_RESULT，所以执行mTask.finish方法。这个时候doInBackground已经执行完了并返回了result，便开始执行onPostExecute方法，并将result传递进去。因为InternalHandler是通过Looper.getMainLooper()获得的，所以是在主线程，所以最后onPostExecute方法便又回到了主线程执行。这个时候onPostExecute就可以拿到doInBackground异步执行返回的result，直接更新UI。

结论：InternalHandler获得消息后执行onPostExecute回调方法，一个AsyncTask任务便到此结束了