分析LinkedHashMap源码的LRU实现

一、前言

前段时间研究了memcached，而且操作系统的课程也刚刚完成，在两个里面多次出现LRU（last recently used最近最少使用）算法，虽然思想很简单。但是还是值得我们研究，无意间在看LinkedHashMap的源码的时候看见貌似这个类里面有默认的LRU实现。我们现在就来分析一下他的源代码

 /**     * Returns <tt>true</tt> if this map should remove its eldest entry.     * This method is invoked by <tt>put</tt> and <tt>putAll</tt> after     * inserting a new entry into the map.  It provides the implementor     * with the opportunity to remove the eldest entry each time a new one     * is added.  This is useful if the map represents a cache: it allows     * the map to reduce memory consumption by deleting stale entries.     *     * <p>Sample use: this override will allow the map to grow up to 100     * entries and then delete the eldest entry each time a new entry is     * added, maintaining a steady state of 100 entries.     * <pre>     *     private static final int MAX_ENTRIES = 100;     *     *     protected boolean removeEldestEntry(Map.Entry eldest) {     *        return size() > MAX_ENTRIES;     *     }     * </pre>     *     * <p>This method typically does not modify the map in any way,     * instead allowing the map to modify itself as directed by its     * return value.  It <i>is</i> permitted for this method to modify     * the map directly, but if it does so, it <i>must</i> return     * <tt>false</tt> (indicating that the map should not attempt any     * further modification).  The effects of returning <tt>true</tt>     * after modifying the map from within this method are unspecified.     *     * <p>This implementation merely returns <tt>false</tt> (so that this     * map acts like a normal map - the eldest element is never removed).     *     * @param    eldest The least recently inserted entry in the map, or if     *           this is an access-ordered map, the least recently accessed     *           entry.  This is the entry that will be removed it this     *           method returns <tt>true</tt>.  If the map was empty prior     *           to the <tt>put</tt> or <tt>putAll</tt> invocation resulting     *           in this invocation, this will be the entry that was just     *           inserted; in other words, if the map contains a single     *           entry, the eldest entry is also the newest.     * @return   <tt>true</tt> if the eldest entry should be removed     *           from the map; <tt>false</tt> if it should be retained.     */    protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {        return false;//返回false代表不会删除map会自动扩容，返回true代表会删除    }

很明显，上一个函数写得很清楚，该函数数默认返回false的，代表linkedhashmap会自动的进行扩容操作，如果返回true的话map则会删掉排在最后的一个元素（linkedhashmap是有序的）我们可以来看看addENtry函数是怎样的

/**     * This override alters behavior of superclass put method. It causes newly     * allocated entry to get inserted at the end of the linked list and     * removes the eldest entry if appropriate.     */    void addEntry(int hash, K key, V value, int bucketIndex) {        createEntry(hash, key, value, bucketIndex);        // Remove eldest entry if instructed, else grow capacity if appropriate        Entry<K,V> eldest = header.after;        if (removeEldestEntry(eldest)) {//返回true，删掉entry            removeEntryForKey(eldest.key);        } else {//否则自动两倍扩容            if (size >= threshold)                resize(2 * table.length);        }    }

那么现在就剩下排序的问题了，大家都知道LRU的原理就是把最近使用的排在前面，最少使用的排在后面（addENTRY时会删除多余的元素），那么linkedhashmap是在什么时候开始为最近使用的排序呢？很明显我们要知道他什么时候使用就应该是i我们调用get方法的时候，那我们现在来看看get方法

    /**     * Returns the value to which the specified key is mapped,     * or {@code null} if this map contains no mapping for the key.     *     * <p>More formally, if this map contains a mapping from a key     * {@code k} to a value {@code v} such that {@code (key==null ? k==null :     * key.equals(k))}, then this method returns {@code v}; otherwise     * it returns {@code null}.  (There can be at most one such mapping.)     *     * <p>A return value of {@code null} does not <i>necessarily</i>     * indicate that the map contains no mapping for the key; it's also     * possible that the map explicitly maps the key to {@code null}.     * The {@link #containsKey containsKey} operation may be used to     * distinguish these two cases.     */    public V get(Object key) {        Entry<K,V> e = (Entry<K,V>)getEntry(key);//取得entry，        if (e == null)            return null;        e.recordAccess(this);//这个方法很重要        return e.value;    }

还有一点笔者必须要提醒大家，我们传入参数的时候有个这个参数accessOrder，顾名思义，他是为了排序而生。true代表排序。false反之

 /**     * The iteration ordering method for this linked hash map: <tt>true</tt>     * for access-order, <tt>false</tt> for insertion-order.     *     * @serial     */    private final boolean accessOrder;

我们可以看到。当我们执行get方法的时候会调用一个recordAccess的方法传入this变量。ok，他应该是把操作交给entry类了吧。好吧我们来看看entry的源代码

 /**     * LinkedHashMap entry.     */    private static class Entry<K,V> extends HashMap.Entry<K,V> {        // These fields comprise the doubly linked list used for iteration.        Entry<K,V> before, after;        Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {            super(hash, key, value, next);        }        /**         * Removes this entry from the linked list.         */        private void remove() {//删除该entry            before.after = after;            after.before = before;        }        /**         * Inserts this entry before the specified existing entry in the list.//加入到头部         */        private void addBefore(Entry<K,V> existingEntry) {            after  = existingEntry;            before = existingEntry.before;            before.after = this;            after.before = this;        }        /**         * This method is invoked by the superclass whenever the value         * of a pre-existing entry is read by Map.get or modified by Map.set.         * If the enclosing Map is access-ordered, it moves the entry         * to the end of the list; otherwise, it does nothing.         */        void recordAccess(HashMap<K,V> m) {            LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;            if (lm.accessOrder) {//得到传过来的linkedhashmap的order值。如果是true这进行一下操作，先执行remove（）接着执行addbefore()                lm.modCount++;//根据方法名字大家都应该恍然大悟了吧                remove();                addBefore(lm.header);            }        }        void recordRemoval(HashMap<K,V> m) {            remove();        }    }

ok！linkedHashmap的Lru实现就是这么简单，但是个人认为不算很完美的LRU，大家有没有看到一个弊端，只要调用一次就跑到最前面去了，我觉得这不是一个很好的实现。

下面给出一个自己实现的一个简单的LRUCache类

package algori;import java.util.ArrayList;import java.util.Collection;import java.util.LinkedHashMap;import java.util.Map;/** *  实现LRU算法 * @author xiezhaodong * * @param <K> * @param <V> */public class LRUCache <K,V> extends LinkedHashMap<K, V>{private static final int DEFAULT_CAPACITY=100;private static final float DEFAULT_FACTOR=0.75f;private int REAL_CAPACOTY;//记录真实容量public LRUCache(int initialCapacity, float loadFactor){super(initialCapacity, loadFactor, true);this.REAL_CAPACOTY=initialCapacity;}public LRUCache() {this(DEFAULT_CAPACITY,DEFAULT_FACTOR);}//覆盖父类方法，超过容量以后去掉LRU中的数据@Overrideprotected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {return size()>REAL_CAPACOTY;}public synchronized V getCache (K key) {     return get(key); }    public synchronized void putCache(K key, V value) {    put (key, value); }    public synchronized void clear() {     clear(); }    public synchronized int usedEntries() {     return size(); }     public synchronized Collection<Map.Entry<K,V>> getAll() {     return new ArrayList<Map.Entry<K,V>>(entrySet());    }    }  

转载请注明http://blog.csdn.net/a837199685/article