转载请标明出处：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 应用初始化及窗体事件（按键）的分发 [此博文包含图片]
2. Android复制assets目录下的图片到内存
3. Android单张图片查看、单指移动、双指缩放、双击最大化或最小化
4. Android 开发艺术探索笔记（十五） 之 Android 的线程和线程池
5. [Android] 旋转照片/图片
6. Android 效率开发之图片保存到图库
7. Android PNG渐变背景图片失真问题

随机推荐

1. 原有Android项目集成RN入坑计（一）
2. android网络编程――使用Android中的网络
3. Android 如何进行js交互
4. Android WebView介绍
5. Android Develop
6. Android多分辨率适配实践【1】使用字体图
7. [Android][Android Studio] *.jar 与 *.a
8. android and webview
9. android 不是内部或外部命令
10. Android AsyncTask完全解析，带你从源码的