AsyncTask源码解析

用户1269200

发布于 2018-02-01 17:43:06

7440

发布于 2018-02-01 17:43:06

文章被收录于专栏：刘望舒刘望舒

导语

AsyncTask对Android开发者来说并不陌生，当有耗时任务并涉及UI交互，AsyncTask可是处理异步任务的利器。AsyncTask使用也很方便，开发的时候多留意不要内存泄漏，一般处理方法就是把AsyncTask写成静态内部类的形式。

使用方法

new AsyncTask<Integer, Integer, Boolean>() {
           private int NUM = 0;
           @Override
           protected void onPreExecute() {
               super.onPreExecute();
               textView.setText("onPreExceute");
           }
           @Override
           protected Boolean doInBackground(Integer... integers) {
               for (int i = 0; i < 20; i++) {
                   try {
                       NUM ++;
                       publishProgress(NUM);
                       Thread.sleep(1000);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
               return NUM == 20;
           }

           @Override
           protected void onPostExecute(Boolean aBoolean) {
               super.onPostExecute(aBoolean);
               textView.setText("onPostExcute: " + aBoolean);
           }

           @Override
           protected void onProgressUpdate(Integer... values) {
               super.onProgressUpdate(values);
               textView.setText("onProgressUpdate: " + values[0]);
           }

           @Override
           protected void onCancelled(Boolean aBoolean) {
               super.onCancelled(aBoolean);
               textView.setText("onCancelled: " + aBoolean);
           }

           @Override
           protected void onCancelled() {
               super.onCancelled();
               textView.setText("onCancelled");
           }

       }.execute(1);

关键方法

onPreExecute、doInBackground、publishProgress、onPostExecute、onProgressUpdate、onCancelled是AsyncTask的几个关键方法，开发者可处理自己的逻辑。除了doInBackground在异步线程执行外，publishProgress可在任意线程处理，其他方法都是在UI线程处理。publishProgress和onProgressUpdate配合使用。

参数

Integer, Integer, Boolean，在AsyncTask三个参数的呈现形式是：Params,Progress,Result，从字面意思我们就知道，Params即入参，Progress即进度，Result即返回结果，可根据实际业务逻辑灵活配置。

源码分析

从execute()开始吧

   @MainThread
   public final AsyncTask<Params, Progress, Result> execute(Params... params) {
       return executeOnExecutor(sDefaultExecutor, params);
   }
   @MainThread
   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)");
           }
       }
       mStatus = Status.RUNNING;
       onPreExecute();
       mWorker.mParams = params;
       exec.execute(mFuture);
       return this;
   }

Status有三个值：PENDING、RUNNING、FINISHED，分别表示初始、运行、结束三个状态。从executeOnExecutor方法里可以看出，一开始执行Status状态就置成了RUNNING运行状态，这里出现了关键方法之一 onPreExecute，也就是执行异步任务doInBackground前的一个状态，一般用来处理界面元素初始化相关，运行在UI线程。下面两行代码则开启了doInBackground的工作：

mWorker.mParams = params;exec.execute(mFuture);

mWorker是什么呢？mFuture又是什么呢？我们知道exec是一个Executor对象，说明它是一个线程池，那么可以知道mFuture应该是Runnable或Callable对象。mWorker对象则承载了入参，和mFuture肯定是依赖关系。继续往下深入，一探mFuture和mWorker的究竟。在AsyncTask构造方法里面，发现了这两个对象的初始化相关：

public AsyncTask(@Nullable Looper callbackLooper) {
       mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
           ? getMainHandler()
           : new Handler(callbackLooper);
       mWorker = new WorkerRunnable<Params, Result>() {
           public Result call() throws Exception {
               mTaskInvoked.set(true);
               Result result = null;
               try {
                   Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);            
                   result = doInBackground(mParams);
                   Binder.flushPendingCommands();
               } catch (Throwable tr) {
                   mCancelled.set(true);
                   throw tr;
               } finally {
                   postResult(result);
               }
               return result;
           }
       };

       mFuture = new FutureTask<Result>(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);
               }
           }
       };
   }

原来mWorker是一个Runnable，mFuture是一个FutureTask，mWorker用mFuture来承载。 FutureTask在平时开发过程中用的较少，可能很多开发者对它还有些陌生。这里做个简单介绍：FutureTask是一个用来执行异步任务的类，同时当程序执行完成之后还会返回运算的结果。官方释义：这是一个可以取消的异步计算，该类提供了Future的基本实现，具有启动和取消运算，查询运算是否结束，并且检查返回计算的结果，该结果只能在运行完成之后才能获取到，如果程序没有运行结束，则get()将会阻塞。程序运行结束之后，无法重新启动或者是取消程序（除非调用runAndReset方法）。FutureTask可以承载Callable和Runnable，两者的区别是：Callable可以携带返回参数，而Runnable不支持。我们来看看mWorker的实现：

private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
       Params[] mParams;
   }

WorkerRunnable是一个抽象类，继承自Callable，并携带了Result参数，由于AsyncTask是一个带结果返回的对象，所以用Callable实现。这里可以知道AsyncTask构造方法里的mWorker即是WorkerRunnable的具体实现，抽象类里只是承载了入参。

到这里，就清楚AsyncTask整体的运行模式了：Executor —> FutureTask —> Callable 。内部维护一个线程池，线程池处理异步任务，异步任务承载Callable进行任务的执行。

继续深入，mWoker就类似一个带任务的小兵，具体的执行工作都在它身上完成。一探mWoker究竟吧。具体实现代码再拎出来：

mWorker = new WorkerRunnable<Params, Result>() {
           public Result call() throws Exception {
               mTaskInvoked.set(true);
               Result result = null;
               try {
                   Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                   result = doInBackground(mParams);
                   Binder.flushPendingCommands();
               } catch (Throwable tr) {
                   mCancelled.set(true);
                   throw tr;
               } finally {
                   postResult(result);
               }
               return result;
           }
       };

在回调的call方法里，我们发现关键方法之二doInBackground，说明异步任务在这里执行，返回了Result对象。Process.setThreadPriority设置了线程优先级，这里任务在后台执行，所以优先级设置成THREAD_PRIORITY_BACKGROUND。关于Binder.flushPendingCommands()，官方释义：将当前线程中挂起的任何绑定命令刷新到内核驱动程序中。在执行可能很长时间阻塞的操作之前调用此功能是有用的，以确保任何挂起的对象引用已被释放，以防止进程对对象持有比它所需时间更长的时间。这里不做深究。异步任务执行完毕又是如何告知UI线程的呢？这里的逻辑我们要看FutureTask的具体实现和处理了：

mFuture = new FutureTask<Result>(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);
               }
           }
       };

可以看出当任务执行完毕，即在done方法回调里由postResultIfNotInvoked处理：

private void postResultIfNotInvoked(Result result) {
       final boolean wasTaskInvoked = mTaskInvoked.get();
       if (!wasTaskInvoked) {
           postResult(result);
       }
   }

可以看出返回的结果对象Result最终通过postResult方法执行，去看看：

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

发现这就是我们常用的handler啊，这里发送了一条msg.what=MESSAGE_POST_RESULT，msg.object=AsyncTaskResult的消息给getHandler()。继续看看getHandler()怎么处理的：

private Handler getHandler() {
       return mHandler;
   }

这。。。不是我想要的结果啊。好吧，继续追踪mHandler。才发现早在AsyncTask构造方法里就对mHandler进行了初始化。

mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
           ? getMainHandler()
           : new Handler(callbackLooper);

好吧，继续看getMainHandler()具体实现：

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

继续吧，看InternalHandler具体实现：

private static class InternalHandler extends Handler {
       public InternalHandler(Looper looper) {
           super(looper);
       }
       @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
       @Override
       public void handleMessage(Message msg) {
           AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
           switch (msg.what) {
               case MESSAGE_POST_RESULT:      
                   result.mTask.finish(result.mData[0]);
                   break;
               case MESSAGE_POST_PROGRESS:
                   result.mTask.onProgressUpdate(result.mData);
                   break;
           }
       }
   }

终于找到了handler的具体实现，这里发现了关键方法之三onProgressUpdate，可以看到他处理两类消息：MESSAGE_POST_RESULT和MESSAGE_POST_PROGRESS。很显然这里的逻辑都是在UI线程发生。MESSAGE_POST_RESULT处理异步任务执行完返回的Result，可以知道MESSAGE_POST_PROGRESS应该就是处理publishProgress发送的消息了。看看publishProgress的实现：

 @WorkerThread
   protected final void publishProgress(Progress... values) {
       if (!isCancelled()) {
           getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                   new AsyncTaskResult<Progress>(this, values)).sendToTarget();
       }
   }

这里发现了关键方法之三publishProgress，可以看出，MESSAGE_POST_PROGRESS通过publishProgress发出，和MESSAGE_POST_RESULT发送对象的参数不一样，MESSAGE_POST_PROGRESS携带的是Progress，MESSAGE_POST_RESULT携带的是Result。这逻辑也是通的，看来AsyncTaskResult也就是一个数据对象啦。看看具体实现：

@SuppressWarnings({"RawUseOfParameterizedType"})
   private static class AsyncTaskResult<Data> {
       final AsyncTask mTask;
       final Data[] mData;
       AsyncTaskResult(AsyncTask task, Data... data) {
           mTask = task;
           mData = data;
       }
   }

好了，到这里我们已经理清异步任务执行的结果或是执行过程中的进度是如何通知UI线程处理了。那么异步处理完成后返回的Result又是如何处理的呢？继续往下看：

  switch (msg.what) {
      case MESSAGE_POST_RESULT:     
          result.mTask.finish(result.mData[0]);
         break;
      case MESSAGE_POST_PROGRESS:
          result.mTask.onProgressUpdate(result.mData);
         break;
     }

对于Result的处理方式：result.mTask.finish(result.mData[0]);result.mTask即AsyncTask本身，我们具体看看它的finish方法具体实现:

private void finish(Result result) {
       if (isCancelled()) {
           onCancelled(result);
       } else {
           onPostExecute(result);
       }
       mStatus = Status.FINISHED;
   }

这里发现了关键方法之四onPostExecute和关键方法之五onCancelled。如果任务没有被取消，则执行onPostExecute，同时Status置于FINISHED，任务结束。

到这里，AsyncTask几个关键方法的执行时机和来龙去脉已经清楚，通过handler进行关联处理。

我们知道AsyncTask可以同时处理多个Runnable任务，那么内部又是如何保证执行顺序呢？初步判断是和线程池相关，于是看看AsyncTask维护的线程池具体实现：

线程池配置：

static {
       ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
               CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
               sPoolWorkQueue, sThreadFactory);
       threadPoolExecutor.allowCoreThreadTimeOut(true);
       THREAD_POOL_EXECUTOR = threadPoolExecutor;
   }

线程池的具体执行类：

private static class SerialExecutor implements Executor {
       final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
       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内部维护了一个ArrayDeque队列，里面可以装载很多Runnable。没当执行一个Runnable的时候，将该Runnable添加到队列尾部，每次执行Runnable的时候从队尾获取Runnable对象。第一个Runnable任务执行的时候，mActive==null，所以会去执行scheduleNext()方法并把该runnable赋值给mActive，当第二个Runnable执行的时候，mActive!=null，就不会去执行scheduleNext了吗？当然不是，我们可以发现run方法回调里用了try finally方法，意思是任何一个Runnable，执行完毕后都会去执行scheduleNext方法。这样相当于保证每个Runnable任务都是等上个Runnable执行完毕后才会去执行。

好了，关于AsyncTask的源码解析主要逻辑都在这了。其中涉及的一些细节，可以自行去查找资料了解。比如用AutomicBoolean来判断任务是否取消(mCancelled)或已经开始执行(mTaskInvoked)。

为更好地理解AsyncTask，建议大家参照AsyncTask源码，造个轮子，毕竟代码量不大。

作者 | 笑漫人生

地址 | https://zhuanlan.zhihu.com/p/31582064

声明 | 本文是笑漫人生原创，已获授权发布，未经原作者允许请勿转载

本文参与腾讯云自媒体分享计划，分享自微信公众号。

原始发表：2018-01-19，如有侵权请联系 cloudcommunity@tencent.com 删除

android

api

本文分享自刘望舒微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体分享计划，欢迎热爱写作的你一起参与！

android

api

登录后参与评论

0 条评论

热度