Java实现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。