LruCache是android提供的一个常用而且有用的数据缓存工具类,通其中是通过键值对来保存数据.对于LruCache首先看看原文的说明:
A cache that holds strong references to a limited number of values. Each time a value is accessed, it is moved to the head of a queue. When a value is added to a full cache, the value at the end of that queue is evicted and may become eligible for garbage
collection.
其大意是:LruCache是一个通过强引用来保存一定数量的数据的缓存技术.每次使用一个数据时候,这个数据就会被移动到队列的最前面(这样维护来一个访问数据的顺序).当新加一个数据到这个已经满了的缓存时候,这个缓存里面最后面的数据(最不常使用的数据)就会被清理掉.
通过上面的说明,基本可以知道LruCache作用和实现方法,不过仅仅上面的说明要深刻理解其中奥秘还是优点困难.上面有四处标记红色的地方,下面通过对这四处红色文字做以下说明.
(1)"一定数量的数据": 这里的"一定数量"通常是指LruCache缓存数据的数量(个数),也就是说LruCache缓存的键值对数据的个数.注意,这里我说的是"通常".当然也有其他情况:也可以是缓存数据所占用的内存的size(其单位一般时k,当然byte都可以),这个时候,你就需要重写LruCache的这个方法:sizeOf(K
key, V value)来计算每一个键值对数据所占用的内存:
private static LruCache<Integer, Drawable> createIconCache() {
final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
final int cacheSize = maxMemory / 8;
return new LruCache<Integer, Drawable>(cacheSize) {
protected int sizeOf(Integer key, Drawable drawable) {
if (drawable instanceof BitmapDrawable) {//计算一个这个BitmapDrawable占用内存
Bitmap bitmap = ((BitmapDrawable) drawable).getBitmap();
return bitmap.getByteCount() / 1024;
}
return 1;//否则返回1,默认情况下返回的就是1
}
};
}
上面的代码时候创建一个缓存Drawable的图片数据的LruCache对象,在方法sizeOf里面判断,如果当前缓存的是BitmapDrawable类型的图片数据,则返回的就是这个图片的内存大小,否则返回1.
很明显,当sizeOf方法返回1的时候,就表示当前的LruCache缓存的数据数量是指键值对数量.下面来看看LruCache中sizeOf方法默认是如何定义的:
protected int sizeOf(K key, V value) {
return 1;
}
默认情况下就是返回1的.所以如果你的LruCache缓存数据如果时图片并且/或者对缓存的数据的内存大小有限制的时候,就需要重写这个方法sizeOf(K key, V value)
(2)这个数据就会被移动到队列的最前面(这样维护来一个访问数据的顺序):其实很快可以知道,hashmap中的LinkedHashMap似乎就可以实现这个功能,LruCache当然也就使用来LinkedHashMap,来看看LruCache的构造方法就清楚了:
public LruCache(int maxSize) {//这里maxSize是指当前LruCache缓存数据最大量
if (maxSize <= 0) {
throw new IllegalArgumentException("maxSize <= 0");
}
this.maxSize = maxSize;
this.map = new LinkedHashMap<K, V>(0, 0.75f, true);//初始化一个LinkedHashMap,并且第三个参数是true,这表明这个LinkedHashMap是按照按访问顺序排序的.
}
(3)已经满了的缓存:每次使用LruCache的时候:调用put(K
key, V value)或者调用get(K key) 时候都会调用trimToSize(int maxSize)检测一下LruCache是否已经满了.
(4)被清理掉:同上面一样,在调用trimToSize检测是否已经满来的时候,如果已经满来就会清理掉,看看源码:
public void trimToSize(int maxSize) {
while (true) {//一个死循环:直到当前LruCache没有满才会跳出这个循环
K key;
V value;
synchronized (this) {
if (size < 0 || (map.isEmpty() && size != 0)) {//异常错误检测:当前已经缓存的数据数量不能为负数,并且没有数据的时候其数据数量不能大于0
throw new IllegalStateException(getClass().getName()
+ ".sizeOf() is reporting inconsistent results!");
}
if (size <= maxSize) {//如果已经缓存的数据数量小于最大容量(没有满),则跳出循环
break;
}
Map.Entry<K, V> toEvict = map.eldest();//通过LinkedHashMap来获取最不常用的一个键值对数据
if (toEvict == null) {
break;
}
key = toEvict.getKey();
value = toEvict.getValue();
map.remove(key); //删除这个数据
size -= <span style="color:#FF0000;">safeSizeOf</span>(key, value); //获取这个删除的键值对数据所占用的容量(有可能是1,也有可能是计算的图片占用的内存,也有可能是其他)
evictionCount++;
}
<span style="color:#FF0000;">entryRemoved</span>(true, key, value, null); //回调用entryRemoved,一般用于通知客户端,这个键值对数据已经被清理出LruCache了
}
}
上面的说明已经很清楚了,不过红色标识的两个方法需要下面来说说:
-
<span style="color:#FF0000;">safeSizeOf<span style="color:#000000;">来看看函数原型:</span></span>
private int safeSizeOf(K key, V value) { int result = sizeOf(key, value); if (result < 0) { throw new IllegalStateException("Negative size: " + key + "=" + value); } return result; }看到了吗,其实就是调用了sizeOf这个方法.
- entryRemoved 来看看函数原型: protected void entryRemoved(boolean evicted, K key, V oldValue, V newValue) {}
是一个空的函数,其实这个方法时给子类重写的,如果你想要知道你的LruCache在悄悄删除数据的时候能够告知你的话,你就需要重写这个方法,比如:你创建一个存储bitmap的数据的LruCache,你可能想要在LruCache清理掉这个数据的时候,自己再调用这个bitmap的recycle()来是否资源的话,你就需要重写entryRemoved了.
到了这里,应该对LruCache比较了解,不过一个问题由此出来了,不知道大家有没有想到:既然LruCache会自己清理掉最不常用的键值对数据,可是最不常用也不代表就不会使用呀!如果,突然使用了已经被清理掉的键值对数据这么办!
举个例子:我的listview来显示100个菜单项,每一个菜单项来显示一个图片,每一个图片都有100k大小,我的LruCache最大容量只有1000k,这样一来当我滑动菜单的时候肯定LruCache会清除掉很多图片.那这么办呢?如果我能够知道已经清理掉的数据需要再次使用就可以了,那我可以重新创建.
为了解决这个问题,LruCache里面的方法get(K
key)会去检测当前获取的数据是否为null,如果是null,则调用方法create来创建.默认情况下create这个方法直接返回 null;所以你自己的LruCache
是需要重写这个方法的.下面来看看get(K key)方法的源码:
public final V get(K key) {//通过key来获取存储的数据
if (key == null) {
throw new NullPointerException("key == null");
}
V mapValue;
synchronized (this) {
mapValue = map.get(key);//其实是通过LinkedHashMap来获取的
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);//如果当前<font color="#FF0000"><font color="#000000"><font color="#FF0000"><font color="#000000"><font color="#FF0000"><font color="#000000"><span style="color:#FF0000;"><span style="color:#000000;"><span style="color:#FF0000;">LruCache</span></span></span></font></font></font></font></font></font>没有这个数据,则调用create创建
if (createdValue == null) {
return null;
}
synchronized (this) {
createCount++;//更新自己创建的数量
mapValue = map.put(key, createdValue);//将新创建的数据加入到LinkedHashMap里面
if (mapValue != null) {
// There was a conflict so undo that last put
map.put(key, mapValue);//如果冲突来再次尝试
} else {
size += safeSizeOf(key, createdValue);//更新当前<font color="#FF0000"><font color="#000000"><font color="#FF0000"><font color="#000000"><font color="#FF0000"><font color="#000000"><span style="color:#FF0000;"><span style="color:#000000;"><span style="color:#FF0000;">LruCache</span></span></span></font></font></font></font></font></font> 已经存储数据的数量
}
}
if (mapValue != null) {
entryRemoved(false, key, createdValue, mapValue);//调用entryRemoved通知已经清理掉了一个数据
return mapValue;
} else {
trimToSize(maxSize);//检测是否已经满了
return createdValue;
}
}
说道到这里,我想已经说的很清楚了.
LruCache
这个工具类其实比较简单的.除了上面我说的特点外,还有其他的一些不太常用的东西,下面来看看里面的几个源方法:
public final V put(K key, V value) {//往<font color="#FF0000"><font color="#000000"><font color="#FF0000"><font color="#000000"><font color="#FF0000"><font color="#000000"><font color="#FF0000"><font color="#000000"><font color="#FF0000"><font color="#000000"><span style="color:#FF0000;"><span style="color:#000000;"><span style="color:#FF0000;">LruCache</span></span></span></font></font></font></font></font></font></font></font></font></font>里面加入数据
if (key == null || value == null) {
throw new NullPointerException("key == null || value == null");
}
V previous;
synchronized (this) {
putCount++;//加入数据个数的更新
size += safeSizeOf(key, value);//<font color="#FF0000"><font color="#000000"><font color="#FF0000"><font color="#000000"><font color="#FF0000"><font color="#000000"><font color="#FF0000"><font color="#000000"><font color="#FF0000"><font color="#000000"><span style="color:#FF0000;"><span style="color:#000000;"><span style="color:#FF0000;">LruCache</span></span></span></font></font></font></font></font></font></font></font></font></font> 存储数据的数量更新
previous = map.put(key, value);
if (previous != null) {
size -= safeSizeOf(key, previous);
}
}
if (previous != null) {
entryRemoved(false, key, previous, value);
}
trimToSize(maxSize);////检测是否已经满了
return previous;
}
public final void evictAll() {//清理掉所有数据
trimToSize(-1); // -1 will evict 0-sized elements
}