带你从源码分析AsyncTask

前言

AsyncTask的分析会用到线程池的相关知识，如果没有了解过，可以先看一下我的笔记：线程池笔记

基础

AsyncTask是Android中用于异步处理的辅助类，十分的有用，能够让我们简单的在工作线程中进行耗时操作（比如I/O，网络请求），然后在UI线程进行更新操作等。

AsyncTask的用法就不说了，相信大家都用了几次了，主要的方法有：

• onPreExecute
• doInBackground
• onProgressUpdate
• onPostExecute
  其中doInBackgroud运行在子线程中，其他均运行在主线程。

源码分析

其实AsyncTask是对线程池的一种封装，那么接下来就从源码来看看AsyncTask吧~
我们一般是通过execute方法进行开启任务：
new MyAsyncTask().execute("#1");

那么我们看看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) {
        ....

        mStatus = Status.RUNNING;

        onPreExecute();

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

        return this;
    }

可以看到execute方法也是调用了executeOnExecutor方法，先执行了onPreExecute()，再执行exec.execute(mFuture)

从上面可以发现exec是sDefaultExecutor对象，那么这个sDefaultExecutor是怎样的呢？我们看看声明：

    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

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

我来解释解释上面的代码：

1. sDefaultExecutor是SerialExecutor的一个对象
2. SerialExecutor的execute方法是新创建一个Runnable对象，并在run方法中执行将作为参数传入的Runnable对象的run方法，并在run方法运行完成之后调用scheduleNext方法(finally代码块)。offer方法是将新创建的Runnable对象加入到mTasks的队尾（mTasks是一个双向队列）
3. 如果mActive为空，即当前没有任务在运行就执行scheduleNext方法
4. scheduleNext是将Runnable对象加入到THREAD_POOL_EXECUTOR线程池运行并执行
5. 所以execute方法并没有执行传入，而只是作为一个任务调度者，真正的执行者是THREAD_POOL_EXECUTOR。
6. 这是一个static对象，所以创建多个MyAsyncTask对象的时候，任务排队排的是同一个队伍，所以会一个一个执行。

例如，当我们如下开启任务的时候：

        new MyAsyncTask().execute("1");
        new MyAsyncTask().execute("2");
        new MyAsyncTask().execute("3");
        new MyAsyncTask().execute("4");

我在doInBackground中sleep了3秒，然后打印传入的参数。执行结果如下图所示，
可以看到明显是隔了3秒才执行一个任务：

AsyncTask.jpg

所以SerialExecutor是一个串行的调度器，让新加入的任务排队，通过加入到THREAD_POOL_EXECUTOR来执行任务。

再来看看THREAD_POOL_EXECUTOR的定义：

    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
    private static final int KEEP_ALIVE = 1;
    private static final BlockingQueue<Runnable> sPoolWorkQueue =
        new LinkedBlockingQueue<Runnable>(128);
    public static final Executor THREAD_POOL_EXECUTOR
            = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                    TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);        

这是一个线程池，其中核心线程数为CPU数量+1，最大线程数为CPU_COUNT * 2 + 1，队列最大容量为128

所以通过execute()方法启动AsyncTask，默认情况下是串行执行的。(从Android3.0开始)

要想并行执行，需调用executeOnExecutor方法，并直接传入THREAD_POOL_EXECUTOR对象：

new MyAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"1");
new MyAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"2");
new MyAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"3");
new MyAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"4");

这样就不会是串行调度了，而是并行调度：

AsyncTask2.jpg

任务几乎是同时执行完毕的。

后记

好了，上面就是我看完开发探索之后，自己慢慢琢磨了一下源码，然后总结的笔记啦，你可以看看AsyncTask的源码，应该会有新的收获哟~