Android源码分析：LruCache 缓存机制实现原理

2401_84149743

于 2024-04-16 19:50:38 发布

阅读量1k

点赞数 28

分类专栏：程序员文章标签： android 缓存

本文链接：https://blog.csdn.net/2401_84149743/article/details/137837751

版权

程序员专栏收录该内容

274 篇文章 0 订阅

订阅专栏

LruCache使用示例

LruCache的使用非常简单，我们就以图片缓存为例：

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

设置LruCache缓存的大小，一般为当前进程可用容量的1/8。
重写sizeOf方法，计算出要缓存的每张图片的大小。

注意：缓存的总容量和每个缓存对象的大小所用单位要一致。

LruCache的实现原理

LruCache的核心思想很好理解，就是要维护一个缓存对象列表，其中对象列表的排列方式是按照访问顺序实现的，即一直没访问的对象，将放在队尾，即将被淘汰。而最近访问的对象将放在队头，最后被淘汰。如下图所示：

那么这个队列到底是由谁来维护的，前面已经介绍了是由LinkedHashMap来维护。

而LinkedHashMap是由数组+双向链表的数据结构来实现的。其中双向链表的结构可以实现访问顺序和插入顺序，使得LinkedHashMap中的：

/**

Constructs a new {@code LinkedHashMap} instance with the specified
capacity, load factor and a flag specifying the ordering behavior.
@param initialCapacity

       the initial capacity of this hash map.

@param loadFactor
```
       the initial load factor.
```
@param accessOrder

       {@code true} if the ordering should be done based on the last

       access (from least-recently accessed to most-recently

       accessed), and {@code false} if the ordering should be the

       order in which the entries were inserted.

*/
public LinkedHashMap(
int initialCapacity, float loadFactor, boolean accessOrder) {
super(initialCapacity, loadFactor);
init();
this.accessOrder = accessOrder;
}

其中accessOrder设置为true则为访问顺序，为false，则为插入顺序。

以具体例子解释，当设置为true时：

public static final void main(String[] args) {
LinkedHashMap<Integer, Integer> map = new LinkedHashMap<>(0, 0.75f, true);
map.put(0, 0);
map.put(1, 1);
map.put(2, 2);
map.put(3, 3);
map.put(4, 4);
map.put(5, 5);
map.put(6, 6);
map.get(1); //访问1
map.get(2); //访问2

for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
System.out.println(entry.getKey() + “:” + entry.getValue());
}
}

输出结果如下：

0:0
3:3
4:4
5:5
6:6
1:1
2:2

即最近访问的对象会被放到队尾，然后最后输出，那么这就正好满足的LRU缓存算法的思想。可见LruCache巧妙实现，就是利用了LinkedHashMap的这种数据结构。

下面我们在LruCache源码中具体看看，怎么应用LinkedHashMap来实现缓存的添加，获得和删除的。

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; //当前cache的大小
private int maxSize; //cache最大大小

private int putCount; //put的次数
private int createCount; //create的次数
private int evictionCount; //驱逐剔除的次数
private int hitCount; //命中的次数
private int missCount; //未命中次数

//…省略…
}

构造函数如下，可以看到LruCache正是用了LinkedHashMap的accessOrder=true构造参数实现LRU访问顺序：

public LruCache(int maxSize) {
if (maxSize <= 0) {
throw new IllegalArgumentException(“maxSize <= 0”);
}
this.maxSize = maxSize;
//将LinkedHashMap的accessOrder设置为true来实现LRU顺序
this.map = new LinkedHashMap<K, V>(0, 0.75f, true);
}

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++; //插入次数加1
size += safeSizeOf(key, value); //更新缓存的大小
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;
}

可以看到**put()方法并没有什么难点，重要的就是在添加过缓存对象后，调用trimToSize()**方法，来判断缓存是否已满，如果满了就要删除近期最少使用的算法。

trimToSize方法

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小于最大缓存，或者map为空，则不需要再删除缓存对象，跳出循环
if (size <= maxSize || map.isEmpty()) {
break;
}

//迭代器获取第一个对象，即队头的元素，近期最少访问的元素
Map.Entry<K, V> toEvict = map.entrySet().iterator().next();
key = toEvict.getKey();
value = toEvict.getValue();
//删除该对象，并更新缓存大小
map.remove(key);
size -= safeSizeOf(key, value);
evictionCount++;
}
entryRemoved(true, key, value, null);
}
}

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

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

我们先看LruCache的get()方法。