一、LruCache简介

    LruCache采用的缓存算法为LRU（Least Recently Used），即最近最少使用算法。核心思想是当缓存满时，会优先淘汰那些近期最少使用的缓存对象。其内部采用的数据结构是LinkedHashMap，当缓存满时，把最近最少使用的对象从内存中移除，并提供了get和put方法来完成缓存的获取和添加操作。

    常用于图片缓存，但不局限与图片缓存。而且，LruCache是线程安全的，因此是可以采用多线程并发处理。

二、LruCache使用

LruCache的使用非常简单，以图片缓存为例。

创建LruCache：

//获取到应用的最大内存
int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
//设置LruCache的缓存大小
int cacheSize = maxMemory / 8;
//重写sizeOf，并返回以kB为单位的缓存对象的大小
mMemoryCache = new LruCache<String, Bitmap>(cacheSize){
  @Override
  protected int sizeOf(String key, Bitmap value) {
     return value.getRowBytes() * value.getHeight() / 1024;
      }
};

使用：

//获取到缓存对象
mMemoryCache.get(key);
//添加缓存对象
mMemoryCache.put(key,value);

三、LruCache原理

借用网上一张很形象的照片：

LruCache的核心思想就是维护一个缓存对象列表。按照访问顺序进行排列，最近访问的对象将放在队头，一直没访问的对象，将放在队尾，淘汰时从队尾淘汰。

LruCache的构造函数：

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最后一个参数设置为访问顺序。

在LinkedHashMap中

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

accessOrder 为true时为访问顺序，为false，则为插入顺序。

举个栗子：

public static final void main(String[] args) {
        LinkedHashMap<Integer, Integer> map = new LinkedHashMap<>(0, 0.75f, true);
        map.put(0, 0);
        map.put(1, 1);
        map.put(2, 2);
        map.put(3, 3);
        map.put(4, 4);
        map.put(5, 5);
        map.put(6, 6);
        map.get(1);
        map.get(2);

        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + ":" + entry.getValue());

        }
    }

为true时输出结果是：

0:0
3:3
4:4
5:5
6:6
1:1
2:2

为false时结果是：

0:0
1:1
2:2
3:3
4:4
5:5
6:6

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) {
            //插入的缓存对象值加1
            putCount++;
            //增加已有缓存的大小
            size += safeSizeOf(key, value);
           //向map中加入缓存对象
            previous = map.put(key, value);
            //如果已有缓存对象，则缓存大小恢复到之前
            if (previous != null) {
                size -= safeSizeOf(key, previous);
            }
        }
        //entryRemoved()是个空方法，可以自行实现
        if (previous != null) {
            entryRemoved(false, key, previous, value);
        }
        //调整缓存大小(关键方法)
        trimToSize(maxSize);
        return previous;
    }

这里面没什么难点，需要注意一下trimToSize()方法。判断缓存是否已满，如果满了就会不断地删除LinkedHashMap中队尾的元素，即近期最少访问的，直到缓存大小小于最大值。

public void trimToSize(int maxSize) {
        //死循环
        while (true) {
            K key;
            V value;
            synchronized (this) {
                //如果map为空并且缓存size不等于0或者缓存size小于0，抛出异常
                if (size < 0 || (map.isEmpty() && size != 0)) {
                    throw new IllegalStateException(getClass().getName()
                            + ".sizeOf() is reporting inconsistent results!");
                }
                //如果缓存大小size小于最大缓存，或者map为空，不需要再删除缓存对象，跳出循环
                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);
        }
    }

get（）方法：

public final V get(K key) {
        //key为空抛出异常
        if (key == null) {
            throw new NullPointerException("key == null");
        }

        V mapValue;
        synchronized (this) {
            //获取对应的缓存对象
            //get()方法会实现将访问的元素更新到队列头部的功能
            mapValue = map.get(key);
            if (mapValue != null) {
                hitCount++;
                return mapValue;
            }
            missCount++;
        }

get()方法获取集合中的缓存对象时，就代表访问了一次该元素，将会更新队列，保持整个队列是按照访问顺序排序。这个更新过程就是在LinkedHashMap中的get()方法中完成的。

public V get(Object key) {
        LinkedHashMapEntry<K,V> e = (LinkedHashMapEntry<K,V>)getEntry(key);
        if (e == null)
            return null;
        //实现排序的关键方法
        e.recordAccess(this);
        return e.value;
    }

void recordAccess(HashMap<K,V> m) {
            LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
            //判断是否是访问排序
            if (lm.accessOrder) {
                lm.modCount++;
                //删除此元素
                remove();
                //将此元素移动到队列的头部
                addBefore(lm.header);
            }
        }