Android多线程任务优化1：探讨AsyncTask的缺陷

时间：2023-11-24 22:19:14
 AsyncTask还有别的缺陷，在生成listview的时候，如果adapter里面的count动态改变的话，不能使用AsyncTask，只能使用Thread+Handler，否则会出现如下错误



java.lang.IllegalStateException: The content of the adapter has changed but ListView did not receive a notification. Make sure the content of your adapter is not modified from a background thread, but only
from the UI thread. [in ListView(2130968590, class com.ryantang.rtimageloader.CustomListView) with Adapter(class android.widget.HeaderViewListAdapter)]



在重写ListView的onScroll方法时，想动态改变listview的项目数，用了AsyncTask发生了这个FC。。

经过亲测

executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR)

这么调用才会fc

直接execute()不会fc，顺序逐一加载。

解决办法：可以自己写线程池，

private static final BlockingQueue<Runnable> sPoolWorkQueue = 

new LinkedBlockingQueue<Runnable>(10); 

可以改成final LinkedBlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>();无大小限制的

其实AsyncTask的使用时有技巧的，应该采用分项和预读来控制，不可能一段程序里进行不休止的运行，而且应该控制好异常处理，应该由一个控制线程来处理AsyncTask的调用判断线程池是否满了，如果满了则线程睡眠否则请求AsyncTask继续处理。






导语：在开发Android应用的过程中，我们需要时刻注意保障应用的稳定性和界面响应性，因为不稳定或者响应速度慢的应用将会给用户带来非常差的交互体验。在越来越讲究用户体验的大环境下，用户也许会因为应用的一次Force Close(简称FC)或者延迟严重的动画效果而卸载你的应用。由于现在的应用大多需要异步连接网络，本系列文章就以构建网络应用为例，从稳定性和响应性两个角度分析多线程网络任务的性能优化方法。

概述：为了不阻塞UI线程（亦称主线程），提高应用的响应性，我们经常会使用新开线程的方式，异步处理那些导致阻塞的任务(如要了解Android异步处理的实现方式和原理，请先阅读《Android异步处理系列文章索引》)。

AsyncTask是Android为我们提供的方便编写异步任务的工具类，但是，在了解AsyncTask的实现原理之后，发现AsyncTask并不能满足我们所有的需求，使用不当还有可能导致应用FC。

本文主要通过分析AsyncTask提交任务的策略和一个具体的例子，说明AsyncTask的不足之处，至于解决办法，我们将在下篇再讲解。

分析：

AsyncTask类包含一个全局静态的线程池，线程池的配置参数如下：

  1. private static final int CORE_POOL_SIZE =5;//5个核心工作线程
  2. private static final int MAXIMUM_POOL_SIZE = 128;//最多128个工作线程
  3. private static final int KEEP_ALIVE = 1;//空闲线程的超时时间为1秒
  4. private static final BlockingQueue<Runnable> sWorkQueue =
  5. new LinkedBlockingQueue<Runnable>(10);//等待队列
  6. private static final ThreadPoolExecutorsExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE,
  7. MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sWorkQueue,sThreadFactory);//线程池是静态变量，所有的异步任务都会放到这个线程池的工作线程内执行。

我们这里不详细讲解ThreadPoolExecutor的原理，但将会讲解一个异步任务提交到AsyncTask的线程池时可能会出现的4种情况,并会提出在Android硬件配置普遍较低这个客观条件下，每个情况可能会出现的问题。

1、线程池中的工作线程少于5个时，将会创建新的工作线程执行异步任务（红色表示新任务，下同）

Android多线程任务优化1：探讨AsyncTask的缺陷

2、线程池中已经有5个线程，缓冲队列未满，异步任务将会放到缓冲队列中等待

Android多线程任务优化1：探讨AsyncTask的缺陷

3、线程池中已经有5个线程，缓冲队列已满，那么线程池将新开工作线程执行异步任务

Android多线程任务优化1：探讨AsyncTask的缺陷

问题：Android的设备一般不超过2个cpu核心，过多的线程会造成线程间切换频繁,消耗系统资源。

4、线程池中已经有128个线程，缓冲队列已满，如果此时向线程提交任务，将会抛出RejectedExecutionException

Android多线程任务优化1：探讨AsyncTask的缺陷

问题：抛出的错误不catch的话会导致程序FC。

好吧，理论分析之后还是要结合实际例子，我们通过实现一个模拟异步获取网络图片的例子，看看会不会出现上面提到的问题。

例子：使用GridView模拟异步加载大量图片

ActivityA.java

  1. package com.zhuozhuo;
  2. import java.util.ArrayList;
  3. import java.util.Collection;
  4. import java.util.HashMap;
  5. import java.util.Iterator;
  6. import java.util.List;
  7. import java.util.ListIterator;
  8. import java.util.Map;
  9. import android.app.Activity;
  10. import android.app.AlertDialog;
  11. import android.app.Dialog;
  12. import android.app.ListActivity;
  13. import android.app.ProgressDialog;
  14. import android.content.Context;
  15. import android.content.DialogInterface;
  16. import android.content.Intent;
  17. import android.database.Cursor;
  18. import android.graphics.Bitmap;
  19. import android.os.AsyncTask;
  20. import android.os.Bundle;
  21. import android.provider.ContactsContract;
  22. import android.util.Log;
  23. import android.view.LayoutInflater;
  24. import android.view.View;
  25. import android.view.ViewGroup;
  26. import android.widget.AbsListView;
  27. import android.widget.AbsListView.OnScrollListener;
  28. import android.widget.Adapter;
  29. import android.widget.AdapterView;
  30. import android.widget.AdapterView.OnItemClickListener;
  31. import android.widget.BaseAdapter;
  32. import android.widget.GridView;
  33. import android.widget.ImageView;
  34. import android.widget.ListAdapter;
  35. import android.widget.SimpleAdapter;
  36. import android.widget.TextView;
  37. import android.widget.Toast;
  38. public class ActivityA extends Activity {
  39. private GridView mGridView;
  40. private List<HashMap<String, Object>> mData;
  41. private BaseAdapter mAdapter;
  42. private ProgressDialog mProgressDialog;
  43. private static final int DIALOG_PROGRESS = 0;
  44. @Override
  45. public void onCreate(Bundle savedInstanceState) {
  46. super.onCreate(savedInstanceState);
  47. setContentView(R.layout.main);
  48. mGridView = (GridView) findViewById(R.id.gridview);
  49. mData = new ArrayList<HashMap<String,Object>>();
  50. mAdapter = new CustomAdapter();
  51. mGridView.setAdapter(mAdapter);
  52. }
  53. protected void onStart () {
  54. super.onStart();
  55. new GetGridDataTask().execute(null);//执行获取数据的任务
  56. }
  57. @Override
  58. protected Dialog onCreateDialog(int id) {
  59. switch (id) {
  60. case DIALOG_PROGRESS:
  61. mProgressDialog = new ProgressDialog(ActivityA.this);
  62. mProgressDialog.setMessage("正在获取数据");
  63. mProgressDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
  64. return mProgressDialog;
  65. }
  66. return null;
  67. }
  68. class CustomAdapter extends BaseAdapter {
  69. CustomAdapter() {
  70. }
  71. @Override
  72. public int getCount() {
  73. return mData.size();
  74. }
  75. @Override
  76. public Object getItem(int position) {
  77. return mData.get(position);
  78. }
  79. @Override
  80. public long getItemId(int position) {
  81. return 0;
  82. }
  83. @Override
  84. public View getView(int position, View convertView, ViewGroup parent) {
  85. View view = convertView;
  86. ViewHolder vh;
  87. if(view == null) {
  88. view = LayoutInflater.from(ActivityA.this).inflate(R.layout.list_item, null);
  89. vh = new ViewHolder();
  90. vh.tv = (TextView) view.findViewById(R.id.textView);
  91. vh.iv = (ImageView) view.findViewById(R.id.imageView);
  92. view.setTag(vh);
  93. }
  94. vh = (ViewHolder) view.getTag();
  95. vh.tv.setText((String) mData.get(position).get("title"));
  96. Integer id = (Integer) mData.get(position).get("pic");
  97. if(id != null) {
  98. vh.iv.setImageResource(id);
  99. }
  100. else {
  101. vh.iv.setImageBitmap(null);
  102. }
  103. FifoAsyncTask task = (FifoAsyncTask) mData.get(position).get("task");
  104. if(task == null || task.isCancelled()) {
  105. Log.d("Test", "" + position);
  106. mData.get(position).put("task", new GetItemImageTask(position).execute(null));//执行获取图片的任务
  107. }
  108. return view;
  109. }
  110. }
  111. static class ViewHolder {
  112. TextView tv;
  113. ImageView iv;
  114. }
  115. class GetGridDataTask extends FifoAsyncTask<Void, Void, Void> {
  116. protected void onPreExecute () {
  117. mData.clear();
  118. mAdapter.notifyDataSetChanged();
  119. showDialog(DIALOG_PROGRESS);//打开等待对话框
  120. }
  121. @Override
  122. protected Void doInBackground(Void... params) {
  123. try {
  124. Thread.sleep(500);//模拟耗时的网络操作
  125. } catch (InterruptedException e) {
  126. e.printStackTrace();
  127. }
  128. for(int i = 0; i < 200; i++) {
  129. HashMap<String, Object> hm = new HashMap<String, Object>();
  130. hm.put("title", "Title");
  131. mData.add(hm);
  132. }
  133. return null;
  134. }
  135. protected void onPostExecute (Void result) {
  136. mAdapter.notifyDataSetChanged();//通知ui界面更新
  137. dismissDialog(DIALOG_PROGRESS);//关闭等待对话框
  138. }
  139. }
  140. class GetItemImageTask extends FifoAsyncTask<Void, Void, Void> {
  141. int pos;
  142. GetItemImageTask(int pos) {
  143. this.pos = pos;
  144. }
  145. @Override
  146. protected Void doInBackground(Void... params) {
  147. try {
  148. Thread.sleep(2000); //模拟耗时的网络操作
  149. } catch (InterruptedException e) {
  150. e.printStackTrace();
  151. }
  152. mData.get(pos).put("pic", R.drawable.icon);
  153. return null;
  154. }
  155. protected void onPostExecute (Void result) {
  156. mAdapter.notifyDataSetChanged();//通知ui界面更新
  157. }
  158. }
  159. }

Android多线程任务优化1：探讨AsyncTask的缺陷

由运行图可见

当网络情况较差，异步任务不能尽快完成执行的情况下，新开的线程会造成listview滑动不流畅。当开启的工作线程过多时，还有出现FC的可能。

至此，你还相信万能的AsyncTask吗？至于你信不信，反正我不信。

总结：

AsyncTask可能存在新开大量线程消耗系统资源和导致应用FC的风险，因此，我们需要根据自己的需求自定义不同的线程池，由于篇幅问题，将留到下篇再讲。

为了给用户带来良好的交互体验，在Android应用的开发过程中需要把繁重的任务（IO，网络连接等）放到其他线程中异步执行，达到不阻塞UI的效果。

本系列文章由浅入深介绍Android进行异步处理的实现方法和系统底层的实现原理。

提供资料:

Android异步处理一：使用Thread+Handler实现非UI线程更新UI界面 （入门）

介绍如何使用Thread+Handler的方式从非UI线程发送界面更新消息到UI线程

Android异步处理二：使用AsyncTask异步更新UI界面 （入门）

介绍如何使用AsyncTask异步更新UI界面

Android异步处理三：Handler+Looper+MessageQueue深入详解（进阶）

追踪系统代码，介绍Thread+Handler的实现原理

Android异步处理四：AsyncTask的实现原理（进阶）

追踪系统代码，介绍系统底层AsyncTask的实现原理


相关文章