LruCache源码解析

　　Android开发中，为了减少用户的流量使用和使APP体验更流畅，我们通常会使用缓存技术。通常来说，缓存分两级。第一级，是内存缓存，它的好处是，读写非常快，缺点则是，过量地使用会使APP整体变得十分卡顿，因为运行的内存不足了，甚至引起OOM。第二级则是文件缓存（File,SQLite等），文件缓存的读写效率要低于内存缓存。但是空间更加的充足。

　　一级缓存由于空间很有限，我们通常会为它设置一个size，当超过这个size时，缓存会将不常用的内容清掉。

　　Android中提供了一个方便的容器，用来处理这个缓存问题——LruCache。在此阅读它的源码并做一下笔记。

　　

public class LruCache<K, V> {
    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;
    private int createCount;
    private int evictionCount;
    private int hitCount;
    private int missCount;

　　从这里可以很容易地发现，LruCache本质上就是一个LinkedHashMap，我们对它进行控制，达到上述的效果。先看一下这个类的几个属性。

　　size是当前缓存的大小

　　maxSize是缓存的最大大小

　　后面的属性具体作用在阅读过程中再来理解。

　　接下来，我们再看一下LruCache的构建函数。　　

    /**
     * @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);
    }

　　这一段代码很简单，就是设置缓存的最大size并新建一个LinkedHashMap的对象。并对输入合法性作了检测，如果其值不大于0，则抛出异常。

　　接下来是重设maxSize的方法。

    /**
     * Sets the size of the cache.
     * @param maxSize The new maximum size.
     *
     * @hide
     */
    public void resize(int maxSize) {
        if (maxSize <= 0) {
            throw new IllegalArgumentException("maxSize <= 0");
        }

        synchronized (this) {
            this.maxSize = maxSize;
        }
        trimToSize(maxSize);
    }

　　除了重设maxSize外，这个方法在最后还对已有的缓存进行了修整。因为当我们将最大缓存修改的比当前缓存还小时，就会有一部分已有的缓存需要清理。所以，我们接下来看一下，清理的方法

    /**
     * @param maxSize the maximum size of the cache before returning. May be -1
     *     to evict even 0-sized elements.
     */
    private 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;
                }

                // BEGIN LAYOUTLIB CHANGE
                // get the last item in the linked list.
                // This is not efficient, the goal here is to minimize the changes
                // compared to the platform version.
                Map.Entry<K, V> toEvict = null;
                for (Map.Entry<K, V> entry : map.entrySet()) {
                    toEvict = entry;
                }
                // END LAYOUTLIB CHANGE

                if (toEvict == null) {
                    break;
                }

                key = toEvict.getKey();
                value = toEvict.getValue();
                map.remove(key);
                size -= safeSizeOf(key, value);
                evictionCount++;
            }

            entryRemoved(true, key, value, null);
        }
    }

　　整个方法处在一个死循环中，前面先对输入合法性进行了检查，并且只有在 if (size > maxSize)的情况下，才会进行清理、修整。循环中，我们会通过一个for循环找到LinkedHashMap中的最后一项。上面代码中，找到最后一项的代码并不是最优的，它的编写者是为了保持它与线上版本一至。找到最后一项后，获取它的key和value。从LinkedHashMap中移除它，并计算它能够释放的内存大小，再重新检查，现在是内存状况是否满足maxSize的限定，并调用了一个空方法entryRemoved（我们可以通过继承重写这个方法，进行一些扩展）。如果不满足，继续清理。其中safeSizeof是计算缓存中一项的大小的方法，我们再来看看它：

　　

    private int safeSizeOf(K key, V value) {
        int result = sizeOf(key, value);
        if (result < 0) {
            throw new IllegalStateException("Negative size: " + key + "=" + value);
        }
        return result;
    }
    /**
     * Returns the size of the entry for {@code key} and {@code value} in
     * user-defined units.  The default implementation returns 1 so that size
     * is the number of entries and max size is the maximum number of entries.
     *
     * <p>An entry's size must not change while it is in the cache.
     */
    protected int sizeOf(K key, V value) {
        return 1;
    }

　　由上面的代码可以看到，不论我们存什么，LruCache都认为一项存的大小为1。这样，我们在设置大小时，实际设置的是我们要存多少项数据。如果要我们需要它能够真正地反映我们存的内容的大小，我们需要继承并重写sizeOf这个方法。

　　至此，就看完了LruCache的一次初始化。接下来，我们来看看它是如何保存数据。

　　

    /**
     * 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++;
            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;
    }

　　照常先是输入合法性检查，然后会将新的储存值的size加入到整个LruCache的size中。将新的值放入LinkedHashMap中，并取出老的值。然后将老的值占的size从LruCache整个size中减去。接着，调用空方法entryRemoved，最后，修整缓存的size。并将被取代掉的那个值，返回。

　　可以看到，LruCache的put的方法几乎就是LinkedHashMap的扩展。多了输入合法性检查、调整size，修整缓存三部分。这里的重点是，由于LinkedHashMap是一个有序的Map结构，因此，不论是insert还是update，最近操作的数据，都会放在最前面。

　　

　　然后，我们再来看看LruCache的get部分：

    /**
     * Returns the value for {@code key} if it exists in the cache or can be
     * created by {@code #create}. If a value was returned, it is moved to the
     * head of the queue. This returns null if a value is not cached and cannot
     * be created.
     */
    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
                map.put(key, mapValue);
            } else {
                size += safeSizeOf(key, createdValue);
            }
        }

        if (mapValue != null) {
            entryRemoved(false, key, createdValue, mapValue);
            return mapValue;
        } else {
            trimToSize(maxSize);
            return createdValue;
        }
    }

　　这个方法比较长，可以分为两部分。第一部分是比较常规的从LinkedHashMap中取值，第二部分则是，如果map中不存在这个值，则新建一个这样的值。但是新建的方法，原类中是一个空方法，需要我们自行继承、重写。

综上，我们已经分析了LruCache这个类的大部分方法。总结下来它的工作模式就是，将新建或者更新的数据放在最前面，每次操作后，检查size大小，如果size超过了maxSize，则将最后面的值进行清理，使size回归正常范围。如果我们继承这个类，我们可以比较方便的扩展如下内容：

1、每个数据占用的内存大小的计算

2、清理缓存后的我们调用的方法

3、如果要获取的值，不存在于LruCache中，我们新建它调用的方法。

 　　Done~