LinkedHashMap实现LRU缓存算法

LinkedHashMap的get()方法除了返回元素之外还可以把被访问的元素放到链表的底端，这样一来每次顶端的元素就是remove的元素。

构造函数如下：

public LinkedHashMap (int initialCapacity, float loadFactor, boolean accessOrder)；

initialCapacity   初始容量

loadFactor    加载因子，一般是 0.75f

accessOrder   false基于插入顺序，true 基于访问顺序（get一个元素后，这个元素被加到最后，使用了LRU 最近最少被使用的调度算法）

 

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

/**
 * 该类是线程安全的带有容量限制的LinkedHashMap
 * 超容量的元素采用LRU方式删除
 * 线程安全仅限于已经覆盖的几个方法，若有其他需要可自行添加
 * 迭代操作不保证数据的一致性，即使remove方法是线程安全的也会抛ConcurrentModificationException
 */
public class LinkedMapLRU<K, V> extends LinkedHashMap<K, V> {
    private static final long serialVersionUID = -7911712053305433954L;
    
    private int capacity;
    private final ReentrantLock lock = new ReentrantLock();
    
    public LinkedMapLRU(int capacity) {
        super(capacity, 0.75f, true);
        this.capacity = capacity;
    }
    @Override
    public V put(K key, V value) {
        try {
            lock.lock();
            return super.put(key, value);
        } finally {
            lock.unlock();
        }
    }
    @Override
    public V get(Object key) {
        try {
            lock.lock();
            return super.get(key);
        } finally {
            lock.unlock();
        }
    }
    @Override
    public V remove(Object key) {
        try {
            lock.lock();
            return super.remove(key);
        } finally {
            lock.unlock();
        }
    }
    
    @Override
    public boolean removeEldestEntry(Map.Entry<K,V> eldest) {
        if(size() > capacity) {
            System.out.println(eldest.getKey() +":" + eldest.getValue());
            return true;
        }
        return false;
    }
    
    public void setMaxSize(int size) {
        this.capacity = size;
    }

}

 

测试类：

LinkedMapLRU<Integer, Integer>  LRU = new LinkedMapLRU<Integer, Integer>(3);
        LRU.put(3, 1);
        LRU.put(6, 2);
        LRU.put(9, 3);
        LRU.get(3); //key=3移到顶部
        LRU.put(12, 4);
        LRU.put(15, 5);
        for(Map.Entry<Integer, Integer> entry : LRU.entrySet()) {
            System.out.println(entry.getKey() + " " +entry.getValue());
        }

测试结果:

6:2
9:3
3 1
12 4
15 5