浅析LRUCache原理

一. LruCache基本原理

LRU全称为Least Recently Used，即最近最少使用。

LRU算法就是当缓存空间满了的时候，将最近最少使用的数据从缓存空间中删除，以增加可用的缓存空间来缓存新数据。

这个算法的内部有一个缓存列表，每当一个缓存数据被访问的时候，这个数据就会被提到列表尾部，每次都这样的话，列表的头部数据就是最近最不常使用的了，当缓存空间不足时，就会删除列表头部的缓存数据。

二. LruCache的使用

//获取系统分配给每个应用程序的最大内存
int maxMemory=(int)(Runtime.getRuntime().maxMemory()/1024); int cacheSize=maxMemory/8; private LruCache<String, Bitmap> mMemoryCache; //给LruCache分配1/8 mMemoryCache = new LruCache<String, Bitmap>(mCacheSize){ //重写该方法，来测量Bitmap的大小 @Override protected int sizeOf(String key, Bitmap value) { return value.getRowBytes() * value.getHeight()/1024; } };

三. LruCache部分源码解析

LruCache 利用 LinkedHashMap 的一个特性（accessOrder＝true 基于访问顺序），再加上对 LinkedHashMap 的数据操作上锁实现的缓存策略。

LruCache 的数据缓存是内存中的：

首先设置了内部 LinkedHashMap 构造参数 accessOrder=true，实现了数据按照访问顺序排序。
LruCache类在调用get(K key) 方法时，都会调用LinkedHashMap.get(Object key) 。设置了 accessOrder=true 后，调用LinkedHashMap.get(Object key) 都会通过LinkedHashMap的afterNodeAccess()方法将数据移到队尾。
由于最新访问的数据在尾部，在 put 和 trimToSize 的方法执行下，如果发生数据移除，会优先移除掉头部数据

1.构造方法


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

LinkedHashMap参数介绍：

initialCapacity 用于初始化该 LinkedHashMap 的大小。
loadFactor（负载因子）这个LinkedHashMap的父类 HashMap 里的构造参数，涉及到扩容问题，比如 HashMap 的最大容量是100，那么这里设置0.75f的话，到75的时候就会扩容。
accessOrder,这个参数是排序模式，true表示在访问的时候进行排序( LruCache 核心工作原理就在此)，false表示在插入的时才排序。

2.添加数据 LruCache.put(K key, V value)

/**
     * 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++; //safeSizeOf(key, value)。 //这个方法返回的是1，也就是将缓存的个数加1. // 当缓存的是图片的时候，这个size应该表示图片占用的内存的大小，所以应该重写里面调用的sizeOf(key, value)方法 size += safeSizeOf(key, value); //向map中加入缓存对象,若缓存中已存在，返回已有的值，否则执行插入新的数据，并返回null previous = map.put(key, value); //如果已有缓存对象，则缓存大小恢复到之前 if (previous != null) { size -= safeSizeOf(key, previous); } } //entryRemoved()是个空方法，可以自行实现 if (previous != null) { entryRemoved(false, key, previous, value); } trimToSize(maxSize); return previous; }

开始的时候确实是把值放入LinkedHashMap，不管超不超过你设定的缓存容量。
根据 safeSizeOf方法计算此次添加数据的容量是多少，并且加到size 里。
方法执行到最后时，通过trimToSize()方法来判断size 是否大于maxSize。

可以看到put()方法并没有太多的逻辑，重要的就是在添加过缓存对象后，调用 trimToSize()方法，来判断缓存是否已满，如果满了就要删除近期最少使用的数据。

2.trimToSize(int maxSize)

/**
     * Remove the eldest entries until the total of remaining entries is at or
     * below the requested size.
     *
     * @param maxSize the maximum size of the cache before returning. May be -1
     *            to evict even 0-sized elements.
     */
    public void trimToSize(int maxSize) { while (true) { K key; V value; synchronized (this) { //如果map为空并且缓存size不等于0或者缓存size小于0，抛出异常 if (size < 0 || (map.isEmpty() && size != 0)) { throw new IllegalStateException(getClass().getName() + ".sizeOf() is reporting inconsistent results!"); } //如果缓存大小size小于最大缓存，不需要再删除缓存对象，跳出循环 if (size <= maxSize) { break; } //在缓存队列中查找最近最少使用的元素，若不存在，直接退出循环，若存在则直接在map中删除。 Map.Entry<K, V> toEvict = map.eldest(); if (toEvict == null) { break; } key = toEvict.getKey(); value = toEvict.getValue(); map.remove(key); size -= safeSizeOf(key, value); //回收次数+1 evictionCount++; } entryRemoved(true, key, value, null); } }

/**
 * Returns the eldest entry in the map, or {@code null} if the map is empty.
 *
 * Android-added.
 *
 * @hide
 */
public Map.Entry<K, V> eldest() { Entry<K, V> eldest = header.after; return eldest != header ? eldest : null; }

trimToSize()方法不断地删除LinkedHashMap中队首的元素，即近期最少访问的，直到缓存大小小于最大值。

扫描二维码关注公众号，回复： 11267992 查看本文章

3.LruCache.get(K key)

    /**
     * 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.
     * 通过key获取缓存的数据，如果通过这个方法得到的需要的元素，那么这个元素会被放在缓存队列的尾部，
     * 
     */
    public final V get(K key) { if (key == null) { throw new NullPointerException("key == null"); } V mapValue; synchronized (this) { //从LinkedHashMap中获取数据。 mapValue = map.get(key); if (mapValue != null) { hitCount++; return mapValue; } missCount++; } /* * 正常情况走不到下面 * 因为默认的 create(K key) 逻辑为null * 走到这里的话说明实现了自定义的create(K key) 逻辑，比如返回了一个不为空的默认值 */ /* * 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. * 译：如果通过key从缓存集合中获取不到缓存数据，就尝试使用creat(key)方法创造一个新数据。 * create(key)默认返回的也是null，需要的时候可以重写这个方法。 */ V createdValue = create(key); if (createdValue == null) { return null; } //如果重写了create(key)方法，创建了新的数据，就讲新数据放入缓存中。 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; } }

当调用LruCache的get()方法获取集合中的缓存对象时，就代表访问了一次该元素，将会更新队列，保持整个队列是按照访问顺序排序,这个更新过程就是在LinkedHashMap中的get()方法中完成的。

总结

LruCache中维护了一个集合LinkedHashMap，该LinkedHashMap是以访问顺序排序的。
当调用put()方法时，就会在集合中添加元素，并调用trimToSize()判断缓存是否已满，如果满了就用LinkedHashMap的迭代器删除队首元素，即近期最少访问的元素。
当调用get()方法访问缓存对象时，就会调用LinkedHashMap的get()方法获得对应集合元素，同时会更新该元素到队尾。

作者：karlsu
链接：https://www.jianshu.com/p/e7843dc350ae
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。