AsyncTask 源码研究

AsyncTask 可以让我们安全轻松的操作 UI线程，允许我们在后台执行操作并在 UI线程发布结果。

用法

在 Android 中跨线程通信的方式很多，像 Handler，runOnUiThread, AsyncTask， Rxjava 等各有自己的特点，AsyncTask 不需要依赖，使用简单所以我们经常用来完成一些简单的一步任务。

在使用过程中，我们经常需要重写其中一些方法：

AsyncTask<String, Integer, Long> asyncTask = new AsyncTask<String, Integer, Long>() {

    //抽象方法，此方法在子线程中执行
    @Override
    protected Long doInBackground(String... params) {
        return null;
    }
    //UI线程，在 doInBackground 之前，可以做一些准备检查工作
    @Override
    protected void onPreExecute() {
        super.onPreExecute();
    }

    //UI线程,在 doInBackground 之后，参数是其返回值
    //如果任务被取消掉，则不会调用该方法
    @Override
    protected void onPostExecute(Long along) {
        super.onPostExecute(along);
    }

    //UI线程，在 publishProgress 方法调用之后
    @Override
    protected void onProgressUpdate(Integer... values) {
        super.onProgressUpdate(values);
    }
};
asyncTask.execute("url");

正常情况下这写方法就可以满足我们的需求了，我们今天重点则是从源码角度来对 AsyncTask 有一个更深刻的认识。

AsyncTask 中的子线程

既然是用来执行异步任务的那其中就肯定少不了子线程，创建子线程一般会通过 Thread or 线程池。

/**
  * 可以用来并行执行任务的 Executor
  */
public static final Executor THREAD_POOL_EXECUTOR
            = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                    TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

从代码看，AsyncTask 是创建了一个静态的线程池，我们重点关注第五个参数 sPoolWorkQueue

private static final BlockingQueue<Runnable> sPoolWorkQueue = new LinkedBlockingQueue<Runnable>(128);

可以看到其实际是一个阻塞的先进先出队列

AsyncTask 中的线程通信

上面我们已经了解到 AsyncTask 中的任务是教给线程池执行的，那么他又是如何通知 UI线程呢？

private static class InternalHandler extends Handler {
    public InternalHandler() {
        //在这里绑定了UI线程的Looper
        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;
        }
    }
}

可以看到其内部依然是封装了我们熟悉的 Handler 来实现线程通信的

AsyncTask 中的任务传递过程

接下来进入到我们本次学习的重点，根据上面的分析我们已经知道：AsyncTask 内部利用线程池来执行异步任务，利用 Handler 来实现线程通信。但具体一个任务在 AsyncTask 中是怎么传递的呢？有我们需要注意的地方吗？就让我们从 execute 方法开始吧！

execute(params…) 执行任务

从上边的示例代码中可以知道，我们通常都是通过调用 execute 传入参数来执行异步任务的,最终会调用 executeOnExecutor：
传入 Runnable 的情况不再讨论，感兴趣的同学可以自己学习

@MainThread
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
        Params... params) {
    if (mStatus != Status.PENDING) {
            throw new IllegalStateException("a task can be executed only once");
        }
    }

    mStatus = Status.RUNNING;

    onPreExecute();

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

    return this;
}

从代码中可以看到：
1. 必须在 UI线程 中调用 execute 方法
2. 一个 AsyncTask 对象只能被执行一次

这里我们重点落在第一个参数上 Executor exec，又一个执行器？跟我们之前的 线程池 有什么瓜葛呢？
我们一起来分析下其默认的 SerialExecutor，从名字看就能看出是个串行执行器：

private static class SerialExecutor implements Executor {
    final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
    Runnable mActive;
    // 通过对 Runnable 的进一步转换，很巧妙的实现了 Runnable 的串行执行
    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. 内部的线程池只需无脑的执行分配到的任务
2. 通过设置的 Executor 来控制任务的执行顺序等逻辑
   小伙伴们有更好的想法可以提出来

结束语

就分析到这里吧，了解了上边的内容后再结合源码就非常容易读懂了！