LRUCache是Android中实现内存缓存相关的组件类，当缓存满时其使用最近最少使用策略来淘汰相关的元素，以控制缓存大小。本文主要基于LRUCache相关源码分析LRUCache的创建、缓存的添加、获取、删除流程。

LRUCache创建

LRUCache的创建可以直接看其构造函数

	public LruCache(int maxSize) {if (maxSize <= 0) {throw new IllegalArgumentException("maxSize <= 0");}this.maxSize = maxSize;this.map = new LinkedHashMap<K, V>(0, 0.75f, true);}

其创建时需要设置最大的缓存大小，此外会创建一个LinkedHashMap来存储缓存对象的引用。
当我们使用LRUCache时一般如下：

	int cacheSize = 4 * 1024 * 1024; // 4MiB   LruCache<String, Bitmap> bitmapCache = new LruCache<String, Bitmap(cacheSize) {       
、	protected int sizeOf(String key, Bitmap value) {           return value.getByteCount();       }   
}

添加缓存

添加缓存调用LRUCahe的put(key,value)方法,put方法先通过sizeof函数计算当前待添加节点所占内存大小，然后将其添加到map中，重新计算当前缓存大小，如果旧节点非空，则调用entryRemove方法通知该旧节点已移除，以方便使用者做清理操作。最后再调用trimToSize()方法检查并移除已超过maxSize的最老的节点。

 public final V put(K key, V value) {//注意 key和value都不能为nullif (key == null || value == null) {throw new NullPointerException("key == null || value == null");}V previous;synchronized (this) {putCount++;size += safeSizeOf(key, value);previous = map.put(key, value);if (previous != null) {size -= safeSizeOf(key, previous);}}if (previous != null) {entryRemoved(false, key, previous, value);}trimToSize(maxSize);return previous;}public void trimToSize(int maxSize) {while (true) {K key;V value;synchronized (this) {if (size < 0 || (map.isEmpty() && size != 0)) {throw new IllegalStateException(getClass().getName()+ ".sizeOf() is reporting inconsistent results!");}if (size <= maxSize) {break;}//删除最老的节点Map.Entry<K, V> toEvict = map.eldest();if (toEvict == null) {break;}key = toEvict.getKey();value = toEvict.getValue();map.remove(key);size -= safeSizeOf(key, value);evictionCount++;}entryRemoved(true, key, value, null);}}

获取缓存

获取缓存调用LRUCache的get方法，其会根据key去map中查找对应值，如果没有，则会调用create方法尝试创建默认值，如果创建了默认值，则会返回默认值，并重新走一遍trimToSize，保证内存缓存大小在maxSize限制内。

public final V get(K key) {if (key == null) {throw new NullPointerException("key == null");}V mapValue;synchronized (this) {mapValue = map.get(key);if (mapValue != null) {hitCount++;return mapValue;}missCount++;}/** Attempt to create a value. This may take a long time, and the map* may be different when create() returns. If a conflicting value was* added to the map while create() was working, we leave that value in* the map and release the created value.*/V createdValue = create(key);if (createdValue == null) {return null;}synchronized (this) {createCount++;mapValue = map.put(key, createdValue);if (mapValue != null) {// There was a conflict so undo that last putmap.put(key, mapValue);} else {size += safeSizeOf(key, createdValue);}}if (mapValue != null) {entryRemoved(false, key, createdValue, mapValue);return mapValue;} else {trimToSize(maxSize);return createdValue;}}

删除缓存

删除缓存主要涉及三件事：

1. 从map中删除该节点
2. entryRemove方法通知使用者该节点已被移除
3. 重新计算当前缓存的大小

public final V remove(K key) {if (key == null) {throw new NullPointerException("key == null");}V previous;synchronized (this) {previous = map.remove(key);if (previous != null) {size -= safeSizeOf(key, previous);}}if (previous != null) {entryRemoved(false, key, previous, null);}return previous;}

LinkedHashMap如何实现LRU算法

LinkedHashMap继承于HashMap，同时内部自定义了LinkedHashMapEntry节点形成了双向链表结构，其内部有head和tail两个指向头和尾节点的指针，通过accessOrder变量来控制是否顺序。

	static class LinkedHashMapEntry<K,V> extends HashMap.Node<K,V> {LinkedHashMapEntry<K,V> before, after;LinkedHashMapEntry(int hash, K key, V value, Node<K,V> next) {super(hash, key, value, next);}}transient LinkedHashMapEntry<K,V> head;transient LinkedHashMapEntry<K,V> tail;//true表示按照访问顺序，false表示按照插入顺序final boolean accessOrder;

那么如何LinkedHashMap如何更新节点顺序呢？我们看下get方法的流程就知道了。

	public V get(Object key) {Node<K,V> e;//调用父类HashMap的getNode方法获取key对应的节点,该方法会根据hash去对应的桶内查找key相等的节点if ((e = getNode(hash(key), key)) == null)return null;//如果accessOrder=true，则表示要按照访问顺序对节点排序if (accessOrder)afterNodeAccess(e);return e.value;}

get方法做了两件事：

1. 调用父类HashMap的getNode方法获取key对应的节点
2. 如果获取到节点值且accessOrder=true，则调用afterNodeAccess方法，该方法会对节点排序

接下来看下afterNodeAccess方法

	void afterNodeAccess(Node<K,V> e) { // move node to lastLinkedHashMapEntry<K,V> last;//如果tail节点不等于当前节点if (accessOrder && (last = tail) != e) {LinkedHashMapEntry<K,V> p =(LinkedHashMapEntry<K,V>)e, b = p.before, a = p.after;//将p节点从链表中删除p.after = null;if (b == null)head = a;elseb.after = a;if (a != null)a.before = b;elselast = b;if (last == null)head = p;else {p.before = last;last.after = p;}//更新tail节点指向p，即当前p变成了尾节点，即最新使用的节点，当LRUCache中大小超过maxSize时，会调用eldest方法找到最近最少使用的节点。实际上就是返回head节点tail = p;++modCount;}}public Map.Entry<K, V> eldest() {return head;}