Android 多线程：AsyncTask的原理及其源码分析

在Android Handler：手把手带你深入分析 Handler机制源码中我们分析了最基础也最重要的Handler机制源码部分，但是使用起来没有那么方便，今天我们就来介绍一个关于Handler源码的封装类AsyncTask（基于Android 10），使用起來使用起来比较方便，不用我们自己切换线程，它内部已经封装好了，我们只需要关注自己的业务逻辑即可。

Android中的多线程

• 直接使用Thread类
• 使用Runnable类
• 使用线程池
• 使用Handler
• 使用AsyncTask(本文重点讲解的部分)
• 使用HandlerThread

如何使用AsyncTask？

• 我们这里使用AsyncTask来模拟下载进度的逻辑，代码如下：

  public class DownloadAsyncTask extends AsyncTask {
  
      @Override
      protected void onPreExecute() {
          super.onPreExecute();
          Log.i("bbb", "-----------------onPreExecute: " + Thread.currentThread().getName());
      }
  
      @Override
      protected String doInBackground(String... strings) {
          for (int i = 0; i < 3; i++) {
              Log.i("bbb", "----------------doInBackground progress:" + i + "---" + Thread.currentThread().getName());
              publishProgress(i);
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
          return "success";
      }
  
  
      @Override
      protected void onProgressUpdate(Integer... values) {
          super.onProgressUpdate(values);
          Log.i("bbb", "--------------onProgressUpdate  progress:" + values[0] + "--name:" + Thread.currentThread().getName());
      }
  
      @Override
      protected void onPostExecute(String s) {
          super.onPostExecute(s);
          Log.i("bbb", "-------------------onPostExecute  value:" + s + "---" + Thread.currentThread().getName());
      }
  }
  

• 直接通过new DownloadAsyncTask().execute()在主线程调用即可，打印信息如下：

  bbb: -----------------onPreExecute: main
  bbb: ----------------doInBackground progress:0---AsyncTask #2
  bbb: --------------onProgressUpdate  progress:0--name:main
  bbb: ----------------doInBackground progress:1---AsyncTask #2
  bbb: --------------onProgressUpdate  progress:1--name:main
  bbb: ----------------doInBackground progress:2---AsyncTask #2
  bbb: --------------onProgressUpdate  progress:2--name:main
  bbb: -------------------onPostExecute  value:success---main
  

• 从上面AsyncTask的使用来看，还是比较简单的，这里虽然代码简单，但是该覆盖的基本功能都覆盖到了，这里对AsyncTask的使用做一个简单说明。
• 因为AsyncTask是一个抽象类，所以想要使用AsyncTask，就必须得继承它，并实现它的抽象方法，其中只有doInBackground是一个抽象方法，所以doInBackground是必须实现的方法，下面对AsyncTask中的几个重要方法做一个简单说明，后面源码部分详细讲解。

方法	调用的线程	作用
execute(Params... params)	建议在主线程调用	用于执行任务
onPreExecute:	主线程自动执行	用于执行任务前的处理工作，可以不重写，在execute前执行
doInBackground	子线程自动执行	可以通过publishProgress更新进度；返回值即任务执行的结果
onProgressUpdate	主线程自动执行	通过publishProgress执行的方法
onPostExecute	主线程自动执行	接收doInBackground返回的结果
cancel	不限制调用线程	取消任务，但是doInBackground会继续执行到结束，但是最终的结果不会刷新到UI线程，即不会执行onProgressUpdate和onPostExecute

• 通过上面的打印log信息，也能看出只有doInbackground是在子线程执行的，其它的四个方法都是在主线程执行的。
• 但是这里有一点需要注意，上面的log是new DownloadAsyncTask().execute()在主线程调用的结果，如果在子线程调用的话, onPreExecute就不是主线程了，但是不建议在子线程调用，我们的目的就是在主线程和子线程之间切换的，你在子线程调用还有什么意义呢？是吧。有很多文章说必须在主线程调用，这里强调一下，不是必须，是强烈建议在主线程调用。好了，下面我们可以开始源码的旅程吧。

AsyncTask源码分析。

• 我们就先从构造方法说起，源码如下：

  private final WorkerRunnable mWorker;
  
  private static abstract class WorkerRunnable implements Callable {
      Params[] mParams;
  }
  
  private final FutureTask mFuture;
  
  public FutureTask(Callable callable) {
          if (callable == null)
              throw new NullPointerException();
          this.callable = callable;
          this.state = NEW;       // ensure visibility of callable
  }
  
  private static InternalHandler sHandler;
  
  public AsyncTask(@Nullable Looper callbackLooper) {
      mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
          ? getMainHandler()
          : new Handler(callbackLooper);
  
      mWorker = new WorkerRunnable() {
          public Result call() throws Exception {
              mTaskInvoked.set(true);
              Result result = null;
              try {
                  Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                  //noinspection unchecked
                  result = doInBackground(mParams);
                  Binder.flushPendingCommands();
              } catch (Throwable tr) {
                  mCancelled.set(true);
                  throw tr;
              } finally {
                  postResult(result);
              }
              return result;
          }
      };
  
      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);
              }
          }
      };
  }
  

• 上面构造方法中涉及到了三个对象，mHandler,mWorker,mFuture, 下面对其进行详细的讲解：

类	作用
InternalHandler	作用是线程切换，一般我们初始化AsyncTask时候,如果参数为空就实例化一个InternalHandler, 它内部的looper使用的是主线程的Looper, 所以这里就实现了线程的切换对于Handler的讲解可以看Android Handler：手把手带你深入分析 Handler机制源码
WorkerRunnable	它实现了Callable，内部的call方法的返回值就是我们doInbackground的返回值
FutureTask	内部持有了Callable，也就是持有了上面的WorkerRunnable对象，通过get()可以得到上面call()也就是doInbackground的返回值，便于进行下一步处理。

• 通过new DownloadAsyncTask().execute()在主线程调用的时候源码如下：

  private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
  
  public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
  
  public final AsyncTask execute(Params... params) {
      return executeOnExecutor(sDefaultExecutor, params);
  }
  

• 这里先看一下sDefaultExecutor, 它是一个自定义线程池，我们看下它的实现：

  public static final Executor THREAD_POOL_EXECUTOR;
  
  static {
      ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
              CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
              new SynchronousQueue(), sThreadFactory);
      threadPoolExecutor.setRejectedExecutionHandler(sRunOnSerialPolicy);
      THREAD_POOL_EXECUTOR = threadPoolExecutor;
  }
  
  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中使用ArrayDeque队列的形式对需要执行的任务进行了入队操作, 来看源码，当执行execute方法的时候，首先往队列中offer一个要真正执行的Runnable，然后判断mActive == null, 因为这里是第一次执行，所以会执行scheduleNext(),scheduleNext()的逻辑也比较简单，就是从队列中poll取出一个任务，因为前面已经offer一个任务了，所以这里就可以执行刚才offer的任务了，但是真正执行任务的是THREAD_POOL_EXECUTOR, 它是一个自定义的ThreadPoolExecutor, 是真正意义上的线程池，通过上面的源码可以看出来；
• 这时候如果在执行第一个耗时任务的时候，又进来一个任务，这时候的处理逻辑是什么样的呢？这时候还会判断mActive == null是否成立，很显然刚才已经把第一个任务赋值给mActive了，所以这时候并不会真正的执行后来的任务，而是先入队列，等到第一个耗时任务执行完毕之后，会执行finally中的scheduleNext()方法，这时候就会从队列中poll得到下一个任务来执行了，从上面的分析就能看出来，AsyncTask的执行是串行的，并不是真正意义上的多线程，这是为了防止出现并发问题，但是内部维护了一个线程池，对于线程开销有了很大的性能提升。
• 其实在Android1.6之前AsyncTask是串行执行的，在1.6之后内部使用了线程池来并行处理任务，但是从3.0开始又使用了线程池串行执行任务。尽管如此，但是如果我们使用executeOnExecutor(Executor exec, Params... params)的话就可以自己执行线程池，从而达到真正意义上的并发。
• 接着上面的execute调用的executeOnExecutor, 我们继续看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)");
          }
      }
  
      mStatus = Status.RUNNING;
  
      onPreExecute();
  
      mWorker.mParams = params;
      exec.execute(mFuture);
  
      return this;
  }
  

• mStatus用来记录当前的状态，他有三种状态，默认是PENDING状态，当调用execute方法的时候，正常情况下会改变状态为RUNNING状态，当执行完onPostExecute后，会将状态赋值为FINISHED。但是这里要注意，如果我们连续两次通过mAsyncTask.execute调用一个耗时任务，这里会出现Cannot execute task: the task is already running.异常，从上面的源码部分可以看出问题，因为这时候当前任务已经处于RUNNING状态了，不能重复执行，想多次调用的话使用两次new DownloadAsyncTask().execute()就没问题了，这里注意一下。
• 接着就会调用onPreExecute方法，然后把传进来的参数赋值给前面的mWorker.mParams, 便于在后面doInBackground(mParams)中使用。接着就调用了exec.execute(mFuture)开始执行任务了。执行的其实就是FutureTask中的run方法，我们通过源码角度来看一下：

  public void run() {
      if (state != NEW ||
          !U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
          return;
      try {
          Callable c = callable;
          if (c != null && state == NEW) {
              V result;
              boolean ran;
              try {
                  result = c.call();
                  ran = true;
              } catch (Throwable ex) {
                  result = null;
                  ran = false;
                  setException(ex);
              }
              if (ran)
                  set(result);
          }
      } finally {
          // runner must be non-null until state is settled to
          // prevent concurrent calls to run()
          runner = null;
          // state must be re-read after nulling runner to prevent
          // leaked interrupts
          int s = state;
          if (s >= INTERRUPTING)
              handlePossibleCancellationInterrupt(s);
      }
  }
  

• 内部调用了c.call返回了result，这里的c就是上面的WorkerRunnable, 也就是在构造方法中初始化的mWorker, 然后调用set(result)方法，我们看一下源码：

  protected void set(V v) {
      if (U.compareAndSwapInt(this, STATE, NEW, COMPLETING)) {
          outcome = v;
          U.putOrderedInt(this, STATE, NORMAL); // final state
          finishCompletion();
      }
  }
  
  private void finishCompletion() {
      // assert state > COMPLETING;
      for (WaitNode q; (q = waiters) != null;) {
          if (U.compareAndSwapObject(this, WAITERS, q, null)) {
              for (;;) {
                  Thread t = q.thread;
                  if (t != null) {
                      q.thread = null;
                      LockSupport.unpark(t);
                  }
                  WaitNode next = q.next;
                  if (next == null)
                      break;
                  q.next = null; // unlink to help gc
                  q = next;
              }
              break;
          }
      }
  
      done();
  
      callable = null;        // to reduce footprint
  }
  

• 上面set(result)方法回调用finishComplete方法，最终调用了done, done是一个空的实现，需要我们自己实现，在AsyncTask中的FutureTask中我们已经实现了这个done方法，下面我们再回过头看一下最开始构造方法中初始化的call方法以及done方法。

  mWorker = new WorkerRunnable() {
          public Result call() throws Exception {
              mTaskInvoked.set(true);
              Result result = null;
              try {
                  Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                  //noinspection unchecked
                  result = doInBackground(mParams);
                  Binder.flushPendingCommands();
              } catch (Throwable tr) {
                  mCancelled.set(true);
                  throw tr;
              } finally {
                  postResult(result);
              }
              return result;
          }
      };
  
  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);
              }
          }
      };
     
  private void postResultIfNotInvoked(Result result) {
      final boolean wasTaskInvoked = mTaskInvoked.get();
      if (!wasTaskInvoked) {
          postResult(result);
      }
  }
  

• 上面的分析中先执行了call方法, call中先设置了mTaskInvoked.set(true), call之后调用了done，done中调用了然后调用了postResultIfNotInvoked, 源码上面可以看到，首先会判断mTaskInvoked.get(), 如果为false就会调用postResult(result);, 但是实际上在上面call已经赋值为true了，所以这里一般不会执行postResultIfNotInvoked。其实这两个方法主要目的就是为了执行postResult, 那么我们接着上面的call分析。call中调用doInbackground方法，传入了刚才的mParams，而doInbackground就是我们必须要实现的方法，这里返回了result。 在finally中调用了postResult。接着调用了源码如下：

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

• 这里getHandler就是上面的InternalHandler, 它内部的Looper是主线程的Looper, 通过Handler机制，就实现了线程的切换，我们看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:
                  // There is only one result
                  result.mTask.finish(result.mData[0]);
                  break;
              case MESSAGE_POST_PROGRESS:
                  result.mTask.onProgressUpdate(result.mData);
                  break;
          }
      }
  }
  

• 我们看到上面MESSAGE_POST_RESULT对应的是第一个，所以就会执行result.mTask.finish(result.mData[0]), 而mTask就是AsyncTask自身，所以我们看finish即可。我们看下finish方法源码：

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

• 如果我们没有主动调用cancel方法就会进入onPostExecute方法，这里也是在主线程执行的，这个方法是需要我们自己处理的，然后把mStatus = Status.FINISHED, 标志着一个完整的调用结束了。
• 如果我们在doInBackground中调用了publishProgress方法，内部的逻辑是什么样的呢？因为doInbackground是在子线程中执行的，publishProgress的逻辑和postResult逻辑一样, 它发送一个MESSAGE_POST_PROGRESS，通过Handler机制将线程切换到InternalHandler的主线程中，然后会调用result.mTask.onProgressUpdate(result.mData);也就是调用我们重写的onProgressUpdate方法，这里就不贴源码了，小伙伴们可以自己查看源码，比较简单。

AsyncTask取消任务

• 如果在执行的过程中，我们想取消任务的执行怎么办？我们可以调用mAsyncTask.cancel来处理，我们看看源码部分：

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

• 首先调用mCancelled.set(true)，这个值后面会用到。然后调用mFuture.cancel(mayInterruptIfRunning), 内部代码如下：

  public boolean cancel(boolean mayInterruptIfRunning) {
      if (!(state == NEW &&
            U.compareAndSwapInt(this, STATE, NEW,
                mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
          return false;
      try {    // in case call to interrupt throws exception
          if (mayInterruptIfRunning) {
              try {
                  Thread t = runner;
                  if (t != null)
                      t.interrupt();
              } finally { // final state
                  U.putOrderedInt(this, STATE, INTERRUPTED);
              }
          }
      } finally {
          finishCompletion();
      }
      return true;
  }
  

• 最后finally中执行了finishCompletion()方法，接着会调用done，done中会执行postResultIfNotInvoked, 源码如下：

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

• 会不会执行这里的postResult取决于mTaskInvoked的值，如果任务正在执行中，那么这里的mTaskInvoked就为true, 会执行call中finally的postResult；如果还没来得及执行，就会执行这里的postResult。所以不管怎么样，最终的结果也是会执行postResult，上面关于postResult的流程我们详细分析过了，这里我们看下最终会执行到的finish方法：

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

• 由上可以看出，因为我们调用cancel,所以这里的isCancel为true, 就不会执行onPostExecute。这样就实现了取消任务的功能，但是这里要主要一下，如果任务一旦开始执行，调用cancel方法，doInbackground是会执行结束的，但是不会将结果刷新到UI线程而已。包括在doInBackground中调用publishProgress也一样，它的源码如下：

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

• publishProgress也是会先检查标志isCancelled是否已经取消了，如果取消 了就不会将值刷新到UI线程。这一点要理解一下，并不是调用cancel之后，doInbackground也停止工作了。感兴趣的小伙伴可以自己打印看下，这里就不贴代码了。

总结

• 到这里，AsyncTask的源码分析就结束了，其实AsyncTask中维护了一个Handler和两个线程池，用来线程切换和执行任务，这样的话我们只需要关注我们需要关注的业务代码即可。