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

Posted 2022-12-02 单灿灿

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

在加载图片的时候，我们要考虑到内存问题，（内存缓存作为最先被读取的数据，应该存储那些经常使用的数据对象，且内存容量有限，内存缓存的容量应该限定。）如果你加载是高清无码大图很可能会造成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。有兴趣的可以自己去看一下。

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