Android中图片的三级cache策略（内存、文件、网络）

灰太狼 2022-09-20 11:20 141阅读 0赞

http://blog.csdn.net/cuijinquan/article/details/17688615

http://blog.csdn.net/cuijinquan/article/details/17688393

http://blog.csdn.net/cuijinquan/article/details/17688297

**[android中图片的三级cache策略（内存、文件、网络） ][android_cache_]**

**1. 简介**

现在android应用中不可避免的要使用图片，有些图片是可以变化的，需要每次启动时从网络拉取，这种场景在有广告位的应用以及纯图片应用（比如百度美拍）中比较多。

现在有一个问题：假如每次启动的时候都从网络拉取图片的话，势必会消耗很多流量。在当前的状况下，对于非wifi用户来说，流量还是很贵的，一个很耗流量的应用，其用户数量级肯定要受到影响。当然，我想，向百度美拍这样的应用，必然也有其内部的图片缓存策略。总之，图片缓存是很重要而且是必须的。

**2.图片缓存的原理**

实现图片缓存也不难，需要有相应的cache策略。这里我采用 内存-文件-网络 三层cache机制，其中内存缓存包括强引用缓存和软引用缓存（SoftReference），其实网络不算cache，这里姑且也把它划到缓存的层次结构中。当根据url向网络拉取图片的时候，先从内存中找，如果内存中没有，再从缓存文件中查找，如果缓存文件中也没有，再从网络上通过http请求拉取图片。在键值对（key-value）中，这个图片缓存的key是图片url的hash值，value就是bitmap。所以，按照这个逻辑，只要一个url被下载过，其图片就被缓存起来了。

关于Java中对象的软引用（SoftReference），如果一个对象具有软引用，内存空间足够，垃 圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高 速缓存。使用软引用能防止内存泄露，增强程序的健壮性。

从代码上来说，采用一个ImageManager来负责图片的管理和缓存，函数接口为public void loadBitmap(String url, Handler handler) ；其中url为要下载的图片地址，handler为图片下载成功后的回调，在handler中处理message，而message中包含了图片的信息以及bitmap对象。ImageManager中使用的ImageMemoryCache（内存缓存）、ImageFileCache（文件缓存）以及LruCache（最近最久未使用缓存）会在后续文章中介绍。

**3.代码ImageManager.java**

**\[java\]** [view plain][] [copy][view plain]

1. /\*
2. \* 图片管理
3. \* 异步获取图片，直接调用loadImage()函数，该函数自己判断是从缓存还是网络加载
4. \* 同步获取图片，直接调用getBitmap()函数，该函数自己判断是从缓存还是网络加载
5. \* 仅从本地获取图片，调用getBitmapFromNative()
6. \* 仅从网络加载图片，调用getBitmapFromHttp()
7. \* 
8. \*/
9. 
10. **public****class** ImageManager **implements** IManager 
11. \{ 
12. **private****final****static** String TAG = "ImageManager"; 
13. 
14. **private** ImageMemoryCache imageMemoryCache; //内存缓存
15. 
16. **private** ImageFileCache imageFileCache; //文件缓存
17. 
18. //正在下载的image列表
19. **public****static** HashMap<String, Handler> ongoingTaskMap = **new** HashMap<String, Handler>(); 
20. 
21. //等待下载的image列表
22. **public****static** HashMap<String, Handler> waitingTaskMap = **new** HashMap<String, Handler>(); 
23. 
24. //同时下载图片的线程个数
25. **final****static****int** MAX\_DOWNLOAD\_IMAGE\_THREAD = 4; 
26. 
27. **private****final** Handler downloadStatusHandler = **new** Handler()\{ 
28. **public****void** handleMessage(Message msg) 
29. \{ 
30. startDownloadNext(); 
31. \} 
32. \}; 
33. 
34. **public** ImageManager() 
35. \{ 
36. imageMemoryCache = **new** ImageMemoryCache(); 
37. imageFileCache = **new** ImageFileCache(); 
38. \} 
39. 
40. /\*\*
41. \* 获取图片，多线程的入口
42. \*/
43. **public****void** loadBitmap(String url, Handler handler) 
44. \{ 
45. //先从内存缓存中获取，取到直接加载
46. Bitmap bitmap = getBitmapFromNative(url); 
47. 
48. **if** (bitmap != **null**) 
49. \{ 
50. Logger.d(TAG, "loadBitmap:loaded from native"); 
51. Message msg = Message.obtain(); 
52. Bundle bundle = **new** Bundle(); 
53. bundle.putString("url", url); 
54. msg.obj = bitmap; 
55. msg.setData(bundle); 
56. handler.sendMessage(msg); 
57. \} 
58. **else**
59. \{ 
60. Logger.d(TAG, "loadBitmap:will load by network"); 
61. downloadBmpOnNewThread(url, handler); 
62. \} 
63. \} 
64. 
65. /\*\*
66. \* 新起线程下载图片
67. \*/
68. **private****void** downloadBmpOnNewThread(**final** String url, **final** Handler handler) 
69. \{ 
70. Logger.d(TAG, "ongoingTaskMap'size=" \+ ongoingTaskMap.size()); 
71. 
72. **if** (ongoingTaskMap.size() >= MAX\_DOWNLOAD\_IMAGE\_THREAD) 
73. \{ 
74. **synchronized** (waitingTaskMap) 
75. \{ 
76. waitingTaskMap.put(url, handler); 
77. \} 
78. \} 
79. **else**
80. \{ 
81. **synchronized** (ongoingTaskMap) 
82. \{ 
83. ongoingTaskMap.put(url, handler); 
84. \} 
85. 
86. **new** Thread() 
87. \{ 
88. **public****void** run() 
89. \{ 
90. Bitmap bmp = getBitmapFromHttp(url); 
91. 
92. // 不论下载是否成功，都从下载队列中移除,再由业务逻辑判断是否重新下载
93. // 下载图片使用了httpClientRequest，本身已经带了重连机制
94. **synchronized** (ongoingTaskMap) 
95. \{ 
96. ongoingTaskMap.remove(url); 
97. \} 
98. 
99. **if**(downloadStatusHandler != **null**) 
100. \{ 
101. downloadStatusHandler.sendEmptyMessage(0); 
102. 
103. \} 
104. 
105. Message msg = Message.obtain(); 
106. msg.obj = bmp; 
107. Bundle bundle = **new** Bundle(); 
108. bundle.putString("url", url); 
109. msg.setData(bundle); 
110. 
111. **if**(handler != **null**) 
112. \{ 
113. handler.sendMessage(msg); 
114. \} 
115. 
116. \} 
117. \}.start(); 
118. \} 
119. \} 
120. 
121. 
122. /\*\*
123. \* 依次从内存，缓存文件，网络上加载单个bitmap,不考虑线程的问题
124. \*/
125. **public** Bitmap getBitmap(String url) 
126. \{ 
127. // 从内存缓存中获取图片
128. Bitmap bitmap = imageMemoryCache.getBitmapFromMemory(url); 
129. **if** (bitmap == **null**) 
130. \{ 
131. // 文件缓存中获取
132. bitmap = imageFileCache.getImageFromFile(url); 
133. **if** (bitmap != **null**) 
134. \{ 
135. // 添加到内存缓存
136. imageMemoryCache.addBitmapToMemory(url, bitmap); 
137. \} 
138. **else**
139. \{ 
140. // 从网络获取
141. bitmap = getBitmapFromHttp(url); 
142. \} 
143. \} 
144. **return** bitmap; 
145. \} 
146. 
147. /\*\*
148. \* 从内存或者缓存文件中获取bitmap
149. \*/
150. **public** Bitmap getBitmapFromNative(String url) 
151. \{ 
152. Bitmap bitmap = **null**; 
153. bitmap = imageMemoryCache.getBitmapFromMemory(url); 
154. 
155. **if**(bitmap == **null**) 
156. \{ 
157. bitmap = imageFileCache.getImageFromFile(url); 
158. **if**(bitmap != **null**) 
159. \{ 
160. // 添加到内存缓存
161. imageMemoryCache.addBitmapToMemory(url, bitmap); 
162. \} 
163. \} 
164. **return** bitmap; 
165. \} 
166. 
167. /\*\*
168. \* 通过网络下载图片,与线程无关
169. \*/
170. **public** Bitmap getBitmapFromHttp(String url) 
171. \{ 
172. Bitmap bmp = **null**; 
173. 
174. **try**
175. \{ 
176. **byte**\[\] tmpPicByte = getImageBytes(url); 
177. 
178. **if** (tmpPicByte != **null**) 
179. \{ 
180. bmp = BitmapFactory.decodeByteArray(tmpPicByte, 0, 
181. tmpPicByte.length); 
182. \} 
183. tmpPicByte = **null**; 
184. \} 
185. **catch**(Exception e) 
186. \{ 
187. e.printStackTrace(); 
188. \} 
189. 
190. **if**(bmp != **null**) 
191. \{ 
192. // 添加到文件缓存
193. imageFileCache.saveBitmapToFile(bmp, url); 
194. // 添加到内存缓存
195. imageMemoryCache.addBitmapToMemory(url, bmp); 
196. \} 
197. 
198. **return** bmp; 
199. \} 
200. 
201. /\*\*
202. \* 下载链接的图片资源
203. \* 
204. \* @param url
205. \* 
206. \* @return 图片
207. \*/
208. **public****byte**\[\] getImageBytes(String url) 
209. \{ 
210. **byte**\[\] pic = **null**; 
211. **if** (url != **null** && !"".equals(url)) 
212. \{ 
213. Requester request = RequesterFactory.getRequester( 
214. Requester.REQUEST\_REMOTE, RequesterFactory.IMPL\_HC); 
215. // 执行请求
216. MyResponse myResponse = **null**; 
217. MyRequest mMyRequest; 
218. mMyRequest = **new** MyRequest(); 
219. mMyRequest.setUrl(url); 
220. mMyRequest.addHeader(HttpHeader.REQ.ACCEPT\_ENCODING, "identity"); 
221. InputStream is = **null**; 
222. ByteArrayOutputStream baos = **null**; 
223. **try** \{ 
224. myResponse = request.execute(mMyRequest); 
225. is = myResponse.getInputStream().getImpl(); 
226. baos = **new** ByteArrayOutputStream(); 
227. **byte**\[\] b = **new****byte**\[512\]; 
228. **int** len = 0; 
229. **while** ((len = is.read(b)) != -1) 
230. \{ 
231. baos.write(b, 0, len); 
232. baos.flush(); 
233. \} 
234. pic = baos.toByteArray(); 
235. Logger.d(TAG, "icon bytes.length=" \+ pic.length); 
236. 
237. \} 
238. **catch** (Exception e3) 
239. \{ 
240. e3.printStackTrace(); 
241. **try**
242. \{ 
243. Logger.e(TAG, 
244. "download shortcut icon faild and responsecode="
245. \+ myResponse.getStatusCode()); 
246. \} 
247. **catch** (Exception e4) 
248. \{ 
249. e4.printStackTrace(); 
250. \} 
251. \} 
252. **finally**
253. \{ 
254. **try**
255. \{ 
256. **if** (is != **null**) 
257. \{ 
258. is.close(); 
259. is = **null**; 
260. \} 
261. \} 
262. **catch** (Exception e2) 
263. \{ 
264. e2.printStackTrace(); 
265. \} 
266. **try**
267. \{ 
268. **if** (baos != **null**) 
269. \{ 
270. baos.close(); 
271. baos = **null**; 
272. \} 
273. \} 
274. **catch** (Exception e2) 
275. \{ 
276. e2.printStackTrace(); 
277. \} 
278. **try**
279. \{ 
280. request.close(); 
281. \} 
282. **catch** (Exception e1) 
283. \{ 
284. e1.printStackTrace(); 
285. \} 
286. \} 
287. \} 
288. **return** pic; 
289. \} 
290. 
291. /\*\*
292. \* 取出等待队列第一个任务，开始下载
293. \*/
294. **private****void** startDownloadNext() 
295. \{ 
296. **synchronized**(waitingTaskMap) 
297. \{ 
298. Logger.d(TAG, "begin start next"); 
299. Iterator iter = waitingTaskMap.entrySet().iterator(); 
300. 
301. **while** (iter.hasNext()) 
302. \{ 
303. 
304. Map.Entry entry = (Map.Entry) iter.next(); 
305. Logger.d(TAG, "WaitingTaskMap isn't null,url=" \+ (String)entry.getKey()); 
306. 
307. **if**(entry != **null**) 
308. \{ 
309. waitingTaskMap.remove(entry.getKey()); 
310. downloadBmpOnNewThread((String)entry.getKey(), (Handler)entry.getValue()); 
311. \} 
312. **break**; 
313. \} 
314. \} 
315. \} 
316. 
317. **public** String startDownloadNext\_ForUnitTest() 
318. \{ 
319. String urlString = **null**; 
320. **synchronized**(waitingTaskMap) 
321. \{ 
322. Logger.d(TAG, "begin start next"); 
323. Iterator iter = waitingTaskMap.entrySet().iterator(); 
324. 
325. **while** (iter.hasNext()) 
326. \{ 
327. Map.Entry entry = (Map.Entry) iter.next(); 
328. urlString = (String)entry.getKey(); 
329. waitingTaskMap.remove(entry.getKey()); 
330. **break**; 
331. \} 
332. \} 
333. **return** urlString; 
334. \} 
335. 
336. /\*\*
337. \* 图片变为圆角
338. \* @param bitmap:传入的bitmap
339. \* @param pixels：圆角的度数，值越大，圆角越大
340. \* @return bitmap:加入圆角的bitmap
341. \*/
342. **public****static** Bitmap toRoundCorner(Bitmap bitmap, **int** pixels) 
343. \{ 
344. **if**(bitmap == **null**) 
345. **return****null**; 
346. 
347. Bitmap output = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Config.ARGB\_8888); 
348. Canvas canvas = **new** Canvas(output); 
349. 
350. **final****int** color = 0xff424242; 
351. **final** Paint paint = **new** Paint(); 
352. **final** Rect rect = **new** Rect(0, 0, bitmap.getWidth(), bitmap.getHeight()); 
353. **final** RectF rectF = **new** RectF(rect); 
354. **final****float** roundPx = pixels; 
355. 
356. paint.setAntiAlias(**true**); 
357. canvas.drawARGB(0, 0, 0, 0); 
358. paint.setColor(color); 
359. canvas.drawRoundRect(rectF, roundPx, roundPx, paint); 
360. 
361. paint.setXfermode(**new** PorterDuffXfermode(Mode.SRC\_IN)); 
362. canvas.drawBitmap(bitmap, rect, rect, paint); 
363. 
364. **return** output; 
365. \} 
366. 
367. **public****byte** managerId() 
368. \{ 
369. **return** IMAGE\_ID; 
370. \} 
371. \}

* [android中图片的三级cache策略（内存、文件、网络）之二：内存缓存策略][android_cache] 
 
 * ## 前言 ##
 
 记得很久之前我写了一篇banner的文章，好多朋友找我要代码，并要我开放banner中使用的图片管理工厂-ImageManager。如果想很好地理解下面的故事，请参看我半年前写的两篇博文：[android中图片的三级cache策略（内存、文件、网络） 一][android_cache_ 1] 和 [android中左右滑屏的实现（广告位banner组件）][android_banner]。当时没有发上来是由于如下几点原因：首先代码较多，其次当时写的时候也参考了网络上存在的三级cache策略（大同小异），并且采用了Android项目中开源的LruCache页面淘汰算法（近期最少使用算法），还有一点就是这是实际项目使用的代码，不便直接开放，但是现在我决定把它稍作修改后开放给大家。这里我想说说那个banner，平心而论，banner的代码很多，如果采用ViewPager之类的则可以减少不少代码，但是我更看重banner的实现思想以及它的封装和事件传递，在自定义控件的封装和架构上，我到现在还觉得banner是及其成功的，尤其是banner和ImageManager结合以后，整个功能浑然天成，超高内聚，使用起来及其方便，最少只需要两行代码，你不需要导入xml，也不需要处理Json拉取策略，因为相关业务层都被封装在了banner内部，对外只保留很少的几个接口，只要实现它就能和banner内部进行交互。下面我将要介绍三级cache策略之二：内存缓存策略。
 
 ## 内存缓存策略 ##
 
 当有一个图片要去从网络下载的时候，我们并不会直接去从网络下载，因为在这个时代，用户的流量是宝贵的，耗流量的应用是不会得到用户的青睐的。那我们该怎么办呢？这样，我们会先从内存缓存中去查找是否有该图片，如果没有就去文件缓存中查找是否有该图片，如果还没有，我们就从网络下载图片。本博文的侧重点是如何做内存缓存，内存缓存的查找策略是：先从强引用缓存中查找，如果没有再从软引用缓存中查找，如果在软引用缓存中找到了，就把它移入强引用缓存；如果强引用缓存满了，就会根据Lru算法把某些图片移入软引用缓存，如果软引用缓存也满了，最早的软引用就会被删除。这里，我有必要说明下几个概念：强引用、软引用、弱引用、Lru。
 
 **强引用**：就是直接引用一个对象，一般的对象引用均是强引用
 
 **软引用**：引用一个对象，当内存不足并且除了我们的引用之外没有其他地方引用此对象的情况 下，该对象会被gc回收
 
 **弱引用**：引用一个对象，当除了我们的引用之外没有其他地方引用此对象的情况下，只要gc被调用，它就会被回收（请注意它和软引用的区别）
 
 **Lru**：Least Recently Used 近期最少使用算法，是一种页面置换算法，其思想是在缓存的页面数目固定的情况下，那些最近使用次数最少的页面将被移出，对于我们的内存缓存来说，强引用缓存大小固定为4M，如果当缓存的图片大于4M的时候，有些图片就会被从强引用缓存中删除，哪些图片会被删除呢，就是那些近期使用次数最少的图片。
 
 ## 代码 ##
 
 **\[java\]** [view plain][view plain 1] [copy][view plain 1]
 
 1. **public****class** ImageMemoryCache \{ 
 2. /\*\*
 3. \* 从内存读取数据速度是最快的，为了更大限度使用内存，这里使用了两层缓存。
 4. \* 强引用缓存不会轻易被回收，用来保存常用数据，不常用的转入软引用缓存。
 5. \*/
 6. **private****static****final** String TAG = "ImageMemoryCache"; 
 7. 
 8. **private****static** LruCache<String, Bitmap> mLruCache; // 强引用缓存
 9. 
 10. **private****static** LinkedHashMap<String, SoftReference<Bitmap>> mSoftCache; // 软引用缓存
 11. 
 12. **private****static****final****int** LRU\_CACHE\_SIZE = 4 \* 1024 \* 1024; // 强引用缓存容量：4MB
 13. 
 14. **private****static****final****int** SOFT\_CACHE\_NUM = 20; // 软引用缓存个数
 15. 
 16. // 在这里分别初始化强引用缓存和弱引用缓存
 17. **public** ImageMemoryCache() \{ 
 18. mLruCache = **new** LruCache<String, Bitmap>(LRU\_CACHE\_SIZE) \{ 
 19. @Override
 20. // sizeOf返回为单个hashmap value的大小
 21. **protected****int** sizeOf(String key, Bitmap value) \{ 
 22. **if** (value != **null**) 
 23. **return** value.getRowBytes() \* value.getHeight(); 
 24. **else**
 25. **return**0; 
 26. \} 
 27. 
 28. @Override
 29. **protected****void** entryRemoved(**boolean** evicted, String key, 
 30. Bitmap oldValue, Bitmap newValue) \{ 
 31. **if** (oldValue != **null**) \{ 
 32. // 强引用缓存容量满的时候，会根据LRU算法把最近没有被使用的图片转入此软引用缓存
 33. Logger.d(TAG, "LruCache is full,move to SoftRefernceCache"); 
 34. mSoftCache.put(key, **new** SoftReference<Bitmap>(oldValue)); 
 35. \} 
 36. \} 
 37. \}; 
 38. 
 39. mSoftCache = **new** LinkedHashMap<String, SoftReference<Bitmap>>( 
 40. SOFT\_CACHE\_NUM, 0.75f, **true**) \{ 
 41. **private****static****final****long** serialVersionUID = 1L; 
 42. 
 43. /\*\*
 44. \* 当软引用数量大于20的时候，最旧的软引用将会被从链式哈希表中移出
 45. \*/
 46. @Override
 47. **protected****boolean** removeEldestEntry( 
 48. Entry<String, SoftReference<Bitmap>> eldest) \{ 
 49. **if** (size() > SOFT\_CACHE\_NUM) \{ 
 50. Logger.d(TAG, "should remove the eldest from SoftReference"); 
 51. **return****true**; 
 52. \} 
 53. **return****false**; 
 54. \} 
 55. \}; 
 56. \} 
 57. 
 58. /\*\*
 59. \* 从缓存中获取图片
 60. \*/
 61. **public** Bitmap getBitmapFromMemory(String url) \{ 
 62. Bitmap bitmap; 
 63. 
 64. // 先从强引用缓存中获取
 65. **synchronized** (mLruCache) \{ 
 66. bitmap = mLruCache.get(url); 
 67. **if** (bitmap != **null**) \{ 
 68. // 如果找到的话，把元素移到LinkedHashMap的最前面，从而保证在LRU算法中是最后被删除
 69. mLruCache.remove(url); 
 70. mLruCache.put(url, bitmap); 
 71. Logger.d(TAG, "get bmp from LruCache,url=" \+ url); 
 72. **return** bitmap; 
 73. \} 
 74. \} 
 75. 
 76. // 如果强引用缓存中找不到，到软引用缓存中找，找到后就把它从软引用中移到强引用缓存中
 77. **synchronized** (mSoftCache) \{ 
 78. SoftReference<Bitmap> bitmapReference = mSoftCache.get(url); 
 79. **if** (bitmapReference != **null**) \{ 
 80. bitmap = bitmapReference.get(); 
 81. **if** (bitmap != **null**) \{ 
 82. // 将图片移回LruCache
 83. mLruCache.put(url, bitmap); 
 84. mSoftCache.remove(url); 
 85. Logger.d(TAG, "get bmp from SoftReferenceCache, url=" \+ url); 
 86. **return** bitmap; 
 87. \} **else** \{ 
 88. mSoftCache.remove(url); 
 89. \} 
 90. \} 
 91. \} 
 92. **return****null**; 
 93. \} 
 94. 
 95. /\*\*
 96. \* 添加图片到缓存
 97. \*/
 98. **public****void** addBitmapToMemory(String url, Bitmap bitmap) \{ 
 99. **if** (bitmap != **null**) \{ 
 100. **synchronized** (mLruCache) \{ 
 101. mLruCache.put(url, bitmap); 
 102. \} 
 103. \} 
 104. \} 
 105. 
 106. **public****void** clearCache() \{ 
 107. mSoftCache.clear(); 
 108. \} 
 109. \} 
 
 另外，给出LruCache供大家参考：
 
 **\[java\]** [view plain][view plain 1] [copy][view plain 1]
 
 1. /\*
 2. \* Copyright (C) 2011 The Android Open Source Project
 3. \*
 4. \* Licensed under the Apache License, Version 2.0 (the "License");
 5. \* you may not use this file except in compliance with the License.
 6. \* You may obtain a copy of the License at
 7. \*
 8. \* http://www.apache.org/licenses/LICENSE-2.0
 9. \*
 10. \* Unless required by applicable law or agreed to in writing, software
 11. \* distributed under the License is distributed on an "AS IS" BASIS,
 12. \* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13. \* See the License for the specific language governing permissions and
 14. \* limitations under the License.
 15. \*/
 16. 
 17. /\*\*
 18. \* Cache保存一个强引用来限制内容数量，每当Item被访问的时候，此Item就会移动到队列的头部。
 19. \* 当cache已满的时候加入新的item时，在队列尾部的item会被回收。
 20. \* 
 21. \* 如果你cache的某个值需要明确释放，重写entryRemoved()
 22. \* 
 23. \* 如果key相对应的item丢掉啦，重写create().这简化了调用代码，即使丢失了也总会返回。
 24. \* 
 25. \* 默认cache大小是测量的item的数量，重写sizeof计算不同item的大小。
 26. \* 
 27. \* <pre> \{@code
 28. \* int cacheSize = 4 \* 1024 \* 1024; // 4MiB
 29. \* LruCache<String, Bitmap> bitmapCache = new LruCache<String, Bitmap>(cacheSize) \{ 
 30. \* protected int sizeOf(String key, Bitmap value) \{ 
 31. \* return value.getByteCount();
 32. \* \}
 33. \* \}\}</pre>
 34. \*
 35. \* This class is thread-safe. Perform multiple cache operations atomically by
 36. \* synchronizing on the cache: <pre> \{@code
 37. \* synchronized (cache) \{ 
 38. \* if (cache.get(key) == null) \{ 
 39. \* cache.put(key, value);
 40. \* \}
 41. \* \}\}</pre>
 42. \*
 43. \* 不允许key或者value为null
 44. \* 当get（），put（），remove（）返回值为null时，key相应的项不在cache中
 45. \*/
 46. **public****class** LruCache<K, V> \{ 
 47. **private****final** LinkedHashMap<K, V> map; 
 48. 
 49. /\*\* Size of this cache in units. Not necessarily the number of elements. \*/
 50. **private****int** size;//已经存储的大小
 51. **private****int** maxSize;//规定的最大存储空间
 52. 
 53. **private****int** putCount;//put的次数
 54. **private****int** createCount;//create的次数
 55. **private****int** evictionCount; //回收的次数
 56. **private****int** hitCount;//命中的次数
 57. **private****int** missCount;//丢失的次数
 58. 
 59. /\*\*
 60. \* @param maxSize for caches that do not override \{@link \#sizeOf\}, this is
 61. \* the maximum number of entries in the cache. For all other caches,
 62. \* this is the maximum sum of the sizes of the entries in this cache.
 63. \*/
 64. **public** LruCache(**int** maxSize) \{ 
 65. **if** (maxSize <= 0) \{ 
 66. **throw****new** IllegalArgumentException("maxSize <= 0"); 
 67. \} 
 68. **this**.maxSize = maxSize; 
 69. **this**.map = **new** LinkedHashMap<K, V>(0, 0.75f, **true**); 
 70. \} 
 71. 
 72. /\*\*
 73. \*通过key返回相应的item，或者创建返回相应的item。相应的item会移动到队列的头部，
 74. \* 如果item的value没有被cache或者不能被创建，则返回null。
 75. \*/
 76. **public****final** V get(K key) \{ 
 77. **if** (key == **null**) \{ 
 78. **throw****new** NullPointerException("key == null"); 
 79. \} 
 80. 
 81. V mapValue; 
 82. **synchronized** (**this**) \{ 
 83. mapValue = map.get(key); 
 84. **if** (mapValue != **null**) \{ 
 85. hitCount++; 
 86. **return** mapValue; 
 87. \} 
 88. missCount++; 
 89. \} 
 90. 
 91. /\*
 92. \* Attempt to create a value. This may take a long time, and the map
 93. \* may be different when create() returns. If a conflicting value was
 94. \* added to the map while create() was working, we leave that value in
 95. \* the map and release the created value.
 96. \*/
 97. 
 98. V createdValue = create(key); 
 99. **if** (createdValue == **null**) \{ 
 100. **return****null**; 
 101. \} 
 102. 
 103. **synchronized** (**this**) \{ 
 104. createCount++; 
 105. mapValue = map.put(key, createdValue); 
 106. 
 107. **if** (mapValue != **null**) \{ 
 108. // There was a conflict so undo that last put
 109. map.put(key, mapValue); 
 110. \} **else** \{ 
 111. size += safeSizeOf(key, createdValue); 
 112. \} 
 113. \} 
 114. 
 115. **if** (mapValue != **null**) \{ 
 116. entryRemoved(**false**, key, createdValue, mapValue); 
 117. **return** mapValue; 
 118. \} **else** \{ 
 119. trimToSize(maxSize); 
 120. **return** createdValue; 
 121. \} 
 122. \} 
 123. 
 124. /\*\*
 125. \* Caches \{@code value\} for \{@code key\}. The value is moved to the head of
 126. \* the queue.
 127. \*
 128. \* @return the previous value mapped by \{@code key\}.
 129. \*/
 130. **public****final** V put(K key, V value) \{ 
 131. **if** (key == **null** || value == **null**) \{ 
 132. **throw****new** NullPointerException("key == null || value == null"); 
 133. \} 
 134. 
 135. V previous; 
 136. **synchronized** (**this**) \{ 
 137. putCount++; 
 138. size += safeSizeOf(key, value); 
 139. previous = map.put(key, value); 
 140. **if** (previous != **null**) \{ 
 141. size -= safeSizeOf(key, previous); 
 142. \} 
 143. \} 
 144. 
 145. **if** (previous != **null**) \{ 
 146. entryRemoved(**false**, key, previous, value); 
 147. \} 
 148. 
 149. trimToSize(maxSize); 
 150. **return** previous; 
 151. \} 
 152. 
 153. /\*\*
 154. \* @param maxSize the maximum size of the cache before returning. May be -1
 155. \* to evict even 0-sized elements.
 156. \*/
 157. **private****void** trimToSize(**int** maxSize) \{ 
 158. **while** (**true**) \{ 
 159. K key; 
 160. V value; 
 161. **synchronized** (**this**) \{ 
 162. **if** (size < 0 || (map.isEmpty() && size != 0)) \{ 
 163. **throw****new** IllegalStateException(getClass().getName() 
 164. \+ ".sizeOf() is reporting inconsistent results!"); 
 165. \} 
 166. 
 167. **if** (size <= maxSize) \{ 
 168. **break**; 
 169. \} 
 170. 
 171. /\*
 172. \* Map.Entry<K, V> toEvict = map.eldest(); 
 173. \*/
 174. //modify by echy
 175. 
 176. Iterator<Entry<K, V>> iter = map.entrySet().iterator(); 
 177. Map.Entry<K, V> toEvict = **null**; 
 178. **while** (iter.hasNext()) 
 179. \{ 
 180. 
 181. toEvict = (Entry<K, V>) iter.next(); 
 182. **break**; 
 183. \} 
 184. 
 185. 
 186. **if** (toEvict == **null**) \{ 
 187. **break**; 
 188. \} 
 189. 
 190. key = toEvict.getKey(); 
 191. value = toEvict.getValue(); 
 192. 
 193. 
 194. map.remove(key); 
 195. size -= safeSizeOf(key, value); 
 196. evictionCount++; 
 197. \} 
 198. 
 199. entryRemoved(**true**, key, value, **null**); 
 200. \} 
 201. \} 
 202. 
 203. /\*\*
 204. \* Removes the entry for \{@code key\} if it exists.
 205. \*
 206. \* @return the previous value mapped by \{@code key\}.
 207. \*/
 208. **public****final** V remove(K key) \{ 
 209. **if** (key == **null**) \{ 
 210. **throw****new** NullPointerException("key == null"); 
 211. \} 
 212. 
 213. V previous; 
 214. **synchronized** (**this**) \{ 
 215. previous = map.remove(key); 
 216. **if** (previous != **null**) \{ 
 217. size -= safeSizeOf(key, previous); 
 218. \} 
 219. \} 
 220. 
 221. **if** (previous != **null**) \{ 
 222. entryRemoved(**false**, key, previous, **null**); 
 223. \} 
 224. 
 225. **return** previous; 
 226. \} 
 227. 
 228. /\*\*
 229. \* Called for entries that have been evicted or removed. This method is
 230. \* invoked when a value is evicted to make space, removed by a call to
 231. \* \{@link \#remove\}, or replaced by a call to \{@link \#put\}. The default
 232. \* implementation does nothing.
 233. \*
 234. \* The method is called without synchronization: other threads may
 235. \* access the cache while this method is executing.
 236. \*
 237. \* @param evicted true if the entry is being removed to make space, false
 238. \* if the removal was caused by a \{@link \#put\} or \{@link \#remove\}.
 239. \* @param newValue the new value for \{@code key\}, if it exists. If non-null,
 240. \* this removal was caused by a \{@link \#put\}. Otherwise it was caused by
 241. \* an eviction or a \{@link \#remove\}.
 242. \*/
 243. **protected****void** entryRemoved(**boolean** evicted, K key, V oldValue, V newValue) \{\} 
 244. 
 245. /\*\*
 246. \* Called after a cache miss to compute a value for the corresponding key.
 247. \* Returns the computed value or null if no value can be computed. The
 248. \* default implementation returns null.
 249. \*
 250. \* The method is called without synchronization: other threads may
 251. \* access the cache while this method is executing.
 252. \*
 253. \* If a value for \{@code key\} exists in the cache when this method
 254. \* returns, the created value will be released with \{@link \#entryRemoved\}
 255. \* and discarded. This can occur when multiple threads request the same key
 256. \* at the same time (causing multiple values to be created), or when one
 257. \* thread calls \{@link \#put\} while another is creating a value for the same
 258. \* key.
 259. \*/
 260. **protected** V create(K key) \{ 
 261. **return****null**; 
 262. \} 
 263. 
 264. **private****int** safeSizeOf(K key, V value) \{ 
 265. **int** result = sizeOf(key, value); 
 266. **if** (result < 0) \{ 
 267. **throw****new** IllegalStateException("Negative size: " \+ key + "=" \+ value); 
 268. \} 
 269. **return** result; 
 270. \} 
 271. 
 272. /\*\*
 273. \* Returns the size of the entry for \{@code key\} and \{@code value\} in
 274. \* user-defined units. The default implementation returns 1 so that size
 275. \* is the number of entries and max size is the maximum number of entries.
 276. \*
 277. \* An entry's size must not change while it is in the cache.
 278. \*/
 279. **protected****int** sizeOf(K key, V value) \{ 
 280. **return**1; 
 281. \} 
 282. 
 283. /\*\*
 284. \* Clear the cache, calling \{@link \#entryRemoved\} on each removed entry.
 285. \*/
 286. **public****final****void** evictAll() \{ 
 287. trimToSize(-1); // -1 will evict 0-sized elements
 288. \} 
 289. 
 290. /\*\*
 291. \* For caches that do not override \{@link \#sizeOf\}, this returns the number
 292. \* of entries in the cache. For all other caches, this returns the sum of
 293. \* the sizes of the entries in this cache.
 294. \*/
 295. **public****synchronized****final****int** size() \{ 
 296. **return** size; 
 297. \} 
 298. 
 299. /\*\*
 300. \* For caches that do not override \{@link \#sizeOf\}, this returns the maximum
 301. \* number of entries in the cache. For all other caches, this returns the
 302. \* maximum sum of the sizes of the entries in this cache.
 303. \*/
 304. **public****synchronized****final****int** maxSize() \{ 
 305. **return** maxSize; 
 306. \} 
 307. 
 308. /\*\*
 309. \* Returns the number of times \{@link \#get\} returned a value that was
 310. \* already present in the cache.
 311. \*/
 312. **public****synchronized****final****int** hitCount() \{ 
 313. **return** hitCount; 
 314. \} 
 315. 
 316. /\*\*
 317. \* Returns the number of times \{@link \#get\} returned null or required a new
 318. \* value to be created.
 319. \*/
 320. **public****synchronized****final****int** missCount() \{ 
 321. **return** missCount; 
 322. \} 
 323. 
 324. /\*\*
 325. \* Returns the number of times \{@link \#create(Object)\} returned a value.
 326. \*/
 327. **public****synchronized****final****int** createCount() \{ 
 328. **return** createCount; 
 329. \} 
 330. 
 331. /\*\*
 332. \* Returns the number of times \{@link \#put\} was called.
 333. \*/
 334. **public****synchronized****final****int** putCount() \{ 
 335. **return** putCount; 
 336. \} 
 337. 
 338. /\*\*
 339. \* Returns the number of values that have been evicted.
 340. \*/
 341. **public****synchronized****final****int** evictionCount() \{ 
 342. **return** evictionCount; 
 343. \} 
 344. 
 345. /\*\*
 346. \* Returns a copy of the current contents of the cache, ordered from least
 347. \* recently accessed to most recently accessed.
 348. \*/
 349. **public****synchronized****final** Map<K, V> snapshot() \{ 
 350. **return****new** LinkedHashMap<K, V>(map); 
 351. \} 
 352. 
 353. @Override**public****synchronized****final** String toString() \{ 
 354. **int** accesses = hitCount + missCount; 
 355. **int** hitPercent = accesses != 0 ? (100 \* hitCount / accesses) : 0; 
 356. **return** String.format("LruCache\[maxSize=%d,hits=%d,misses=%d,hitRate=%d%%\]", 
 357. maxSize, hitCount, missCount, hitPercent); 
 358. \} 
 359. \} 
 
 [android中图片的三级cache策略（内存、文件、网络）之三：文件缓存策略][android_cache 1] 
 
 * ## 前言 ##
 
 如果想很好地理解下面的故事，请参看我半年前写的两篇博文：[android中图片的三级cache策略（内存、文件、网络） 一][android_cache_ 1] 和 [android中左右滑屏的实现（广告位banner组件）][android_banner]，还有昨天晚上写的[android中图片的三级cache策略（内存、文件、网络）之二：内存缓存策略][android_cache 2]。
 
 ## 文件缓存策略 ##
 
 当一张图片从网络下载成功以后，这个图片会被加入内存缓存和文件缓存，对于文件缓存来说，这张图片将被以url的哈希值加cach后缀名的形式存储在SD卡上，这样，当下一次再需要同一个url的图片的时候，就不需要从网络下载了，而是直接通过url来进行查找。同时一张图片被访问时，它的最后修改时间将被更新，这样的意义在于：当SD卡空间不足的时候，将会按照最后修改时间来删除40%缓存的图片，确切来说，那些修改时间比较早的图片将会被删除。 
 
 
 ## 代码展示 ##
 
 **\[java\]** [view plain][view plain 2] [copy][view plain 2] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
 
 1. **public****class** ImageFileCache 
 2. \{ 
 3. **private****static****final** String TAG = "ImageFileCache"; 
 4. 
 5. //图片缓存目录
 6. **private****static****final** String IMGCACHDIR = "/sdcard/ImgCach"; 
 7. 
 8. //保存的cache文件宽展名
 9. **private****static****final** String CACHETAIL = ".cach"; 
 10. 
 11. **private****static****final****int** MB = 1024\*1024; 
 12. 
 13. **private****static****final****int** CACHE\_SIZE = 1; 
 14. 
 15. //当SD卡剩余空间小于10M的时候会清理缓存
 16. **private****static****final****int** FREE\_SD\_SPACE\_NEEDED\_TO\_CACHE = 10; 
 17. 
 18. **public** ImageFileCache() 
 19. \{ 
 20. //清理部分文件缓存
 21. removeCache(IMGCACHDIR); 
 22. \} 
 23. 
 24. /\*\* 
 25. \* 从缓存中获取图片 
 26. \*/
 27. **public** Bitmap getImageFromFile(**final** String url) 
 28. \{ 
 29. **final** String path = IMGCACHDIR + "/" \+ convertUrlToFileName(url); 
 30. File file = **new** File(path); 
 31. **if** (file != **null** && file.exists()) 
 32. \{ 
 33. Bitmap bmp = BitmapFactory.decodeFile(path); 
 34. **if** (bmp == **null**) 
 35. \{ 
 36. file.delete(); 
 37. \} 
 38. **else**
 39. \{ 
 40. updateFileTime(path); 
 41. Logger.d(TAG, "get bmp from FileCache,url=" \+ url); 
 42. **return** bmp; 
 43. \} 
 44. \} 
 45. **return****null**; 
 46. \} 
 47. 
 48. /\*\*
 49. \* 将图片存入文件缓存 
 50. \*/
 51. **public****void** saveBitmapToFile(Bitmap bm, String url) 
 52. \{ 
 53. **if** (bm == **null**) \{ 
 54. **return**; 
 55. \} 
 56. //判断sdcard上的空间
 57. **if** (FREE\_SD\_SPACE\_NEEDED\_TO\_CACHE > SdCardFreeSpace()) 
 58. \{ 
 59. //SD空间不足
 60. **return**; 
 61. \} 
 62. 
 63. String filename = convertUrlToFileName(url); 
 64. File dirFile = **new** File(IMGCACHDIR); 
 65. **if** (!dirFile.exists()) 
 66. dirFile.mkdirs(); 
 67. File file = **new** File(IMGCACHDIR +"/" \+ filename); 
 68. **try**
 69. \{ 
 70. file.createNewFile(); 
 71. OutputStream outStream = **new** FileOutputStream(file); 
 72. bm.compress(Bitmap.CompressFormat.JPEG, 100, outStream); 
 73. outStream.flush(); 
 74. outStream.close(); 
 75. \} 
 76. **catch** (FileNotFoundException e) 
 77. \{ 
 78. Logger.d(TAG, "FileNotFoundException"); 
 79. \} 
 80. **catch** (IOException e) 
 81. \{ 
 82. Logger.d(TAG, "IOException"); 
 83. \} 
 84. \} 
 85. 
 86. /\*\*
 87. \* 计算存储目录下的文件大小，
 88. \* 当文件总大小大于规定的CACHE\_SIZE或者sdcard剩余空间小于FREE\_SD\_SPACE\_NEEDED\_TO\_CACHE的规定
 89. \* 那么删除40%最近没有被使用的文件
 90. \*/
 91. **private****boolean** removeCache(String dirPath) 
 92. \{ 
 93. File dir = **new** File(dirPath); 
 94. File\[\] files = dir.listFiles(); 
 95. 
 96. **if** (files == **null**) 
 97. \{ 
 98. **return****true**; 
 99. \} 
 100. 
 101. **if** (!android.os.Environment.getExternalStorageState().equals(android.os.Environment.MEDIA\_MOUNTED)) 
 102. \{ 
 103. **return****false**; 
 104. \} 
 105. 
 106. **int** dirSize = 0; 
 107. **for** (**int** i = 0; i < files.length; i++) 
 108. \{ 
 109. **if** (files\[i\].getName().contains(CACHETAIL)) 
 110. \{ 
 111. dirSize += files\[i\].length(); 
 112. \} 
 113. \} 
 114. 
 115. **if** (dirSize > CACHE\_SIZE \* MB || FREE\_SD\_SPACE\_NEEDED\_TO\_CACHE > SdCardFreeSpace()) 
 116. \{ 
 117. **int** removeFactor = (**int**) (0.4 \* files.length); 
 118. Arrays.sort(files, **new** FileLastModifSort()); 
 119. **for** (**int** i = 0; i < removeFactor; i++) 
 120. \{ 
 121. **if** (files\[i\].getName().contains(CACHETAIL)) 
 122. \{ 
 123. files\[i\].delete(); 
 124. \} 
 125. \} 
 126. \} 
 127. 
 128. **if** (SdCardFreeSpace() <= CACHE\_SIZE) 
 129. \{ 
 130. **return****false**; 
 131. \} 
 132. 
 133. **return****true**; 
 134. \} 
 135. 
 136. /\*\*
 137. \* 修改文件的最后修改时间
 138. \*/
 139. **public****void** updateFileTime(String path) 
 140. \{ 
 141. File file = **new** File(path); 
 142. **long** newModifiedTime = System.currentTimeMillis(); 
 143. file.setLastModified(newModifiedTime); 
 144. \} 
 145. 
 146. /\*\* 
 147. \* 计算SD卡上的剩余空间 
 148. \*/
 149. **private****int** SdCardFreeSpace() 
 150. \{ 
 151. StatFs stat = **new** StatFs(Environment.getExternalStorageDirectory().getPath()); 
 152. **double** sdFreeMB = ((**double**)stat.getAvailableBlocks() \* (**double**) stat.getBlockSize()) / MB; 
 153. **return** (**int**) sdFreeMB; 
 154. \} 
 155. 
 156. /\*\* 
 157. \* 将url转成文件名 
 158. \*/
 159. **private** String convertUrlToFileName(String url) 
 160. \{ 
 161. **return** url.hashCode() + CACHETAIL; 
 162. \} 
 163. 
 164. /\*\*
 165. \* 根据文件的最后修改时间进行排序
 166. \*/
 167. **private****class** FileLastModifSort **implements** Comparator<File> 
 168. \{ 
 169. **public****int** compare(File file0, File file1) 
 170. \{ 
 171. **if** (file0.lastModified() > file1.lastModified()) 
 172. \{ 
 173. **return**1; 
 174. \} 
 175. **else****if** (file0.lastModified() == file1.lastModified()) 
 176. \{ 
 177. **return**0; 
 178. \} 
 179. **else**
 180. \{ 
 181. **return** \-1; 
 182. \} 
 183. \} 
 184. \} 
 185. 
 186. \} 
 
 说明：上述代码很好理解而且都有注释，不用多说了。
 
 到这里，整个banner体系的代码都被介绍了，希望代码中的思想能够对大家有所启发，谢谢大家的捧场！
 
 转载:[http://blog.csdn.net/singwhatiwanna/article/details/17588159][http_blog.csdn.net_singwhatiwanna_article_details_17588159]

[android_cache_]: http://blog.csdn.net/cuijinquan/article/details/17688615
[view plain]: http://blog.csdn.net/singwhatiwanna/article/details/9054001#
[android_cache]: http://blog.csdn.net/cuijinquan/article/details/17688393
[android_cache_ 1]: http://blog.csdn.net/singwhatiwanna/article/details/9054001
[android_banner]: http://blog.csdn.net/singwhatiwanna/article/details/8875241
[view plain 1]: http://blog.csdn.net/singwhatiwanna/article/details/17566439#
[android_cache 1]: http://blog.csdn.net/cuijinquan/article/details/17688297
[android_cache 2]: http://blog.csdn.net/singwhatiwanna/article/details/17566439
[view plain 2]: http://blog.csdn.net/singwhatiwanna/article/details/17588159#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/129337
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/129337/fork
[http_blog.csdn.net_singwhatiwanna_article_details_17588159]: http://blog.csdn.net/singwhatiwanna/article/details/17588159