LRU缓存设计

 

　　LRU缓存设计是一个能够考察许多知识点以及实际编程能力的题目，因为我们在实际工作中是很有可能会去自己写一个LRU算法的简单缓存。本题是LeetCode的第 146 题。LRU——即 Least Recently Used，淘汰最近最少使用的元素的算法。考察的主要内容包括：

• LRU算法的原理与思想
• 具有实际开发意义的编程题
• 线程安全的设计

 

设计思路

　　首先考虑简单的设计实现。一个LRU的缓存是基于队列实现的，Java中可以基于LinkedList或者Deque队列实现。需要实现两个基本操作get/put

1. 数据结构上，缓存需要指定容量，不能随意扩展。
2. 用一个线程安全的ConcurrentHashMap存储数据的键值对。
3. 用一个Deque队列表征数据的最近使用频率。

 

get操作

• 当需要查询的数据已经在缓存中时，返回其值，并将其在队列中的位置重置。
• 若数据不存在返回-1（假设需要缓存的数据均为正数）

 

put操作

• 当需要put的数据已经存在于缓存中时，更新其在队列的位置，将其放置到队列尾端，表示为最近使用；然后将新的数据put到缓存map中。
• 当需要put的数据不存在于缓存中，且缓存容量达到指定上限时，从队列首移除一个元素，将新元素放置到队尾，再移除map中的数据，更新缓存。

 

public class LRUCache {

    private final int capacity;

    private Map<Integer, Integer> map = new ConcurrentHashMap<>();
    private Deque<Integer> queue = new LinkedList<Integer>();

    public LRUCache(int capacity) {
        this.capacity = capacity;
    }
    
    public int get(int key) {
        Integer value = map.get(key);
        if (value != null) {
            
            this.queue.remove((Integer)key);
            this.queue.addLast(key);
            return value;
        }
        return -1;
    }
    
    public void put(int key, int value) {
        if (map.get(key) != null) {
            this.queue.remove((Integer)key);
            this.queue.addLast(key);
            map.put(key, value);
            return;
        }

        if (queue.size() >= capacity) {
            Integer lruKey = this.queue.pollFirst();
            map.remove(lruKey);
        }
        this.queue.addLast(key);
        map.put(key, value);
    }
}

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */

 

　　好了，这个题目现在已经完成了，然而光这些，在实际开发中缓存往往会被多线程同时访问，我们考虑的就需要更加周密，也更能体现我们的水平。那么线程安全的实现需要一些说明额外的东西呢？

　　答案就是——加锁。因为对缓存队列和map的操作是可能多个线程同时进行的，所以我们用可重入锁 ReetrantLock 去保护这一过程即可。ReetrantLock 的原理这里就先不赘述。

 

考虑线程安全的设计实现

• 不论是get还是put方法，对LRU缓存的map和queue进行操作时必须加锁进行，无论操作是否成功，均需要解锁，所以我们用finally关键字包含unlock操作，代码如下。

public class LRUCache {

    private final int capacity;

    private ReentrantLock lock = new ReentrantLock();

    private Map<Integer, Integer> map = new ConcurrentHashMap<>();
    private Deque<Integer> queue = new LinkedList<Integer>();

    public LRUCache(int capacity) {
        this.capacity = capacity;
    }
    
    public int get(int key) {
        Integer value = map.get(key);
        if (value != null) {
            lock.lock();
            try {
                this.queue.remove((Integer)key);
                this.queue.addLast(key);
                return value;
            } finally {
                lock.unlock();
            }
        }
        return -1;
    }
    
    public void put(int key, int value) {
        if (map.get(key) != null) {
            lock.lock();
            try {
                this.queue.remove((Integer)key);
                this.queue.addLast(key);
                map.put(key, value);
            } finally {
                lock.unlock();
            }
            return;
        }

        lock.lock();
        try {
            if (queue.size() >= capacity) {
                Integer lruKey = this.queue.pollFirst();
                map.remove(lruKey);
            }
            this.queue.addLast(key);
            map.put(key, value);
        } finally {
            lock.unlock();
        }
    }
}

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */