[转]【安卓笔记】AsyncTask源码剖析

迈不过友情╰ 2023-08-17 16:13 119阅读 0赞

\[转\]【安卓笔记】AsyncTask源码剖析

[http://blog.csdn.net/chdjj/article/details/39122547][http_blog.csdn.net_chdjj_article_details_39122547]

前言：

初学AsyncTask时，就想研究下它的实现源码，怎奈源码看了好几遍都没看懂，于是搁置了。最近心血来潮，又看了一些源码，如 HandlerThread，IntentService，AsyncQueryHandler等，收获颇深，于是乎想回头再研究下AsyncTask， 没想到这次居然很容易看懂了。。。

**正文：**

注：1.读者阅读本文前，必须对android的Handler机制以及j.u.c中的线程池有所了解;2.AsyncTask使用方式不再赘述。3.不同版本AsyncTask内容有些不同.

首先明确AsyncTask是个抽象类，接受三个泛型参数，分表代表任务所需参数类型，任务进度类型，结果类型。

**\[java\]** [view plain][http_blog.csdn.net_chdjj_article_details_39122547] [copy][http_blog.csdn.net_chdjj_article_details_39122547]

1.  public abstract class AsyncTask<Params, Progress, Result>

开发者继承AsyncTask后必须重写doInbackground方法，其他方法如onPostExecute等按需重写。

其内部有个静态全局的线程池变量THREAD\_POOL\_EXECUTOR， AsyncTask的doInbackground中的任务就是由此线程池执行。

**\[java\]** [view plain][http_blog.csdn.net_chdjj_article_details_39122547] [copy][http_blog.csdn.net_chdjj_article_details_39122547]

1.  public static final Executor THREAD\_POOL\_EXECUTOR 
2.  = new ThreadPoolExecutor(CORE\_POOL\_SIZE, MAXIMUM\_POOL\_SIZE, KEEP\_ALIVE, 
3.  TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

ThreadPoolExecutor 各参数含义如下，CORE\_POOL\_SIZE为核心线程数量，MAXIMUM\_POOL\_SIZE为线程池最大线程数量，KEEP\_ALIVE参数表明 当线程池的线程数量大于核心线程数量，那么空闲时间超过KEEP\_ALIVE时，超出部分的线程将被回收,sPoolWorkQueue是任务队列，存储 的是一个个Runnable,sThreadFactory是线程工厂，用于创建线程池中的线程。所有这些参数在AsyncTask内部都已经定义好：

**\[java\]** [view plain][http_blog.csdn.net_chdjj_article_details_39122547] [copy][http_blog.csdn.net_chdjj_article_details_39122547]

1.  private static final int CORE\_POOL\_SIZE = 5; 
2.  private static final int MAXIMUM\_POOL\_SIZE = 128; 
3.  private static final int KEEP\_ALIVE = 1; 
4.  private static final ThreadFactory sThreadFactory = new ThreadFactory() \{ 
5.  private final AtomicInteger mCount = new AtomicInteger(1); 
6.  public Thread newThread(Runnable r) \{ 
7.  return new Thread(r, "AsyncTask \#" + mCount.getAndIncrement()); 
8.  \}
9.  \};
10. private static final BlockingQueue<Runnable> sPoolWorkQueue = 
11. new LinkedBlockingQueue<Runnable>(10);

AsyncTask并不是直接使用上述线程池，而是进行了一层“包装”，这个类就是SerialExecutor,这是个串行的线程池。

**\[java\]** [view plain][http_blog.csdn.net_chdjj_article_details_39122547] [copy][http_blog.csdn.net_chdjj_article_details_39122547]

1.  /\*\* 
2.   \* An \{@link Executor\} that executes tasks one at a time in serial 
3.   \* order. This serialization is global to a particular process. 
4.   \*/ 
5.  public static final Executor SERIAL\_EXECUTOR = new SerialExecutor();

看其具体实现：

**\[java\]** [view plain][http_blog.csdn.net_chdjj_article_details_39122547] [copy][http_blog.csdn.net_chdjj_article_details_39122547]

1.  private static class SerialExecutor implements Executor \{ 
2.  final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>(); 
3.  Runnable mActive;
4.  public synchronized void execute(final Runnable r) \{ 
5.  mTasks.offer(new Runnable() \{ 
6.  public void run() \{ 
7.  try \{ 
8.  r.run();
9.  \} finally \{ 
10. scheduleNext();
11. \}
12. \}
13. \});
14. if (mActive == null) \{ 
15. scheduleNext();
16. \}
17. \}
18. protected synchronized void scheduleNext() \{ 
19. if ((mActive = mTasks.poll()) != null) \{ 
20. THREAD\_POOL\_EXECUTOR.execute(mActive);
21. \}
22. \}
23. \}

调用execute方法时，先将Runnable包装一下（即加上try-finally块）然后加入队列，接着判断当前mActive是否为 空，第一次调用，此值为空，所以会调用scheduleNext方法，从队列中取出头部的任务，交给线程池THREAD\_POOL\_EXECUTOR处 理，而处理过程是这样的，先执行原先的Runnable的run方法，接着再执行scheduleNext从队列中取出Runnable，如此循环，直到 队列为空，mActive重新为空为止。我们发现，经过这样的处理， **所有任务将串行执行**。

**所以我们需要注意，如果两个AsyncTask都调用execute时，如果其中一个AsyncTask任务执行时间非常长，这将导致另一个AsyncTask的任务排队等候，无法执行，因为它们共享同一个线程池且池是串行执行任务的。**

接着看其他成员：

**\[java\]** [view plain][http_blog.csdn.net_chdjj_article_details_39122547] [copy][http_blog.csdn.net_chdjj_article_details_39122547]

1.  private static final int MESSAGE\_POST\_RESULT = 0x1;//当前消息类型--->任务完成消息 
2.  private static final int MESSAGE\_POST\_PROGRESS = 0x2;//当前消息类型-->进度消息 
3.  private static final InternalHandler sHandler = new InternalHandler(); 
4.  private static volatile Executor sDefaultExecutor = SERIAL\_EXECUTOR;//默认线程池 
5.  private final WorkerRunnable<Params, Result> mWorker; 
6.  private final FutureTask<Result> mFuture; 
7.  private volatile Status mStatus = Status.PENDING;//当前状态 
8.  
9.  private final AtomicBoolean mCancelled = new AtomicBoolean(); 
10. private final AtomicBoolean mTaskInvoked = new AtomicBoolean();

sDefaultExecutor指明默认的线程池是串行池,mStatus指明当前任务状态，Status是个枚举类型：

**\[java\]** [view plain][http_blog.csdn.net_chdjj_article_details_39122547] [copy][http_blog.csdn.net_chdjj_article_details_39122547]

1.  public enum Status \{ 
2.  /\*\* 
3.   \* Indicates that the task has not been executed yet. 
4.   \*/ 
5.  PENDING,//等待执行 
6.  /\*\* 
7.   \* Indicates that the task is running. 
8.   \*/ 
9.  RUNNING,//执行 
10. /\*\* 
11.  \* Indicates that \{@link AsyncTask\#onPostExecute\} has finished. 
12.  \*/ 
13. FINISHED,//执行结束 
14. \}

重点看InternalHandler实现：

**\[java\]** [view plain][http_blog.csdn.net_chdjj_article_details_39122547] [copy][http_blog.csdn.net_chdjj_article_details_39122547]

1.  private static class InternalHandler extends Handler \{ 
2.  @SuppressWarnings(\{ "unchecked", "RawUseOfParameterizedType"\}) 
3.  @Override 
4.  public void handleMessage(Message msg) \{ 
5.  AsyncTaskResult result = (AsyncTaskResult) msg.obj;
6.  switch (msg.what) \{ 
7.  case MESSAGE\_POST\_RESULT: 
8.  // There is only one result 
9.  result.mTask.finish(result.mData\[0\]); 
10. break; 
11. case MESSAGE\_POST\_PROGRESS: 
12. result.mTask.onProgressUpdate(result.mData);
13. break; 
14. \}
15. \}
16. \}

InternalHandler继承自Handler，并复写了handleMessage，该方法根据消息类型做不同处理，如 果任务完成，则调用finish方法，而finish方法根据任务状态（取消or完成）调用onCancelled或者onPostExecute，这两 个是回调方法，通常我们会在onPostExecute中根据任务执行结果更新UI，这也是为什么文档中要求AsyncTask必须在UI线程中创建的原 因，我们的Handler须与UI线程的Looper绑定才能更新UI,并且子线程默认是没有Looper的。

**\[java\]** [view plain][http_blog.csdn.net_chdjj_article_details_39122547] [copy][http_blog.csdn.net_chdjj_article_details_39122547]

1.  private void finish(Result result) \{ 
2.  if (isCancelled()) \{ 
3.  onCancelled(result);
4.  \} else \{ 
5.  onPostExecute(result);
6.  \}
7.  mStatus = Status.FINISHED;
8.  \}

**如果是更新进度的消息(MESSAGE\_POST\_PROGRESS),那么调用onProgressUpdate方法。**

接下来我们关注的问题是 **doInbackground方法在何处被调用**？联想AsyncTask的使用，当我们创建好一个AsyncTask实例后，我们将调用其execute方法，所以，doInbackground方法应该在execute方法中执行，找到其实现：

**\[java\]** [view plain][http_blog.csdn.net_chdjj_article_details_39122547] [copy][http_blog.csdn.net_chdjj_article_details_39122547]

1.  public final AsyncTask<Params, Progress, Result> execute(Params... params) \{ 
2.  return executeOnExecutor(sDefaultExecutor, params); 
3.  \}

并没有直接调用doInbackground，而是调用了executeOnExecutor方法:

**\[java\]** [view plain][http_blog.csdn.net_chdjj_article_details_39122547] [copy][http_blog.csdn.net_chdjj_article_details_39122547]

1.  public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec, 
2.  Params... params) \{
3.  if (mStatus != Status.PENDING) \{ 
4.  switch (mStatus) \{ 
5.  case RUNNING: 
6.  throw new IllegalStateException("Cannot execute task:" 
7.  \+ " the task is already running."); 
8.  case FINISHED: 
9.  throw new IllegalStateException("Cannot execute task:" 
10. \+ " the task has already been executed " 
11. \+ "(a task can be executed only once)"); 
12. \}
13. \}
14. mStatus = Status.RUNNING;
15. onPreExecute();
16. mWorker.mParams = params;
17. exec.execute(mFuture);
18. return this; 
19. \}

executeOnExecutor方法的作用是使用指定的线程池执行任务，这里当然使用的是sDefaultExecutor,也就是SerialExecutor,但是我们注意到这个方法是公共的，也就是说 **我们可以手动配置线程池，让AsyncTask并行执行起来，最简单的方法就是使用内部定义好的THREAD\_POOL\_EXECUTOR。**

executeOnExecutor方法首先检查当前状态，如果不是Pending状态则抛出异常，紧接着修改状态为Running态，接着调用onPreExecute方法(预处理，相信大家不陌生)。

关键代码是exec.execute(mFuture)这一句，这行代码的作用是执行mFuture中定义好的任务，mFuture为 FutureTask类型，FutureTask是Runnable的实现类（j.u.c中的），所以可以作为线程池execute方法的参数,我们找到 其定义：

**\[java\]** [view plain][http_blog.csdn.net_chdjj_article_details_39122547] [copy][http_blog.csdn.net_chdjj_article_details_39122547]

1.  mFuture = new FutureTask<Result>(mWorker) \{ 
2.  @Override 
3.  protected void done() \{ 
4.  try \{ 
5.  postResultIfNotInvoked(get());
6.  \} catch (InterruptedException e) \{ 
7.  android.util.Log.w(LOG\_TAG, e);
8.  \} catch (ExecutionException e) \{ 
9.  throw new RuntimeException("An error occured while executing doInBackground()", 
10. e.getCause());
11. \} catch (CancellationException e) \{ 
12. postResultIfNotInvoked(null); 
13. \}
14. \}
15. \};

我们都知道，FutureTask构造时必须传入一个Callable的实现类，线程最终执行的是Callable的call方法(不明白的请看java线程并发库),所以mWorker必然是Callable的实现类:

**\[java\]** [view plain][http_blog.csdn.net_chdjj_article_details_39122547] [copy][http_blog.csdn.net_chdjj_article_details_39122547]

1.  private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> \{ 
2.  Params\[\] mParams;
3.  \}
4.  Worker = new WorkerRunnable<Params, Result>() \{ 
5.  public Result call() throws Exception \{ 
6.  mTaskInvoked.set(true); 
7.  Process.setThreadPriority(Process.THREAD\_PRIORITY\_BACKGROUND);
8.  //noinspection unchecked 
9.  return postResult(doInBackground(mParams)); 
10. \}
11. \};

最终，我们在WorkRunnable方法中找到了doInBackground方法,历经艰辛啊！！

剩下最后一个问题： **消息是如何发送给Handler的？**

**1.任务执行完毕的消息是通过postResult方法发送的：**

**\[java\]** [view plain][http_blog.csdn.net_chdjj_article_details_39122547] [copy][http_blog.csdn.net_chdjj_article_details_39122547]

1.  private Result postResult(Result result) \{ 
2.  @SuppressWarnings("unchecked") 
3.  Message message = sHandler.obtainMessage(MESSAGE\_POST\_RESULT,
4.  new AsyncTaskResult<Result>(this, result)); 
5.  message.sendToTarget();
6.  return result; 
7.  \}

这个AsyncTaskResult封装了数据域和对象本身：

**\[java\]** [view plain][http_blog.csdn.net_chdjj_article_details_39122547] [copy][http_blog.csdn.net_chdjj_article_details_39122547]

1.  private static class AsyncTaskResult<Data> \{ 
2.  final AsyncTask mTask; 
3.  final Data\[\] mData; 
4.  AsyncTaskResult(AsyncTask task, Data... data) \{
5.  mTask = task;
6.  mData = data;
7.  \}
8.  \}

2.任务进度更新消息是通过publishProgress方法发送的：

**\[java\]** [view plain][http_blog.csdn.net_chdjj_article_details_39122547] [copy][http_blog.csdn.net_chdjj_article_details_39122547]

1.  protected final void publishProgress(Progress... values) \{ 
2.  if (!isCancelled()) \{ 
3.  sHandler.obtainMessage(MESSAGE\_POST\_PROGRESS,
4.  new AsyncTaskResult<Progress>(this, values)).sendToTarget(); 
5.  \}
6.  \}

至此，AsyncTask源码分析完毕！

稍微做个 **总结**：

**1.AsyncTask是对线程池和Handler的封装，但是默认情况下任务是串行执行的,需注意，多个AsyncTask实例共享同一线程池(线程池是static的)；**

**2.高并发任务并不推荐使用AsyncTask，而应该改用线程池；**

**3.务必在主线程中创建AsyncTask，因为AsyncTask内部的Handler在创建时必须要绑定主线程的Looper;**

**4.只能在doInBackground方法中执行耗时任务，其他方法如onPreExecute、onPostExecute等运行于主线程上.**

转载于:https://www.cnblogs.com/vc60er/p/4670713.html

[http_blog.csdn.net_chdjj_article_details_39122547]: http://blog.csdn.net/chdjj/article/details/39122547

发表评论取消回复

表情：

评论列表（有 0 条评论，119人围观）

还没有评论，来说两句吧...

相关阅读

相关 Flutter 安卓平台源码剖析（一）

文章目录 * * 前言 * 启动流程 * * 入口Activity * * 环境初始化 ...

Love The Way You Lie/ 2024年04月18日 09:32/ 0 赞/ 182 阅读

相关【安卓源码】JD获取cookies

因为玩青龙，京东一个月需要获取一次ck，浏览器滑块是真的恶心，为方便自己操作写了这个小工具。最近炸年兽刚好很多人需要获取ck。代码是火山写的，文后附带源码和apk文件

雨点打透心脏的1/2处/ 2024年03月26日 21:18/ 0 赞/ 100 阅读

相关安卓源码下载:

安卓源码下载:[https://github.com/aosp-mirror][https_github.com_aosp-mirror] [http://androidxr

柔情只为你懂/ 2023年10月06日 12:06/ 0 赞/ 11 阅读

相关 [转]【安卓笔记】AsyncTask源码剖析

\[转\]【安卓笔记】AsyncTask源码剖析 [http://blog.csdn.net/chdjj/article/details/39122547][http_bl

迈不过友情╰/ 2023年08月17日 16:13/ 0 赞/ 120 阅读

相关源码分析--AsyncTask

查看文档 AsyncTask enables proper and easy use of the UI thread. This class allows to perfo

ゝ一纸荒年。/ 2022年08月06日 15:07/ 0 赞/ 222 阅读

相关 AsyncTask源码分析

知识点阅读： [Android Thread Pool(线程池)的介绍][Android Thread Pool] [Android AsyncTask的介绍][

骑猪看日落/ 2022年07月16日 06:29/ 0 赞/ 216 阅读

相关 AsyncTask源码分析

前言 [IntentService使用及源码分析][IntentService] [HandlerThread源码分析][HandlerThread] [AsyncT

落日映苍穹つ/ 2022年07月10日 11:26/ 0 赞/ 199 阅读

相关 xamarin学习笔记A14(安卓AsyncTask和RunOnUiThread)

(每次学习一点xamarin就做个学习笔记和视频来加深记忆巩固知识) 如有不正确的地方，请帮我指正。简介 AsyncTask类和Activity.RunOnUi

朱雀/ 2022年06月06日 06:17/ 0 赞/ 190 阅读

相关 AsyncTask源码详解

在分析源码之前，首先引用一段源码中的注释说明AsyncTask的定义： > AsyncTask能够正确，方便的使用UI线程。AsyncTask可以在不用使用Threads 和

逃离我推掉我的手/ 2022年01月20日 10:53/ 0 赞/ 277 阅读

相关安卓消息机制源码分析

一、明确 1.主线程不能进行耗时操作（主线程进行耗时操作会导致应用ANR） 2.子线程不能更新UI（子线程更新UI会导致CalledFromWrongThreadExce

痛定思痛。/ 2022年01月20日 07:27/ 0 赞/ 298 阅读