浅析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 的数据操作上锁实现的缓存策略。
LinkedHashMap默认的构造参数是默认 插入顺序的，就是说你插入的是什么顺序，读出来的就是什么顺序，但是也有访问顺序，就是说你访问了一个key，这个key就跑到了最后面。
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中队首的元素，即近期最少访问的，直到缓存大小小于最大值。
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
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
