LruCache源码解析

最近正在看android官方文档，看到Displaying Bitmaps Efficiently部分，正好看到LruCache，所以便想了解LruCache的源码。

正文

先从LruCache类的成员变量

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;//put的次数    private int createCount;//create的次数    private int evictionCount;//回收的次数    private int hitCount;//命中的次数    private int missCount;//丢失的次数

LruCache成员变量不多，其中最重要的是size，maxSize和map这三个成员变量，前两个用于缓存大小的管理，后一个则用于存放缓存的内容。LruCache保存一个LinkedHashMap（双链表），每当value被访问的时候，此value就会移动到队列的头部，当cache已满的时候加入新的value时，在队列尾巴的value会被回收。

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);    }

传入maxSize即是我们限定的缓存大小，在构造函数中对map进行了初始化，传入的三个参数中最重要的是第三个参数，将accessOrder设置为true。即访问顺序（从近期访问最少到近期访问最多的顺序来保存元素）符合Lru算法。
如果不是很清楚访问顺序和插入顺序，可以看下

http://www.cnblogs.com/yejg1212/archive/2013/04/01/2992921.html

接下来看LruCache的put方法

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++;            size += safeSizeOf(key, value);    //新加进来的value将会被放置在链表的尾部，put方法会返回key对应的原value，若没有则返回null            previous = map.put(key, value);    //如果key对应的value被替换，删除原有value的内存大小            if (previous != null) {                size -= safeSizeOf(key, previous);            }        }        if (previous != null) {            entryRemoved(false, key, previous, value);        }        trimToSize(maxSize);        return previous;    }

上述代码中，可以发现LruCache的put方法主要是调用了HashMap的put方法

 @Override public V put(K key, V value) {        if (key == null) {            return putValueForNullKey(value);        }        int hash = Collections.secondaryHash(key);        HashMapEntry<K, V>[] tab = table;        int index = hash & (tab.length - 1);        for (HashMapEntry<K, V> e = tab[index]; e != null; e = e.next) {            if (e.hash == hash && key.equals(e.key)) {                preModify(e);                V oldValue = e.value;                e.value = value;                return oldValue;            }        }        // No entry for (non-null) key is present; create one        modCount++;        if (size++ > threshold) {            tab = doubleCapacity();            index = hash & (tab.length - 1);        }        addNewEntry(key, value, hash, index);        return null;    }

addNewEntry以上的代码主要是判断传进来的key是否已经存在，如果存在则更换对应的value并返回上一个value，如果key不存在，则执行addNewEntry方法。
LinkedHashMap继承自HashMap，LinkedHashMap本身并没有重写put方法，而是通过重写addNewEntry方法实现value的添加。

@Override void addNewEntry(K key, V value, int hash, int index) {        LinkedEntry<K, V> header = this.header;        // Remove eldest entry if instructed to do so.        LinkedEntry<K, V> eldest = header.nxt;        if (eldest != header && removeEldestEntry(eldest)) {            remove(eldest.key);        }        // Create new entry, link it on to list, and put it into table        LinkedEntry<K, V> oldTail = header.prv;        LinkedEntry<K, V> newTail = new LinkedEntry<K,V>(                key, value, hash, table[index], header, oldTail);        table[index] = oldTail.nxt = header.prv = newTail;    }

其中红色线段代表nxt，蓝色代表pre（画的丑，不要见怪）

回到LruCache中的put方法，在其中还有一个重要的方法trimToSize（int maxSize）其作用的是移除一直没被调用的项，直到剩余项的数小于请求的大小，如果maxSize传入-1，则清空缓存中的所有对象。

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;                }                //离header最近的，即上图中的1                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);        }    }

将上述的进行总结：往cache中添加value时，会将加入的value添加到双链表的尾部，同时判断当前缓冲的大小是否已经超过了限定的大小，删除最“老”的。

接下来LruCache的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.                */        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 put                 //如果mapValue不为空，则撤销上一步的put操作。                map.put(key, mapValue);            } else {                size += safeSizeOf(key, createdValue);            }        }        if (mapValue != null) {            entryRemoved(false, key, createdValue, mapValue);            return mapValue;        } else {        //每次新加入对象都需要调用trimToSize方法看是否需要回收            trimToSize(maxSize);            return createdValue;        }    }

上面代码中出现的create方法需要我们去重写，但基本上不会去重写该方法，因为如果value丢失我们都会重新去获取。
相同的上述代码中最重要的是map.get（），查看LinkedHashMap的get方法。

@Override 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.         */        if (key == null) {            HashMapEntry<K, V> e = entryForNullKey;            if (e == null)                return null;            if (accessOrder)                makeTail((LinkedEntry<K, V>) e);            return e.value;        }    //查询链表中是否已具有该key对应的value，如果有再判读accessOrder是否为true        int hash = Collections.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 (accessOrder)                    makeTail((LinkedEntry<K, V>) e);                return e.value;            }        }        return null;    }

put方法的功能就是从链表中获取key对应的value（因为不是解析LinkedHashMap所以不具体说明），这里需要关注的是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++;    }

该方法将访问的key的项放到链表的尾部。

总结

可以发现Lru算法的实现是通过LinkedHashMap来实现的，通过将新添加的和最近访问的项放到链表的尾部，当缓存大于限制时，移除头部的项来实现近期最少使用算法。