最简单的LRU算法实现，线程安全的

 LRU算法用途之广就不说了，凡是要用cache的地方都可以见到它的身影。特别是线程多，并发高，数据量大的环境下。

jdk1.5真好，在LinkedHashMap.java的源码中直接有这样的字样、“This kind of map is well-suited to building LRU caches.......The removeEldestEntry(Map.Entry) method may be overridden to impose a policy for removing stale mappings automatically when new mappings are added to the map.” 就是说自己写一下removeEldestEntry就搞定了。难为我当年自己写了一个。

以下是代码，我增加的是线程安全的代码

Java代码

1. import java.util.LinkedHashMap;   
2. import java.util.concurrent.locks.Lock;   
3. import java.util.concurrent.locks.ReentrantLock;   
4.   
5. public class LRULinkedHashMap<K, V> extends LinkedHashMap<K, V>   
6. {   
7.     private final int maxCapacity;   
8.     private static final float DEFAULT_LOAD_FACTOR = 0.75f;   
9.     private final Lock lock = new ReentrantLock();   
10.   
11.     public LRULinkedHashMap(int maxCapacity)   
12.     {   
13.         super(maxCapacity, DEFAULT_LOAD_FACTOR, true);   
14.         this.maxCapacity = maxCapacity;   
15.     }   
16.   
17.     @Override  
18.     protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest)   
19.     {   
20.         return size() > maxCapacity;   
21.     }   
22.   
23.     @Override  
24.     public V get(Object key)   
25.     {   
26.         try {   
27.             lock.lock();   
28.             return super.get(key);   
29.         }   
30.         finally {   
31.             lock.unlock();   
32.         }   
33.     }   
34.   
35.     @Override  
36.     public V put(K key, V value)   
37.     {   
38.         try {   
39.             lock.lock();   
40.             return super.put(key, value);   
41.         }   
42.         finally {   
43.             lock.unlock();   
44.         }   
45.     }   
46. }  

import java.util.LinkedHashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

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

注意，只有get和put是线程安全的。