Android LruCache

LRU(Least Recently Used)采用近期最少使用的算法，它的核心思想是当缓存满时，会优先淘汰那些近期最少使用的缓存对象。采用LRU算法的缓存有两种：LrhCache和DisLruCache分别用于实现内存缓存和硬盘缓存，其核心思想都是LRU缓存算法。

缓存对象列表由LinkedHashMap来维护。而LinkedHashMap是由数组+双向链表的数据结构来实现的。其中双向链表的结构可以实现访问顺序和插入顺序，使得LinkedHashMap中的对像能按照一定顺序排列起来。
通过下面构造函数来指定LinkedHashMap中双向链表的结构是访问顺序还是插入顺序。

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

其中accessOrder设置为true则为访问顺序，为false，则为插入顺序。
以具体例子解释： 当设置为true时

@Test
public void testLinkHashMap() {
    LinkedHashMap<Integer, String> map = new LinkedHashMap<>(0, 0.75f, true);
    map.put(0, "a");
    map.put(1, "b");
    map.put(2, "c");
    map.put(3, "d");
    map.put(4, "e");
    map.put(5, "f");
    map.put(6, "g");
    map.get(1);
    map.get(2);
    for (Map.Entry<Integer, String> entry : map.entrySet()) {
        System.out.println(entry.getKey() + ":" + entry.getValue());
    }
    System.out.println(map.values().stream().findFirst());
}

输出结果：

0:a
3:d
4:e
5:f
6:g
1:b
2:c
Optional[a]

如果构造方法传的是false,那么输出结果是:

0:a
1:b
2:c
3:d
4:e
5:f
6:g
Optional[a]

有以上结果可以看出，这个设置为true时，如果对一个元素进行了操作(put,get)，就会把那个元素放到集合的最后，设置为false时，无论怎么操作，集合元素的顺序都是按照插入的顺序来进行存储的。

到了这里我们可以知道，这个LinkedHashMap正是实现Lru算法的核心之处，当内容容量达到最大值时，只需要移除这个集合的前面的元素直到集合的容量足够存储数据时就可以了。

下面我们在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);
}

LruCache是线程安全的，提供了get()和put()方法来完成缓存的获取和添加操作。使用LruCache类时需要强应用，因为强应用不容易被GC回收。来看看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) {
        //插入的缓存对象值加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;
}

可以看到put()方法并没有什么难点，重要的就是在添加过缓存对象后，调用trimToSize()方法，来判断缓存是否已满，如果满了就要删除近期最少使用的算法。
trimToSize()方法：

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

trimToSize()方法不断地删除LinkedHashMap中队首的元素，即近期最少访问的，直到缓存大小小于最大值。
当调用LruCache的get()方法获取集合中的缓存对象时，就代表访问了一次该元素，将会更新队列，保持整个队列是按照访问顺序排序。这个更新过程就是在LinkedHashMap中的get()方法中完成的。

先看LruCache的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++;
    }
}

其中LinkedHashMap的get()方法如下：

public V get(Object key) {
    Node e;
    if ((e = this.getNode(hash(key), key)) == null) {
        return null;
    } else {
        if (this.accessOrder) {
            this.afterNodeAccess(e);
        }

        return e.value;
    }
}

调用afterNodeAccess()方法如下：

void afterNodeAccess(Node<K, V> e) {
    LinkedHashMap.Entry last;
    if (this.accessOrder && (last = this.tail) != e) {
        LinkedHashMap.Entry<K, V> p = (LinkedHashMap.Entry)e;
        LinkedHashMap.Entry<K, V> b = p.before;
        LinkedHashMap.Entry<K, V> a = p.after;
        p.after = null;
        if (b == null) {
            this.head = a;
        } else {
            b.after = a;
        }

        if (a != null) {
            a.before = b;
        } else {
            last = b;
        }

        if (last == null) {
            this.head = p;
        } else {
            p.before = last;
            last.after = p;
        }
        // 关键代码,将操作后的节点放到队列的末尾	
        this.tail = p;
        ++this.modCount;
    }

}

由此可见LruCache中维护了一个集合LinkedHashMap，该LinkedHashMap是以访问顺序排序的。当调用put()方法时，就会在集合中添加元素，并调用trimToSize()判断缓存是否已满，如果满了就用LinkedHashMap的迭代器删除队首元素，即近期最少访问的元素。当调用get()方法访问缓存对象时，就会调用LinkedHashMap的get()方法获得对应集合元素，同时会更新该元素到队尾。