AsyncTask研究

侯亮

（本文以Android 7.0为准）

1. AsyncTask概述

在Android平台上，要执行异步工作时，我们常常会用到AsyncTask。这个类可以算是历史悠久，早在Android 1.5版时，它就存在了。

AsyncTask的使用方法比较简单，无非是创建一个AsyncTask派生类对象，重写其doInBackground()函数，然后在合适时机调用这个对象的execute()或executeOnExecutor()函数即可。

1private static class MyTask extends AsyncTask<Void, Void, Void> ｛
2    // . . . . . .
3    @Override
4    public Void doInBackground(Void... param) {
5        //. . . . . .
6        return null;
7    }
8｝
9
10private class TestClickListener implements View.OnClickListener {
11    public void onClick(View v) {
12        switch (v.getId()) {
13        case R.id.scan_btn:
14            testTask();
15            break;
16        . . . . . .
17    }
18            
19    private void testTask() {
20        for (int i = 0; i < 5; i++) {
21            MyTask t = new MyTask(i+100);
22            t.execute();    // 调用execute()即可
23        }
24    }

一般情况下，我们会像上面代码中这样调用AsyncTask的execute()函数，这样，投入执行的task会串行执行。不过，有时候我们也希望task们可以并行执行，此时只需把execute()换成executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR)即可。

2. AsyncTask的内部机制

AsyncTask本身是个抽象的泛型基类，正如前面所说，在实际使用时，我们必须定义它的派生类，并在实现AsyncTask派生类时，重写其doInBackground()成员函数。

AysncTask的声明如下：
【frameworks/base/core/java/android/os/AsyncTask.java】

public abstract class AsyncTask<Params, Progress, Result> 

作为一种异步执行的任务，AsyncTask是依靠内部的线程池来完成任务调度的。大体上说，AsyncTask内部搞了两个静态的执行器，分别表示成AsyncTask.THREAD_POOL_EXECUTOR 和 AsyncTask.SERIAL_EXECUTOR，前者是可并行执行的执行器（线程池），后者是串行执行的执行器（线程池）。

AsyncTask的构造函数如下：

1/**
2 * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
3 */
4public AsyncTask() {
5    mWorker = new WorkerRunnable<Params, Result>() {
6        public Result call() throws Exception {
7            mTaskInvoked.set(true);
8
9            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
10            //noinspection unchecked
11            Result result = doInBackground(mParams);
12            Binder.flushPendingCommands();
13            return postResult(result);
14        }
15    };
16
17    mFuture = new FutureTask<Result>(mWorker) {
18        @Override
19        protected void done() {
20            try {
21                postResultIfNotInvoked(get());
22            } catch (InterruptedException e) {
23                android.util.Log.w(LOG_TAG, e);
24            } catch (ExecutionException e) {
25                throw new RuntimeException("An error occurred while executing doInBackground()", e.getCause());
26            } catch (CancellationException e) {
27                postResultIfNotInvoked(null);
28            }
29        }
30    };
31}

构造函数的注释中说的很明确，必须在UI线程里构造AsyncTask对象。而且构造函数里为两个重要的成员：mWorker和mFuture赋了值，这个我们后文再细说。

2.1 AsyncTask的execute()

我们先回过头看前文曾经提到的AsyncTask的execute()函数，其代码如下：
【frameworks/base/core/java/android/os/AsyncTask.java】

1@MainThread
2public final AsyncTask<Params, Progress, Result> execute(Params... params) {
3    return executeOnExecutor(sDefaultExecutor, params);
4}

因为params参数是可变长参数，所以execute()可以接受0到n个参数。注意，execute()和executeOnExecutor()都必须在UI线程里调用。

execute()只是简单地调用executeOnExecutor()而已，它传递的静态变量sDefaultExecutor引用的就是串行执行器AsyncTask.SERIAL_EXECUTOR：

private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

executeOnExecutor()的代码截选如下：

1@MainThread
2public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
3        Params... params) {
4    . . . . . .
5    . . . . . .
6    mStatus = Status.RUNNING;
7    onPreExecute();
8    mWorker.mParams = params;
9    exec.execute(mFuture);  // 注意，mFuture本身实现了Runnable接口
10    return this;
11}

也就是说，最终还是在调用执行器的execute()函数，只不过会把一个mFuture委托给执行器去回调。

默认情况下使用的串行执行器类是SerialExecutor，它的代码如下：

1private static class SerialExecutor implements Executor {
2    final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
3    Runnable mActive;
4
5    public synchronized void execute(final Runnable r) { // 参数r一般就是mFuture引用的对象
6        mTasks.offer(new Runnable() {
7            public void run() {
8                try {
9                    r.run();
10                } finally {
11                    scheduleNext();
12                }
13            }
14        });
15        if (mActive == null) {
16            scheduleNext();
17        }
18    }
19
20    protected synchronized void scheduleNext() {
21        if ((mActive = mTasks.poll()) != null) {
22            THREAD_POOL_EXECUTOR.execute(mActive);
23        }
24    }
25}

从代码里可以看到，所谓的串行执行器内部，其实也是在复用THREAD_POOL_EXECUTOR，只不过利用对mActive的判断，把调用的流程改成串行的了。

SerialExecutor内部使用的是java.util.ArrayDeque队列，它的poll()函数可以检索并移除此队列的头部，如果返回null，则表示此队列已经取空了。每次摘取一个列头，并记录在mActive变量里，然后交给THREAD_POOL_EXECUTOR来处理。

ThreadPoolExecutor是java提供的线程池实现。总之，线程池会在后续的某个时刻，回调上面插入的Runnable对象的run()。在executeOnExecutor()函数里，我们已经看到向执行器添加了AsynctTask的mFuture成员，而mFuture本身实现了Runnable接口，以后回调就是回调mFuture的run()函数。

2.2 AsyncTask和线程池的协作

2.2.1 AsyncTask里的mFuture

AsyncTask的mFuture非常重要，它的定义如下：

private final FutureTask<Result> mFuture;

类型为FutureTask，其实现可以参考JDK里的代码：
【java/util/concurrent/FutureTask.java】

public class FutureTask<V> implements RunnableFuture<V> 

【java/util/concurrent/FunnableFuture.java】

public interface RunnableFuture<V> extends Runnable, Future<V>

在前文列出AsyncTask构造函数时，我们已经看到mFuture的创建代码了，注意，在创建FutureTask对象时，传入了mWorker，它会被记入mFuture内部（如果分析JDK的代码，可以看到大体上就是记入mFuture.sync.callable了）。后续在被线程池执行时，这个mWorker才是最核心的对象。

欲了解详情，我们先得看看AsyncTask机制运用的线程池。在AsyncTask类里这样定义线程池成员的：

1private static final BlockingQueue<Runnable> sPoolWorkQueue =
2        new LinkedBlockingQueue<Runnable>(128);
3public static final Executor THREAD_POOL_EXECUTOR;
4static {
5    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
6            CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
7            sPoolWorkQueue, sThreadFactory);
8    threadPoolExecutor.allowCoreThreadTimeOut(true);
9    THREAD_POOL_EXECUTOR = threadPoolExecutor;
10}
11public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

注意，线程池都是记在静态变量里的，它的生命期和进程的生命期基本一致。

细心的同学还记得，前文在定义AsyncTask派生类时，我们写的是private static class，大家不要忘记加static，否则就是写了一个普通内嵌类，而普通内嵌类对象内部会隐式地引用其外部类，这样当我们的task对象记入线程池后，就有可能导致task的外部类（很有可能是个Activity或Service）对象在较长时间内都不能被垃圾回收机制回收，从而导致内存泄漏。

本文的重点并不想太深入线程池的内部机理，我们只做必要的探讨即可。我们大体上只需知道线程池里的线程会执行FutureTask的run()函数即可。而FutureTask的run()代码如下：
【java/util/concurrent/FutureTask.java】

1public void run() {
2    sync.innerRun();
3}
4而FutureTask.Sync的innerRun()代码如下：
5void innerRun() {
6    if (!compareAndSetState(READY, RUNNING))
7        return;
8
9    runner = Thread.currentThread();
10    if (getState() == RUNNING) { // recheck after setting thread
11        V result;
12        try {
13            result = callable.call();  // 这一步间接调用到AsyncTask的doInBackground()。
14        } catch (Throwable ex) {
15            setException(ex);
16            return;
17        }
18        set(result);  // 如果不出异常的话，会对call返回的结果执行set()操作。
19    } else {
20        releaseShared(0); // cancel
21    }
22}

其中会调用callable.call()，这一步就会间接调用到AsyncTask的doInBackground()。再接下来，如果不出异常的话，会对call()返回的结果执行set()操作。大家还记得前文WorkerRunnable实现的call()函数吗？它最后返回语句为：return postResult(result);现在设置的就是postResult()返回的Result对象，其归根溯源就是doInBackground()返回的那个Result对象。

FutureTask的set()函数的代码如下：
【java/util/concurrent/FutureTask.java】

1protected void set(V v) {
2    sync.innerSet(v);
3}
4
5    void innerSet(V v) {
6        for (;;) {
7            int s = getState();
8            if (s == RAN)
9                return;
10            if (s == CANCELLED) {
11                releaseShared(0);
12                return;
13            }
14            if (compareAndSetState(s, RAN)) {
15                result = v;
16                releaseShared(0);
17                done();
18                return;
19            }
20        }
21    }

结果记录进Sync类的result成员，然后回调FutureTask的done()函数，这也就回调到前文我们看到的AysncTask的mFuture的done()函数了。我们再列一下mFuture的代码：
【frameworks/base/core/java/android/os/AsyncTask.java】

1    mFuture = new FutureTask<Result>(mWorker) {
2        @Override
3        protected void done() {
4            try {
5                postResultIfNotInvoked(get());
6            } catch (InterruptedException e) {
7                android.util.Log.w(LOG_TAG, e);
8            } catch (ExecutionException e) {
9                throw new RuntimeException("An error occurred while executing doInBackground()", e.getCause());
10            } catch (CancellationException e) {
11                postResultIfNotInvoked(null);
12            }
13        }
14    };

done()里面做的无法一些善后处理。

1private void postResultIfNotInvoked(Result result) {
2    final boolean wasTaskInvoked = mTaskInvoked.get();
3    if (!wasTaskInvoked) {
4        postResult(result);
5    }
6}

2.2.2 AsyncTask里的mWorker

AsyncTask的另一个重要成员是mWorker，

private final WorkerRunnable<Params, Result> mWorker;

除了在executeOnExecutor()里会为mWorker的mParams成员赋值外，AsyncTask一般不会直接操作mWorker。mWorker会间接记录进mFuture。当mFuture被回调时，系统会间接回调mWorker的call()成员函数，而这个call()函数是整个AsyncTask的核心行为。

现在我们可以画一张AsyncTask的示意图：

其实，当一个AsyncTask被安插进线程池时，线程池主要关心的是其mFuture成员引用的FutureTask。所以我们可以画出如下示意图：

当回调发生时，最终间接执行到mWorker成员的call()函数，在介绍AsyncTask的构造函数时，我们已经见过该函数的代码，现在再列一遍：

1    mWorker = new WorkerRunnable<Params, Result>() {
2        public Result call() throws Exception {
3            mTaskInvoked.set(true);
4
5            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); // 设为后台线程
6            //noinspection unchecked
7            Result result = doInBackground(mParams);
8            Binder.flushPendingCommands();   // ???
9            return postResult(result);
10        }
11    };

看到了吗，当线程池里的某个线程回调到上面的call()函数时，会先把线程优先级设置为“后台线程”，然后会调用doInBackground()函数。大家还记得吧，前文说过我们在实现一个AsyncTask派生类时，主要重写的就是这个doInBackground()函数，现在终于派上用场了。

上面代码中还调用了一个不常见的函数：Binder.flushPendingCommands()。这个函数对应的注释是这样说的：（本函数）会将所有在当前线程里挂起的“Binder命令”扔回内核驱动。一般可以在执行那些有可能阻塞较长时间的操作之前调用一下该函数，这样可以确保挂起的对象引用被及时释放，避免“持有执行对象的进程”占据比“实际需要持有的时间”更长的时间。这部分说明让人有点儿迷惑，或许此处的调用仅仅只是为了在doInBackground()之后做一些binder驱动层的清理动作。

2.2.3 UI线程和AsyncTask工作线程之间的协作

回调的call()函数最终还会通过postResult()，发回一条MESSAGE_POST_RESULT消息。postResult()的代码如下：

1private Result postResult(Result result) {
2    @SuppressWarnings("unchecked")
3    Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
4            new AsyncTaskResult<Result>(this, result));
5    message.sendToTarget();
6    return result;
7}

此处的getHandler()得到的实际是一个可向UI线程发送消息的handler（即AsyncTask的静态成员sHandler）。getHandler()的代码如下：

1private static Handler getHandler() {
2    synchronized (AsyncTask.class) {
3        if (sHandler == null) {
4            sHandler = new InternalHandler();
5        }
6        return sHandler;
7    }
8}

这里搞了个类似单例的sHandler，类型为InternalHandler：

1private static class InternalHandler extends Handler {
2    public InternalHandler() {
3        super(Looper.getMainLooper());    // 用于向UI线程发送消息！
4    }
5
6    @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
7    @Override
8    public void handleMessage(Message msg) {
9        AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
10        switch (msg.what) {
11            case MESSAGE_POST_RESULT:
12                // There is only one result
13                result.mTask.finish(result.mData[0]);
14                break;
15            case MESSAGE_POST_PROGRESS:
16                result.mTask.onProgressUpdate(result.mData);
17                break;
18        }
19    }
20}

从InternalHandler的构造函数可以看到，postResult()最终就是向UI线程发回MESSAGE_POST_RESULT消息的。

当UI线程最终处理MESSAGE_POST_RESUTL消息时，会调用AsyncTask的finish()。

1private void finish(Result result) {
2    if (isCancelled()) {
3        onCancelled(result);
4    } else {
5        onPostExecute(result);
6    }
7    mStatus = Status.FINISHED;
8}

另一方面，用户在编写doInBackground()时，还可以在合适时机调用publishProgress()，向UI线程发出MESSAGE_POST_PROGRESS消息。publishProgress()的代码如下：

1@WorkerThread
2protected final void publishProgress(Progress... values) {
3    if (!isCancelled()) {
4        getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
5                new AsyncTaskResult<Progress>(this, values)).sendToTarget();
6    }
7}

这个消息同样被刚刚说到的InternalHandler处理，处理时会回调AsyncTask的onProgressUpdate()。

关于UI线程和执行AsyncTask的线程之间的交互，我们可以画一张示意图如下：

这张图反映了一个AsyncTask对象在运作时，大体上是如何被UI线程和工作线程调用执行的。

2.2.4 AsyncTask的内部状态

细心的读者还会发现，AsyncTask在finish()时会把自己的状态置为Status.FINISHED。简单说来，AsyncTask可以处于3种状态，分别是PENDING、RUNNING、FINISHED。这3种状态的切换很简单，示意图如下：

2.2.5 cancel动作

当然，用户还可以随时中途放弃执行当前任务。不管是在主线程处理MESSAGE_POST_PROGRESS时，还是在工作线程处理doInBackground()时，用户都可以调用cancel()函数。该函数的代码如下：
【frameworks/base/core/java/android/os/AsyncTask.java】

1public final boolean cancel(boolean mayInterruptIfRunning) {
2    mCancelled.set(true);
3    return mFuture.cancel(mayInterruptIfRunning);
4}

【java/util/concurrent/FutureTask.java】

1public boolean cancel(boolean mayInterruptIfRunning) {
2    return sync.innerCancel(mayInterruptIfRunning);
3}

【java/util/concurrent/FutureTask.java】

1boolean innerCancel(boolean mayInterruptIfRunning) {
2    for (;;) {
3        int s = getState();
4        if (ranOrCancelled(s))
5            return false;
6        if (compareAndSetState(s, CANCELLED))
7            break;
8    }
9    if (mayInterruptIfRunning) {
10        Thread r = runner;
11        if (r != null)
12            r.interrupt();
13    }
14    releaseShared(0);
15    done();
16    return true;
17}

简单地说，cancel()动作会将mCancelled设为true，这样以后再调用isCancelled()时，就会返回true。前文我们已经看过AsyncTask的finish()的代码，现在再列一下：

1private void finish(Result result) {
2    if (isCancelled()) {
3        onCancelled(result);
4    } else {
5        onPostExecute(result);
6    }
7    mStatus = Status.FINISHED;
8}

可以看到，如果该任务是被用户cancel的，那么finish时执行的会是onCancelled()，而不是onPostExecute()。另外，为了确保在用户cancel任务之后，该任务能真的快速退出，我们应该在doInBackground()里周期性地检查一下isCancelled()的返回值，一旦发现，就立即退出。

3 小结

关于AsyncTask的知识，我们就先说这么多。现在大体总结一下：
1）使用AsyncTask时，主要是重写其派生类的doInBackground()，而且该函数会在线程池的某个工作线程里被回调的；
2）必须在UI线程调用AsyncTask的execute()或executeOnExecutor()；
3）可以在doInBackground()里的合适时机调用publishProgress()，向UI线程通知工作进展；
4）可以随时调用cancel()，放弃执行任务。