转载请注明出处：http://blog.csdn.net/singwhatiwanna/article/details/17596225

前言

什么是AsyncTask，相信搞过android开发的朋友们都不陌生。AsyncTask内部封装了Thread和Handler，可以让我们在后台进行计算并且把计算的结果及时更新到UI上，而这些正是Thread+Handler所做的事情，没错，AsyncTask的作用就是简化Thread+Handler，让我们能够通过更少的代码来完成一样的功能，这里，我要说明的是：AsyncTask只是简化Thread+Handler而不是替代，实际上它也替代不了。同时，AsyncTask从最开始到现在已经经过了几次代码修改，任务的执行逻辑慢慢地发生了改变，并不是大家所想象的那样：AsyncTask是完全并行执行的就像多个线程一样，其实不是的，所以用AsyncTask的时候还是要注意，下面会一一说明。另外本文主要是分析AsyncTask的源代码以及使用时候的一些注意事项，如果你还不熟悉AsyncTask，请先阅读android之AsyncTask来了解其基本用法。

这里先给出AsyncTask的一个例子：

[java] view plain copy
  1. privateclassDownloadFilesTaskextendsAsyncTask<URL,Integer,Long>{
  2. protectedLongdoInBackground(URL...urls){
  3. intcount=urls.length;
  4. longtotalSize=0;
  5. for(inti=0;i<count;i++){
  6. totalSize+=Downloader.downloadFile(urls[i]);
  7. publishProgress((int)((i/(float)count)*100));
  8. //Escapeearlyifcancel()iscalled
  9. if(isCancelled())break;
  10. }
  11. returntotalSize;
  12. }
  14. protectedvoidonProgressUpdate(Integer...progress){
  15. setProgressPercent(progress[0]);
  16. }
  18. protectedvoidonPostExecute(Longresult){
  19. showDialog("Downloaded"+result+"bytes");
  20. }
  21. }

使用AsyncTask的规则

  • AsyncTask的类必须在UI线程加载（从4.1开始系统会帮我们自动完成）
  • AsyncTask对象必须在UI线程创建
  • execute方法必须在UI线程调用
  • 不要在你的程序中去直接调用onPreExecute(), onPostExecute, doInBackground, onProgressUpdate方法
  • 一个AsyncTask对象只能执行一次，即只能调用一次execute方法，否则会报运行时异常
  • AsyncTask不是被设计为处理耗时操作的，耗时上限为几秒钟，如果要做长耗时操作，强烈建议你使用Executor，ThreadPoolExecutor以及FutureTask
  • 在1.6之前，AsyncTask是串行执行任务的，1.6的时候AsyncTask开始采用线程池里处理并行任务，但是从3.0开始，为了避免AsyncTask所带来的并发错误，AsyncTask又采用一个线程来串行执行任务

AsyncTask到底是串行还是并行？

给大家做一下实验，请看如下实验代码：代码很简单，就是点击按钮的时候同时执行5个AsyncTask，每个AsyncTask休眠3s，同时把每个AsyncTask执行结束的时间打印出来，这样我们就能观察出到底是串行执行还是并行执行。

[java] view plain copy
  1. @Override
  2. publicvoidonClick(Viewv){
  3. if(v==mButton){
  4. newMyAsyncTask("AsyncTask#1").execute("");
  5. newMyAsyncTask("AsyncTask#2").execute("");
  6. newMyAsyncTask("AsyncTask#3").execute("");
  7. newMyAsyncTask("AsyncTask#4").execute("");
  8. newMyAsyncTask("AsyncTask#5").execute("");
  9. }
  11. }
  13. privatestaticclassMyAsyncTaskextendsAsyncTask<String,Integer,String>{
  15. privateStringmName="AsyncTask";
  17. publicMyAsyncTask(Stringname){
  18. super();
  19. mName=name;
  20. }
  22. @Override
  23. protectedStringdoInBackground(String...params){
  24. try{
  25. Thread.sleep(3000);
  26. }catch(InterruptedExceptione){
  27. e.printStackTrace();
  28. }
  29. returnmName;
  30. }
  32. @Override
  33. protectedvoidonPostExecute(Stringresult){
  34. super.onPostExecute(result);
  35. SimpleDateFormatdf=newSimpleDateFormat("yyyy-MM-ddHH:mm:ss");
  36. Log.e(TAG,result+"executefinishat"+df.format(newDate()));
  37. }
  38. }
我找了2个手机，系统分别是4.1.1和2.3.3，按照我前面的描述，AsyncTask在4.1.1应该是串行的，在2.3.3应该是并行的，到底是不是这样呢？请看Log

Android 4.1.1上执行：从下面Log可以看出，5个AsyncTask共耗时15s且时间间隔为3s，很显然是串行执行的


Android 2.3.3上执行：从下面Log可以看出，5个AsyncTask的结束时间是一样的，很显然是并行执行


结论：从上面的两个Log可以看出，我前面的描述是完全正确的。下面请看源码，让我们去了解下其中的原理。

源码分析

[java] view plain copy
  1. /*
  2. *Copyright(C)2008TheAndroidOpenSourceProject
  3. *
  4. *LicensedundertheApacheLicense,Version2.0(the"License");
  5. *youmaynotusethisfileexceptincompliancewiththeLicense.
  6. *YoumayobtainacopyoftheLicenseat
  7. *
  8. *http://www.apache.org/licenses/LICENSE-2.0
  9. *
  10. *Unlessrequiredbyapplicablelaworagreedtoinwriting,software
  11. *distributedundertheLicenseisdistributedonan"ASIS"BASIS,
  12. *WITHOUTWARRANTIESORCONDITIONSOFANYKIND,eitherexpressorimplied.
  13. *SeetheLicenseforthespecificlanguagegoverningpermissionsand
  14. *limitationsundertheLicense.
  15. */
  17. packageandroid.os;
  19. importjava.util.ArrayDeque;
  20. importjava.util.concurrent.BlockingQueue;
  21. importjava.util.concurrent.Callable;
  22. importjava.util.concurrent.CancellationException;
  23. importjava.util.concurrent.Executor;
  24. importjava.util.concurrent.ExecutionException;
  25. importjava.util.concurrent.FutureTask;
  26. importjava.util.concurrent.LinkedBlockingQueue;
  27. importjava.util.concurrent.ThreadFactory;
  28. importjava.util.concurrent.ThreadPoolExecutor;
  29. importjava.util.concurrent.TimeUnit;
  30. importjava.util.concurrent.TimeoutException;
  31. importjava.util.concurrent.atomic.AtomicBoolean;
  32. importjava.util.concurrent.atomic.AtomicInteger;
  34. publicabstractclassAsyncTask<Params,Progress,Result>{
  35. privatestaticfinalStringLOG_TAG="AsyncTask";
  37. //获取当前的cpu核心数
  38. privatestaticfinalintCPU_COUNT=Runtime.getRuntime().availableProcessors();
  39. //线程池核心容量
  40. privatestaticfinalintCORE_POOL_SIZE=CPU_COUNT+1;
  41. //线程池最大容量
  42. privatestaticfinalintMAXIMUM_POOL_SIZE=CPU_COUNT*2+1;
  43. //过剩的空闲线程的存活时间
  44. privatestaticfinalintKEEP_ALIVE=1;
  45. //ThreadFactory线程工厂，通过工厂方法newThread来获取新线程
  46. privatestaticfinalThreadFactorysThreadFactory=newThreadFactory(){
  47. //原子整数，可以在超高并发下正常工作
  48. privatefinalAtomicIntegermCount=newAtomicInteger(1);
  50. publicThreadnewThread(Runnabler){
  51. returnnewThread(r,"AsyncTask#"+mCount.getAndIncrement());
  52. }
  53. };
  54. //静态阻塞式队列，用来存放待执行的任务，初始容量：128个
  55. privatestaticfinalBlockingQueue<Runnable>sPoolWorkQueue=
  56. newLinkedBlockingQueue<Runnable>(128);
  58. /**
  59. *静态并发线程池，可以用来并行执行任务，尽管从3.0开始，AsyncTask默认是串行执行任务
  60. *但是我们仍然能构造出并行的AsyncTask
  61. */
  62. publicstaticfinalExecutorTHREAD_POOL_EXECUTOR
  63. =newThreadPoolExecutor(CORE_POOL_SIZE,MAXIMUM_POOL_SIZE,KEEP_ALIVE,
  64. TimeUnit.SECONDS,sPoolWorkQueue,sThreadFactory);
  66. /**
  67. *静态串行任务执行器，其内部实现了串行控制，
  68. *循环的取出一个个任务交给上述的并发线程池去执行
  69. */
  70. publicstaticfinalExecutorSERIAL_EXECUTOR=newSerialExecutor();
  71. //消息类型：发送结果
  72. privatestaticfinalintMESSAGE_POST_RESULT=0x1;
  73. //消息类型：更新进度
  74. privatestaticfinalintMESSAGE_POST_PROGRESS=0x2;
  75. /**静态Handler，用来发送上述两种通知，采用UI线程的Looper来处理消息
  76. *这就是为什么AsyncTask必须在UI线程调用，因为子线程
  77. *默认没有Looper无法创建下面的Handler，程序会直接Crash
  78. */
  79. privatestaticfinalInternalHandlersHandler=newInternalHandler();
  80. //默认任务执行器，被赋值为串行任务执行器，就是它，AsyncTask变成串行的了
  81. privatestaticvolatileExecutorsDefaultExecutor=SERIAL_EXECUTOR;
  82. //如下两个变量我们先不要深究，不影响我们对整体逻辑的理解
  83. privatefinalWorkerRunnable<Params,Result>mWorker;
  84. privatefinalFutureTask<Result>mFuture;
  85. //任务的状态默认为挂起，即等待执行，其类型标识为易变的（volatile）
  86. privatevolatileStatusmStatus=Status.PENDING;
  87. //原子布尔型，支持高并发访问，标识任务是否被取消
  88. privatefinalAtomicBooleanmCancelled=newAtomicBoolean();
  89. //原子布尔型，支持高并发访问，标识任务是否被执行过
  90. privatefinalAtomicBooleanmTaskInvoked=newAtomicBoolean();
  92. /*串行执行器的实现，我们要好好看看，它是怎么把并行转为串行的
  93. *目前我们需要知道，asyncTask.execute(Params...)实际上会调用
  94. *SerialExecutor的execute方法，这一点后面再说明。也就是说：当你的asyncTask执行的时候，
  95. *首先你的task会被加入到任务队列，然后排队，一个个执行
  96. */
  97. privatestaticclassSerialExecutorimplementsExecutor{
  98. //线性双向队列，用来存储所有的AsyncTask任务
  99. finalArrayDeque<Runnable>mTasks=newArrayDeque<Runnable>();
  100. //当前正在执行的AsyncTask任务
  101. RunnablemActive;
  103. publicsynchronizedvoidexecute(finalRunnabler){
  104. //将新的AsyncTask任务加入到双向队列中
  105. mTasks.offer(newRunnable(){
  106. publicvoidrun(){
  107. try{
  108. //执行AsyncTask任务
  109. r.run();
  110. }finally{
  111. //当前AsyncTask任务执行完毕后，进行下一轮执行，如果还有未执行任务的话
  112. //这一点很明显体现了AsyncTask是串行执行任务的，总是一个任务执行完毕才会执行下一个任务
  113. scheduleNext();
  114. }
  115. }
  116. });
  117. //如果当前没有任务在执行，直接进入执行逻辑
  118. if(mActive==null){
  119. scheduleNext();
  120. }
  121. }
  123. protectedsynchronizedvoidscheduleNext(){
  124. //从任务队列中取出队列头部的任务，如果有就交给并发线程池去执行
  125. if((mActive=mTasks.poll())!=null){
  126. THREAD_POOL_EXECUTOR.execute(mActive);
  127. }
  128. }
  129. }
  131. /**
  132. *任务的三种状态
  133. */
  134. publicenumStatus{
  135. /**
  136. *任务等待执行
  137. */
  138. PENDING,
  139. /**
  140. *任务正在执行
  141. */
  142. RUNNING,
  143. /**
  144. *任务已经执行结束
  145. */
  146. FINISHED,
  147. }
  149. /**隐藏API：在UI线程中调用，用来初始化Handler*/
  150. publicstaticvoidinit(){
  151. sHandler.getLooper();
  152. }
  154. /**隐藏API：为AsyncTask设置默认执行器*/
  155. publicstaticvoidsetDefaultExecutor(Executorexec){
  156. sDefaultExecutor=exec;
  157. }
  159. /**
  160. *Createsanewasynchronoustask.ThisconstructormustbeinvokedontheUIthread.
  161. */
  162. publicAsyncTask(){
  163. mWorker=newWorkerRunnable<Params,Result>(){
  164. publicResultcall()throwsException{
  165. mTaskInvoked.set(true);
  167. Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
  168. //noinspectionunchecked
  169. returnpostResult(doInBackground(mParams));
  170. }
  171. };
  173. mFuture=newFutureTask<Result>(mWorker){
  174. @Override
  175. protectedvoiddone(){
  176. try{
  177. postResultIfNotInvoked(get());
  178. }catch(InterruptedExceptione){
  179. android.util.Log.w(LOG_TAG,e);
  180. }catch(ExecutionExceptione){
  181. thrownewRuntimeException("AnerroroccuredwhileexecutingdoInBackground()",
  182. e.getCause());
  183. }catch(CancellationExceptione){
  184. postResultIfNotInvoked(null);
  185. }
  186. }
  187. };
  188. }
  190. privatevoidpostResultIfNotInvoked(Resultresult){
  191. finalbooleanwasTaskInvoked=mTaskInvoked.get();
  192. if(!wasTaskInvoked){
  193. postResult(result);
  194. }
  195. }
  196. //doInBackground执行完毕，发送消息
  197. privateResultpostResult(Resultresult){
  198. @SuppressWarnings("unchecked")
  199. Messagemessage=sHandler.obtainMessage(MESSAGE_POST_RESULT,
  200. newAsyncTaskResult<Result>(this,result));
  201. message.sendToTarget();
  202. returnresult;
  203. }
  205. /**
  206. *返回任务的状态
  207. */
  208. publicfinalStatusgetStatus(){
  209. returnmStatus;
  210. }
  212. /**
  213. *这个方法是我们必须要重写的，用来做后台计算
  214. *所在线程：后台线程
  215. */
  216. protectedabstractResultdoInBackground(Params...params);
  218. /**
  219. *在doInBackground之前调用，用来做初始化工作
  220. *所在线程：UI线程
  221. */
  222. protectedvoidonPreExecute(){
  223. }
  225. /**
  226. *在doInBackground之后调用，用来接受后台计算结果更新UI
  227. *所在线程：UI线程
  228. */
  229. protectedvoidonPostExecute(Resultresult){
  230. }
  232. /**
  233. *RunsontheUIthreadafter{@link#publishProgress}isinvoked.
  234. /**
  235. *在publishProgress之后调用，用来更新计算进度
  236. *所在线程：UI线程
  237. */
  238. protectedvoidonProgressUpdate(Progress...values){
  239. }
  241. /**
  242. *cancel被调用并且doInBackground执行结束，会调用onCancelled，表示任务被取消
  243. *这个时候onPostExecute不会再被调用，二者是互斥的，分别表示任务取消和任务执行完成
  244. *所在线程：UI线程
  245. */
  246. @SuppressWarnings({"UnusedParameters"})
  247. protectedvoidonCancelled(Resultresult){
  248. onCancelled();
  249. }
  251. protectedvoidonCancelled(){
  252. }
  254. publicfinalbooleanisCancelled(){
  255. returnmCancelled.get();
  256. }
  258. publicfinalbooleancancel(booleanmayInterruptIfRunning){
  259. mCancelled.set(true);
  260. returnmFuture.cancel(mayInterruptIfRunning);
  261. }
  263. publicfinalResultget()throwsInterruptedException,ExecutionException{
  264. returnmFuture.get();
  265. }
  267. publicfinalResultget(longtimeout,TimeUnitunit)throwsInterruptedException,
  268. ExecutionException,TimeoutException{
  269. returnmFuture.get(timeout,unit);
  270. }
  272. /**
  273. *这个方法如何执行和系统版本有关，在AsyncTask的使用规则里已经说明，如果你真的想使用并行AsyncTask，
  274. *也是可以的，只要稍作修改
  275. *必须在UI线程调用此方法
  276. */
  277. publicfinalAsyncTask<Params,Progress,Result>execute(Params...params){
  278. //串行执行
  279. returnexecuteOnExecutor(sDefaultExecutor,params);
  280. //如果我们想并行执行，这样改就行了，当然这个方法我们没法改
  281. //returnexecuteOnExecutor(THREAD_POOL_EXECUTOR,params);
  282. }
  284. /**
  285. *通过这个方法我们可以自定义AsyncTask的执行方式，串行or并行，甚至可以采用自己的Executor
  286. *为了实现并行，我们可以在外部这么用AsyncTask：
  287. *asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,Params...params);
  288. *必须在UI线程调用此方法
  289. */
  290. publicfinalAsyncTask<Params,Progress,Result>executeOnExecutor(Executorexec,
  291. Params...params){
  292. if(mStatus!=Status.PENDING){
  293. switch(mStatus){
  294. caseRUNNING:
  295. thrownewIllegalStateException("Cannotexecutetask:"
  296. +"thetaskisalreadyrunning.");
  297. caseFINISHED:
  298. thrownewIllegalStateException("Cannotexecutetask:"
  299. +"thetaskhasalreadybeenexecuted"
  300. +"(ataskcanbeexecutedonlyonce)");
  301. }
  302. }
  304. mStatus=Status.RUNNING;
  305. //这里#onPreExecute会最先执行
  306. onPreExecute();
  308. mWorker.mParams=params;
  309. //然后后台计算#doInBackground才真正开始
  310. exec.execute(mFuture);
  311. //接着会有#onProgressUpdate被调用，最后是#onPostExecute
  313. returnthis;
  314. }
  316. /**
  317. *这是AsyncTask提供的一个静态方法，方便我们直接执行一个runnable
  318. */
  319. publicstaticvoidexecute(Runnablerunnable){
  320. sDefaultExecutor.execute(runnable);
  321. }
  323. /**
  324. *打印后台计算进度，onProgressUpdate会被调用
  325. */
  326. protectedfinalvoidpublishProgress(Progress...values){
  327. if(!isCancelled()){
  328. sHandler.obtainMessage(MESSAGE_POST_PROGRESS,
  329. newAsyncTaskResult<Progress>(this,values)).sendToTarget();
  330. }
  331. }
  333. //任务结束的时候会进行判断，如果任务没有被取消，则onPostExecute会被调用
  334. privatevoidfinish(Resultresult){
  335. if(isCancelled()){
  336. onCancelled(result);
  337. }else{
  338. onPostExecute(result);
  339. }
  340. mStatus=Status.FINISHED;
  341. }
  343. //AsyncTask内部Handler，用来发送后台计算进度更新消息和计算完成消息
  344. privatestaticclassInternalHandlerextendsHandler{
  345. @SuppressWarnings({"unchecked","RawUseOfParameterizedType"})
  346. @Override
  347. publicvoidhandleMessage(Messagemsg){
  348. AsyncTaskResultresult=(AsyncTaskResult)msg.obj;
  349. switch(msg.what){
  350. caseMESSAGE_POST_RESULT:
  351. //Thereisonlyoneresult
  352. result.mTask.finish(result.mData[0]);
  353. break;
  354. caseMESSAGE_POST_PROGRESS:
  355. result.mTask.onProgressUpdate(result.mData);
  356. break;
  357. }
  358. }
  359. }
  361. privatestaticabstractclassWorkerRunnable<Params,Result>implementsCallable<Result>{
  362. Params[]mParams;
  363. }
  365. @SuppressWarnings({"RawUseOfParameterizedType"})
  366. privatestaticclassAsyncTaskResult<Data>{
  367. finalAsyncTaskmTask;
  368. finalData[]mData;
  370. AsyncTaskResult(AsyncTasktask,Data...data){
  371. mTask=task;
  372. mData=data;
  373. }
  374. }
  375. }

让你的AsyncTask在3.0以上的系统中并行起来

通过上面的源码分析，我已经给出了在3.0以上系统中让AsyncTask并行执行的方法，现在，让我们来试一试，代码还是之前采用的测试代码，我们要稍作修改，调用AsyncTask的executeOnExecutor方法而不是execute，请看：

[java] view plain copy
  1. @TargetApi(Build.VERSION_CODES.HONEYCOMB)
  2. @Override
  3. publicvoidonClick(Viewv){
  4. if(v==mButton){
  5. newMyAsyncTask("AsyncTask#1").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"");
  6. newMyAsyncTask("AsyncTask#2").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"");
  7. newMyAsyncTask("AsyncTask#3").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"");
  8. newMyAsyncTask("AsyncTask#4").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"");
  9. newMyAsyncTask("AsyncTask#5").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"");
  10. }
  12. }
  14. privatestaticclassMyAsyncTaskextendsAsyncTask<String,Integer,String>{
  16. privateStringmName="AsyncTask";
  18. publicMyAsyncTask(Stringname){
  19. super();
  20. mName=name;
  21. }
  23. @Override
  24. protectedStringdoInBackground(String...params){
  25. try{
  26. Thread.sleep(3000);
  27. }catch(InterruptedExceptione){
  28. e.printStackTrace();
  29. }
  30. returnmName;
  31. }
  33. @Override
  34. protectedvoidonPostExecute(Stringresult){
  35. super.onPostExecute(result);
  36. SimpleDateFormatdf=newSimpleDateFormat("yyyy-MM-ddHH:mm:ss");
  37. Log.e(TAG,result+"executefinishat"+df.format(newDate()));
  38. }
  39. }
下面是系统为4.1.1手机打印出的Log：很显然，我们的目的达到了，成功的让AsyncTask在4.1.1的手机上并行起来了，很高兴吧！希望这篇文章对你有用。






更多相关文章

  1. SpringBoot 2.0 中 HikariCP 数据库连接池原理解析
  2. [置顶] Android硬件加速
  3. android连接真机 调试未测试
  4. Android系统稳定性-ANR
  5. Android的Activity什么时候会调用onCreate()而不调用onStart()？
  6. Handler消息机制 源码解读
  7. AsyncTask工作原理分析
  8. android studio 导入Google源码
  9. Android的DDMS中的Threads的各个字段的含义

随机推荐

  1. Android(安卓)intent.Action 参数值及对
  2. 关于Android(安卓)Studio 查看源码 throw
  3. android第一天：搭建基础环境
  4. Android(安卓)studio里Toast,menu的用法
  5. android4.0去掉锁屏和休眠 Power键按钮
  6. android的日期格式化 android.text.forma
  7. Android：：整理基础之—— startActivityFor
  8. Android关于获取时间的记录(小结)
  9. Android源码中的单例模式
  10. android传感器sensor