简析Android中LruCache缓存类

标签：android   强应用   内存溢出   缓存   lrucache   

/***************************************************

 * TODO: description .

 * @author: gao_chun

 * @since:  2015-4-7

 * @version: 1.0.0

 * @remark: 转载请注明出处

 **************************************************/

　　设备屏幕上一次最多能显示多少张图片？

有多少图片需要进行预加载，因为有可能很快也会显示在屏幕上？

　　你的设备的屏幕大小和分辨率分别是多少？

一个超高分辨率的设备（例如 Galaxy Nexus) 比起一个较低分辨率的设备（例如 Nexus S），在持有相同数量图片的时候，需要更大的缓存空间。

　　图片被访问的频率有多高？会不会有一些图片的访问频率比其它图片要高？

如果有的话，你也许应该让一些图片常驻在内存当中，或者使用多个LruCache 对象来区分不同组的图片。

　　并没有一个指定的缓存大小可以满足所有的应用程序，这是由你决定的。你应该去分析程序内存的使用情况，然后制定出一个合适的解决方案。一个太小的缓存空间，有可能造成图片频繁地被释放和重新加载，这并没有好处。而一个太大的缓存空间，则有可能还是会引起 java.lang.OutOfMemory 的异常。

搜索并整理了一些资料：

1. package android.util;  
2.   
3. import java.util.LinkedHashMap;  
4. import java.util.Map;  
5.   
6. /** 
7.  * A cache that holds strong references to a limited number of values. Each time 
8.  * a value is accessed, it is moved to the head of a queue. When a value is 
9.  * added to a full cache, the value at the end of that queue is evicted and may 
10.  * become eligible for garbage collection. 
11.  * Cache保存一个强引用来限制内容数量，每当Item被访问的时候，此Item就会移动到队列的头部。
12.  * 当cache已满的时候加入新的item时，在队列尾部的item会被回收。
13.  * <p>If your cached values hold resources that need to be explicitly released, 
14.  * override {@link #entryRemoved}. 
15.  * 如果你cache的某个值需要明确释放，重写entryRemoved()
16.  * <p>If a cache miss should be computed on demand for the corresponding keys, 
17.  * override {@link #create}. This simplifies the calling code, allowing it to 
18.  * assume a value will always be returned, even when there‘s a cache miss. 
19.  * 如果key相对应的item丢掉啦，重写create().这简化了调用代码，即使丢失了也总会返回。
20.  * <p>By default, the cache size is measured in the number of entries. Override 
21.  * {@link #sizeOf} to size the cache in different units. For example, this cache 
22.  * is limited to 4MiB of bitmaps: 默认cache大小是测量的item的数量，重写sizeof计算不同item的大小。
23.  * <pre>   {@code 
24.  *   int cacheSize = 4 * 1024 * 1024; // 4MiB 
25.  *   LruCache<String, Bitmap> bitmapCache = new LruCache<String, Bitmap>(cacheSize) { 
26.  *       protected int sizeOf(String key, Bitmap value) { 
27.  *           return value.getByteCount(); 
28.  *       } 
29.  *   }}</pre> 
30.  * 
31.  * <p>This class is thread-safe. Perform multiple cache operations atomically by 
32.  * synchronizing on the cache: <pre>   {@code 
33.  *   synchronized (cache) { 
34.  *     if (cache.get(key) == null) { 
35.  *         cache.put(key, value); 
36.  *     } 
37.  *   }}</pre> 
38.  * 
39.  * <p>This class does not allow null to be used as a key or value. A return 
40.  * value of null from {@link #get}, {@link #put} or {@link #remove} is 
41.  * unambiguous: the key was not in the cache.
42.  * 不允许key或者value为null  当get（），put（），remove（）返回值为null时，key相应的项不在cache中
43.  */  
44. public class LruCache<K, V> {  
45.     private final LinkedHashMap<K, V> map;  
46.   
47.     /** Size of this cache in units. Not necessarily the number of elements. */  
48.     private int size; //已经存储的大小
49.     private int maxSize; //规定的最大存储空间
50.   
51.     private int putCount;  //put的次数
52.     private int createCount;  //create的次数
53.     private int evictionCount;  //回收的次数
54.     private int hitCount;  //命中的次数
55.     private int missCount;  //丢失的次数
56.   
57.     /** 
58.      * @param maxSize for caches that do not override {@link #sizeOf}, this is 
59.      *     the maximum number of entries in the cache. For all other caches, 
60.      *     this is the maximum sum of the sizes of the entries in this cache. 
61.      */  
62.     public LruCache(int maxSize) {  
63.         if (maxSize <= 0) {  
64.             throw new IllegalArgumentException("maxSize <= 0");  
65.         }  
66.         this.maxSize = maxSize;  
67.         this.map = new LinkedHashMap<K, V>(0, 0.75f, true);  
68.     }  
69.   
70.     /** 
71.      * Returns the value for {@code key} if it exists in the cache or can be 
72.      * created by {@code #create}. If a value was returned, it is moved to the 
73.      * head of the queue. This returns null if a value is not cached and cannot 
74.      * be created. 通过key返回相应的item，或者创建返回相应的item。相应的item会移动到队列的头部，
75.      * 如果item的value没有被cache或者不能被创建，则返回null。
76.      */  
77.     public final V get(K key) {  
78.         if (key == null) {  
79.             throw new NullPointerException("key == null");  
80.         }  
81.   
82.         V mapValue;  
83.         synchronized (this) {  
84.             mapValue = map.get(key);  
85.             if (mapValue != null) {  
86.                 hitCount++;  //命中
87.                 return mapValue;  
88.             }  
89.             missCount++;  //丢失
90.         }  
91.   
92.         /* 
93.          * Attempt to create a value. This may take a long time, and the map 
94.          * may be different when create() returns. If a conflicting value was 
95.          * added to the map while create() was working, we leave that value in 
96.          * the map and release the created value. 
97.          * 如果丢失了就试图创建一个item
98.          */  
99.   
100.         V createdValue = create(key);  
101.         if (createdValue == null) {  
102.             return null;  
103.         }  
104.   
105.         synchronized (this) {  
106.             createCount++;//创建++  
107.             mapValue = map.put(key, createdValue);  
108.   
109.             if (mapValue != null) {  
110.                 // There was a conflict so undo that last put  
111.                 //如果前面存在oldValue，那么撤销put（） 
112.                 map.put(key, mapValue);  
113.             } else {  
114.                 size += safeSizeOf(key, createdValue);  
115.             }  
116.         }  
117.   
118.         if (mapValue != null) {  
119.             entryRemoved(false, key, createdValue, mapValue);  
120.             return mapValue;  
121.         } else {  
122.             trimToSize(maxSize);  
123.             return createdValue;  
124.         }  
125.     }  
126.   
127.     /** 
128.      * Caches {@code value} for {@code key}. The value is moved to the head of 
129.      * the queue. 
130.      * 
131.      * @return the previous value mapped by {@code key}. 
132.      */  
133.     public final V put(K key, V value) {  
134.         if (key == null || value == null) {  
135.             throw new NullPointerException("key == null || value == null");  
136.         }  
137.   
138.         V previous;  
139.         synchronized (this) {  
140.             putCount++;  
141.             size += safeSizeOf(key, value);  
142.             previous = map.put(key, value);  
143.             if (previous != null) {  //返回的先前的value值
144.                 size -= safeSizeOf(key, previous);  
145.             }  
146.         }  
147.   
148.         if (previous != null) {  
149.             entryRemoved(false, key, previous, value);  
150.         }  
151.   
152.         trimToSize(maxSize);  
153.         return previous;  
154.     }  
155.   
156.     /** 
157.      * @param maxSize the maximum size of the cache before returning. May be -1 
158.      *     to evict even 0-sized elements. 
159.      *  清空cache空间
160.      */  
161.     private void trimToSize(int maxSize) {  
162.         while (true) {  
163.             K key;  
164.             V value;  
165.             synchronized (this) {  
166.                 if (size < 0 || (map.isEmpty() && size != 0)) {  
167.                     throw new IllegalStateException(getClass().getName()  
168.                             + ".sizeOf() is reporting inconsistent results!");  
169.                 }  
170.   
171.                 if (size <= maxSize) {  
172.                     break;  
173.                 }  
174.   
175.                 Map.Entry<K, V> toEvict = map.eldest();  
176.                 if (toEvict == null) {  
177.                     break;  
178.                 }  
179.   
180.                 key = toEvict.getKey();  
181.                 value = toEvict.getValue();  
182.                 map.remove(key);  
183.                 size -= safeSizeOf(key, value);  
184.                 evictionCount++;  
185.             }  
186.   
187.             entryRemoved(true, key, value, null);  
188.         }  
189.     }  
190.   
191.     /** 
192.      * Removes the entry for {@code key} if it exists. 
193.      * 删除key相应的cache项，返回相应的value
194.      * @return the previous value mapped by {@code key}. 
195.      */  
196.     public final V remove(K key) {  
197.         if (key == null) {  
198.             throw new NullPointerException("key == null");  
199.         }  
200.   
201.         V previous;  
202.         synchronized (this) {  
203.             previous = map.remove(key);  
204.             if (previous != null) {  
205.                 size -= safeSizeOf(key, previous);  
206.             }  
207.         }  
208.   
209.         if (previous != null) {  
210.             entryRemoved(false, key, previous, null);  
211.         }  
212.   
213.         return previous;  
214.     }  
215.   
216.     /** 
217.      * Called for entries that have been evicted or removed. This method is 
218.      * invoked when a value is evicted to make space, removed by a call to 
219.      * {@link #remove}, or replaced by a call to {@link #put}. The default 
220.      * implementation does nothing. 
221.      * 当item被回收或者删掉时调用。改方法当value被回收释放存储空间时被remove调用，
222.      * 或者替换item值时put调用，默认实现什么都没做。
223.      * <p>The method is called without synchronization: other threads may 
224.      * access the cache while this method is executing. 
225.      * 
226.      * @param evicted true if the entry is being removed to make space, false 
227.      *     if the removal was caused by a {@link #put} or {@link #remove}. 
228.      * true---为释放空间被删除；false---put或remove导致
229.      * @param newValue the new value for {@code key}, if it exists. If non-null, 
230.      *     this removal was caused by a {@link #put}. Otherwise it was caused by 
231.      *     an eviction or a {@link #remove}. 
232.      */  
233.     protected void entryRemoved(boolean evicted, K key, V oldValue, V newValue) {}  
234.   
235.     /** 
236.      * Called after a cache miss to compute a value for the corresponding key. 
237.      * Returns the computed value or null if no value can be computed. The 
238.      * default implementation returns null. 
239.      * 当某Item丢失时会调用到，返回计算的相应的value或者null
240.      * <p>The method is called without synchronization: other threads may 
241.      * access the cache while this method is executing. 
242.      * 
243.      * <p>If a value for {@code key} exists in the cache when this method 
244.      * returns, the created value will be released with {@link #entryRemoved} 
245.      * and discarded. This can occur when multiple threads request the same key 
246.      * at the same time (causing multiple values to be created), or when one 
247.      * thread calls {@link #put} while another is creating a value for the same 
248.      * key. 
249.      */  
250.     protected V create(K key) {  
251.         return null;  
252.     }  
253.   
254.     private int safeSizeOf(K key, V value) {  
255.         int result = sizeOf(key, value);  
256.         if (result < 0) {  
257.             throw new IllegalStateException("Negative size: " + key + "=" + value);  
258.         }  
259.         return result;  
260.     }  
261.   
262.     /** 
263.      * Returns the size of the entry for {@code key} and {@code value} in 
264.      * user-defined units.  The default implementation returns 1 so that size 
265.      * is the number of entries and max size is the maximum number of entries. 
266.      * 返回用户定义的item的大小，默认返回1代表item的数量，最大size就是最大item值
267.      * <p>An entry‘s size must not change while it is in the cache. 
268.      */  
269.     protected int sizeOf(K key, V value) {  
270.         return 1;  
271.     }  
272.   
273.     /** 
274.      * Clear the cache, calling {@link #entryRemoved} on each removed entry. 
275.      * 清空cacke
276.      */  
277.     public final void evictAll() {  
278.         trimToSize(-1); // -1 will evict 0-sized elements  
279.     }  
280.   
281.     /** 
282.      * For caches that do not override {@link #sizeOf}, this returns the number 
283.      * of entries in the cache. For all other caches, this returns the sum of 
284.      * the sizes of the entries in this cache. 
285.      */  
286.     public synchronized final int size() {  
287.         return size;  
288.     }  
289.   
290.     /** 
291.      * For caches that do not override {@link #sizeOf}, this returns the maximum 
292.      * number of entries in the cache. For all other caches, this returns the 
293.      * maximum sum of the sizes of the entries in this cache. 
294.      */  
295.     public synchronized final int maxSize() {  
296.         return maxSize;  
297.     }  
298.   
299.     /** 
300.      * Returns the number of times {@link #get} returned a value that was 
301.      * already present in the cache. 
302.      */  
303.     public synchronized final int hitCount() {  
304.         return hitCount;  
305.     }  
306.   
307.     /** 
308.      * Returns the number of times {@link #get} returned null or required a new 
309.      * value to be created. 
310.      */  
311.     public synchronized final int missCount() {  
312.         return missCount;  
313.     }  
314.   
315.     /** 
316.      * Returns the number of times {@link #create(Object)} returned a value. 
317.      */  
318.     public synchronized final int createCount() {  
319.         return createCount;  
320.     }  
321.   
322.     /** 
323.      * Returns the number of times {@link #put} was called. 
324.      */  
325.     public synchronized final int putCount() {  
326.         return putCount;  
327.     }  
328.   
329.     /** 
330.      * Returns the number of values that have been evicted. 
331.      * 返回被回收的数量
332.      */  
333.     public synchronized final int evictionCount() {  
334.         return evictionCount;  
335.     }  
336.   
337.     /** 
338.      * Returns a copy of the current contents of the cache, ordered from least 
339.      * recently accessed to most recently accessed. 返回当前cache的副本，从最近最少访问到最多访问
340.      */  
341.     public synchronized final Map<K, V> snapshot() {  
342.         return new LinkedHashMap<K, V>(map);  
343.     }  
344.   
345.     @Override public synchronized final String toString() {  
346.         int accesses = hitCount + missCount;  
347.         int hitPercent = accesses != 0 ? (100 * hitCount / accesses) : 0;  
348.         return String.format("LruCache[maxSize=%d,hits=%d,misses=%d,hitRate=%d%%]",  
349.                 maxSize, hitCount, missCount, hitPercent);  
350.     }  
351. }  

简析Android中LruCache缓存类

标签：android   强应用   内存溢出   缓存   lrucache   

原文地址：http://blog.csdn.net/gao_chun/article/details/44922019