Android内存缓存管理LruCache源码解析与示例

在深圳出差，非常忙，抽空写文章，这些文章的质量很可能不高，但还是希望可以帮到你。

在加载图片的时候，我们要考虑到内存问题，（内存缓存作为最先被读取的数据，应该存储那些经常使用的数据对象，且内存容量有限，内存缓存的容量应该限定。）如果你加载是高清无码大图很可能会造成OOM，那我们需要一个东西来管理这个图片与其缓存。

今天我们来讲一下LruCache的原理及实现，这个谷歌推荐的内存缓存的方法。

那么Lru是什么？

LRU全称为Least Recently Used，即最近最少使用，是一种缓存置换算法。（多加一句LFU（least frequently used ）算法，则淘汰的是最不经常使用的）。

问题：当有新的内容需要加入我们的缓存，但我们的缓存空闲的空间不足以放进新的内容时，如何舍弃原有的部分内容从而腾出空间用来放新的内容。

让我们进入一下LruCache的学习

首先让我们看一下使用方法中的初始化MemoryCache：

public class BitmapMemoryCache {

private static final String TAG = "BitmapMemoryCache";

private static BitmapMemoryCache sInstance = new BitmapMemoryCache();

private LruCache<String, Bitmap> mMemoryCache;

public Map<String, SoftReference<Bitmap>> mImageCacheMap = new HashMap<String, SoftReference<Bitmap>>();

/*单例模式*/
public  BitmapMemoryCache getInstance() {
return BitmapMemoryCache.sInstance;
}

private BitmapMemoryCache() {
int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);//获取系统分配给应用的总内存大小，不是获取系统全部的的
int cacheSize = maxMemory / 8;//设置图片内存缓存占用八分之一，要依据你申请下来的和你估算使用的大小来
Log.e(TAG, "" + cacheSize);
mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {
@Override
protected int sizeOf(String key, Bitmap bitmap) {
// 重写此方法来衡量每张图片的大小，默认返回图片数量。
Log.w(TAG, "addBitmapTo " + (bitmap.getByteCount() / 1024));
return bitmap.getByteCount() / 1024;
}
};
}
}

接着让我们进入LruCache源码

明显的可以看出LruCache是利用了LinkedHashMap

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;//当前缓存内容的大小。
private int maxSize; // 最大可缓存的大小

private int putCount;// put方法被调用的次数
private int createCount;//create(Object) 被调用的次数
private int evictionCount;//被置换出来的元素的个数
private int hitCount; //get方法获取到缓存中的元素的次数
private int missCount;//get方法未获取到缓存中元素的次数

/**
* @param maxSize for caches that do not override {@link #sizeOf}, this is
*     the maximum number of entries in the cache. For all other caches,
*     this is the maximum sum of the sizes of the entries in this cache.
*/
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);
}

/**
* Sets the size of the cache.
*//设置缓存大小
* @param maxSize The new maximum size.
*/
public void resize(int maxSize) {
if (maxSize <= 0) {
throw new IllegalArgumentException("maxSize <= 0");
}

synchronized (this) {
this.maxSize = maxSize;
}
trimToSize(maxSize);
}
}

走到这里我们有个疑问—LinkedHashMap是什么？它是怎么实现LRU这种缓存策略的？

看文中的一句代码：

this.map = new LinkedHashMap<K, V>(0, 0.75f, true);

让我们进入LinkedHashMap源码来看一下。

进入构造方法查看。

/**

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

参数说明：

initialCapacity 初始容量大小，使用无参构造方法时，此值默认是4(安卓SdkVersion 24中默认4，这里是使用了父类HashMap的默认值)

loadFactor 加载因子，使用无参构造方法时，此值默认是 0.75f(安卓SdkVersion 24中默认0.75，这里是使用了父类HashMap的默认值)

accessOrder false： 基于插入顺序 true： 基于访问顺序

LinkedHashMap继承自HashMap，不同的是，它是一个双向循环链表，它的每一个数据结点都有两个指针，分别指向直接前驱和直接后继，这一个我们可以从它的内部类LinkedEntry中看出，其定义如下：

/**
private static class LinkedHashMapEntry<K,V> extends HashMapEntry<K,V> {
// These fields comprise the doubly linked list used for iteration.
LinkedHashMapEntry<K,V> before, after;
//一个双向循环链表，它的每一个数据结点都有两个指针，
//分别指向直接前驱和直接后继

LinkedHashMapEntry(int hash, K key, V value, HashMapEntry<K,V> next) {
super(hash, key, value, next);
}

private void remove() {
before.after = after;
after.before = before;
}

// Inserts this entry before the specified existing entry in the list.

private void addBefore(LinkedHashMapEntry<K,V> existingEntry) {
after  = existingEntry;
before = existingEntry.before;
before.after = this;
after.before = this;
}

void recordAccess(HashMap<K,V> m) {
LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
if (lm.accessOrder) {
lm.modCount++;
remove();
addBefore(lm.header);
}
}

void recordRemoval(HashMap<K,V> m) {
remove();
}
}

LinkedHashMap实现了双向循环链表的数据结构。

1,当链表不为空时，header.after指向第一个结点，header.before指向最后一个结点；

2,当链表为空时，header.after与header.before都指向它本身。

@Override

void init() {

header = new LinkedHashMapEntry<>(-1, null, null,null);

header.before = header.after = header;

}

accessOrder是指定它的排序方式，当它为false时，只按插入的顺序排序，即新放入的顺序会在链表的尾部；而当它为true时，更新或访问某个节点的数据时，这个对应的结点也会被放到尾部。

它通过构造方法public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder)来赋值。

我们加入一个新结点来看一下方法执行过程（在LinkedHashMap中）：

void addEntry(int hash, K key, V value, int bucketIndex) {
// Previous Android releases called removeEldestEntry() before actually
// inserting a value but after increasing the size.
// The RI is documented to call it afterwards.
// **** THIS CHANGE WILL BE REVERTED IN A FUTURE ANDROID RELEASE ****

//这个地方我专门去看了24和25，他并没有改，不知什么原因，欺骗我的感情

// Remove eldest entry if instructed  如果得到通知，移除最旧的
LinkedHashMapEntry<K,V> eldest = header.after;
if (eldest != header) {
boolean removeEldest;
size++;
try {
removeEldest = removeEldestEntry(eldest);
} finally {
size--;
}
if (removeEldest) {
removeEntryForKey(eldest.key);
}
}

super.addEntry(hash, key, value, bucketIndex);//调用父类的添加方法
}

好，我们来看一下父类的添加方法:

想要理解HashMap可以看我的这篇HashMap源码解析

//父类的这个方法也是将新添加的放入尾部，这里既是链表的尾部
void addEntry(int hash, K key, V value, int bucketIndex) {
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);
hash = (null != key) ? sun.misc.Hashing.singleWordWangJenkinsHash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}

createEntry(hash, key, value, bucketIndex);
}
void createEntry(int hash, K key, V value, int bucketIndex) {
HashMapEntry<K,V> e = table[bucketIndex];
table[bucketIndex] = new HashMapEntry<>(hash, key, value, e);
size++;
}

当我们加入新的元素之后，链表的顺序如图：

那么当我们访问了或者是更新了某个元素（当accessOrder为true时），链表里的元素位置怎么变化呢？

让我们来看一下get(Object key)方法的流程：

public V get(Object key) {
LinkedHashMapEntry<K,V> e = (LinkedHashMapEntry<K,V>)getEntry(key);//获取LinkedHashMapEntry
if (e == null)
return null;
e.recordAccess(this);//此方法记录下来，并重新排序
return e.value;
}

进入recordAccess()查看：

这个方法是在LinkedHashMapEntry内部：

//从这段代码中我们看到，首先执行remove，在执行addBefore
LinkedHashMapEntry<K,V> before, after;

void recordAccess(HashMap<K,V> m) {
LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
if (lm.accessOrder) {
lm.modCount++;
remove();
addBefore(lm.header);
}
}

private void remove() {//这是将此节点取出，如图一
before.after = after;
after.before = before;
//这有点绕，按照我的图片来捋一遍
//  node1.after=node3;
//  node3.before=node1
}
private void addBefore(LinkedHashMapEntry<K,V> existingEntry) {//此处将header传入，将操作的节点放置链表末尾
after  = existingEntry;
before = existingEntry.before;
before.after = this;
after.before = this;
}

图一：



是不是理解了LinkedHashMap的排序原理了？

熟悉了LinkedHashMap，让我们来分析LruCache；

我们发现，通过它来实现Lru算法也就变得理所当然了。我们所需要做的，就只剩下定义缓存的最大大小，记录缓存当前大小，在放入新数据时检查是否超过最大大小。

所以LruCache定义了以下三个必需的成员变量：

private final LinkedHashMap<K, V> map;

/** Size of this cache in units. Not necessarily the number of elements. */
private int size;//当前缓存内容的大小。
private int maxSize; // 最大可缓存的大小

让我们来解析一下它的get方法：

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++;//获取到缓存中的元素的次数+1，在文章头部有这几个参数的介绍
return mapValue;
}
missCount++;//未获取到缓存中的元素的次数+1
}

V createdValue = create(key);
if (createdValue == null) {
return null;//如果没有为key创建新值成功，则直接返回null
}

synchronized (this) {
createCount++;
mapValue = map.put(key, createdValue);
//create调用次数+1  将创建的值放入map中，如果map在前面的过程中正好放入了这对key-value，那么会返回放入的value

if (mapValue != null) {
// There was a conflict so undo that last put
map.put(key, mapValue);
/如果不为null，说明不需要我们所创建的值，所以把返回的值放进去
} else {
size += safeSizeOf(key, createdValue);
//为null，说明我们更新了这个key的值，需要重新计算大小
}
}

if (mapValue != null) {//上面放入的值有冲突
entryRemoved(false, key, createdValue, mapValue);// 移除之前创建的值，改为mapValue
return mapValue;
} else {
//没有冲突时，因为放入了新创建的值，大小已经有变化，所以需要调整大小
trimToSize(maxSize);
return createdValue;
}
}

LruCache是可能被多个线程同时访问的，所以在读写map时进行加锁。

当获取不到对应的key的值时，它会调用其create(K key)方法，这个方法用于当缓存没有命名时计算一个key所对应的值，它的默认实现是直接返回null。

这个方法并没有加上同步锁，也就是在它进行创建时，map可能已经有了变化。

所以在get方法中，如果create(key)返回的V不为null，会再把它给放到map中，并检查是否在它创建的期间已经有其他对象也进行创建并放到map中了，

如果有，则会放弃这个创建的对象，而把之前的对象留下，否则因为我们放入了新创建的值，所以要计算现在的大小并进行trimToSize。

trimToSize方法是根据传进来的maxSize，如果当前大小超过了这个maxSize，则会移除最老的结点，直到不超过。

trimToSize方法如下：

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

接下来，我们再来看LruCach的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++;
size += safeSizeOf(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;
}

主要逻辑是，计算新增加的大小，加入size，

然后把key-value放入map中，如果是更新旧的数据（map.put(key, value)会返回之前的value），则减去旧数据的大小，并调用entryRemoved(false, key, previous, value)方法通知旧数据被更新为新的值。

最后也是调用trimToSize(maxSize)修整缓存的大小。

文末附上我以前写的一个管理类

/**
* Bitmap缓存，简单缓存.
* Created by ChangMingShan on 2015/12/26.
*/
public class BitmapMemoryCache {

private static final String TAG = "BitmapMemoryCache";

private static BitmapMemoryCache sInstance = new BitmapMemoryCache();

private LruCache<String, Bitmap> mMemoryCache;

/**
* 单例模式.
*/
public static BitmapMemoryCache getInstance() {
return BitmapMemoryCache.sInstance;
}

private BitmapMemoryCache() {
int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
int cacheSize = maxMemory / 8;
mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {
@Override
protected int sizeOf(String key, Bitmap bitmap) {
// 重写此方法来衡量每张图片的大小，默认返回图片数量。
return bitmap.getByteCount() / 1024;
}
};
}
public synchronized void addBitmapToMemoryCache(String key, Bitmap bitmap) {
if (mMemoryCache.get(key) == null) {
if (key != null && bitmap != null)
mMemoryCache.put(key, bitmap);
} else
Log.w(TAG, "the res is aready exits");
}

public synchronized Bitmap getBitmapFromMemCache(String key) {
Bitmap bm = mMemoryCache.get(key);
if (key != null) {
return bm;
}
return null;
}

/**
* 移除缓存
*
* @param key
*/
public synchronized void removeImageCache(String key) {
if (key != null) {
if (mMemoryCache != null) {
Bitmap bm = mMemoryCache.remove(key);
if (bm != null)
bm.recycle();
}
}
}
/**
* 移除缓存
*/
public synchronized void clearImageCache() {

if (mMemoryCache != null) {
if (mMemoryCache.size() > 0) {
Log.d("CacheUtils",
"mMemoryCache.size() " + mMemoryCache.size());
mMemoryCache.evictAll();
Log.d("CacheUtils", "mMemoryCache.size()" + mMemoryCache.size());
}
mMemoryCache = null;
}
}

public Bitmap loadLocal(String path) {

Bitmap bitmap=BitmapFactory.decodeFile(path);

addBitmapToMemoryCache(path, bitmap);

return getBitmapFromMemCache(path);
}
public void clearCache() {
if (mMemoryCache != null) {
if (mMemoryCache.size() > 0) {
Log.d("CacheUtils",
"mMemoryCache.size() " + mMemoryCache.size());
mMemoryCache.evictAll();
Log.d("CacheUtils", "mMemoryCache.size()" + mMemoryCache.size());
}
mMemoryCache = null;
}
}
/*
将图片进行压缩

BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true; // 设置了此属性一定要记得将值设置为false
Bitmap bitmap = null;
bitmap = BitmapFactory.decodeFile(url, options);
int be = (int) ((options.outHeight > options.outWidth ? options.outHeight / 150
: options.outWidth / 200));
if (be <= 0) // 判断200是否超过原始图片高度
be = 1; // 如果超过，则不进行缩放
options.inSampleSize = be;
options.inPreferredConfig = Bitmap.Config.ARGB_4444;
options.inPurgeable = true;
options.inInputShareable = true;
options.inJustDecodeBounds = false;
try {
bitmap = BitmapFactory.decodeFile(url, options);
} catch (OutOfMemoryError e) {
System.gc();
Log.e(TAG, "OutOfMemoryError");
}
*/

}

结语

通过上面的分析，我们了解到LruCache是通过LinkedHashMap来实现，使用LRU算法。

LruCache是对LRU策略的内存缓存的实现，后来的系统源码中也曾经加上该算法的磁盘缓存的实现，也有对应磁盘缓存的源码DiskLruCache.Java。有兴趣的可以自己去看一下。

本篇文章是个人的理解，如有错误请指出。欢迎大家一起交流！