您的位置: 首页  >  文章  >  Android多线程任务优化2：实现后台预读线程

Android多线程任务优化2：实现后台预读线程

分类: 文章 • 2025-06-01 18:06:46

导语：从上一篇《多线程任务的优化1：探讨AsyncTask的缺陷》我们了解到，使用AsyncTask有导致应用FC的风险，而且AsyncTask并不能满足我们一些特定的需求。下面我们介绍一种通过模仿AsyncTask的封装方式，实现一个后台预读数据的线程。

概述：在空闲时对获取成本较高的数据（如要读取本地或网络资源）进行预读是提高性能的有效手段。为了给用户带来更好的交互体验，提高响应性，很多网络应用（如新闻阅读类应用）都在启动的时候进行预读，把网络数据缓存到sdcard或者内存中。

例子：下面介绍一个实现预读的例子，打开应用之后会有一个欢迎界面，在打开欢迎界面的同时我们在后台启动预读线程，预读下一个Activity需要显示的数据,预读数据保存到一个静态的Hashmap中。

首先要编写我们的后台预读线程，遵循不重复造轮子的原则，我们对AsyncTask稍作修改就可以满足需求。下面是我们自定义的PreReadTask类代码：

PreReadTask.java 实现预读线程

[java]view plaincopy
  1. packagecom.zhuozhuo;
  2. importjava.util.concurrent.ExecutorService;
  3. importjava.util.concurrent.Executors;
  4. importjava.util.concurrent.PriorityBlockingQueue;
  5. importjava.util.concurrent.RejectedExecutionHandler;
  6. importjava.util.concurrent.SynchronousQueue;
  7. importjava.util.concurrent.ThreadPoolExecutor;
  8. importjava.util.concurrent.TimeUnit;
  9. importjava.util.concurrent.BlockingQueue;
  10. importjava.util.concurrent.LinkedBlockingQueue;
  11. importjava.util.concurrent.ThreadFactory;
  12. importjava.util.concurrent.Callable;
  13. importjava.util.concurrent.FutureTask;
  14. importjava.util.concurrent.ExecutionException;
  15. importjava.util.concurrent.TimeoutException;
  16. importjava.util.concurrent.CancellationException;
  17. importjava.util.concurrent.atomic.AtomicInteger;
  19. importandroid.content.SyncResult;
  20. importandroid.os.Process;
  21. importandroid.os.Handler;
  22. importandroid.os.Message;
  23. publicabstractclassPreReadTask<Params,Progress,Result>{
  24. privatestaticfinalStringLOG_TAG="FifoAsyncTask";
  26. //privatestaticfinalintCORE_POOL_SIZE=5;
  27. //privatestaticfinalintMAXIMUM_POOL_SIZE=5;
  28. //privatestaticfinalintKEEP_ALIVE=1;
  30. //privatestaticfinalBlockingQueue<Runnable>sWorkQueue=
  31. //newLinkedBlockingQueue<Runnable>();
  32. //
  33. privatestaticfinalThreadFactorysThreadFactory=newThreadFactory(){
  34. privatefinalAtomicIntegermCount=newAtomicInteger(1);
  36. publicThreadnewThread(Runnabler){
  37. returnnewThread(r,"PreReadTask#"+mCount.getAndIncrement());
  38. }
  39. };
  41. privatestaticfinalExecutorServicesExecutor=Executors.newSingleThreadExecutor(sThreadFactory);//只有一个工作线程的线程池
  43. privatestaticfinalintMESSAGE_POST_RESULT=0x1;
  44. privatestaticfinalintMESSAGE_POST_PROGRESS=0x2;
  45. privatestaticfinalintMESSAGE_POST_CANCEL=0x3;
  47. privatestaticfinalInternalHandlersHandler=newInternalHandler();
  49. privatefinalWorkerRunnable<Params,Result>mWorker;
  50. privatefinalFutureTask<Result>mFuture;
  52. privatevolatileStatusmStatus=Status.PENDING;
  54. /**
  55. *Indicatesthecurrentstatusofthetask.Eachstatuswillbesetonlyonce
  56. *duringthelifetimeofatask.
  57. */
  58. publicenumStatus{
  59. /**
  60. *Indicatesthatthetaskhasnotbeenexecutedyet.
  61. */
  62. PENDING,
  63. /**
  64. *Indicatesthatthetaskisrunning.
  65. */
  66. RUNNING,
  67. /**
  68. *Indicatesthat{@linkFifoAsyncTask#onPostExecute}hasfinished.
  69. */
  70. FINISHED,
  71. }
  73. /**
  74. *Createsanewasynchronoustask.ThisconstructormustbeinvokedontheUIthread.
  75. */
  76. publicPreReadTask(){
  77. mWorker=newWorkerRunnable<Params,Result>(){
  78. publicResultcall()throwsException{
  79. Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
  80. returndoInBackground(mParams);
  81. }
  82. };
  84. mFuture=newFutureTask<Result>(mWorker){
  85. @Override
  86. protectedvoiddone(){
  87. Messagemessage;
  88. Resultresult=null;
  90. try{
  91. result=get();
  92. }catch(InterruptedExceptione){
  93. android.util.Log.w(LOG_TAG,e);
  94. }catch(ExecutionExceptione){
  95. thrownewRuntimeException("AnerroroccuredwhileexecutingdoInBackground()",
  96. e.getCause());
  97. }catch(CancellationExceptione){
  98. message=sHandler.obtainMessage(MESSAGE_POST_CANCEL,
  99. newPreReadTaskResult<Result>(PreReadTask.this,(Result[])null));
  100. message.sendToTarget();
  101. return;
  102. }catch(Throwablet){
  103. thrownewRuntimeException("Anerroroccuredwhileexecuting"
  104. +"doInBackground()",t);
  105. }
  107. message=sHandler.obtainMessage(MESSAGE_POST_RESULT,
  108. newPreReadTaskResult<Result>(PreReadTask.this,result));
  109. message.sendToTarget();
  110. }
  111. };
  112. }
  114. /**
  115. *Returnsthecurrentstatusofthistask.
  116. *
  117. *@returnThecurrentstatus.
  118. */
  119. publicfinalStatusgetStatus(){
  120. returnmStatus;
  121. }
  123. /**
  124. *Overridethismethodtoperformacomputationonabackgroundthread.The
  125. *specifiedparametersaretheparameterspassedto{@link#execute}
  126. *bythecallerofthistask.
  127. *
  128. *Thismethodcancall{@link#publishProgress}topublishupdates
  129. *ontheUIthread.
  130. *
  131. *@paramparamsTheparametersofthetask.
  132. *
  133. *@returnAresult,definedbythesubclassofthistask.
  134. *
  135. *@see#onPreExecute()
  136. *@see#onPostExecute
  137. *@see#publishProgress
  138. */
  139. protectedabstractResultdoInBackground(Params...params);
  141. /**
  142. *RunsontheUIthreadbefore{@link#doInBackground}.
  143. *
  144. *@see#onPostExecute
  145. *@see#doInBackground
  146. */
  147. protectedvoidonPreExecute(){
  148. }
  150. /**
  151. *RunsontheUIthreadafter{@link#doInBackground}.The
  152. *specifiedresultisthevaluereturnedby{@link#doInBackground}
  153. *ornullifthetaskwascancelledoranexceptionoccured.
  154. *
  155. *@paramresultTheresultoftheoperationcomputedby{@link#doInBackground}.
  156. *
  157. *@see#onPreExecute
  158. *@see#doInBackground
  159. */
  160. @SuppressWarnings({"UnusedDeclaration"})
  161. protectedvoidonPostExecute(Resultresult){
  162. }
  164. /**
  165. *RunsontheUIthreadafter{@link#publishProgress}isinvoked.
  166. *Thespecifiedvaluesarethevaluespassedto{@link#publishProgress}.
  167. *
  168. *@paramvaluesThevaluesindicatingprogress.
  169. *
  170. *@see#publishProgress
  171. *@see#doInBackground
  172. */
  173. @SuppressWarnings({"UnusedDeclaration"})
  174. protectedvoidonProgressUpdate(Progress...values){
  175. }
  177. /**
  178. *RunsontheUIthreadafter{@link#cancel(boolean)}isinvoked.
  179. *
  180. *@see#cancel(boolean)
  181. *@see#isCancelled()
  182. */
  183. protectedvoidonCancelled(){
  184. }
  186. /**
  187. *Returns<tt>true</tt>ifthistaskwascancelledbeforeitcompleted
  188. *normally.
  189. *
  190. *@return<tt>true</tt>iftaskwascancelledbeforeitcompleted
  191. *
  192. *@see#cancel(boolean)
  193. */
  194. publicfinalbooleanisCancelled(){
  195. returnmFuture.isCancelled();
  196. }
  198. /**
  199. *Attemptstocancelexecutionofthistask.Thisattemptwill
  200. *failifthetaskhasalreadycompleted,alreadybeencancelled,
  201. *orcouldnotbecancelledforsomeotherreason.Ifsuccessful,
  202. *andthistaskhasnotstartedwhen<tt>cancel</tt>iscalled,
  203. *thistaskshouldneverrun.Ifthetaskhasalreadystarted,
  204. *thenthe<tt>mayInterruptIfRunning</tt>parameterdetermines
  205. *whetherthethreadexecutingthistaskshouldbeinterruptedin
  206. *anattempttostopthetask.
  207. *
  208. *@parammayInterruptIfRunning<tt>true</tt>ifthethreadexecutingthis
  209. *taskshouldbeinterrupted;otherwise,in-progresstasksareallowed
  210. *tocomplete.
  211. *
  212. *@return<tt>false</tt>ifthetaskcouldnotbecancelled,
  213. *typicallybecauseithasalreadycompletednormally;
  214. *<tt>true</tt>otherwise
  215. *
  216. *@see#isCancelled()
  217. *@see#onCancelled()
  218. */
  219. publicfinalbooleancancel(booleanmayInterruptIfRunning){
  220. returnmFuture.cancel(mayInterruptIfRunning);
  221. }
  223. /**
  224. *Waitsifnecessaryforthecomputationtocomplete,andthen
  225. *retrievesitsresult.
  226. *
  227. *@returnThecomputedresult.
  228. *
  229. *@throwsCancellationExceptionIfthecomputationwascancelled.
  230. *@throwsExecutionExceptionIfthecomputationthrewanexception.
  231. *@throwsInterruptedExceptionIfthecurrentthreadwasinterrupted
  232. *whilewaiting.
  233. */
  234. publicfinalResultget()throwsInterruptedException,ExecutionException{
  235. returnmFuture.get();
  236. }
  238. /**
  239. *Waitsifnecessaryforatmostthegiventimeforthecomputation
  240. *tocomplete,andthenretrievesitsresult.
  241. *
  242. *@paramtimeoutTimetowaitbeforecancellingtheoperation.
  243. *@paramunitThetimeunitforthetimeout.
  244. *
  245. *@returnThecomputedresult.
  246. *
  247. *@throwsCancellationExceptionIfthecomputationwascancelled.
  248. *@throwsExecutionExceptionIfthecomputationthrewanexception.
  249. *@throwsInterruptedExceptionIfthecurrentthreadwasinterrupted
  250. *whilewaiting.
  251. *@throwsTimeoutExceptionIfthewaittimedout.
  252. */
  253. publicfinalResultget(longtimeout,TimeUnitunit)throwsInterruptedException,
  254. ExecutionException,TimeoutException{
  255. returnmFuture.get(timeout,unit);
  256. }
  258. /**
  259. *Executesthetaskwiththespecifiedparameters.Thetaskreturns
  260. *itself(this)sothatthecallercankeepareferencetoit.
  261. *
  262. *ThismethodmustbeinvokedontheUIthread.
  263. *
  264. *@paramparamsTheparametersofthetask.
  265. *
  266. *@returnThisinstanceofAsyncTask.
  267. *
  268. *@throwsIllegalStateExceptionIf{@link#getStatus()}returnseither
  269. *{@linkFifoAsyncTask.Status#RUNNING}or{@linkFifoAsyncTask.Status#FINISHED}.
  270. */
  271. publicfinalPreReadTask<Params,Progress,Result>execute(Params...params){
  272. if(mStatus!=Status.PENDING){
  273. switch(mStatus){
  274. caseRUNNING:
  275. thrownewIllegalStateException("Cannotexecutetask:"
  276. +"thetaskisalreadyrunning.");
  277. caseFINISHED:
  278. thrownewIllegalStateException("Cannotexecutetask:"
  279. +"thetaskhasalreadybeenexecuted"
  280. +"(ataskcanbeexecutedonlyonce)");
  281. }
  282. }
  284. mStatus=Status.RUNNING;
  286. onPreExecute();
  288. mWorker.mParams=params;
  289. sExecutor.execute(mFuture);
  291. returnthis;
  292. }
  294. /**
  295. *Thismethodcanbeinvokedfrom{@link#doInBackground}to
  296. *publishupdatesontheUIthreadwhilethebackgroundcomputationis
  297. *stillrunning.Eachcalltothismethodwilltriggertheexecutionof
  298. *{@link#onProgressUpdate}ontheUIthread.
  299. *
  300. *@paramvaluesTheprogressvaluestoupdatetheUIwith.
  301. *
  302. *@see#onProgressUpdate
  303. *@see#doInBackground
  304. */
  305. protectedfinalvoidpublishProgress(Progress...values){
  306. sHandler.obtainMessage(MESSAGE_POST_PROGRESS,
  307. newPreReadTaskResult<Progress>(this,values)).sendToTarget();
  308. }
  310. privatevoidfinish(Resultresult){
  311. if(isCancelled())result=null;
  312. onPostExecute(result);
  313. mStatus=Status.FINISHED;
  314. }
  316. privatestaticclassInternalHandlerextendsHandler{
  317. @SuppressWarnings({"unchecked","RawUseOfParameterizedType"})
  318. @Override
  319. publicvoidhandleMessage(Messagemsg){
  320. PreReadTaskResultresult=(PreReadTaskResult)msg.obj;
  321. switch(msg.what){
  322. caseMESSAGE_POST_RESULT:
  323. //Thereisonlyoneresult
  324. result.mTask.finish(result.mData[0]);
  325. break;
  326. caseMESSAGE_POST_PROGRESS:
  327. result.mTask.onProgressUpdate(result.mData);
  328. break;
  329. caseMESSAGE_POST_CANCEL:
  330. result.mTask.onCancelled();
  331. break;
  332. }
  333. }
  334. }
  336. privatestaticabstractclassWorkerRunnable<Params,Result>implementsCallable<Result>{
  337. Params[]mParams;
  338. }
  340. @SuppressWarnings({"RawUseOfParameterizedType"})
  341. privatestaticclassPreReadTaskResult<Data>{
  342. finalPreReadTaskmTask;
  343. finalData[]mData;
  345. PreReadTaskResult(PreReadTasktask,Data...data){
  346. mTask=task;
  347. mData=data;
  348. }
  349. }
  350. }


对比AsyncTask我们实际只修改了一个地方

[java]view plaincopy
  1. privatestaticfinalExecutorServicesExecutor=Executors.newSingleThreadExecutor(sThreadFactory);//只有一个工作线程的线程池

通过Executors.newSingleThreadExecutor，我们把PreReadTask的的线程池设置成只有一个工作线程，并且带有一个无边界的缓冲队列，这一个工作线程以先进先出的顺序不断从缓冲队列中取出并执行任务。

创建完后台预读的线程。我们通过一个例子介绍如何使用这个后台预读线程。

这个例子由两个Activity组成，WelcomeActivity是欢迎界面，在欢迎界面中会停留三秒，在此时我们对数据进行预读,预读成功后保存到一个全局的静态hashmap中。MainActivity是主界面，在主界面中显示一个listview，listview中的图片是模拟从网络获取的，当静态hashmap中存在数据（也就是已经成功预读的数据）的时，从hashmap中取，如果不存在，才从网络获取。

点此下载工程代码

WelcomeActivity.java 欢迎界面，停留三秒，预读数据

[java]view plaincopy
  1. packagecom.zhuozhuo;
  3. importandroid.app.Activity;
  4. importandroid.content.Intent;
  5. importandroid.graphics.BitmapFactory;
  6. importandroid.os.AsyncTask;
  7. importandroid.os.Bundle;
  8. importandroid.os.Handler;
  9. importandroid.widget.Toast;
  11. publicclassWelcomeActivityextendsActivity{
  13. privateHandlerhandler=newHandler();
  15. @Override
  16. publicvoidonCreate(BundlesavedInstanceState){
  17. super.onCreate(savedInstanceState);
  18. setContentView(R.layout.welcome);
  19. for(inti=0;i<15;i++){//预读15张图片
  20. ReadImgTasktask=newReadImgTask();
  21. task.execute(String.valueOf(i));
  22. }
  23. Toast.makeText(getApplicationContext(),"PreReading...",Toast.LENGTH_LONG).show();
  24. handler.postDelayed(newRunnable(){
  26. @Override
  27. publicvoidrun(){
  28. startActivity(newIntent(WelcomeActivity.this,MainActivity.class));//启动MainActivity
  30. finish();
  31. }
  32. },3000);//显示三秒钟的欢迎界面
  33. }
  35. classReadImgTaskextendsPreReadTask<String,Void,Void>{
  37. @Override
  38. protectedVoiddoInBackground(String...arg0){
  39. try{
  40. Thread.sleep(200);//模拟网络延时
  41. }catch(InterruptedExceptione){
  42. //TODOAuto-generatedcatchblock
  43. e.printStackTrace();
  44. }
  45. Data.putData(arg0[0],BitmapFactory.decodeResource(getResources(),R.drawable.icon));//把预读的数据放到hashmap中
  46. returnnull;
  47. }
  49. }
  51. }


MainActivity.java 主界面，有一个listview，listview中显示图片和文字，模拟图片从网络异步获取

[java]view plaincopy
  1. packagecom.zhuozhuo;
  3. importjava.util.ArrayList;
  4. importjava.util.Collection;
  5. importjava.util.HashMap;
  6. importjava.util.Iterator;
  7. importjava.util.List;
  8. importjava.util.ListIterator;
  9. importjava.util.Map;
  12. importandroid.app.Activity;
  13. importandroid.app.AlertDialog;
  14. importandroid.app.Dialog;
  15. importandroid.app.ListActivity;
  16. importandroid.app.ProgressDialog;
  17. importandroid.content.Context;
  18. importandroid.content.DialogInterface;
  19. importandroid.content.Intent;
  20. importandroid.database.Cursor;
  21. importandroid.graphics.Bitmap;
  22. importandroid.graphics.BitmapFactory;
  23. importandroid.os.AsyncTask;
  24. importandroid.os.Bundle;
  25. importandroid.provider.ContactsContract;
  26. importandroid.util.Log;
  27. importandroid.view.LayoutInflater;
  28. importandroid.view.View;
  29. importandroid.view.ViewGroup;
  30. importandroid.widget.AbsListView;
  31. importandroid.widget.AbsListView.OnScrollListener;
  32. importandroid.widget.Adapter;
  33. importandroid.widget.AdapterView;
  34. importandroid.widget.AdapterView.OnItemClickListener;
  35. importandroid.widget.BaseAdapter;
  36. importandroid.widget.GridView;
  37. importandroid.widget.ImageView;
  38. importandroid.widget.ListAdapter;
  39. importandroid.widget.ListView;
  40. importandroid.widget.SimpleAdapter;
  41. importandroid.widget.TextView;
  42. importandroid.widget.Toast;
  44. publicclassMainActivityextendsActivity{
  47. privateListViewmListView;
  48. privateList<HashMap<String,Object>>mData;
  50. privateBaseAdaptermAdapter;
  53. @Override
  54. publicvoidonCreate(BundlesavedInstanceState){
  55. super.onCreate(savedInstanceState);
  56. setContentView(R.layout.main);
  57. mListView=(ListView)findViewById(R.id.listview);
  58. mData=newArrayList<HashMap<String,Object>>();
  59. mAdapter=newCustomAdapter();
  61. mListView.setAdapter(mAdapter);
  62. for(inti=0;i<100;i++){//初始化100项数据
  63. HashMapdata=newHashMap<String,Object>();
  64. data.put("title","title"+i);
  65. mData.add(data);
  66. }
  67. }
  72. classCustomAdapterextendsBaseAdapter{
  75. CustomAdapter(){
  77. }
  79. @Override
  80. publicintgetCount(){
  81. returnmData.size();
  82. }
  84. @Override
  85. publicObjectgetItem(intposition){
  86. returnmData.get(position);
  87. }
  89. @Override
  90. publiclonggetItemId(intposition){
  91. return0;
  92. }
  94. @Override
  95. publicViewgetView(intposition,ViewconvertView,ViewGroupparent){
  96. Viewview=convertView;
  97. ViewHoldervh;
  98. if(view==null){
  99. view=LayoutInflater.from(MainActivity.this).inflate(R.layout.list_item,null);
  100. vh=newViewHolder();
  101. vh.tv=(TextView)view.findViewById(R.id.textView);
  102. vh.iv=(ImageView)view.findViewById(R.id.imageView);
  103. view.setTag(vh);
  104. }
  105. vh=(ViewHolder)view.getTag();
  106. vh.tv.setText((String)mData.get(position).get("title"));
  107. Bitmapbitmap=(Bitmap)mData.get(position).get("pic");
  108. if(bitmap!=null){
  109. vh.iv.setImageBitmap(bitmap);
  110. }
  111. else{
  112. vh.iv.setImageBitmap(null);
  113. }
  115. AsyncTasktask=(AsyncTask)mData.get(position).get("task");
  116. if(task==null||task.isCancelled()){
  117. mData.get(position).put("task",newGetItemImageTask(position).execute(null));//启动线程异步获取图片
  118. }
  120. returnview;
  121. }
  125. }
  127. staticclassViewHolder{
  128. TextViewtv;
  129. ImageViewiv;
  130. }
  133. classGetItemImageTaskextendsAsyncTask<Void,Void,Void>{//获取图片仍采用AsyncTask，这里的优化放到下篇再讨论
  135. intid;
  137. GetItemImageTask(intid){
  138. this.id=id;
  139. }
  141. @Override
  142. protectedVoiddoInBackground(Void...params){
  144. Bitmapbm=(Bitmap)Data.getData(String.valueOf(id));
  145. if(bm!=null){//如果hashmap中已经有数据，
  146. mData.get(id).put("pic",bm);
  147. }
  148. else{//模拟从网络获取
  149. try{
  150. Thread.sleep(200);//模拟网络延时
  151. }catch(InterruptedExceptione){
  152. e.printStackTrace();
  153. }
  154. mData.get(id).put("pic",BitmapFactory.decodeResource(getResources(),R.drawable.icon));
  155. }
  156. returnnull;
  157. }
  159. protectedvoidonPostExecute(Voidresult){
  160. mAdapter.notifyDataSetChanged();
  161. }
  163. }


Data.java 静态的Hashmap保存预读数据

[java]view plaincopy
  1. packagecom.zhuozhuo;
  3. importjava.util.AbstractMap;
  4. importjava.util.HashMap;
  5. importjava.util.concurrent.ConcurrentHashMap;
  7. publicclassData{
  8. privatestaticAbstractMap<String,Object>mData=newConcurrentHashMap<String,Object>();
  10. privateData(){
  12. }
  14. publicstaticvoidputData(Stringkey,Objectobj){
  15. mData.put(key,obj);
  16. }
  18. publicstaticObjectgetData(Stringkey){
  19. returnmData.get(key);
  20. }
  21. }

运行结果：

Android多线程任务优化2：实现后台预读线程

Android多线程任务优化2：实现后台预读线程

从执行结果可以看到，当进入MainActivity时，listview中的第一屏的图片已经加载好了。

这个简单例子中还不能很好地体现预读带来的用户体验的优势，不过一些应用（如前面提到过的新闻阅读类应用），实现了预读机制，使响应性大大提高，增强了用户体验。

总结：

1、通过实现自定义的AsyncTask来避免AsyncTask引起的FC风险和满足特定的后台异步任务需求

2、实现后台预读可以提高应用的响应性。

3、使用Executors.newSingleThreadExecutor()创建只有一个工作队列的线程池来实现预读需求。

引申：

1、预读队列的工作线程可以不止一个，请根据需求配置自己的线程池。

2、adapter的getview()方法中，我们仍然采用了AsyncTask实现异步获取图片，下篇我们将探讨更好的解决办法，在提高响应性的同时，避免了AyncTask带来的FC风险

3、预读也要控制成本，存储空间、耗电和流量都是要考虑的因素。

相关推荐