自己写个AsyncTask

转载

jdsjlzx 2022-11-15 19:15:39 博主文章分类：Android开发

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

一需求和api选型

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

能定义以下执行过程的操作：预执行、执行后台任务、执行进度反馈、执行完毕、终止线程执行
能停止线程任务
子线程能与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<Params, Progress, Result> {

    /**
     * 模板方法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的话，需要先理解下这对组合。以下做个简单的介绍：

Callable与Runable

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

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

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

Future

public interface Future<V> {
 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<String> future = Executors.newSingleThreadExecutor().submit(mCallable);
//阻塞线程，等待Callable.call()的返回值
String result = future.get();

FutureTask

自己写个AsyncTask_子线程

FutureTask的继承关系

从FutureTask的继承关系来看，它既是Runable也是Future，所以我们可以把当做Runable来使用，同时它也具备Future的能力，可以终止线程，可以阻塞线程，等待Callable的执行，并获取返回值。另外要注意的是，它的构造函数是public FutureTask(Callable<V> callable)，因此实例化FutureTask时需要Callable对象作为参数。
关于这部分基础知识的demo代码在此处，有需要的可以跑起来看看。
SimpleAsyncTask中的FutureTask
介绍完Future和Callable的基础知识后，我们回归正题。FutureTask在AsyncTask里充当了线程的角色，因此耗时的后台任务doInBackground应该在FutureTask中调用，同时我们还要提供线程池对象来执行FutureTask，代码如下:

public abstract class SimpleAsyncTask<Params, Progress, Result> {

 //...省略部分代码
 private static final Executor EXECUTOR = Executors.newCachedThreadPool();
 private WorkerRunnable<Params, Result> mWorker;
 private FutureTask<Result> mFuture;

 public SimpleAsyncTask() {
     mWorker = new WorkerRunnable<Params, Result>() {
         @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<Params, Result> implements Callable<Result> {
     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，这个静态内部类有几点要注意：

它是静态的单实例，所有AsyncTask对象共享
它必须持有mainLooper对象，才能与主线程进行交互
注意它调用几个模板方法的时机
代码如下：

public abstract class SimpleAsyncTask<Params, Progress, Result> {

 //省略部分代码

 /**
  * 一个静态的单例对象，所有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<Data> {
     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<Progress> 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<Params, Progress, Result> 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作为一只命途多舛的小麻雀，他是一只纯粹的麻雀，脱离了低级趣味的麻雀，值得好好品尝的小麻雀。

参考文章：http://droidyue.com/blog/2015/12/20/worker-thread-in-android/?droid_refer=ninki_postshttp://droidyue.com/blog/2014/11/08/bad-smell-of-asynctask-in-android/index.htmlhttp://stackoverflow.com/questions/25322651/asynctask-source-code-questions

上一篇：Android基于http协议多文件上传

下一篇：2016Android某公司面试题

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯