AsyncTask: 一只命途多舛的小麻雀

AsyncTask是一只命途多舛的小麻雀，为什么说它命途多舛，因为它一直被改，从Android 1.6之前，然后1.6到2.3，再从3.0到现在（其实5.1开始后也有细微的改动），反反复复，从串行到并行，再恢复至串行，可见其内心之纠结，尽管如此，它还是不断被开发人员各种吐槽，内存泄露，不靠谱的cancel等等，真可谓命途多舛。

可是天将降大任于斯人也，它毕竟是一只小麻雀啊，不到三百行代码量的一只小麻雀，其特点便是麻雀虽小五脏俱全，因此好好解读一下源码是很有必要的。如何来解读呢，不妨我们自己来创建一只简化版的小麻雀——SimpleAsyncTask，通过这种方式来加深理解。

作为一个标题党，小麻雀已经完成它的使命了，其实这篇文章真正的标题应该是《从FutureTask到AsyncTask》或者《自己写个AsyncTask》，以下，开始正题。

一 需求和api选型

想想看我们对于AsyncTask的需求是什么，大概会有以下几点：

1. 能定义以下执行过程的操作：预执行、执行后台任务、执行进度反馈、执行完毕、终止线程执行
2. 能停止线程任务
3. 子线程能与UI线程交互（反馈线程执行进度和执行结果）

第1点，我们定义这些方法目的是让调用者重写而实现各种交互，因此这5种操作实际上是5个抽象方法（或者空方法），我们需要在SimpleAsyncTask类中合适的时机去调用这5个抽象方法，显然，这是模板方法模式（Template Method）的应用。

对于第2点，如何停止线程？这方面的最佳实践是中断+条件变量，纵观java.util.concurrent，有个api很适合这个场景，那便是Future和Callback，而作为Future的唯一实现——FutureTask便是我们写AsyncTask的重点。

第3点，看到子线程和UI线程，so easy呀，有了Handler，麻麻再也不用担心线程之间的通讯了，关于Handler，如果你闲的蛋疼的话不妨看看笔者写的《Handler和他的小伙伴们》上和中。 有一点要注意的是，AsyncTask会在各Activity中实例化，有可能在主线程或子线程中实例化，这么多的AsyncTask实例中，我们只需要一个持有mainLooper的Handler的实例，因此它将是一个单例对象，单个进程内共享。

确定好需求和api选型之后，接下来我们来写代码。

二 使用Template Method

首先定义五个空方法：预执行、执行后台任务、执行进度反馈、执行完毕、终止线程执行。

public abstract class SimpleAsyncTask {

    /**
     * 模板方法1-预执行，应在线程启动之前执行
     */
    protected void onPreExecute() {
    }

    /**
     * 模板方法2-执行后台任务，应该在线程体中调用，即在FutureTask中调用
     */
    protected abstract Result doInBackground(Params params);

    /**
     * 模板方法3-执行进度反馈，应该在Handler中调用
     */
    protected void onProgressUpdate(Progress progress) {
    }

    /**
     * 模板方法4-执行完毕，应该在Handler中调用
     */
    protected void onPostExecute(Result result) {
    }

    /**
     * 模板方法5-终止线程执行，应该在Handler中调用
     */
    protected void onCancelled() {
    }
}

这几个方法见名知意，同时从各自携带的参数类型可以清晰的理解几个泛型的作用：

• Params：执行后台任务的时候使用
• Progress：反馈进度的时候使用
• Result:反馈结果的时候使用
  （注：这里为了代码简洁，去掉了Params和Progress的可变参数）

当然，模板方法模式最重要的是我们在何时去调用这些抽象的模板方法，很显然，doInBackground作为后台执行的逻辑，应该在线程中调用，也就是下文会讲到的FutureTask，而其他几个方法跟UI有关系，会在主线程中执行，因此它们会在Handler中调用到。

三 FutureTask开发

上文提到，Future和Callable是java.util.concurrent中提供了取消任务的一组api，要理解AsyncTask的话，需要先理解下这对组合。以下做个简单的介绍：

1. Callable与Runable

   public interface Callable {
    V call() throws Exception;
   }

   简单来讲，Callable接口等价于Runable，call()等价于run()，区别在于它是有返回值的。

   我们可以通过ExecutorService调用Callable，执行后将返回Future对象，比如:
   Future future = Executors.newSingleThreadExecutor().submit(mCallable);

2. Future

   public interface Future {
    boolean cancel(boolean mayInterruptIfRunning);
   
    boolean isDone();
   
    V get() throws InterruptedException, ExecutionException;
   
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
   }

   Future接口两个方法着重理解下，一是cancel(boolean mayInterruptIfRunning)，顾名思义就是终止线程，二是get()，它会阻塞线程，直到Callable的call()返回对象，并以此作为返回值。至于mayInterruptIfRunning这个boolean值的含义，大家看看FutureTask中相应的源码就直到了，其实只是多了thread.interrupt()的逻辑而已。结合Callable的代码，Future的使用如下：

   Future future = Executors.newSingleThreadExecutor().submit(mCallable);
   //阻塞线程，等待Callable.call()的返回值
   String result = future.get();

3. FutureTask

   
   

   FutureTask的继承关系

   
   从FutureTask的继承关系来看，它既是Runable也是Future，所以我们可以把当做Runable来使用，同时它也具备Future的能力，可以终止线程，可以阻塞线程，等待Callable的执行，并获取返回值。另外要注意的是，它的构造函数是public FutureTask(Callable callable)，因此实例化FutureTask时需要Callable对象作为参数。

   关于这部分基础知识的demo代码在此处，有需要的可以跑起来看看。

4. SimpleAsyncTask中的FutureTask
   介绍完Future和Callable的基础知识后，我们回归正题。FutureTask在AsyncTask里充当了线程的角色，因此耗时的后台任务doInBackground应该在FutureTask中调用，同时我们还要提供线程池对象来执行FutureTask，代码如下:

   public abstract class SimpleAsyncTask {
   
    //...省略部分代码
    private static final Executor EXECUTOR = Executors.newCachedThreadPool();
    private WorkerRunnable mWorker;
    private FutureTask mFuture;
   
    public SimpleAsyncTask() {
        mWorker = new WorkerRunnable() {
            @Override
            public Result call() throws Exception {
                //调用模板方法2-执行后台任务
                Result result = doInBackground(mParams);
                //提交结果给Handler
                return postResult(result);
            }
        };
   
        //此为线程对象
        mFuture = new FutureTask<>(mWorker);
    }
   
    public void execute(Params params) {
        mWorker.mParams = params;
        //在线程启动前调用预执行的模板方法，意味着它在调用AsyncTask.execute()的所在线程里执行，如果是在子线程中，则无法处理UI
        //调用模板方法1-预执行
        onPreExecute();
        //执行FutureTask启动线程
        EXECUTOR.execute(mFuture);
    }
   
    private static abstract class WorkerRunnable implements Callable {
        Params mParams;
    }
    //...省略部分代码
   }

四 Handler开发

到目前为止，我们已经消费掉了两个模板方法，分别是onPreExecute和doInBackground，此时还剩下3个模板方法，他们都需要有UI交互的，因此他们将在Handler中被调用。

首先，对于终止线程和线程执行完毕这两个方法，我们都称之为线程finish了，所以我们先定义个finish(Result result)方法，如下：

private void finish(Result result) {
    if (isCancelled()) {
        //调用模板方法：终止线程执行
        onCancelled();
    } else {
        //调用模板方法：线程执行完毕
        onPostExecute(result);
    }
}

接下来，开始写关键的Handler类对象，因为该Handler位于SimpleAsyncTask内部，因此把它命名为InternalHandler，这个静态内部类有几点要注意：

1. 它是静态的单实例，所有AsyncTask对象共享
2. 它必须持有mainLooper对象，才能与主线程进行交互

3. 注意它调用几个模板方法的时机
   代码如下：

   public abstract class SimpleAsyncTask {
   
    //省略部分代码
   
    /**
     * 一个静态的单例对象，所有AsyncTask对象共享的
     */
    private static InternalHandler sHandler = new InternalHandler();
   
    private static class InternalHandler extends Handler {
        /**
         * 注：此为android 22之后的写法，构造函数里默认指定mainLooper对象
         * 它的好处是无论Handler在什么时机被实例化，都可以与主线程进行交互
         * 相比之下，之前版本的AsyncTask必须在ActivityThread中执行AsyncTask.init()
         */
        public InternalHandler() {
            super(Looper.getMainLooper());
        }
   
        @Override
        public void handleMessage(Message msg) {
            AsyncTaskResult result = (AsyncTaskResult) msg.obj;
            switch (msg.what) {
                case MESSAGE_POST_RESULT:
                    //调用模板方法4和5，取消或者完成
                    result.mTask.finish(result.mData);
                    break;
                case MESSAGE_POST_PROGRESS:
                    //调用模板方法3-执行进度反馈
                    result.mTask.onProgressUpdate(result.mData);
                    break;
            }
        }
    }
   
    /**
     * 由于InternalHandler是静态内部类，无法引用外部类SimpleAsyncTask的实例对象，
     * 因此需要将外部类对象作为属性传递进来，所以封装此类
     */
    private static class AsyncTaskResult {
        final SimpleAsyncTask mTask;
        final Data mData;
   
        AsyncTaskResult(SimpleAsyncTask task, Data data) {
            mTask = task;
            mData = data;
        }
    }
   
    //省略部分代码
   }

   到目前为止5个模板方法都已经调用到了，其中四个方法均有触发的时机和调用的时机，除了onProgressUpdate，它只有调用，但并没有触发的时机，因此，我们还要提供一个方法，供调用者主动触发：

   protected final void publishProgress(Progress progress) {
    if (!isCancelled()) {
        AsyncTaskResult taskResult = new AsyncTaskResult<>(this, progress);
        sHandler.obtainMessage(MESSAGE_POST_PROGRESS, taskResult).sendToTarget();
    }
   }

   写到这里，我们这只简化版的小麻雀基本上已经完成，当然对比源码还是有一点点细微的不同，大家可以自行对比一下。通过自己写个SimpleAsyncTask的方式可以帮助我们更好的理解源码，以上所写的完整代码在此。

五 关于其他细节

• 串行or并行？
  在SimpleAsyncTask中，我们使用private static final Executor EXECUTOR = Executors.newCachedThreadPool()作为线程池，而实际上，源码中的默认线程池是自定义的，这个类是SerialExecutor，从类的命名上看，Serial是串行的意思，所以很明显，AsyncTask默认是串行的。除此之外，AsyncTask里还有个线程池 THREAD_POOL_EXECUTOR，实在需要并行的话我们就用这个线程池。

  如果都些都不满足要求，我们也可以自定义符合自己业务要求的线程池，并通过setDefaultExecutor(Executor exec)改变默认的线程池。

• 不能执行多次
  AsyncTask只能执行一次，类似这样的代码是会抛异常的：

  MyAsyncTask asyncTask = new MyAsyncTask();
  asyncTask.execute();
  asyncTask.execute();

  原理很简单，AsyncTask会判断当前状态，如果是RUNNING或者FINISHED状态，则直接抛异常：

  //execute最终会执行到executeOnExecutor
  public final AsyncTask executeOnExecutor(Executor exec,
            Params... params) {
    if (mStatus != Status.PENDING) {
        switch (mStatus) {
            case RUNNING:
                throw new IllegalStateException("Cannot execute task:"
                        + " the task is already running.");
            case FINISHED:
                throw new IllegalStateException("Cannot execute task:"
                        + " the task has already been executed "
                        + "(a task can be executed only once)");
        }
    }
    //省略部分代码
  }

• AsyncTask是否只能在主线程创建和运行？
  比如，这样的代码能否正常使用：

  new Thread(new Runnable() {
    @Override
    public void run() {
        MyAsyncTask myAsyncTask = new MyAsyncTask();
        mSimpleAsyncTask.execute("task1");
    }
  }).start();

  从Android4.1(API 16)之后其实已经没什么问题了，通过源码来理解的话非常简单，比如在我们自己写的SimpleAsyncTask中，重写了Handler的构造器，如下:

  public InternalHandler() {
    super(Looper.getMainLooper());
  }

  这样一来，无论AsyncTask在什么时候创建，实例化出来的静态InternalHandler对象都持有mainLooper，都能与主线程进行通讯。有一点小区别，如果在子线程中调用execute()，则onPreExecute不能执行UI的操作，否则会抛异常。

  要注意的是，这是Android 5.1(API 22)以及之后的写法，API 16~API 21是另外一种写法，参考下一点。

• AsyncTask.init()
  AsyncTask中有个隐藏方法init()(API 22之后已经移除)

  /** @hide Used to force static handler to be created. */
  public static void init() {
    sHandler.getLooper();
  }

  与此对应的，在ActivityThread的main方法中会调用AsyncTask.init()，目的是什么？

  由于AsyncTask中的Handler是静态的单实例对象，他会在类加载期间进行初始化，万一调用者在子线程中加载AsyncTask，将会导致同一进程的所有AsyncTask无法使用。因此，系统先下手为强，一开始就直接加载，保证该Handler持有主线程的mainLooper，能正常进行UI交互。

• postResultIfNotInvoked的作用是什么？
  AsyncTask有很多逻辑干扰了我们解读源码，postResultIfNotInvoked便是其中一个。它实际上是Google解决的一个bug，确保如果cancel()方法过早调用的场景下，onCancelled()仍然能顺利的执行，参考stackoverflow这篇文章。

  比如，我们自定义的SimpleAsyncTask，如果我们执行以下代码，onCancelled()是不会执行的，而AsyncTask则可以正常执行:

  mSimpleAsyncTask = new MySimpleAsyncTask();
  mSimpleAsyncTask.execute("task1");
  //马上终止线程
  mSimpleAsyncTask.cancel(true);

六 最后

AsyncTask作为一只命途多舛的小麻雀，他是一只纯粹的麻雀，脱离了低级趣味的麻雀，值得好好品尝的小麻雀。

参考文章：
blog.csdn.net/guolin_blog…
droidyue.com/blog/2015/1…
droidyue.com/blog/2014/1…
stackoverflow.com/questions/2…