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 的情况不再讨论，感兴趣的同学可以自己学习

@MainThreadpublic 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 来控制任务的执行顺序等逻辑
   小伙伴们有更好的想法可以提出来

结束语

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