转 如何高效使用和管理Bitmap--图片缓存管理模块的设计与实现

上周为360全景项目引入了图片缓存模块。因为是在Android4.0平台以上运作，出于惯性，都会在设计之前查阅相关资料，尽量避免拿一些以前2.3平台积累的经验来进行类比处理。开发文档中有一个 BitmapFun的示例，仔细拜读了一下，虽说围绕着Bitmap的方方面面讲得都很深入，但感觉很难引入到当前项目中去。         现在的图片服务提供者基本上都来源于网络。对于应用平台而言，访问网络属于耗时操作。尤其是在移动终端设备上，它的显著表现为系统的延迟时间变长、用户交互性变差等。可以想象，一个携带着这些问题的应用在市场上是很难与同类产品竞争的。 
        说明一下，本文借鉴了 Keegan小钢和安卓巴士的处理模板，主要针对的是4.0以上平台应用。2.3以前平台执行效果未知，请斟酌使用或直接略过：），当然更欢迎您把测试结果告知笔者。 
一、图片加载流程 
        首先，我们谈谈加载图片的流程，项目中的该模块处理流程如下： 
1.在UI主线程中，从内存缓存中获取图片，找到后返回。找不到进入下一步； 
2.在工作线程中，从磁盘缓存中获取图片，找到即返回并更新内存缓存。找不到进入下一步； 
3.在工作线程中，从网络中获取图片，找到即返回并同时更新内存缓存和磁盘缓存。找不到显示默认以提示。

二、内存缓存类（PanoMemCache）

这里使用Android提供的LruCache类，该类保存一个强引用来限制内容数量，每当Item被访问的时候，此Item就会移动到队列的头部。当cache已满的时候加入新的item时，在队列尾部的item会被回收。

[java] view plain copy print ?

1. public class PanoMemoryCache {
2. // LinkedHashMap初始容量
3. private static final int INITIAL_CAPACITY = 16;
4. // LinkedHashMap加载因子
5. private static final int LOAD_FACTOR = 0.75f;
6. // LinkedHashMap排序模式
7. private static final boolean ACCESS_ORDER = true;
8. // 软引用缓存
9. private static LinkedHashMap<String, SoftReference<Bitmap>> mSoftCache;
10. // 硬引用缓存
11. private static LruCache<String, Bitmap> mLruCache;
12. public PanoMemoryCache() {
13. // 获取单个进程可用内存的最大值
14. // 方式一：使用ActivityManager服务（计量单位为M）
15. /*int memClass = ((ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE)).getMemoryClass();*/
16. // 方式二：使用Runtime类（计量单位为Byte）
17. final int memClass = (int) Runtime.getRuntime().maxMemory();
18. // 设置为可用内存的1/4（按Byte计算）
19. final int cacheSize = memClass / 4;
20. mLruCache = new LruCache<String, Bitmap>(cacheSize) {
21. @Override
22. protected int sizeOf(String key, Bitmap value) {
23. if(value != null) {
24. // 计算存储bitmap所占用的字节数
25. return value.getRowBytes() * value.getHeight();
26. } else {
27. return 0;
28. }
29. }
30. @Override
31. protected void entryRemoved(boolean evicted, String key, Bitmap oldValue, Bitmap newValue) {
32. if(oldValue != null) {
33. // 当硬引用缓存容量已满时，会使用LRU算法将最近没有被使用的图片转入软引用缓存
34. mSoftCache.put(key, new SoftReference<Bitmap>(oldValue));
35. }
36. }
37. };
38. /*
39. * 第一个参数：初始容量（默认16）
40. * 第二个参数：加载因子（默认0.75）
41. * 第三个参数：排序模式（true：按访问次数排序；false：按插入顺序排序）
42. */
43. mSoftCache = new LinkedHashMap<String, SoftReference<Bitmap>>(INITIAL_CAPACITY, LOAD_FACTOR, ACCESS_ORDER) {
44. private static final long serialVersionUID = 7237325113220820312L;
45. @Override
46. protected boolean removeEldestEntry(Entry<String, SoftReference<Bitmap>> eldest) {
47. if(size() > SOFT_CACHE_SIZE) {
48. return true;
49. }
50. return false;
51. }
52. };
53. }
54. /**
55. * 从缓存中获取Bitmap
56. * @param url
57. * @return bitmap
58. */
59. public Bitmap getBitmapFromMem(String url) {
60. Bitmap bitmap = null;
61. // 先从硬引用缓存中获取
62. synchronized (mLruCache) {
63. bitmap = mLruCache.get(url);
64. if(bitmap != null) {
65. // 找到该Bitmap之后，将其移到LinkedHashMap的最前面，保证它在LRU算法中将被最后删除。
66. mLruCache.remove(url);
67. mLruCache.put(url, bitmap);
68. return bitmap;
69. }
70. }
71. // 再从软引用缓存中获取
72. synchronized (mSoftCache) {
73. SoftReference<Bitmap> bitmapReference = mSoftCache.get(url);
74. if(bitmapReference != null) {
75. bitmap = bitmapReference.get();
76. if(bitmap != null) {
77. // 找到该Bitmap之后，将它移到硬引用缓存。并从软引用缓存中删除。
78. mLruCache.put(url, bitmap);
79. mSoftCache.remove(url);
80. return bitmap;
81. } else {
82. mSoftCache.remove(url);
83. }
84. }
85. }
86. return null;
87. }
88. /**
89. * 添加Bitmap到内存缓存
90. * @param url
91. * @param bitmap
92. */
93. public void addBitmapToCache(String url, Bitmap bitmap) {
94. if(bitmap != null) {
95. synchronized (mLruCache) {
96. mLruCache.put(url, bitmap);
97. }
98. }
99. }
100. /**
101. * 清理软引用缓存
102. */
103. public void clearCache() {
104. mSoftCache.clear();
105. mSoftCache = null;
106. }
107. }

补充一点，由于4.0平台以后对SoftReference类引用的对象调整了回收策略，所以该类中的软引用缓存实际上没什么效果，可以去掉。2.3以前平台建议保留。 
三、磁盘缓存类（PanoDiskCache）

[java] view plain copy print ?

1. public class PanoDiskCache {
2. private static final String TAG = "PanoDiskCache";
3. // 文件缓存目录
4. private static final String CACHE_DIR = "panoCache";
5. private static final String CACHE_FILE_SUFFIX = ".cache";
6. private static final int MB = 1024 * 1024;
7. private static final int CACHE_SIZE = 10; // 10M
8. private static final int SDCARD_CACHE_THRESHOLD = 10;
9. public PanoDiskCache() {
10. // 清理文件缓存
11. removeCache(getDiskCacheDir());
12. }
13. /**
14. * 从磁盘缓存中获取Bitmap
15. * @param url
16. * @return
17. */
18. public Bitmap getBitmapFromDisk(String url) {
19. String path = getDiskCacheDir() + File.separator + genCacheFileName(url);
20. File file = new File(path);
21. if(file.exists()) {
22. Bitmap bitmap = BitmapFactory.decodeFile(path);
23. if(bitmap == null) {
24. file.delete();
25. } else {
26. updateLastModified(path);
27. return bitmap;
28. }
29. }
30. return null;
31. }
32. /**
33. * 将Bitmap写入文件缓存
34. * @param bitmap
35. * @param url
36. */
37. public void addBitmapToCache(Bitmap bitmap, String url) {
38. if(bitmap == null) {
39. return;
40. }
41. // 判断当前SDCard上的剩余空间是否足够用于文件缓存
42. if(SDCARD_CACHE_THRESHOLD > calculateFreeSpaceOnSd()) {
43. return;
44. }
45. String fileName = genCacheFileName(url);
46. String dir = getDiskCacheDir();
47. File dirFile = new File(dir);
48. if(!dirFile.exists()) {
49. dirFile.mkdirs();
50. }
51. File file = new File(dir + File.separator + fileName);
52. try {
53. file.createNewFile();
54. FileOutputStream out = new FileOutputStream(file);
55. bitmap.compress(Bitmap.CompressFormat.JPEG, 100, out);
56. out.flush();
57. out.close();
58. } catch (FileNotFoundException e) {
59. Log.e(TAG, "FileNotFoundException");
60. } catch (IOException e) {
61. Log.e(TAG, "IOException");
62. }
63. }
64. /**
65. * 清理文件缓存
66. * 当缓存文件总容量超过CACHE_SIZE或SDCard的剩余空间小于SDCARD_CACHE_THRESHOLD时，将删除40%最近没有被使用的文件
67. * @param dirPath
68. * @return
69. */
70. private boolean removeCache(String dirPath) {
71. File dir = new File(dirPath);
72. File[] files = dir.listFiles();
73. if(files == null || files.length == 0) {
74. return true;
75. }
76. if(!Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
77. return false;
78. }
79. int dirSize = 0;
80. for (int i = 0; i < files.length; i++) {
81. if(files[i].getName().contains(CACHE_FILE_SUFFIX)) {
82. dirSize += files[i].length();
83. }
84. }
85. if(dirSize > CACHE_SIZE * MB || SDCARD_CACHE_THRESHOLD > calculateFreeSpaceOnSd()) {
86. int removeFactor = (int) (0.4 * files.length + 1);
87. Arrays.sort(files, new FileLastModifiedSort());
88. for (int i = 0; i < removeFactor; i++) {
89. if(files[i].getName().contains(CACHE_FILE_SUFFIX)) {
90. files[i].delete();
91. }
92. }
93. }
94. if(calculateFreeSpaceOnSd() <= SDCARD_CACHE_THRESHOLD) {
95. return false;
96. }
97. return true;
98. }
99. /**
100. * 更新文件的最后修改时间
101. * @param path
102. */
103. private void updateLastModified(String path) {
104. File file = new File(path);
105. long time = System.currentTimeMillis();
106. file.setLastModified(time);
107. }
108. /**
109. * 计算SDCard上的剩余空间
110. * @return
111. */
112. private int calculateFreeSpaceOnSd() {
113. StatFs stat = new StatFs(Environment.getExternalStorageDirectory().getPath());
114. double sdFreeMB = ((double) stat.getAvailableBlocks() * (double) stat.getBlockSize()) / MB;
115. return (int) sdFreeMB;
116. }
117. /**
118. * 生成统一的磁盘文件后缀便于维护
119. * 从URL中得到源文件名称，并为它追加缓存后缀名.cache
120. * @param url
121. * @return 文件存储后的名称
122. */
123. private String genCacheFileName(String url) {
124. String[] strs = url.split(File.separator);
125. return strs[strs.length - 1] + CACHE_FILE_SUFFIX;
126. }
127. /**
128. * 获取磁盘缓存目录
129. * @return
130. */
131. private String getDiskCacheDir() {
132. return getSDPath() + File.separator + CACHE_DIR;
133. }
134. /**
135. * 获取SDCard目录
136. * @return
137. */
138. private String getSDPath() {
139. File sdDir = null;
140. // 判断SDCard是否存在
141. boolean sdCardExist = Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);
142. if(sdCardExist) {
143. // 获取SDCard根目录
144. sdDir = Environment.getExternalStorageDirectory();
145. }
146. if(sdDir != null) {
147. return sdDir.toString();
148. } else {
149. return "";
150. }
151. }
152. /**
153. * 根据文件最后修改时间进行排序
154. */
155. private class FileLastModifiedSort implements Comparator<File> {
156. @Override
157. public int compare(File lhs, File rhs) {
158. if(lhs.lastModified() > rhs.lastModified()) {
159. return 1;
160. } else if(lhs.lastModified() == rhs.lastModified()) {
161. return 0;
162. } else {
163. return -1;
164. }
165. }
166. }
167. }

四、图片工具类（PanoUtils） 
1.从网络上获取图片：downloadBitmap()

[java] view plain copy print ?

1. /**
2. * 从网络上获取Bitmap，并进行适屏和分辨率处理。
3. * @param context
4. * @param url
5. * @return
6. */
7. public static Bitmap downloadBitmap(Context context, String url) {
8. HttpClient client = new DefaultHttpClient();
9. HttpGet request = new HttpGet(url);
10. try {
11. HttpResponse response = client.execute(request);
12. int statusCode = response.getStatusLine().getStatusCode();
13. if(statusCode != HttpStatus.SC_OK) {
14. Log.e(TAG, "Error " + statusCode + " while retrieving bitmap from " + url);
15. return null;
16. }
17. HttpEntity entity = response.getEntity();
18. if(entity != null) {
19. InputStream in = null;
20. try {
21. in = entity.getContent();
22. return scaleBitmap(context, readInputStream(in));
23. } finally {
24. if(in != null) {
25. in.close();
26. in = null;
27. }
28. entity.consumeContent();
29. }
30. }
31. } catch (IOException e) {
32. request.abort();
33. Log.e(TAG, "I/O error while retrieving bitmap from " + url, e);
34. } catch (IllegalStateException e) {
35. request.abort();
36. Log.e(TAG, "Incorrect URL: " + url);
37. } catch (Exception e) {
38. request.abort();
39. Log.e(TAG, "Error while retrieving bitmap from " + url, e);
40. } finally {
41. client.getConnectionManager().shutdown();
42. }
43. return null;
44. }

2.从输入流读取字节数组，看起来是不是很眼熟啊！

[java] view plain copy print ?

1. public static byte[] readInputStream(InputStream in) throws Exception {
2. ByteArrayOutputStream out = new ByteArrayOutputStream();
3. byte[] buffer = new byte[1024];
4. int len = 0;
5. while((len = in.read(buffer)) != -1) {
6. out.write(buffer, 0, len);
7. }
8. in.close();
9. return out.toByteArray();
10. }

3.对下载的源图片进行适屏处理，这也是必须的：）

[java] view plain copy print ?

1. /**
2. * 按使用设备屏幕和纹理尺寸适配Bitmap
3. * @param context
4. * @param in
5. * @return
6. */
7. private static Bitmap scaleBitmap(Context context, byte[] data) {
8. WindowManager windowMgr = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
9. DisplayMetrics outMetrics = new DisplayMetrics();
10. windowMgr.getDefaultDisplay().getMetrics(outMetrics);
11. int scrWidth = outMetrics.widthPixels;
12. int scrHeight = outMetrics.heightPixels;
13. BitmapFactory.Options options = new BitmapFactory.Options();
14. options.inJustDecodeBounds = true;
15. Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0, data.length, options);
16. int imgWidth = options.outWidth;
17. int imgHeight = options.outHeight;
18. if(imgWidth > scrWidth || imgHeight > scrHeight) {
19. options.inSampleSize = calculateInSampleSize(options, scrWidth, scrHeight);
20. }
21. options.inJustDecodeBounds = false;
22. bitmap = BitmapFactory.decodeByteArray(data, 0, data.length, options);
23. // 根据业务的需要，在此处还可以进一步做处理
24. ...
25. return bitmap;
26. }
27. /**
28. * 计算Bitmap抽样倍数
29. * @param options
30. * @param reqWidth
31. * @param reqHeight
32. * @return
33. */
34. public static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
35. // 原始图片宽高
36. final int height = options.outHeight;
37. final int width = options.outWidth;
38. int inSampleSize = 1;
39. if (height > reqHeight || width > reqWidth) {
40. // 计算目标宽高与原始宽高的比值
41. final int heightRatio = Math.round((float) height / (float) reqHeight);
42. final int widthRatio = Math.round((float) width / (float) reqWidth);
43. // 选择两个比值中较小的作为inSampleSize的值
44. inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
45. if(inSampleSize < 1) {
46. inSampleSize = 1;
47. }
48. }
49. return inSampleSize;
50. }

五、使用decodeByteArray()还是decodeStream()？ 
        讲到这里，有童鞋可能会问我为什么使用BitmapFactory.decodeByteArray(data, 0, data.length, opts)来创建Bitmap，而非使用BitmapFactory.decodeStream(is, null, opts)。你这样做不是要多写一个静态方法readInputStream()吗？ 
        没错，decodeStream()确实是该使用情景下的首选方法，但是在有些情形下，它会导致图片资源不能即时获取，或者说图片被它偷偷地缓存起来，交 还给我们的时间有点长。但是延迟性是致命的，我们等不起。所以在这里选用decodeByteArray()获取，它直接从字节数组中获取，贴近于底层 IO、脱离平台限制、使用起来风险更小。 
六、引入缓存机制后获取图片的方法

[java] view plain copy print ?

1. /**
2. * 加载Bitmap
3. * @param url
4. * @return
5. */
6. private Bitmap loadBitmap(String url) {
7. // 从内存缓存中获取，推荐在主UI线程中进行
8. Bitmap bitmap = memCache.getBitmapFromMem(url);
9. if(bitmap == null) {
10. // 从文件缓存中获取，推荐在工作线程中进行
11. bitmap = diskCache.getBitmapFromDisk(url);
12. if(bitmap == null) {
13. // 从网络上获取，不用推荐了吧，地球人都知道~_~
14. bitmap = PanoUtils.downloadBitmap(this, url);
15. if(bitmap != null) {
16. diskCache.addBitmapToCache(bitmap, url);
17. memCache.addBitmapToCache(url, bitmap);
18. }
19. } else {
20. memCache.addBitmapToCache(url, bitmap);
21. }
22. }
23. return bitmap;
24. }

七、工作线程池化 
        有关多线程的切换问题以及在UI线程中执行loadBitmap()方法无效的问题，请参见另一篇博文： 使用严苛模式打破Android4.0以上平台应用中UI主线程的“独断专行”。 
有关工作线程的处理方式，这里推荐使用定制线程池的方式，核心代码如下：

[java] view plain copy print ?

1. // 线程池初始容量
2. private static final int POOL_SIZE = 4;
3. private ExecutorService executorService;
4. @Override
5. public void onCreate(Bundle savedInstanceState) {
6. super.onCreate(savedInstanceState);
7. // 获取当前使用设备的CPU个数
8. int cpuNums = Runtime.getRuntime().availableProcessors();
9. // 预开启线程池数目
10. executorService = Executors.newFixedThreadPool(cpuNums * POOL_SIZE);
11. ...
12. executorService.submit(new Runnable() {
13. // 此处执行一些耗时工作，不要涉及UI工作。如果遇到，直接转交UI主线程
14. pano.setImage(loadBitmap(url));
15. });
16. ...
17. }

我们知道，线程构造也是比较耗资源的。一定要对其进行有效的管理和维护。千万不要随意而行，一张图片的工作线程不搭理也许没什么，当使用场景变为 ListView和GridView时，线程池化工作就显得尤为重要了。Android不是提供了AsyncTask吗？为什么不用它？其实 AsyncTask底层也是靠线程池支持的，它默认分配的线程数是128，是远大于我们定制的executorService。