LruCache

 1 //获取系统分配给每个应用程序的最大内存
 2 int maxMemory=(int)(Runtime.getRuntime().maxMemory()/1024);
 3 int cacheSize=maxMemory/8; 
 4 private LruCache<String, Bitmap> mMemoryCache;
 5 //给LruCache分配1/8 
 6 mMemoryCache = new LruCache<String, Bitmap>(mCacheSize){  
 7     //重写该方法，来测量Bitmap的大小  
 8     @Override  
 9     protected int sizeOf(String key, Bitmap value) {  
10         return value.getRowBytes() * value.getHeight()/1024;  
11     }  
12 };

 1  /**
 2      * @param maxSize for caches that do not override {@link #sizeOf}, this is
 3      *     the maximum number of entries in the cache. For all other caches,
 4      *     this is the maximum sum of the sizes of the entries in this cache.
 5      */
 6     public LruCache(int maxSize) {
 7         if (maxSize <= 0) {
 8             throw new IllegalArgumentException("maxSize <= 0");
 9         }
10         this.maxSize = maxSize;
11         this.map = new LinkedHashMap<K, V>(0, 0.75f, true);
12     }

 1 /**
 2      * Caches {@code value} for {@code key}. The value is moved to the head of
 3      * the queue.
 4      *
 5      * @return the previous value mapped by {@code key}.
 6      */
 7     public final V put(K key, V value) {
 8         if (key == null || value == null) {
 9             throw new NullPointerException("key == null || value == null");
10         }
11 
12         V previous;
13         synchronized (this) {
14             putCount++;
15              //safeSizeOf(key, value)。
16              //这个方法返回的是1，也就是将缓存的个数加1.
17             // 当缓存的是图片的时候，这个size应该表示图片占用的内存的大小，所以应该重写里面调用的sizeOf(key, value)方法
18             size += safeSizeOf(key, value);
19             //向map中加入缓存对象,若缓存中已存在，返回已有的值，否则执行插入新的数据，并返回null
20             previous = map.put(key, value);
21             //如果已有缓存对象，则缓存大小恢复到之前
22             if (previous != null) {
23                 size -= safeSizeOf(key, previous);
24             }
25         }
26           //entryRemoved()是个空方法，可以自行实现
27         if (previous != null) {
28             entryRemoved(false, key, previous, value);
29         }
30 
31         trimToSize(maxSize);
32         return previous;
33     }

 1 /**
 2      * Remove the eldest entries until the total of remaining entries is at or
 3      * below the requested size.
 4      *
 5      * @param maxSize the maximum size of the cache before returning. May be -1
 6      *            to evict even 0-sized elements.
 7      */
 8     public void trimToSize(int maxSize) {
 9         while (true) {
10             K key;
11             V value;
12             synchronized (this) {
13               //如果map为空并且缓存size不等于0或者缓存size小于0，抛出异常
14                 if (size < 0 || (map.isEmpty() && size != 0)) {
15                     throw new IllegalStateException(getClass().getName()
16                             + ".sizeOf() is reporting inconsistent results!");
17                 }
18      //如果缓存大小size小于最大缓存，不需要再删除缓存对象，跳出循环
19                 if (size <= maxSize) {
20                     break;
21                 }
22      //在缓存队列中查找最近最少使用的元素，若不存在，直接退出循环，若存在则直接在map中删除。
23                 Map.Entry<K, V> toEvict = map.eldest();
24                 if (toEvict == null) {
25                     break;
26                 }
27 
28                 key = toEvict.getKey();
29                 value = toEvict.getValue();
30                 map.remove(key);
31                 size -= safeSizeOf(key, value);
32                 //回收次数+1
33                 evictionCount++;
34             }
35 
36             entryRemoved(true, key, value, null);
37         }
38     }
39 
40 
41 /**
42  * Returns the eldest entry in the map, or {@code null} if the map is empty.
43  *
44  * Android-added.
45  *
46  * @hide
47  */
48 public Map.Entry<K, V> eldest() {
49     Entry<K, V> eldest = header.after;
50     return eldest != header ? eldest : null;
51 }

 1  /**
 2      * Returns the value for {@code key} if it exists in the cache or can be
 3      * created by {@code #create}. If a value was returned, it is moved to the
 4      * head of the queue. This returns null if a value is not cached and cannot
 5      * be created.
 6      * 通过key获取缓存的数据，如果通过这个方法得到的需要的元素，那么这个元素会被放在缓存队列的尾部，
 7      * 
 8      */
 9     public final V get(K key) {
10         if (key == null) {
11             throw new NullPointerException("key == null");
12         }
13 
14         V mapValue;
15         synchronized (this) {
16               //从LinkedHashMap中获取数据。
17             mapValue = map.get(key);
18             if (mapValue != null) {
19                 hitCount++;
20                 return mapValue;
21             }
22             missCount++;
23         }
24     /*
25      * 正常情况走不到下面
26      * 因为默认的 create(K key) 逻辑为null
27      * 走到这里的话说明实现了自定义的create(K key) 逻辑，比如返回了一个不为空的默认值
28      */
29         /*
30          * Attempt to create a value. This may take a long time, and the map
31          * may be different when create() returns. If a conflicting value was
32          * added to the map while create() was working, we leave that value in
33          * the map and release the created value.
34          * 译：如果通过key从缓存集合中获取不到缓存数据，就尝试使用creat(key)方法创造一个新数据。
35          * create(key)默认返回的也是null，需要的时候可以重写这个方法。
36          */
37 
38         V createdValue = create(key);
39         if (createdValue == null) {
40             return null;
41         }
42         //如果重写了create(key)方法，创建了新的数据，就讲新数据放入缓存中。
43         synchronized (this) {
44             createCount++;
45             mapValue = map.put(key, createdValue);
46 
47             if (mapValue != null) {
48                 // There was a conflict so undo that last put
49                 map.put(key, mapValue);
50             } else {
51                 size += safeSizeOf(key, createdValue);
52             }
53         }
54 
55         if (mapValue != null) {
56             entryRemoved(false, key, createdValue, mapValue);
57             return mapValue;
58         } else {
59             trimToSize(maxSize);
60             return createdValue;
61         }
62     }