AsyncTask源码分析

基础知识点

1.线程池Executor
2.Future
3.Callable
4.中断线程
5.Handler
6.枚举
7.泛型
8.单例模式
9.可变参数

AsyncTask设计思想

1.回调函数
2.如何有序调度任务
3.串行或并行执行任务
4.中断任务
5.线程调度

回调函数

AsyncTask，是可异步执行任务的工具类。开发者只需要至少重写一个回调函数doInBackground(Params... params);就能完成线程调度

我们看看它的使用方法:
我们写一个抽象类AsyncTask的具体子类MyAsyncTask，并覆写其四个函数。

private class MyAsynckTask extends AsyncTask {
    /**
     * 任务被执行前，会被调用，UI线程做一些提示操作，如显示进度条
     */
    @Override protected void onPreExecute() {
      super.onPreExecute();
      Log.d(TAG, "onPreExecute: " + Thread.currentThread().getName());
    }  

    /**
     * 在后台子线程执行任务，返回类型String
     * @param params  模拟计算时间
     * @return
     */    

    @Override protected String doInBackground(Long... params) {
      try {
        TimeUnit.SECONDS.sleep(params[0]);//模拟后台耗时计算，参数大小作为计算时间
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      Log.d(TAG, "doInBackground: " + Thread.currentThread().getName());
      return Thread.currentThread().getName();
    }


    /**
     * 任务执行完毕后，在主线程回调这个函数。
     * @param s  后台任务返回的结果
     */
    @Override protected void onPostExecute(String s) {
      super.onPostExecute(s);
      Log.d(TAG, "onPostExecute: " + s + " ---" + Thread.currentThread().getName());
    }

    /**
     * 任务中途被取消会回调它
     */
    @Override protected void onCancelled() {
      super.onCancelled();
      Log.d(TAG, "onCancelled: ");
    }
  }

我们主要看doInBackground(Parms...parm)函数，它是什么时候被回调的呢？在后台FutrueTask类执行call()函数时回调。这里WorkerRunable是一个实现了Callable接口的实现类，它可以执行任务后能携带一个返回值Result，并拓展了可以持有一个Parms参数。我们看看它的回调时刻：

  public AsyncTask() {
    mWorker = new WorkerRunnable() {
        public Result call() throws Exception {
             /省略一些代码
            Result result = null;
            result = doInBackground(mParams);
            ````省略一些代码
            return result;
        }
  };

我们在UI线程使用它即可：

   new MyAsynckTask().execute(100l);
   new MyAsynckTask().execute(5l);
   new MyAsynckTask().execute(5l);
   new MyAsynckTask().execute(5l);

输出结果：

04-03 22:44:47.713 4256-4256/com.fulaan.asynctaskdemo D/MainActivity: onPreExecute: main
04-03 22:44:47.713 4256-4256/com.fulaan.asynctaskdemo D/MainActivity: onPreExecute: main
04-03 22:44:47.713 4256-4256/com.fulaan.asynctaskdemo D/MainActivity: onPreExecute: main
04-03 22:44:47.714 4256-4256/com.fulaan.asynctaskdemo D/MainActivity: onPreExecute: main
04-03 22:44:52.746 4256-4295/com.fulaan.asynctaskdemo D/MainActivity: doInBackground: AsyncTask #1
04-03 22:44:52.747 4256-4256/com.fulaan.asynctaskdemo D/MainActivity: onPostExecute: AsyncTask #1 ---main
04-03 22:44:57.788 4256-4376/com.fulaan.asynctaskdemo D/MainActivity: doInBackground: AsyncTask #2
04-03 22:44:57.788 4256-4256/com.fulaan.asynctaskdemo D/MainActivity: onPostExecute: AsyncTask #2 ---main
04-03 22:45:02.832 4256-4450/com.fulaan.asynctaskdemo D/MainActivity: doInBackground: AsyncTask #3
04-03 22:45:02.833 4256-4256/com.fulaan.asynctaskdemo D/MainActivity: onPostExecute: AsyncTask #3 ---main
04-03 22:45:07.875 4256-4450/com.fulaan.asynctaskdemo D/MainActivity: doInBackground: AsyncTask #3
04-03 22:45:07.875 4256-4256/com.fulaan.asynctaskdemo D/MainActivity: onPostExecute: AsyncTask #3 ---main

所以，我们在基类里面写一些函数钩子，并调用，然后然使用者在具体实现类里面去实现。

如何结合线程池串行调度任务

从上面的输出结果来看，AsyncTask是默认串行执行的（不考虑版本问题）。它用了两个调度器Executor实现。

SERIAL_EXECUTOR，用队列保存等待被被执行的任务
*THREAD_POOL_EXECUTOR。异步执行任务

SerialExecutor串行调度。我们把任务装入一个队列数据结构，一个个排队执行，代码:

 private static class SerialExecutor implements Executor {
    final ArrayDeque mTasks = new ArrayDeque();//一个环形队列用来保存提交过来的任务。
    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);
            }
        }
    }

我们直接看SerialExecutor在同步方法execute（r）中的实现，它有两步：
第一步: 保存任务到队列。新建一个Runable包裹提交进来的任务，在try作用域里面先执行r.run()，必须等任务执行完后，在finally作用域中会执行 scheduleNext()，来调度下一个任务。因此任务是串行执行的。最后我们会把这个新建的Runnable对象放入队列mTasks中。

第二步:查看是否有可立即执行的任务mActive。如果有，则立即放入THREAD_POOL_EXECUTOR执行。

我们再看看scheduleNext()函数，就是调用mTasks.poll())从队列得到下一个任务，执行。
文字描述也许会迷糊，不如看下图［采用OmniGraffle软件制作］：

串行调度图.png

至此，为什么要两个调度器呢？我认为是为了遵守单一职责的设计原则。一个调度器只负责一件事，前面SerialExecutor我们已经分析。那THREAD_POOL_EXECUTOR线程池调度器则是根据CPU数构造线程Thread缓存池，节约资源，提高AsyncTask执行性能。

3.为什么要串行执行任务？不串行可以吗？

为什么要串行执行，我认为是为了保证数据一致性。正如官方文档说的：

tasks are executed on a single thread to avoid common application errors caused by parallel execution.

If you truly want parallel execution, you can invoke
executeOnExecutor(java.util.concurrent.Executor, Object[])} with
THREAD_POOL_EXECUTOR.

意思是说，串行模式能够避免一些并发异常。如果你真的需要并发执行，这可以调用executeOnExecutor(),传入自定义一个Executor，这样就不会去调用SerialExecutor了。而我认为AsyncTask只适合执行一些小任务，因为在串行执行时，如果某个任务执行时间过长，或者中途阻塞，占有CPU太久，则会导致后面排队的任务等待过久。

4.如何取消任务

我们知道为了能得到后台线程运行后的结果，我们的任务实现了的Callable接口，它和Runnable区别是有一个返回值。现在我们想取消任务，我们可以实现Future接口，它除了能通过get()得到返回值，还有cancle()方法用来取消任务，done()回调函数监听是否任务结束

在AsyncTask中，我们用FutureTask这个系统SDK为我们实现了Ruanble和Future的实现类,它可以通过一个Callable类型的对象参数构造出来，这里使用我们的是上文中的WorkRunnable作为参数。
代码如下：

FutureTask mFuture = new FutureTask(mWorker) {
            @Override
            protected void done() {
                try {
                    postResultIfNotInvoked(get());
                } catch (InterruptedException e) {
                    android.util.Log.w(LOG_TAG, e);
                } catch (ExecutionException e) {
                    throw new RuntimeException("An error occurred while executing doInBackground()",
                            e.getCause());
                } catch (CancellationException e) {
                    postResultIfNotInvoked(null);
                }
            }
        };

那么如果我们想取消任务，现在是不是直接调用mFuture.cancel(true)强制中断线程就好了？答案是否定的。因为mFuture.cancel(true)方法内部实现机制其实是：

   //.....省略一些代码
   if (mayInterruptIfRunning) {
                try {
                    Thread t = runner;
                    if (t != null)
                        t.interrupt();
                } finally { // final state
                    U.putOrderedInt(this, STATE, INTERRUPTED);
                }
            }
   //.....省略一些代码

意思是如果任务正在运行，则interrupt()中断线程。而在这里，如果任务正好还在排队尚未执行，而我们想取消未执行的任务，那么直接调用mFuture.cancel(true)就无效！因此，我们还需要考虑未执行的任务如何中断。

令人惊喜的是，在AsyncTask中还提供了一个对象：

 private final AtomicBoolean mCancelled = new AtomicBoolean();

它是一个原子类，通过CAS机制保证了mCancelled可见性，它内部保存了当前任务是否被取消的信号。

那么正确完整的取消任务方案是分两个步骤：
第一步：调用AsyncTask中的cancel方法：

    public final boolean cancel(boolean mayInterruptIfRunning) {
        mCancelled.set(true);//用来取消未执行的任务
        return mFuture.cancel(mayInterruptIfRunning);//用来取消正在执行的任务可能会抛出异常
    }

第二步：在doInBackground回调函数中循环去判断mCancelled中的值确认将要执行的任务是否要求取消:

 @Override protected String doInBackground(Long... params) {
      while (!isCancelled()){
        //todo something...
      }
      return null;
    }

至此，我们成功实现了取消任务功能。

线程调度

在安卓系统中，我们要从子线程更新UI主线程，当然是利用handler+looper+messageQueue机制，在AsyncTask中不例外也是如此。但是除此之外，我们可以学习如何通过单例模式构造一个handler，如何强制构造一个主线程执行的handler。
1.单例模式：

 private static Handler getHandler() {
        synchronized (AsyncTask.class) {
            if (sHandler == null) {
                sHandler = new InternalHandler();
            }
            return sHandler;
        }
    }

看看源码中的这个单例模式，比较简陋，也不是什么double-check ：）

2.强制在主线程执行handler

 private static class InternalHandler extends Handler {
        public InternalHandler() {
            super(Looper.getMainLooper());
        }
｝

如上在父类构造函数［super（Looper.getMainLooper())］初始化Looper。

执行流程图

总调度图.png

总结

AsyncTask作为Activity内部类使用的时候还会因为持有acitivity对象引用，在后台导致内存泄漏问题。推荐阅读其他执行异步任务类框架，如Job、Rxjava等。

~~.gif