Android缓存机制——LruCache

Android的三级缓存，其中主要的就是内存缓存和硬盘缓存。这两种缓存机制的实现都应用到了LruCache算法，下面我们就从使用到源码解析，来彻底理解Android中的缓存机制。

LruCache 介绍

LruCache 顾名思义就是使用LRU缓存策略的缓存，那么LRU是什么呢? 最近最少使用到的（least recently used），就是当超出缓存容量的时候，就优先淘汰链表中最近最少使用的那个数据。

讲到LruCache，其实最关键的还是LinkedHashMap。LruCache的源码本身很少，而实现了LRU的功能都是靠LinkedHashMap。
 

LruCache 使用

// 初始化LruCache
int memory = (int) Runtime.getRuntime().totalMemory() / 1024;
int cache = memory / 8;
LruCache lruCache = new android.util.LruCache<String, Bitmap>(cache) {
    @Override
    protected int sizeOf(String key, Bitmap bitmap) {
        return bitmap.getRowBytes() * bitmap.getHeight() / 1024;
    }
};


// 存
lruCache.put("key", value);
// 取
lruCache.get("key");

LruCache 初始化

LruCache初始化，主要初始化一个 LinkedHashMap ，可以看到比平常我们初始化多一个 accessOrder = true 的过程
accessOrder = true 表示： LinkedHashMap 是按操作顺序排序的，put, get 操作都会把当前元素方法队尾

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);
}

LruCache 存元素

public final V put(@NonNull K key, @NonNull V value) {
    if (key == null || value == null) {
        throw new NullPointerException("key == null || value == null");
    }

    V previous;
    synchronized (this) {
        putCount++;
        // 把当前消耗的size加上当前value的size，safeSizeOf 其实就是继承的 sizeOf 方法计算得到的内存大小
        size += safeSizeOf(key, value);
        // 把元素加入到 LinkedHashMap 当中，返回值 previous 表示当前key值，上次的value值
        previous = map.put(key, value);
        // 如果不为空，把上一次的空间减去
        if (previous != null) {
            size -= safeSizeOf(key, previous);
        }
    }

    if (previous != null) {
    	// 告知元素被移除了，可以自己在这里实现具体移除该做的操作
        entryRemoved(false, key, previous, value);
    }

    // 判断空间有没有超，超出的话，移除队尾最不常使用的元素
    trimToSize(maxSize);
    return previous;
}

// 就是为了防止计算的内存小于0出错，其实就是计算内存的
private int safeSizeOf(K key, V value) {
    int result = sizeOf(key, value);
    if (result < 0) {
        throw new IllegalStateException("Negative size: " + key + "=" + value);
    }
    return result;
}

// 如果要计算真实内存的size，必须自己继承计算
protected int sizeOf(@NonNull K key, @NonNull V value) {
    return 1;
}


public void trimToSize(int maxSize) {
	// 不断循环，知道空间够了为止
    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!");
            }

            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);
    }
}

LruCache 取元素

public final V get(@NonNull K key) {
    if (key == null) {
        throw new NullPointerException("key == null");
    }

    V mapValue;
    synchronized (this) {
    	// 从 LinkedHashMap 中取当前key的元素
        mapValue = map.get(key);
        if (mapValue != null) {
            hitCount++;
            // 如果有直接返回
            return mapValue;
        }
        missCount++;
    }

    // 如果没有，尝试通过 create 方法恢复元素，需要自己继承实现 create 方法
    V createdValue = create(key);
    if (createdValue == null) {
        return null;
    }

    synchronized (this) {
        createCount++;
        // create 方法恢复出来，放入 LinkedHashMap 当中
        mapValue = map.put(key, createdValue);

        // 后续方法和put方法类似
        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;
    }
}

为什么 LinkedHashMap 的 get 方法可以把元素方法队尾

可以看到，当 accessOrder = true 的时候，就多走了一个方法——afterNodeAccess

public V get(Object key) {
    Node<K,V> e;
    if ((e = getNode(hash(key), key)) == null)
        return null;
    if (accessOrder)
        afterNodeAccess(e);
    return e.value;
}

afterNodeAccess 方法，其实就是把元素 e 方法队尾。
 

void afterNodeAccess(Node<K,V> e) { // move node to last
    LinkedHashMapEntry<K,V> last;
    if (accessOrder && (last = tail) != e) {
        LinkedHashMapEntry<K,V> p =
            (LinkedHashMapEntry<K,V>)e, b = p.before, a = p.after;
        p.after = null;
        if (b == null)
            head = a;
        else
            b.after = a;
        if (a != null)
            a.before = b;
        else
            last = b;
        if (last == null)
            head = p;
        else {
            p.before = last;
            last.after = p;
        }
        tail = p;
        ++modCount;
    }
}

LruCache 注意事项

多个继承方法

如果要计算真实内存的size，必须自己继承计算内存size的方法 sizeOf ，不然默认每个对象为 size + 1，不会计算真实内存大小。

如果想某个key的value被回收之后不为空，可以继续使用，必须继承 create 方法，自己在当前key获得的value为空之后，重新创建一个。

如果想要知道某个元素被移除了，可以继承 entryRemoved 方法。
 

找对正确的 LruCache

我看得到是android Q (29) 的源码
android.util.LruCache 中的 trimToSize() 方法，去掉的是队尾。开始我也被搞蒙了很久，LinkedHashMap 不是最近的放在队尾的吗？
后面找了一下，还有一个 android.collection.LruCache ，人家取的就是队列第一个元素。没搞明白是不是 android.util.LruCache 里面错了。
反正后面也找了其他地方得 LruCache ，比如Gilde等，清一色都是去掉的队列第一个元素。
看网上以前android版本的 android.util.LruCache 删的也是第一个元素，不知道什么版本开始删的队尾，有兴趣的可以自己找下。

Map.Entry<K, V> toEvict = null;
for (Map.Entry<K, V> entry : map.entrySet()) {
    toEvict = entry;
}
// END LAYOUTLIB CHANGE

if (toEvict == null) {
    break;
}

key = toEvict.getKey();
value = toEvict.getValue();
map.remove(key);
size -= safeSizeOf(key, value);
evictionCount++;

android.collection.LruCache 中的 trimToSize() 方法，去掉的是队列第一个元素

Map.Entry<K, V> toEvict = map.entrySet().iterator().next();
key = toEvict.getKey();
value = toEvict.getValue();
map.remove(key);
size -= safeSizeOf(key, value);
evictionCount++;

————————————————
版权声明：本文为CSDN博主「吴中乐」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_16927853/article/details/102905637