Android LruCacha 源码分析

LRU 算法，中文叫 近期最少使用 算法。这个算法的思想是当容量已经满的情况下，我们再次向容器里面存放东西的时候，我们需要先删除之前使用最少的元素，因为这个元素在新元素插入之间一使用的最少，我们认为在后面的过程中，这个元素依然是使用次数最少的，当容积不够的时候，我们当然要删除后面过程中使用次数最少的，腾出空间给新的元素。

Android 里面实现了这种算法，名字叫 LruCache 。下面我们从源码(android sdk 23)的角度来解析这个类

public class LruCache<K, V> {    private final LinkedHashMap<K, V> map; // 最重要的一个变量,上面所说的原理就是利用这个 LinkedHashMap 实现的    /** Size of this cache in units. Not necessarily the number of elements. */    private int size; // 已经缓存的元素个数    private int maxSize; // 缓存大小    private int putCount; // 往里面添加元素计数器    private int createCount;// key 为 null 的情况下，默认生成对象的个数    private int evictionCount; // 当加入的元素超过 maxSize 后，调整大小的次数    private int hitCount; // 命中的次数    private int missCount; // 没有命中的次数    /**     * @param maxSize for caches that do not override {@link #sizeOf}, this is     *     the maximum number of entries in the cache. For all other caches,     *     this is the maximum sum of the sizes of the entries in this cache.     */    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);    }    // 省略其他代码}

我们先来看看 put 方法是如何工作的

public final V put(K key, V value) {    // 如果 key 或 value 为 null 那么抛出异常，说明不接受 null    if (key == null || value == null) {        throw new NullPointerException("key == null || value == null");    }    V previous; // 记录 key 的旧值    synchronized (this) {        putCount++; // 插入计数器计数        size += safeSizeOf(key, value); // 修正 size        previous = map.put(key, value); // 取出 LinkedHashMap 里面的旧值        if (previous != null) { // 之前的确保存过            size -= safeSizeOf(key, previous); // 修正 size        }    }    if (previous != null) { // 如果之前保存过，那么删掉这个节点，但是看源码发现，entryRemoved 是空        entryRemoved(false, key, previous, value);    }    // 调整大小，也是最重要的方法之一    trimToSize(maxSize);    // 返回之前插入的值    return previous;}

刚才提到了 trimToSize() ，那我们来看看这个方法的具体实现。

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!");            }            // size(缓存的元素个数) 小于 maxSize(容量) 那么跳出循环            if (size <= maxSize) {                break;            }            // eldest() 取 LinkedHashMap 里面最年老的元素            Map.Entry<K, V> toEvict = map.eldest();            if (toEvict == null) { // 为空说明 LinkedHashMap 里面没有元素了                break;            }            key = toEvict.getKey();            value = toEvict.getValue();            // 删掉 最近最少使用的            map.remove(key);            size -= safeSizeOf(key, value); // 修正 size            evictionCount++; // 缩减计数器        }        // 删除元素，entryRemoved 是一个空方法        entryRemoved(true, key, value, null);    }}

trimToSize() 方法里面 LinkedHashMap.eldest() 方法很重要，LinkedHashMap.eldest() 的作用就是取出最年老，即最近最少使用的元素。如何取到最近最少使用的元素就是 LinkedHashMap 里面的东西了。我们接下来看看 LinkedHashMap 的源码

public class LinkedHashMap<K, V> extends HashMap<K, V> {    /**     * A dummy entry in the circular linked list of entries in the map.     * The first real entry is header.nxt, and the last is header.prv.     * If the map is empty, header.nxt == header && header.prv == header.     */    transient LinkedEntry<K, V> header;    /**     * True if access ordered, false if insertion ordered.     */    private final boolean accessOrder;    /**     * LinkedEntry adds nxt/prv double-links to plain HashMapEntry.     */    static class LinkedEntry<K, V> extends HashMapEntry<K, V> {        LinkedEntry<K, V> nxt;        LinkedEntry<K, V> prv;        /** Create the header entry */        LinkedEntry() {            super(null, null, 0, null);            nxt = prv = this;        }        /** Create a normal entry */        LinkedEntry(K key, V value, int hash, HashMapEntry<K, V> next,                    LinkedEntry<K, V> nxt, LinkedEntry<K, V> prv) {            super(key, value, hash, next);            this.nxt = nxt;            this.prv = prv;        }    }    // 省略其他代码}

首先，有一个 LinkedEntry 内部类，继承自 HashMapEntry , 里面有 2 个引用分别指向之前和之后的元素，说明这个是一个双向链表结构。 LinkedEntry<K, V> header 这个变量就是双向链表的表头了。 accessOrder 这个的意思是是否需要排序，这个在后面会用到。我们先看看 eldest() 方法。

public Entry<K, V> eldest() {    LinkedEntry<K, V> eldest = header.nxt;    return eldest != header ? eldest : null;}

方法很简单，就是取出 header 的 nxt 元素。那为什么 header 的 nxt 袁术就是最近最少使用的元素呢？这个是因为在 put 和 get 过程中，如果 accessOrder 设置为 true 的话，会把对应 key 的 LinkedEntry 节点放到队列的尾部。下面我们通过 get 源码分析下这个过程。

public V get(Object key) {    /*     * This method is overridden to eliminate the need for a polymorphic     * invocation in superclass at the expense of code duplication.     */    // 如果 key 为空，做key 为空的特殊处理    if (key == null) {        HashMapEntry<K, V> e = entryForNullKey;        if (e == null)            return null;        if (accessOrder)            makeTail((LinkedEntry<K, V>) e);        return e.value;    }    // 计算 hash 值    int hash = Collections.secondaryHash(key);    HashMapEntry<K, V>[] tab = table;    // 遍历，找到 key 对应的元素节点    for (HashMapEntry<K, V> e = tab[hash & (tab.length - 1)];            e != null; e = e.next) {        K eKey = e.key;        if (eKey == key || (e.hash == hash && key.equals(eKey))) {            if (accessOrder) // accessOrder 如果为 true ，那么就执行将元素节点放到队列尾部的操作                makeTail((LinkedEntry<K, V>) e);            return e.value;        }    }    // 如果这个 key 之前没有 put 过，那么就返回 null.    return null;}

看代码发现， accessOrder 为 true 的时候，我们才会去做将元素节点放到队列的操作，而在 LruCache 里面，LinkedHashMap 的这个值是 true 的。整个的 LruCache 分析就到这里为止。
最后我们看下 makeTail 的源码

private void makeTail(LinkedEntry<K, V> e) {    // Unlink e 断开 e 的链接    e.prv.nxt = e.nxt;    e.nxt.prv = e.prv;    // Relink e as tail 将 e 链接到队列尾部。所以队列头部就是最早put进去但是一直没使用的    // 也就是所谓的 "最近最少使用"    LinkedEntry<K, V> header = this.header;    LinkedEntry<K, V> oldTail = header.prv;    e.nxt = header;    e.prv = oldTail;    oldTail.nxt = header.prv = e;    modCount++;}