http://blog.csdn.net/liuzhenfeng/article/details/6254224
前幾天去一個公司面試,面試官直接讓上機寫一個LRU緩存,當時寫的很亂,現整理如下:
package com.jd.test;
import java.io.Serializable;
import java.util.LinkedHashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 緩存類(最近最少未使用)
*
* @author liuzhenfeng
*
* @param <K,V>
*/
public class LRUCache<K, V> extends LinkedHashMap<K, V> implements Serializable {
/**
* 緩存默認大小
*/
public static final int DEFAULT_CAPASITY = 20;
/**
* 緩存實際大小
*/
public static int CACHE_CAPASITY = DEFAULT_CAPASITY;
/**
* 線程同步鎖
*/
private static final Lock lock = new ReentrantLock();
public LRUCache() {
super(DEFAULT_CAPASITY);
CACHE_CAPASITY = DEFAULT_CAPASITY;
}
public LRUCache(int size) {
super(size);
CACHE_CAPASITY = size;
}
/*
* 清空緩存
*
* @see java.util.LinkedHashMap#clear()
*/
@Override
public void clear() {
try {
lock.lock();
super.clear();
} finally {
lock.unlock();
}
}
/*
* 判斷是否包含該對象
*
* @see java.util.LinkedHashMap#containsValue(java.lang.Object)
*/
@Override
public boolean containsValue(Object value) {
try {
lock.lock();
return super.containsValue(value);
} finally {
lock.unlock();
}
}
/*
* 從緩存中查詢對象
*
* @see java.util.LinkedHashMap#get(java.lang.Object)
*/
@Override
public V get(Object key) {
try {
lock.lock();
return super.get(key);
} finally {
lock.unlock();
}
}
/*
* 是否刪除最早未使用緩存對象
*
* @see java.util.LinkedHashMap#removeEldestEntry(java.util.Map.Entry)
*/
@Override
protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
try {
lock.lock();
return this.size() > CACHE_CAPASITY;
} finally {
lock.unlock();
}
}
/*
* 判斷緩存中是否包含該key
*
* @see java.util.HashMap#containsKey(java.lang.Object)
*/
@Override
public boolean containsKey(Object key) {
try {
lock.lock();
return super.containsKey(key);
} finally {
lock.unlock();
}
}
/*
* 判斷緩存是否爲空
*
* @see java.util.HashMap#isEmpty()
*/
@Override
public boolean isEmpty() {
try {
lock.lock();
return super.isEmpty();
} finally {
lock.unlock();
}
}
/*
* 放入緩存
*
* @see java.util.HashMap#put(java.lang.Object, java.lang.Object)
*/
@Override
public V put(K key, V value) {
try {
lock.lock();
return super.put(key, value);
} finally {
lock.unlock();
}
}
/*
* 從緩存中刪除
*
* @see java.util.HashMap#remove(java.lang.Object)
*/
@Override
public V remove(Object key) {
try {
lock.lock();
return super.remove(key);
} finally {
lock.unlock();
}
}
/*
* 緩存大小
*
* @see java.util.HashMap#size()
*/
@Override
public int size() {
try {
lock.lock();
return super.size();
} finally {
lock.unlock();
}
}
}
重入鎖(ReentrantLock)是一種遞歸無阻塞的同步機制。以前一直認爲它是synchronized的簡單替代,而且實現機制也不相差太遠。不過最近實踐過程中發現它們之間還是有着天壤之別。
以下是官方說明:一個可重入的互斥鎖定 Lock,它具有與使用 synchronized 方法和語句所訪問的隱式監視器鎖定相同的一些基本行爲和語義,但功能更強大。ReentrantLock 將由最近成功獲得鎖定,並且還沒有釋放該鎖定的線程所擁有。當鎖定沒有被另一個線程所擁有時,調用 lock 的線程將成功獲取該鎖定並返回。如果當前線程已經擁有該鎖定,此方法將立即返回。可以使用 isHeldByCurrentThread() 和 getHoldCount() 方法來檢查此情況是否發生。
它提供了lock()方法:
如果該鎖定沒有被另一個線程保持,則獲取該鎖定並立即返回,將鎖定的保持計數設置爲 1。
如果當前線程已經保持該鎖定,則將保持計數加 1,並且該方法立即返回。
如果該鎖定被另一個線程保持,則出於線程調度的目的,禁用當前線程,並且在獲得鎖定之前,該線程將一直處於休眠狀態,此時鎖定保持計數被設置爲 1。