Android中LruCache到底是如何配合LinkedHashMap实现LRU算法

LruCache是Android3.1提供的一个缓冲类，support包中也有。它对数据的存储采用了近期最少使用算法。

Android开发中，如网络加载图片，如果不进行缓存，那么流量的消耗和体验是很差的。并且Android系统有对每个应用施加了内存限制，一旦超出限制，就看见了常见的OOM的报错。所以我们需要一个有缓存策略的类LruCache，来存放这些图片。

我们从源码来看看，这个高大上的东西如何实现的。

一：看LruCache一般的用法：

int maxMemory = (int) (Runtime.getRuntime().maxMemory()/1024);int cacheSize = maxMemory/8;LruCache<String, Bitmap> mCache = new LruCache<String, Bitmap>(cacheSize){protected int sizeOf(String key, Bitmap value) {return value.getRowBytes()*value.getHeight()/1024;};};

这是一般缓存图片时的写法。其中有一个点，为什么重写sizeOf方法？下面分析源码就明白了~

二：源码分析

1.先看看它的成员变量：

private final LinkedHashMap<K, V> map;    /** Size of this cache in units. Not necessarily the number of elements. */    private int size;//当前内存大小    private int maxSize;//最大内存大小    private int putCount;//加入成功就加一，一下的count，分析源码发现没用到，就只是记录一下    private int createCount;//创建成功加一    private int evictionCount;//清除一次加一    private int hitCount;//成功查找到一次加一    private int missCount;//get但不存在

2.先看看它的构造器：

/**     * @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, <span style="color:#ff0000;">true</span>);    }

传入我们设定的最大大小，然后new 了一个LinkedHashMap。并且看第三个参数为true。看API知道了，true的时候，LinkedHashMap遵循LRU算法。具体LinkedHashMap怎么实现的，下面会浅析一下，先看LruCache，一步步来。表急。。

3.看看我们常用的put方法：

 /**     * Caches {@code value} for {@code key}. The value is moved to the head of     * the queue.     *     * @return the previous value mapped by {@code key}.     */    public final V put(K key, V value) {        if (key == null || value == null) {            throw new NullPointerException("key == null || value == null");        }        V previous;        synchronized (this) {            putCount++;            <span style="color:#ff0000;">size += safeSizeOf(key, value);</span>            previous = map.put(key, value);            if (previous != null) {                size -= safeSizeOf(key, previous);            }        }        if (previous != null) {           <span style="color:#ff0000;"> entryRemoved(false, key, previous, value);</span>        }        <span style="color:#ff0000;">trimToSize(maxSize);</span>        return previous;    }

注意看代码中标红的三句代码：

safeSizeOf()：其中会为了安全判断参数是否合法，然后调用sizeOf()方法。sizeOf()！我们经常会重写的方法。该方法会返回子项的大小。当put 新数据时，当前大小增加新数据大小，发现有老数据存在，linkedHashMap会覆盖老数据，所以减去老数据大小。

entryRemoved()：这个方法也可以选择重写，它会通知删除项的信息。

trimTosize()：这个方法很关键，这个方法会判断当前大小是否超出限制，如果超出则删除一些数据。具体看下面。

4.get方法：

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.         */        <span style="color:#ff0000;">V createdValue = create(key);</span>        if (createdValue == null) {            return null;        }        synchronized (this) {            createCount++;            mapValue = map.put(key, createdValue);            if (mapValue != null) {                // There was a conflict so undo that last put                map.put(key, mapValue);            } else {                size += safeSizeOf(key, createdValue);            }        }        if (mapValue != null) {            entryRemoved(false, key, createdValue, mapValue);            return mapValue;        } else {           <span style="color:#ff0000;"> trimToSize(maxSize);</span>            return createdValue;        }    }

其中标红的create()方法，也是可以重写的。作用就是get不到东西时，如果重写并返回值，就默认创建。不重写此方法，返回null，则不会默认创建。创建成功，都会执行trimTosize()方法。下面我们看看这个关键的方法。

5.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!");                }               <span style="color:#ff0000;"> if (size <= maxSize) {                    break;                }</span>                <span style="color:#ff0000;">Map.Entry<K, V> toEvict = map.eldest();</span>                if (toEvict == null) {                    break;                }                key = toEvict.getKey();                value = toEvict.getValue();                <span style="color:#ff0000;">map.remove(key);                size -= safeSizeOf(key, value);</span>                evictionCount++;            }            entryRemoved(true, key, value, null);        }    }

看看这几句标红的代码。死循环，直到当前大小小于大小限制，才停止，否则一直map.eldest()，从linkedHashMap获取到链表数据，删除掉。

可是就实现了LRU呢？那么LruCache就算分析完了，要把重心移到LinkedHashMap了。

6.LinkedHashMap get和put

LinkedHashMap继承HashMap。它自己维护了一个双向循环链表。它没有重写put方法，但是重写了put'方法调用的addNewEntry。这个方法会把最新的放在链表的header项的前面。get方法我们看一下：

@Override public V get(Object key) {        if (key == null) {            HashMapEntry<K, V> e = entryForNullKey;            if (e == null)                return null;            if (accessOrder)                makeTail((LinkedEntry<K, V>) e);            return e.value;        }        int hash = secondaryHash(key);        HashMapEntry<K, V>[] tab = table;        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 (<span style="color:#ff0000;">accessOrder)</span>                    <span style="color:#ff0000;">makeTail((LinkedEntry<K, V>) e);</span>                return e.value;            }        }        return null;    }

其他代码和咱要研究的关系不大，看标红的，accessOrder，这个LruCache构造器中设为了true，表示使用LRU算法，那么接下来，一切谜团都在makeTail()方法中了。

7.makeTail()

private void makeTail(LinkedEntry<K, V> e) {        // Unlink e        e.prv.nxt = e.nxt;        e.nxt.prv = e.prv;        // Relink e as tail        LinkedEntry<K, V> header = this.header;        LinkedEntry<K, V> oldTail = header.prv;        e.nxt = header;        e.prv = oldTail;        oldTail.nxt = header.prv = e;        modCount++;    }

代码很少，这段代码在当初大学时学链表时，被搞的快了。目的就是，切断原链表的header和tail，插入新的entry到header 的前面，就是说是循环链表的尾部。

下面来个相关的链表图，应该就清晰很多了。网上引用个图：

插入新的entry到header的前面，就是说循环链表的尾部：

1.将要插入的entry断开：

e.prv.nxt = e.nxt：将e的前一项的next指向，e的下一项。

e.nxt.prv = e.prv：将e的下一项的pre指向，e的前一项。

2.插入：

LinkedEntry<K, V> header = this.header：获取到此时的header

 LinkedEntry<K, V> oldTail = header.prv;：获取到此时的tail

 e.nxt = header：将e的next指向header

e.prv = oldTail：将e的pre指向tail。闭环

oldTail.nxt = header.prv = e; header的前一项指向e，tail的下一项指向e。

最后再看一下LruCache中到底删除的是链表的哪个地方。

8.eldest

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

耶！明白了吧，获取了header 的下一项。

三.总结

LruCache只是来控制大小不超过限制，从而操作LinkedHashMap执行删除。重点都在LinkedHashMap。

LruCache优先删除的是LinkedHashMap中循环双向链表中 ：Header 的下一项！当我们调用get，put方法操作某一项的时候，会将此项放在header 的前面，那么此项被删除的优先级是最低的，从而实现了LRU！

希望可以对大家有所帮助，大家发现问题欢迎指正!