<p>写作原因：AsyncTask是Android中轻量级异步操作的方案之一，这篇文章我们不谈其使用过程，我们要谈论的是其实现过程及背后相关的设计思想，这有利于提高我们的代码能力。</p>    <h2><strong>源码分析</strong></h2>    <p>入口：</p>    <pre>  <code class="language-java">new DownloadTask().execute(url);  </code></pre>    <p>AsyncTask是从execute()方法作为执行入口的，我们看看execute()方法。</p>    <pre>  <code class="language-java">@MainThread      public final AsyncTask<Params, Progress, Result> execute(Params... params) {          return executeOnExecutor(sDefaultExecutor, params);      }  </code></pre>    <p>它返回了 executeOnExecutor(sDefaultExecutor, params); 的结果，这里分两条线索，一条是sDefaultExecutor，另一条就是executeOnExecutor()。先看看后者，我们继续深入探究：</p>    <pre>  <code class="language-java">@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;      }  </code></pre>    <p>首先看到有一个mStatus枚举对象，一共有三种状态：PENDING、RUNNING和FINISHED。我们查看声明该变量的地方发现： private volatile Status mStatus = Status.PENDING; ，即一开始时状态为等待。现在我们可以大胆猜测这段代码的作用：查看一个AsyncTask对象是否是等待运行的状态（一开始时是等待），如果不是则分为两种情况（Running和Finished）分别抛出异常，如果是则切换为Running状态。然后调用onPreExecute()方法。下面有两行代码：</p>    <pre>  <code class="language-java">mWorker.mParams = params;  exec.execute(mFuture);  </code></pre>    <p>暂时还难以看出它们的作用，不过应该跟线程的执行相关。这时我们先去看看另外一条路：sDefaultExecutor，sDefaultExecutor实际上是一个静态的SerialExecutor对象。我们看看SerialExecutor是何方神圣：</p>    <pre>  <code class="language-java">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);              }          }      }  </code></pre>    <p>SerialExecutor是一个线程池（有关线程池的基本知识参见前面一篇博文），内部成员包括一个用于储存Runnable的双端队列对象mTasks和一个Runnable对象mActive。在executeOnExecutor()方法中我们调用了execute()方法，理解一下这个方法的作用。首先它在双端队列中插入一个新的线程，这个线程包括mFuture的run()方法和执行scheduleNext()方法。此外当mActive对象为null时也会执行scheduleNext()方法。而scheduleNext()方法作用又是什么呢？它用于将mTasks中的对象取出然后传递给mActive对象，如果不为null则让THREAD_POOL_EXECUTOR调用execute()方法去执行mActive。</p>    <p>源码这样写，我们结合前面的理解一下：</p>    <p>每次启动一个AsyncTask对象时，Android首先会判断它的状态，只有等待时会将该对象状态切换成Running。这样可以防止一个对象多次启动。然后会调用onPreExecute()方法，接着将mFuture对象压入线程池sDefaultExecutor中。这个线程池实际上是一个任务管理器，在这个任务管理器中系统将接收到的mFuture对象的run()方法剥离出来导入自己创建的一个Runnable对象之中，然后通知mActive去从双端队列中取出一个Runnable对象执行。具体执行过程是在THREAD_POOL_EXECUTOR线程池中实现的。到这里又有两个地方有疑问了，其一，mFuture是什么？其二，THREAD_POOL_EXECUTOR怎么运行？下面继续，先看看THREAD_POOL_EXECUTOR怎么运行。</p>    <pre>  <code class="language-java">public static final Executor THREAD_POOL_EXECUTOR              = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,                      TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);  </code></pre>    <p>这个线程池通过标准的线程池类创建，具体实现也就与ThreadPoolExecutor一致了。所以这里就不多费笔墨了，不过可以看出AsyncTask一次执行任务数为CPU核心数+1。</p>    <p>再看看mFuture的来源实现：</p>    <p>博主找到了mFuture的声明和实现：</p>    <pre>  <code class="language-java">private final FutureTask<Result> mFuture;  </code></pre>    <p>在AsyncTask构造方法中：</p>    <pre>  <code class="language-java">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);                  }              }          };  </code></pre>    <p>这是一个FutureTask对象。有关FutureTask相关知识点击此处： <a href="/misc/goto?guid=4959643716426648588" rel="nofollow,noindex">Java并发编程：Callable、Future和FutureTask</a></p>    <pre>  <code class="language-java">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);                  }              }          };  </code></pre>    <p>这里重写了done()方法，表示当该子线程任务完成后回调，将结果传递给以下方法，下面几段源码实现了从子线程中将结果传给主线程的功能，通过InternalHandler来实现：</p>    <pre>  <code class="language-java">private Result postResult(Result result) {          @SuppressWarnings("unchecked")          Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,                  new AsyncTaskResult<Result>(this, result));          message.sendToTarget();          return result;      }  </code></pre>    <p>查看getHandler()方法，有：</p>    <pre>  <code class="language-java">private static Handler getHandler() {          synchronized (AsyncTask.class) {              if (sHandler == null) {                  sHandler = new InternalHandler();              }              return sHandler;          }      }  </code></pre>    <p>继续查看InternalHandler类有：</p>    <pre>  <code class="language-java">private static class InternalHandler extends Handler {          public InternalHandler() {              super(Looper.getMainLooper());          }            @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;              }          }      }  </code></pre>    <p>在InternalHandler中将mWorker得到的结果在主线程中处理，直接结果就是调用了finish方法间接调用onPostExecute(result)，从而实现了从子线程到主线程的结果传递的逻辑。到这里我们大概分析了AsyncTask的基本运行流程。</p>    <h2><strong>总结</strong></h2>    <h3><strong>总体流程</strong></h3>    <p>现在整理一下整体逻辑。创建一个AsyncTask对象首先根据参数Params创建mWorker，然后用mFuture去包装它，这个mFuture会被丢到任务线程池sDefaultExecutor中进行待命，轮到他时会进入THREAD_POOL_EXECUTOR线程池中执行。mWorker中会执行doInBackground()方法，执行后结果会通过sHandler传递主线程的Handler，在onPostExecute()中即可拿到结果。</p>    <h3><strong>收获</strong></h3>    <p>阅读源码是一个逆向推导的过程，需要耐得住性子。有些地方可能存在疑问，这时尚未见到整体难以推出其作用，可能需要到后面一些代码的推导下才能发现作用。有时可能需要借助API来参阅源码中用到的相关的类的作用。此外在源码中存在许多优秀的规范性的东西或者有价值的思想，这些需要慢慢研究总结。</p>    <p> </p>    <p>来自：http://roadtogeek.cn/2016/09/07/探索美妙的AsyncTask实现及阅读源码收获/</p>    <p> </p>