LRUMap源码分析

（1）.LRU算法

百度百科中对LRU算法的解释如下：

LRU是（Least Recently Used）近期最少使用算法。

其实就是把近期最少使用的内容淘汰出局。LRU是一种缓存算法，在空间有限的情况下，把使用频率最低的内容淘汰出缓存，让使用频率高的内容留在缓存里。

（2）在看项目框架的代码时，看到了LRUMap这个类，是apache-commons下的类，由于是第一次听说LRU算法，所以就决定研究一下它的源码。

（3）先来看一下例子：

 

public class TestLRUMap {
    public static void main(String[] args) {
        LRUMap<Integer, Integer> map = new LRUMap<Integer, Integer>(3);
        map.put(1, 1);
        map.put(2, 2);
        map.put(3, 3);
        map.put(4, 4);
        System.out.println(map);
    }
}

 

输出：{2=2, 3=3, 4=4}

增加一行代码，再看结果：

public class TestLRUMap {
    public static void main(String[] args) {
        LRUMap<Integer, Integer> map = new LRUMap<Integer, Integer>(3);
        map.put(1, 1);
        map.put(2, 2);
        map.put(3, 3);
        map.get(1);
        map.put(4, 4);
        System.out.println(map);
    }
}

输出：{3=3, 1=1, 4=4}

两个结果为什么不一样呢？因为第二个例子，我们添加了一行代码：map.get(1);代表1元素是最新使用的，而相应的2就是最长时间没有使用的元素，而map的长度又限制为3，所以2就被删掉了。

（4）下面分析源码：

 首先看get方法：

    public V get(final Object key) {
        final LinkEntry<K, V> entry = getEntry(key);
        if (entry == null) {
            return null;
        }
        //主要看这个方法
        moveToMRU(entry);
        return entry.getValue();
    }

moveToMRUst方法：

    protected void moveToMRU(final LinkEntry<K, V> entry) {
        if (entry.after != header) {
            modCount++;
            // remove
            if(entry.before == null) {
                throw new IllegalStateException("Entry.before is null." +
                    " Please check that your keys are immutable, and that you have used synchronization properly." +
                    " If so, then please report this to dev@commons.apache.org as a bug.");
            }
            //其实就是链表指正的改变，使得被get的元素排到链表中header前面
            entry.before.after = entry.after;
            entry.after.before = entry.before;
            // add first
            entry.after = header;
            entry.before = header.before;
            header.before.after = entry;
            header.before = entry;
        } else if (entry == header) {
            throw new IllegalStateException("Can't move header to MRU" +
                " (please report this to dev@commons.apache.org)");
        }
    }

 接下来看put方法：

public V put(final K key, final V value) {
        //如果key为null，则将其转换为new Object()
        final Object convertedKey = convertKey(key);
        //获得key的hashCode
        final int hashCode = hash(convertedKey);
        //根据hashCode得到其所在数组中的下标
        final int index = hashIndex(hashCode, data.length);
        //获得数组对应下标的HashEntry对象
        HashEntry<K, V> entry = data[index];
        while (entry != null) {
            //如果entry不为空，则判断是否已经有相同key的元素存在
            if (entry.hashCode == hashCode && isEqualKey(convertedKey, entry.key)) {
                //判断是否有相同的key存在，如果有相同的key存在，则替换其值，但不会改变其在链表中的位置
                final V oldValue = entry.getValue();
                updateEntry(entry, value);
                return oldValue;
            }
            entry = entry.next;
        }
        //如果entry为空，说明这个下标上还没有HashEntry对象
        addMapping(index, hashCode, key, value);
        return null;
    }


    protected void addMapping(final int hashIndex, final int hashCode, final K key, final V value) {
        //如果map已满，则执行删除到目前为止最长时间没有使用的元素
        if (isFull()) {
            //由于LRUMap每次添加元素的时候都放在链表中header的前面，所以，header后面的元素是删除的对象
            LinkEntry<K, V> reuse = header.after;
            boolean removeLRUEntry = false;
            if (scanUntilRemovable) {
                while (reuse != header && reuse != null) {
                    if (removeLRU(reuse)) {
                        removeLRUEntry = true;
                        break;
                    }
                    reuse = reuse.after;
                }
                if (reuse == null) {
                    throw new IllegalStateException(
                        "Entry.after=null, header.after" + header.after + " header.before" + header.before +
                        " key=" + key + " value=" + value + " size=" + size + " maxSize=" + maxSize +
                        " Please check that your keys are immutable, and that you have used synchronization properly." +
                        " If so, then please report this to dev@commons.apache.org as a bug.");
                }
            } else {
                removeLRUEntry = removeLRU(reuse);
            }

            if (removeLRUEntry) {
                if (reuse == null) {
                    throw new IllegalStateException(
                        "reuse=null, header.after=" + header.after + " header.before" + header.before +
                        " key=" + key + " value=" + value + " size=" + size + " maxSize=" + maxSize +
                        " Please check that your keys are immutable, and that you have used synchronization properly." +
                        " If so, then please report this to dev@commons.apache.org as a bug.");
                }
                //执行LRUMap的reuseMapping方法
                reuseMapping(reuse, hashIndex, hashCode, key, value);
            } else {
                super.addMapping(hashIndex, hashCode, key, value);
            }
        } else {
            super.addMapping(hashIndex, hashCode, key, value);
        }
    }


       protected void reuseMapping(final LinkEntry<K, V> entry, final int hashIndex, final int hashCode,
                                final K key, final V value) {
        // find the entry before the entry specified in the hash table
        // remember that the parameters (except the first) refer to the new entry,
        // not the old one
        try {
            //获得删除元素在数组中的下标
            final int removeIndex = hashIndex(entry.hashCode, data.length);
            final HashEntry<K, V>[] tmp = data;  // may protect against some sync issues
            HashEntry<K, V> loop = tmp[removeIndex];
            HashEntry<K, V> previous = null;
            //loop的作用是防止map被其他线程修改了导致要删除的元素已经被其他线程给删了
            while (loop != entry && loop != null) {
                previous = loop;
                loop = loop.next;
            }
            if (loop == null) {
                throw new IllegalStateException(
                    "Entry.next=null, data[removeIndex]=" + data[removeIndex] + " previous=" + previous +
                    " key=" + key + " value=" + value + " size=" + size + " maxSize=" + maxSize +
                    " Please check that your keys are immutable, and that you have used synchronization properly." +
                    " If so, then please report this to dev@commons.apache.org as a bug.");
            }

            // reuse the entry
            modCount++;
            removeEntry(entry, removeIndex, previous);
            reuseEntry(entry, hashIndex, hashCode, key, value);
            addEntry(entry, hashIndex);
        } catch (final NullPointerException ex) {
            throw new IllegalStateException(
                    "NPE, entry=" + entry + " entryIsHeader=" + (entry==header) +
                    " key=" + key + " value=" + value + " size=" + size + " maxSize=" + maxSize +
                    " Please check that your keys are immutable, and that you have used synchronization properly." +
                    " If so, then please report this to dev@commons.apache.org as a bug.");
        }
    }

好了，通过源码分析，终于理解了LRUMap是怎么实现LRU算法的。