LRUCache

本人觉得对象锁不错

1. import java.util.LinkedHashMap;  
2. import java.util.concurrent.locks.Lock;  
3. import java.util.concurrent.locks.ReentrantLock;  
4.   
5. public class LRUCache<K, V> extends LinkedHashMap<K, V> {  
6.   
7.     private static final long serialVersionUID = -656812640814484468L;  
8.   
9.     /** 默认最大容量 */  
10.     private static final int DEFAULT_MAX_CAPACITY = 300;  
11.   
12.     private static final int INITIALCAPACITY = 16;  
13.   
14.     /** 负载因子 */  
15.     private static final float DEFAULT_LOAD_FACTOR = 0.75f;  
16.   
17.     private final Lock lock = new ReentrantLock();  
18.   
19.     private volatile int maxCapacity;  
20.   
21.     /** 
22.      * <br> 
23.      * ------------------------------<br> 
24.      */  
25.     public LRUCache() {  
26.         this(DEFAULT_MAX_CAPACITY);  
27.     }  
28.   
29.     public LRUCache(int maxCapacity) {  
30.         super(INITIALCAPACITY, DEFAULT_LOAD_FACTOR, Boolean.TRUE);  
31.         this.maxCapacity = maxCapacity;  
32.     }  
33.   
34.     @Override  
35.     protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {  
36.         return size() > maxCapacity;  
37.     }  
38.   
39.     @Override  
40.     public V get(Object key) {  
41.         try {  
42.             lock.lock();  
43.             return super.get(key);  
44.         } finally {  
45.             lock.unlock();  
46.         }  
47.     }  
48.   
49.     public V put(K key, V value) {  
50.         try {  
51.             lock.lock();  
52.             return super.put(key, value);  
53.         } finally {  
54.             lock.unlock();  
55.         }  
56.     }  
57.   
58.     @Override  
59.     public V remove(Object key) {  
60.         try {  
61.             lock.lock();  
62.             return super.remove(key);  
63.         } finally {  
64.             lock.unlock();  
65.         }  
66.     }  
67.   
68.     @Override  
69.     public boolean containsKey(Object key) {  
70.         try {  
71.             lock.lock();  
72.             return super.containsKey(key);  
73.         } finally {  
74.             lock.unlock();  
75.         }  
76.     }  
77.   
78.     @Override  
79.     public void clear() {  
80.         try {  
81.             lock.lock();  
82.             super.clear();  
83.         } finally {  
84.             lock.unlock();  
85.         }  
86.     }  
87.   
88.     @Override  
89.     public int size() {  
90.         try {  
91.             lock.lock();  
92.             return super.size();  
93.         } finally {  
94.             lock.unlock();  
95.         }  
96.     }  
97.   
98.     /** 
99.      * 获得maxCapacity 
100.      * @return the maxCapacity 
101.      */  
102.     public int getMaxCapacity() {  
103.         return maxCapacity;  
104.     }  
105.   
106.     /** 
107.      * 设置maxCapacity 
108.      * @param maxCapacity the maxCapacity to set 
109.      */  
110.     public void setMaxCapacity(int maxCapacity) {  
111.         this.maxCapacity = maxCapacity;  
112.     }  
113. }  

[java]  view plain copy print ?

1. public class Main {  
2.       
3.     public static void main(String[] args) {  
4.         LRUCache<String, String> lruCache = new LRUCache<String, String>(2);  
5.         lruCache.put("1", "1");  
6.         lruCache.put("2", "2");  
7.         System.out.println(lruCache);  
8.         lruCache.put("3", "3");  
9.         System.out.println(lruCache);  
10.     }  
11. }  

{1=1, 2=2}
{2=2, 3=3}

转自：http://blog.csdn.net/java2000_wl/article/details/7553646