一、前言
前段时间研究了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中的数据
@Override
protected 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