转载请标明出处：http://blog.csdn.net/lmj623565791/article/details/38476887，本文出自【张鸿洋的博客】

最近创建了一个群，方便大家交流，群号：55032675

上一篇博客介绍了Android异步消息处理机制，如果你还不了解，可以看：Android 异步消息处理机制 让你深入理解 Looper、Handler、Message三者关系。那篇博客的最后，提出可以把异步消息处理机制不仅仅是在MainActivity中更新UI，可以用到别的地方，最近也一直在考虑这个问题，有幸，想出来一个实际的案例，将异步消息处理机制用到大量图片的加载的工具类中，其实也特别希望可以写一篇关于大量图片加载的文章，终于有机会了~先简单介绍一下：

1、概述

一般大量图片的加载，比如GridView实现手机的相册功能，一般会用到LruCache，线程池，任务队列等；那么异步消息处理可以用哪呢？

1、用于UI线程当Bitmap加载完成后更新ImageView

2、在图片加载类初始化时，我们会在一个子线程中维护一个Loop实例，当然子线程中也就有了MessageQueue，Looper会一直在那loop停着等待消息的到达，当有消息到达时，从任务队列按照队列调度的方式（FIFO,LIFO等），取出一个任务放入线程池中进行处理。

简易的一个流程：当需要加载一张图片，首先把加载图片加入任务队列，然后使用loop线程（子线程）中的hander发送一个消息，提示有任务到达，loop()（子线程）中会接着取出一个任务，去加载图片，当图片加载完成，会使用UI线程的handler发送一个消息去更新UI界面。

说了这么多，大家估计也觉得云里来雾里去的，下面看实际的例子。

2、图库功能的实现

该程序首先扫描手机中所有包含图片的文件夹，最终选择图片最多的文件夹，使用GridView显示其中的图片

1、布局文件

[html] view plain copy

1. <RelativeLayoutxmlns:android="http://schemas.android.com/apk/res/android"
2. xmlns:tools="http://schemas.android.com/tools"
3. android:layout_width="match_parent"
4. android:layout_height="match_parent">
6. <GridView
7. android:id="@+id/id_gridView"
8. android:layout_width="match_parent"
9. android:layout_height="match_parent"
10. android:cacheColorHint="@android:color/transparent"
11. android:columnWidth="90dip"
12. android:gravity="center"
13. android:horizontalSpacing="20dip"
14. android:listSelector="@android:color/transparent"
15. android:numColumns="auto_fit"
16. android:stretchMode="columnWidth"
17. android:verticalSpacing="20dip">
18. </GridView>
20. </RelativeLayout>

布局文件相当简单就一个GridView

2、MainActivity

[java] view plain copy

1. packagecom.example.zhy_handler_imageloader;
3. importjava.io.File;
4. importjava.io.FilenameFilter;
5. importjava.util.Arrays;
6. importjava.util.HashSet;
7. importjava.util.List;
9. importandroid.app.Activity;
10. importandroid.app.ProgressDialog;
11. importandroid.content.ContentResolver;
12. importandroid.database.Cursor;
13. importandroid.net.Uri;
14. importandroid.os.Bundle;
15. importandroid.os.Environment;
16. importandroid.os.Handler;
17. importandroid.provider.MediaStore;
18. importandroid.widget.GridView;
19. importandroid.widget.ImageView;
20. importandroid.widget.ListAdapter;
21. importandroid.widget.Toast;
23. publicclassMainActivityextendsActivity
24. {
25. privateProgressDialogmProgressDialog;
26. privateImageViewmImageView;
28. /**
29. *存储文件夹中的图片数量
30. */
31. privateintmPicsSize;
32. /**
33. *图片数量最多的文件夹
34. */
35. privateFilemImgDir;
36. /**
37. *所有的图片
38. */
39. privateList<String>mImgs;
41. privateGridViewmGirdView;
42. privateListAdaptermAdapter;
43. /**
44. *临时的辅助类，用于防止同一个文件夹的多次扫描
45. */
46. privateHashSet<String>mDirPaths=newHashSet<String>();
48. privateHandlermHandler=newHandler()
49. {
50. publicvoidhandleMessage(android.os.Messagemsg)
51. {
52. mProgressDialog.dismiss();
53. mImgs=Arrays.asList(mImgDir.list(newFilenameFilter()
54. {
55. @Override
56. publicbooleanaccept(Filedir,Stringfilename)
57. {
58. if(filename.endsWith(".jpg"))
59. returntrue;
60. returnfalse;
61. }
62. }));
63. /**
64. *可以看到文件夹的路径和图片的路径分开保存，极大的减少了内存的消耗；
65. */
66. mAdapter=newMyAdapter(getApplicationContext(),mImgs,
67. mImgDir.getAbsolutePath());
68. mGirdView.setAdapter(mAdapter);
69. };
70. };
72. @Override
73. protectedvoidonCreate(BundlesavedInstanceState)
74. {
75. super.onCreate(savedInstanceState);
76. setContentView(R.layout.activity_main);
77. mGirdView=(GridView)findViewById(R.id.id_gridView);
78. getImages();
80. }
82. /**
83. *利用ContentProvider扫描手机中的图片，此方法在运行在子线程中完成图片的扫描，最终获得jpg最多的那个文件夹
84. */
85. privatevoidgetImages()
86. {
87. if(!Environment.getExternalStorageState().equals(
88. Environment.MEDIA_MOUNTED))
89. {
90. Toast.makeText(this,"暂无外部存储",Toast.LENGTH_SHORT).show();
91. return;
92. }
93. //显示进度条
94. mProgressDialog=ProgressDialog.show(this,null,"正在加载...");
96. newThread(newRunnable()
97. {
99. @Override
100. publicvoidrun()
101. {
102. UrimImageUri=MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
103. ContentResolvermContentResolver=MainActivity.this
104. .getContentResolver();
106. //只查询jpeg和png的图片
107. CursormCursor=mContentResolver.query(mImageUri,null,
108. MediaStore.Images.Media.MIME_TYPE+"=?or"
109. +MediaStore.Images.Media.MIME_TYPE+"=?",
110. newString[]{"image/jpeg","image/png"},
111. MediaStore.Images.Media.DATE_MODIFIED);
113. while(mCursor.moveToNext())
114. {
115. //获取图片的路径
116. Stringpath=mCursor.getString(mCursor
117. .getColumnIndex(MediaStore.Images.Media.DATA));
118. //获取该图片的父路径名
119. FileparentFile=newFile(path).getParentFile();
120. StringdirPath=parentFile.getAbsolutePath();
122. //利用一个HashSet防止多次扫描同一个文件夹（不加这个判断，图片多起来还是相当恐怖的~~）
123. if(mDirPaths.contains(dirPath))
124. {
125. continue;
126. }
127. else
128. {
129. mDirPaths.add(dirPath);
130. }
132. intpicSize=parentFile.list(newFilenameFilter()
133. {
134. @Override
135. publicbooleanaccept(Filedir,Stringfilename)
136. {
137. if(filename.endsWith(".jpg"))
138. returntrue;
139. returnfalse;
140. }
141. }).length;
142. if(picSize>mPicsSize)
143. {
144. mPicsSize=picSize;
145. mImgDir=parentFile;
146. }
147. }
148. mCursor.close();
149. //扫描完成，辅助的HashSet也就可以释放内存了
150. mDirPaths=null;
151. //通知Handler扫描图片完成
152. mHandler.sendEmptyMessage(0x110);
154. }
155. }).start();
157. }
158. }

MainActivity也是比较简单的，使用ContentProvider辅助，找到图片最多的文件夹后，直接handler去隐藏ProgressDialog，然后初始化数据，适配器等；

但是稍微注意一下：

1、在扫描图片时，使用了一个临时的HashSet保存扫描过的文件夹，这样可以有效的避免重复扫描。比如，我手机中有个文件夹下面有3000多张图片，如果不判断则会扫描这个文件夹3000多次，处理器时间以及内存的消耗还是很可观的。

2、在适配器中，保存List<String>的时候，考虑只保存图片的名称，路径单独作为变量传入。一般情况下，图片的路径比图片名长很多，加入有3000张图片，路径长度30，图片平均长度10，则List<String>保存完成路径需要长度为：（30+10）*3000 = 120000 ; 而单独存储只需要：30+10*3000 = 30030 ； 图片越多，节省的内存越客观；

总之，尽可能的去减少内存的消耗，这些都是很容易做到的~

3、GridView的适配器

[java] view plain copy

1. packagecom.example.zhy_handler_imageloader;
3. importjava.util.List;
5. importandroid.content.Context;
6. importandroid.view.LayoutInflater;
7. importandroid.view.View;
8. importandroid.view.ViewGroup;
9. importandroid.widget.BaseAdapter;
10. importandroid.widget.ImageView;
12. importcom.zhy.utils.ImageLoader;
14. publicclassMyAdapterextendsBaseAdapter
15. {
17. privateContextmContext;
18. privateList<String>mData;
19. privateStringmDirPath;
20. privateLayoutInflatermInflater;
21. privateImageLoadermImageLoader;
23. publicMyAdapter(Contextcontext,List<String>mData,StringdirPath)
24. {
25. this.mContext=context;
26. this.mData=mData;
27. this.mDirPath=dirPath;
28. mInflater=LayoutInflater.from(mContext);
30. mImageLoader=ImageLoader.getInstance();
31. }
33. @Override
34. publicintgetCount()
35. {
36. returnmData.size();
37. }
39. @Override
40. publicObjectgetItem(intposition)
41. {
42. returnmData.get(position);
43. }
45. @Override
46. publiclonggetItemId(intposition)
47. {
48. returnposition;
49. }
51. @Override
52. publicViewgetView(intposition,ViewconvertView,finalViewGroupparent)
53. {
54. ViewHolderholder=null;
55. if(convertView==null)
56. {
57. holder=newViewHolder();
58. convertView=mInflater.inflate(R.layout.grid_item,parent,
59. false);
60. holder.mImageView=(ImageView)convertView
61. .findViewById(R.id.id_item_image);
62. convertView.setTag(holder);
63. }else
64. {
65. holder=(ViewHolder)convertView.getTag();
66. }
67. holder.mImageView
68. .setImageResource(R.drawable.friends_sends_pictures_no);
69. //使用Imageloader去加载图片
70. mImageLoader.loadImage(mDirPath+"/"+mData.get(position),
71. holder.mImageView);
72. returnconvertView;
73. }
75. privatefinalclassViewHolder
76. {
77. ImageViewmImageView;
78. }
80. }

可以看到与传统的适配器的写法基本没有什么不同之处，甚至在getView里面都没有出现常见的回调（findViewByTag~用于防止图片的错位）；仅仅多了一行代码：

mImageLoader.loadImage(mDirPath + "/" + mData.get(position),holder.mImageView);是不是用起来还是相当爽的，所有需要处理的细节都被封装了。

4、ImageLoader

现在才到了关键的时刻，我们封装的ImageLoader类，当然我们的异步消息处理机制也出现在其中。

首先是一个懒加载的单例

[java] view plain copy

1. /**
2. *单例获得该实例对象
3. *
4. *@return
5. */
6. publicstaticImageLoadergetInstance()
7. {
9. if(mInstance==null)
10. {
11. synchronized(ImageLoader.class)
12. {
13. if(mInstance==null)
14. {
15. mInstance=newImageLoader(1,Type.LIFO);
16. }
17. }
18. }
19. returnmInstance;
20. }

没啥说的，直接调用私有的构造方法，可以看到，默认传入了1（线程池中线程的数量），和LIFO（队列的工作方式）

[java] view plain copy

1. privateImageLoader(intthreadCount,Typetype)
2. {
3. init(threadCount,type);
4. }
6. privatevoidinit(intthreadCount,Typetype)
7. {
8. //loopthread
9. mPoolThread=newThread()
10. {
11. @Override
12. publicvoidrun()
13. {
14. try
15. {
16. //请求一个信号量
17. mSemaphore.acquire();
18. }catch(InterruptedExceptione)
19. {
20. }
21. Looper.prepare();
23. mPoolThreadHander=newHandler()
24. {
25. @Override
26. publicvoidhandleMessage(Messagemsg)
27. {
28. mThreadPool.execute(getTask());
29. try
30. {
31. mPoolSemaphore.acquire();
32. }catch(InterruptedExceptione)
33. {
34. }
35. }
36. };
37. //释放一个信号量
38. mSemaphore.release();
39. Looper.loop();
40. }
41. };
42. mPoolThread.start();
44. //获取应用程序最大可用内存
45. intmaxMemory=(int)Runtime.getRuntime().maxMemory();
46. intcacheSize=maxMemory/8;
47. mLruCache=newLruCache<String,Bitmap>(cacheSize)
48. {
49. @Override
50. protectedintsizeOf(Stringkey,Bitmapvalue)
51. {
52. returnvalue.getRowBytes()*value.getHeight();
53. };
54. };
56. mThreadPool=Executors.newFixedThreadPool(threadCount);
57. mPoolSemaphore=newSemaphore(threadCount);
58. mTasks=newLinkedList<Runnable>();
59. mType=type==null?Type.LIFO:type;
61. }

然后在私有构造里面调用了我们的init方法，在这个方法的开始就创建了mPoolThread这个子线程，在这个子线程中我们执行了Looper.prepare,初始化mPoolThreadHander，Looper.loop；如果看过上篇博客，一定知道，此时在这个子线程中维护了一个消息队列，且这个子线程会进入一个无限读取消息的循环中，而mPoolThreadHander这个handler发送的消息会直接发送至此线程中的消息队列。然后看mPoolThreadHander中handleMessage的方法，直接调用了getTask方法取出一个任务，然后放入线程池去执行。如果你比较细心，可能会发现里面还有一些信号量的操作的代码，如果你不了解什么是信号量，可以参考： Java 并发专题 ： Semaphore 实现 互斥 与 连接池 。 简单说一下mSemaphore（信号数为1）的作用，由于mPoolThreadHander实在子线程初始化的，所以我在初始化前调用了mSemaphore.acquire去请求一个信号量，然后在初始化完成后释放了此信号量，我为什么这么做呢？因为在主线程可能会立即使用到mPoolThreadHander，但是mPoolThreadHander是在子线程初始化的，虽然速度很快，但是我也不能百分百的保证，主线程使用时已经初始化结束，为了避免空指针异常，所以我在主线程需要使用的时候，是这么调用的：

[java] view plain copy

1. /**
2. *添加一个任务
3. *
4. *@paramrunnable
5. */
6. privatesynchronizedvoidaddTask(Runnablerunnable)
7. {
8. try
9. {
10. //请求信号量，防止mPoolThreadHander为null
11. if(mPoolThreadHander==null)
12. mSemaphore.acquire();
13. }catch(InterruptedExceptione)
14. {
15. }
16. mTasks.add(runnable);
17. mPoolThreadHander.sendEmptyMessage(0x110);
18. }

如果mPoolThreadHander没有初始化完成，则会去acquire一个信号量，其实就是去等待mPoolThreadHander初始化完成。如果对此感兴趣的，可以将关于mSemaphore的代码注释，然后在初始化mPoolThreadHander使用Thread.sleep去暂停1秒，就会发现这样的错误。

初始化结束，就会在getView中调用mImageLoader.loadImage(mDirPath + "/" + mData.get(position),holder.mImageView);方法了，所以我们去看loadImage方法吧

[java] view plain copy

1. /**
2. *加载图片
3. *
4. *@parampath
5. *@paramimageView
6. */
7. publicvoidloadImage(finalStringpath,finalImageViewimageView)
8. {
9. //settag
10. imageView.setTag(path);
11. //UI线程
12. if(mHandler==null)
13. {
14. mHandler=newHandler()
15. {
16. @Override
17. publicvoidhandleMessage(Messagemsg)
18. {
19. ImgBeanHolderholder=(ImgBeanHolder)msg.obj;
20. ImageViewimageView=holder.imageView;
21. Bitmapbm=holder.bitmap;
22. Stringpath=holder.path;
23. if(imageView.getTag().toString().equals(path))
24. {
25. imageView.setImageBitmap(bm);
26. }
27. }
28. };
29. }
31. Bitmapbm=getBitmapFromLruCache(path);
32. if(bm!=null)
33. {
34. ImgBeanHolderholder=newImgBeanHolder();
35. holder.bitmap=bm;
36. holder.imageView=imageView;
37. holder.path=path;
38. Messagemessage=Message.obtain();
39. message.obj=holder;
40. mHandler.sendMessage(message);
41. }else
42. {
43. addTask(newRunnable()
44. {
45. @Override
46. publicvoidrun()
47. {
49. ImageSizeimageSize=getImageViewWidth(imageView);
51. intreqWidth=imageSize.width;
52. intreqHeight=imageSize.height;
54. Bitmapbm=decodeSampledBitmapFromResource(path,reqWidth,
55. reqHeight);
56. addBitmapToLruCache(path,bm);
57. ImgBeanHolderholder=newImgBeanHolder();
58. holder.bitmap=getBitmapFromLruCache(path);
59. holder.imageView=imageView;
60. holder.path=path;
61. Messagemessage=Message.obtain();
62. message.obj=holder;
63. //Log.e("TAG","mHandler.sendMessage(message);");
64. mHandler.sendMessage(message);
65. mPoolSemaphore.release();
66. }
67. });
68. }
70. }

这段代码比较长，当然也是比较核心的代码了

10-29行：首先将传入imageView设置了path，然在初始化了一个mHandler用于设置imageView的bitmap，注意此时在UI线程，也就是这个mHandler发出的消息，会在UI线程中调用。可以看到在handleMessage中，我们从消息中取出ImageView，bitmap，path；然后将path与imageView的tag进行比较，防止图片的错位，最后设置bitmap;

31行：我们首先去从LruCache中去查找是否已经缓存了此图片

32-40：如果找到了，则直接使用mHandler去发送消息，这里使用了一个ImgBeanHolder去封装了ImageView，Bitmap，Path这三个对象。然后更新执行handleMessage代码去更新UI

43-66行：如果没有存在缓存中，则创建一个Runnable对象作为任务，去执行addTask方法加入任务队列

49行：getImageViewWidth根据ImageView获取适当的图片的尺寸，用于后面的压缩图片，代码按顺序贴下下面

54行：会根据计算的需要的宽和高，对图片进行压缩。代码按顺序贴下下面

56行：将压缩后的图片放入缓存

58-64行，创建消息，使用mHandler进行发送，更新UI

[java] view plain copy

1. /**
2. *根据ImageView获得适当的压缩的宽和高
3. *
4. *@paramimageView
5. *@return
6. */
7. privateImageSizegetImageViewWidth(ImageViewimageView)
8. {
9. ImageSizeimageSize=newImageSize();
10. finalDisplayMetricsdisplayMetrics=imageView.getContext()
11. .getResources().getDisplayMetrics();
12. finalLayoutParamsparams=imageView.getLayoutParams();
14. intwidth=params.width==LayoutParams.WRAP_CONTENT?0:imageView
15. .getWidth();//Getactualimagewidth
16. if(width<=0)
17. width=params.width;//Getlayoutwidthparameter
18. if(width<=0)
19. width=getImageViewFieldValue(imageView,"mMaxWidth");//Check
20. //maxWidth
21. //parameter
22. if(width<=0)
23. width=displayMetrics.widthPixels;
24. intheight=params.height==LayoutParams.WRAP_CONTENT?0:imageView
25. .getHeight();//Getactualimageheight
26. if(height<=0)
27. height=params.height;//Getlayoutheightparameter
28. if(height<=0)
29. height=getImageViewFieldValue(imageView,"mMaxHeight");//Check
30. //maxHeight
31. //parameter
32. if(height<=0)
33. height=displayMetrics.heightPixels;
34. imageSize.width=width;
35. imageSize.height=height;
36. returnimageSize;
38. }

[java] view plain copy

1. /**
2. *根据计算的inSampleSize，得到压缩后图片
3. *
4. *@parampathName
5. *@paramreqWidth
6. *@paramreqHeight
7. *@return
8. */
9. privateBitmapdecodeSampledBitmapFromResource(StringpathName,
10. intreqWidth,intreqHeight)
11. {
12. //第一次解析将inJustDecodeBounds设置为true，来获取图片大小
13. finalBitmapFactory.Optionsoptions=newBitmapFactory.Options();
14. options.inJustDecodeBounds=true;
15. BitmapFactory.decodeFile(pathName,options);
16. //调用上面定义的方法计算inSampleSize值
17. options.inSampleSize=calculateInSampleSize(options,reqWidth,
18. reqHeight);
19. //使用获取到的inSampleSize值再次解析图片
20. options.inJustDecodeBounds=false;
21. Bitmapbitmap=BitmapFactory.decodeFile(pathName,options);
23. returnbitmap;
24. }

接下来看AddTask的代码：

[java] view plain copy

1. /**
2. *添加一个任务
3. *
4. *@paramrunnable
5. */
6. privatesynchronizedvoidaddTask(Runnablerunnable)
7. {
8. try
9. {
10. //请求信号量，防止mPoolThreadHander为null
11. if(mPoolThreadHander==null)
12. mSemaphore.acquire();
13. }catch(InterruptedExceptione)
14. {
15. }
16. mTasks.add(runnable);
17. mPoolThreadHander.sendEmptyMessage(0x110);
18. }

可以看到，简单把任务放入任务队列，然后使用mPoolThreadHander发送一个消息到后台的loop中，后台的loop会取出消息执行：mThreadPool.execute(getTask());

execute执行的就是上面分析的Runnable中的run方法了。

注意一下：上述代码中还会看到mPoolSemaphore这个信号量的身影，说下用处；因为调用addTask之后，会直接去从任务队列取出一个任务，放入线程池，由于线程池内部其实也维持着一个队列，那么”从任务队列取出一个任务”这个动作会瞬间完成，直接加入线程池维护的队列中；这样会造成比如用户设置了调度队列为LIFO，但是由于”从任务队列取出一个任务”这个动作会瞬间完成，队列中始终维持在空队列的状态，所以让用户感觉LIFO根本没有效果；所以我按照用户设置线程池工作线程的数量设置了一个信号量，这样在保证任务执行完后，才会从任务队列去取任务，使得LIFO有着很好的效果；有兴趣的可以注释了所有的mPoolSemaphore代码，测试下就明白了。

到此代码基本介绍完毕。细节还是很多的，后面会附上源码，有兴趣的研究下代码，没有兴趣的，可以运行下代码，如果感觉流畅性不错，体验不错，可以作为工具类直接使用，使用也就getView里面一行代码。

贴一下效果图，我手机最多的文件夹大概3000张图片，加载速度还是相当相当流畅的：

真机录的，有点丢帧，注意看效果图，中间我疯狂拖动滚动条，但是图片基本还是瞬间显示的。

说一下，FIFO如果设置为这个模式，在控件中不做处理的话，用户拉的比较慢效果还是不错的，但是用户手机如果有个几千张，瞬间拉到最后，最后一屏图片的显示可能需要喝杯茶了~当然了，大家可以在控件中做处理，要么，拖动的时候不去加载图片，停在来再加载。或者，当手机抬起，给了一个很大的加速度，屏幕还是很快的滑动时停止加载，停下时加载图片。

LIFO这个模式可能用户体验会好很多，不管用户拉多块，最终停下来的那一屏图片都会瞬间显示~

最后掰一掰使用异步消息处理机制作为背后的子线程的好处，其实直接用一个子线程也可以实现，但是，这个子线程run中可能需要while(true）然后每隔200毫秒甚至更短的时间去查询任务队列是否有任务，没有则Thread.sleep，然后再去查询；这样如果长时间没有去添加任务，这个线程依然会不断的去查询；

而异步消息机制，只有在发送消息时才会去执行，当然更准确；当长时间没有任务到达时，也不会去查询，会一直阻塞在这；还有一点，这个机制Android内部实现的，怎么也比我们搞个Thread稳定性、效率高吧~

源码点击下载

更多相关文章

1. 浅谈android的selector，背景选择器
2. Android的selector 背景选择器
3. Android的Handler总结
4. android 简单同步与异步
5. Android复制assets目录下的图片到内存
6. android的消息处理机制（图+源码分析）——Looper,Handler,Message (
7. [转]Android(安卓)应用初始化及窗体事件（按键）的分发 [此博文包含
8. Android(安卓)Handler 异步消息处理机制的妙用 创建强大的图片加
9. Android中Looper简介

随机推荐

1. Android(安卓)判断Service是否开启
2. 关于Android环境配置SDK的问题Failed to
3. 第一次写博客，先上传一下平常开发android
4. Android 源码修改按键长按响应间隔
5. Android之屏幕切换使用技巧
6. Android 中屏幕点击事件的实现
7. 【Android】WebView设置背景色
8. android volley ，多文件 表单上传
9. Android Studio v0.1尝鲜
10. android 如何依赖android:sharedUserId更