前幾天去一個公司面試，面試官直接讓上機寫一個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。