30.Android v4 LruCache

30.Android v4 LruCache

1. 简介

2. 使用方法

sizeOf

entryRemoved

create

entryRemoved

entryRemoved

private static final float ONE_MIB = 1024 * 1024;
// 7MB
private static final int CACHE_SIZE = (int) (7 * ONE_MIB);
private LruCache<String, Bitmap> bitmapCache;
this.bitmapCache = new LruCache<String, Bitmap>(CACHE_SIZE) {
protected int sizeOf(String key, Bitmap value) {
return value.getByteCount();
}

/**
* 1.当被回收或者删掉时调用。该方法当value被回收释放存储空间时被remove调用
* 或者替换条目值时put调用，默认实现什么都没做。
* 2.该方法没用同步调用，如果其他线程访问缓存时，该方法也会执行。
* 3.evicted=true：如果该条目被删除空间 （表示 进行了trimToSize or remove）  evicted=false：put冲突后 或 get里成功create后 导致
* 4.newValue!=null，那么则被put()或get()调用。
*/
@Override
protected void entryRemoved(boolean evicted, String key, Bitmap oldValue, Bitmap newValue) {
mEntryRemovedInfoText.setText(
String.format(Locale.getDefault(), LRU_CACHE_ENTRY_REMOVED_INFO_FORMAT,
evicted, key, oldValue != null ? oldValue.hashCode() : "null",
newValue != null ? newValue.hashCode() : "null"));
// 见上述 3.
if (evicted) {
// 进行了trimToSize or remove (一般是溢出了 或 key-value被删除了 )
if (recentList.contains(key)) {
recentList.remove(key);
refreshText(mRecentInfoText, LRU_CACHE_RECENT_FORMAT, recentList);
}
} else {
// put冲突后 或 get里成功create 后
recentList.remove(key);
refreshText(mRecentInfoText, LRU_CACHE_RECENT_FORMAT, recentList);
}
if (cacheList.contains(key)) {
cacheList.remove(key);
refreshText(mCacheDataText, LRU_CACHE_CACHE_DATA_FORMAT, cacheList);
}
}
};

3. 效果展示

3.1 效果一（验证 LRU，最近没访问的，在溢出时优先被清理）

entryRemoved

3.2 效果二（验证 entryRemoved 的 evicted=false，可以验证冲突）

4. 源码分析

4.1 LruCache 原理概要解析

LinkedHashMap

accessOrder=true

LruCache.get(K key)

LinkedHashMap.get(Object key)

accessOrder=true

LinkedHashMap.get(Object key)

LinkedHashMap.makeTail(LinkedEntry<K, V> e)

LinkedHashMap

LruCache.get

LinkedHashMap.get

put

trimToSize

4.2 LruCache 的唯一构造方法

/**
* LruCache的构造方法：需要传入最大缓存个数
*/
public LruCache(int maxSize) {
// 最大缓存个数小于0，会抛出IllegalArgumentException
if (maxSize <= 0) {
throw new IllegalArgumentException("maxSize <= 0");
}
this.maxSize = maxSize;
/*
* 初始化LinkedHashMap
* 第一个参数：initialCapacity，初始大小
* 第二个参数：loadFactor，负载因子=0.75f
* 第三个参数：accessOrder=true，基于访问顺序；accessOrder=false，基于插入顺序
*/
this.map = new LinkedHashMap<K, V>(0, 0.75f, true);
}

initialCapacity

loadFactor

accessOrder=true

4.3 LruCache.get(K key)

/**
* 根据 key 查询缓存，如果存在于缓存或者被 create 方法创建了。
* 如果值返回了，那么它将被移动到双向循环链表的的尾部。
* 如果如果没有缓存的值，则返回 null。
*/
public final V get(K key) {

...

V mapValue;
synchronized (this) {
// LinkHashMap 如果设置按照访问顺序的话，这里每次get都会重整数据顺序
mapValue = map.get(key);
// 计算 命中次数
if (mapValue != null) {
hitCount++;
return mapValue;
}
// 计算 丢失次数
missCount++;
}

/*
* 官方解释：
* 尝试创建一个值，这可能需要很长时间，并且Map可能在create()返回的值时有所不同。如果在create()执行的时
* 候，一个冲突的值被添加到Map，我们在Map中删除这个值，释放被创造的值。
*/
V createdValue = create(key);
if (createdValue == null) {
return null;
}

/***************************
* 不覆写create方法走不到下面 *
***************************/

/*
* 正常情况走不到这里
* 走到这里的话 说明 实现了自定义的 create(K key) 逻辑
* 因为默认的 create(K key) 逻辑为null
*/
synchronized (this) {
// 记录 create 的次数
createCount++;
// 将自定义create创建的值，放入LinkedHashMap中，如果key已经存在，会返回 之前相同key 的值
mapValue = map.put(key, createdValue);

// 如果之前存在相同key的value，即有冲突。
if (mapValue != null) {
/*
* 有冲突
* 所以 撤销 刚才的 操作
* 将 之前相同key 的值 重新放回去
*/
map.put(key, mapValue);
} else {
// 拿到键值对，计算出在容量中的相对长度，然后加上
size += safeSizeOf(key, createdValue);
}
}

// 如果上面 判断出了 将要放入的值发生冲突
if (mapValue != null) {
/*
* 刚才create的值被删除了，原来的 之前相同key 的值被重新添加回去了
* 告诉 自定义 的 entryRemoved 方法
*/
entryRemoved(false, key, createdValue, mapValue);
return mapValue;
} else {
// 上面 进行了 size += 操作 所以这里要重整长度
trimToSize(maxSize);
return createdValue;
}
}

get

mapValue = map.get(key)

4.4 LinkedHashMap.get(Object key)

/**
* Returns the value of the mapping with the specified key.
*
* @param key
*            the key.
* @return the value of the mapping with the specified key, or {@code null}
*         if no mapping for the specified key is found.
*/
@Override public V get(Object key) {
/*
* This method is overridden to eliminate the need for a polymorphic
* invocation in superclass at the expense of code duplication.
*/
if (key == null) {
HashMapEntry<K, V> e = entryForNullKey;
if (e == null)
return null;
if (accessOrder)
makeTail((LinkedEntry<K, V>) e);
return e.value;
}

int hash = Collections.secondaryHash(key);
HashMapEntry<K, V>[] tab = table;
for (HashMapEntry<K, V> e = tab[hash & (tab.length - 1)];
e != null; e = e.next) {
K eKey = e.key;
if (eKey == key || (e.hash == hash && key.equals(eKey))) {
if (accessOrder)
makeTail((LinkedEntry<K, V>) e);
return e.value;
}
}
return null;
}

if (accessOrder)

accessOrder=true

get

makeTail(LinkedEntry<K, V> e)

4.5 LinkedHashMap.makeTail(LinkedEntry

/**
* Relinks the given entry to the tail of the list. Under access ordering,
* this method is invoked whenever the value of a  pre-existing entry is
* read by Map.get or modified by Map.put.
*/
private void makeTail(LinkedEntry<K, V> e) {
// Unlink e
e.prv.nxt = e.nxt;
e.nxt.prv = e.prv;

// Relink e as tail
LinkedEntry<K, V> header = this.header;
LinkedEntry<K, V> oldTail = header.prv;
e.nxt = header;
e.prv = oldTail;
oldTail.nxt = header.prv = e;
modCount++;
}

4.6 LruCache.put(K key, V value)

public final V put(K key, V value) {
...
synchronized (this) {
...
// 拿到键值对，计算出在容量中的相对长度，然后加上
size += safeSizeOf(key, value);
...
}
...
trimToSize(maxSize);
return previous;
}

safeSizeOf

size

safeSizeOf

sizeOf(K key, V value)

trimToSize

size

maxSize

4.7 LruCache.trimToSize(int maxSize)

public void trimToSize(int maxSize) {
/*
* 这是一个死循环，
* 1.只有 扩容 的情况下能立即跳出
* 2.非扩容的情况下，map的数据会一个一个删除，直到map里没有值了，就会跳出
*/
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!");
}
// 如果是 扩容 或者 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);
}
}

size

maxSize

makeTail

4.8 覆写 entryRemoved 的作用

create

create(K key)

create(key)

create(key)

/**
* 1.当被回收或者删掉时调用。该方法当value被回收释放存储空间时被remove调用
* 或者替换条目值时put调用，默认实现什么都没做。
* 2.该方法没用同步调用，如果其他线程访问缓存时，该方法也会执行。
* 3.evicted=true：如果该条目被删除空间 （表示 进行了trimToSize or remove）  evicted=false：put冲突后 或 get里成功create后
* 导致
* 4.newValue!=null，那么则被put()或get()调用。
*/
protected void entryRemoved(boolean evicted, K key, V oldValue, V newValue) {
}

entryRemoved

4.9 LruCache 局部同步锁

get

put

trimToSize

remove

entryRemoved

entryRemoved

5. 开源项目中的使用

6. 总结

accessOrder=true

LinkedHashMap

entryRemoved

maxSize

sizeOf(K key, V value)

7. 资源