Android LruCache类分析

一. LruCache使用背景

在我们的项目开发中，多多少少都会用到图片资源，有的使用我们的图片资源还会以列表的形式展开，可想而知，当我们滑动列表的时候，如果我们一直生成数据，可想而知，肯定会发生OOM，LruCache就是为了应对这种场景产生的。

二.LruCache原理

LruCache是基于java中的LinkedHashMap实现的，我们在外部先设置这个LinkedHashMap中的所有数据元所占内存空间总和的最大值，当我们从这个容器中获取数据元素的时候，现将数据获取出来，再将其位置移动到队列的头部，这样我们能够保证最经使用的数据元素都在队列的头部，当我们向队列中添加数据的时候，计算整个队列中的所有数据元素的大小，如果数据的总大小超过分配的内存，就从队列的末尾开始销毁数据，直到数据的总大小小于或者等于分配的内存的大小。

三.源码分析

首先看LruCache的构造函数，这里我们传入这个缓存池的最大的大小，同时设置LinkedHashMap为访问模式，也就是当我们从LinkedHashMap中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(K key, V value) {
if (key == null || value == null) {
throw new NullPointerException("key == null || value == null");
}

V previous;
synchronized (this) {
putCount++;
size += safeSizeOf(key, value);
previous = map.put(key, value);
if (previous != null) {
size -= safeSizeOf(key, previous);
}

Log.info(TAG, "LruCache put____________________size:" + size);
}

if (previous != null) {
entryRemoved(false, key, previous, value);
}

trimToSize(maxSize);
return previous;
}

这个方法的主要意思就是，我们将简直对存放到LinkedHashMap中，在添加后，我们在计算整个容器的大小，判断其是否超过之前设置的最大空间值，如果超过就从队列的最后面开始销毁数据，具体方法trimToSize(maxSize);如下：

private 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!");
break;
}

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++;

Log.info(TAG, "LruCache trimToSize____________________size:" + size);
}

entryRemoved(true, key, value, null);
}
}

最后再看一下从缓存池中获取数据的放法：

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

V mapValue;
synchronized (this) {
mapValue = map.get(key);
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);
if (createdValue == null) {
return null;
}

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);
Log.info(TAG, "LruCache get____________________size:" + size);
}
}

if (mapValue != null) {
entryRemoved(false, key, createdValue, mapValue);
return mapValue;
} else {
trimToSize(maxSize);
return createdValue;
}
}

        我们先从缓存池中获取数据，如果获取的数据为null，这个时候我们尝试去创建一个Null值的数据返回，但是到我们执行Create方法的时候，整个缓存池可能会发生变化，所以后面又做了一些处理，整个逻辑还是比较严谨的。

好，对LruCache分析就到这，如果有理解不对，还请指出，下一篇讲解LruCache的具体使用，谢谢！