LinkedHashMap实现一个固定容量的基于最近最少使用算法的缓存类

固定容量的基于最近最少使用算法的LinkedHashMap．可用作简单缓存．使用方法与LinkedHashMap一致．

利用LinkedHashMap实现简单的缓存，必须实现removeEldestEntry方法，具体参见JDK文档.另外还加入了一个可重入的互斥锁定．

使用说明：LRU算法是LinkedHashMap本身通过双向链表来实现，当某个位置被使用(例如get操作)，通过调整链表的指向将该位置调整到头位置，新加入的内容直接放在链表头，如此一来，最近被使用的内容就向链表头移动，需要替换时(已经达到容量时)，链表最后的位置就是最近最少使用的位置。

import java.util.ArrayList; import java.util.Collection; import java.util.LinkedHashMap; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; import java.util.Map; /** * 类说明：利用LinkedHashMap实现简单的缓存， 必须实现removeEldestEntry方法，具体参见JDK文档 * * @author dennis * * @param <K> * @param <V> */ public class LRULinkedHashMap<K, V> extends LinkedHashMap<K, V> { private final int maxCapacity; private static final float DEFAULT_LOAD_FACTOR = 0.75f; private final Lock lock = new ReentrantLock(); public LRULinkedHashMap(int maxCapacity) { super(maxCapacity, DEFAULT_LOAD_FACTOR, true); this.maxCapacity = maxCapacity; } @Override protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) { return size() > maxCapacity; } @Override public boolean containsKey(Object key) { try { lock.lock(); return super.containsKey(key); } finally { lock.unlock(); } } @Override public V get(Object key) { try { lock.lock(); return super.get(key); } finally { lock.unlock(); } } @Override public V put(K key, V value) { try { lock.lock(); return super.put(key, value); } finally { lock.unlock(); } } public int size() { try { lock.lock(); return super.size(); } finally { lock.unlock(); } } public void clear() { try { lock.lock(); super.clear(); } finally { lock.unlock(); } } public Collection<Map.Entry<K, V>> getAll() { try { lock.lock(); return new ArrayList<Map.Entry<K, V>>(super.entrySet()); } finally { lock.unlock(); } } }

源自：http://www.blogjava.net/killme2008/archive/2008/01/14/149645.html