LruCache

文章主要介绍了:
1.LruCache的基本使用
2.LruCache的源码分析
3.基于LinkedHashMap的实现

一、LruCache缓存的实例代码。
假设存的是图片·
long  maxMemory = (int) Runtime.getRuntime().maxMemory();
        int memorySize = (int) (maxMemory/8);
        LruCache<String ,Bitmap> lruCache = new LruCache<String ,Bitmap>(memorySize){
            @Override
            protected int sizeOf(String key, Bitmap value) {
                return value.getByteCount();
            }
        };

maxMemory是缓存定义的最大的值,不能超过这个值,负责就会被回收。
重写sizeOf是为了计算每个数值的大小,等累计缓存的数值超出定义的最大值就会回收。

  • 操作方式:
 // 把Value对象加入到缓存中
    public void putValueToMemory(String key, Bitmap bitmap) {
        if (getValueFromMemory(key) == null) {
            lruCache.put(key, bitmap);
        }
    }

    // 从缓存中得到value对象
    public Bitmap getValueFromMemory(String key) {
        return lruCache.get(key);
    }

    // 从缓存中删除指定的value
    public void removeValueMemory(String key) {
        lruCache.remove(key);
    }

二 、源码调用

(1)属性
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;
    private int createCount;
    private int evictionCount;
    private int hitCount;
    private int missCount;

LinkedHashMap为核心类,Lru也是基于LinkedHashMap从而实现的。

(2)LruCache只有一个构造方法,初始了LinkedHashMap
 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);
    }

LinkedHashMap自身是默认 按照插入的顺序进行排序的,此处初始化的时候new LinkedHashMap<K, V>(0, 0.75f, true); 传入true则将LinkedHashMap的顺序改为访问顺序,说明Lru初始化的时候默认的是访问顺序。

(3)LruCache的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) {对map进行操作之前,先进行同步操作
            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);判断是否需要移除LinkedHashMap中的元素
        return previous;
    }

safeSizeOf方法,是计算LruCache的已经缓存的大小.
entryRemoved(false, key, previous, value);如果找的到对应的key的话是替换新值,不存在的话就是新增。true为删除条目生成空间,false反之.
trimToSize判断是否需要移除LinkedHashMap中的元素

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!");
               }
 **  如果当前的size小于等于最大的size则直接返回,不需要删除数据
               if (size <= maxSize) {
                   break;
               }

           **如果size超出了最大的size,则需要进行删除数据,       
            **map.eldest获取表头的数据,进行删除
               Map.Entry<K, V> toEvict = map.eldest();
               if (toEvict == null) {
                   break;
               }

               key = toEvict.getKey();
               value = toEvict.getValue();
               map.remove(key);**删除数据
               size -= safeSizeOf(key, value);**重新计算缓存大小
               evictionCount++;
           }

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

如同上述注释中写的一样,可以看出,就是不断的循环移除LinkedHashMap双向链表表头的元素,直到缓存的大小小于等于缓存大小为止。

  • map.eldest()返回值
 public Map.Entry<K, V> eldest() {
        return head;
    }

LinkedHashMap map.eldest()的调用是返回表头的集合数据head。

LinkedHashMap继承HashMap,重写的方法中并没有重写put,所以put使用的还是HashMap的put方法,在LruCache类中呢,put相当于调用的是HashMap的put,get调用的是LinkedHashMap重写的get,此处主要就看一下这个put和get方法。在HashMap put方法中,最终会回调afterNodeAccess给LinkedHashMap,在LinkedHashMap的get方法中,最终也是走的这个方法,来操作head集合的赋值,最近的操作的数据则移到表尾。

  • LinkedHashMap中head的处理
 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;
        }
    }

对LinkedHashMap的put和get操作,都会让被操作的Entry移动到双向链表的表尾,删除数据则是从表头开始的,就符合Lru算法的要求。

(4)LruCache的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++;
                return mapValue;
            }
            missCount++;
        }

        V createdValue = create(key);
        if (createdValue == null) { 通过Key尝试创建一个新值,默认返回为null。可重写
            return null;
        }

        synchronized (this) {
            createCount++;
如果我们重写了create(key)方法而且返回值不为空,那么将上述的key与这个返回值写入到map当中
            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);
            }
        }

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

V createdValue = create(key);可重写create,此处是判断当前是值是不是空的,如果不是空的,会将创建的key与createdValue 值捆绑,存到map中。

(5)LruCache的remove方法是从缓存中去删除:

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

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

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

        return previous;
    }

根据Key删除所对应的value值。

总结:

Lru是基于LinkedHashMap实现的, 默认为访问顺序。
HashMap无序,而LinkedHashMap是有序的。序列可分为插入顺序和访问顺序,若是访问顺序,操作已存在的数据时会将其移植双链表表尾。

    原文作者:她的梦z
    原文地址: https://www.jianshu.com/p/290a98652344
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞