C++ LRU缓存算法的设计与实现

常见缓存类型

• LRU (Least recently used) 最近最少使用，如果数据最近被访问过，那么将来被访问的几率也更高。
• LFU (Least frequently used) 最不经常使用，如果一个数据在最近一段时间内使用次数很少，那么在将来一段时间内被使用的可能性也很小。
• FIFO (Fist in first out) 先进先出， 如果一个数据最先进入缓存中，则应该最早淘汰掉。

LRU原理

按照通俗的话解释缓存LRU思想：如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也很小。所以，当指定的空间已存满数据时，应当把最久没有被访问到的数据淘汰。 它是一种内存淘汰算法。

所以我们可以这样处理：

1. 新数据插入到链表头部
2. 每当缓存命中（即缓存数据被访问），则将数据移到链表头部
3. 当链表满的时候，将链表尾部的数据丢弃
   

LRU Cache具备的操作：
1. put(key,value)：如果key在hashmap中存在，则先重置对应的value值，然后获取对应的节点cur，将cur节点从链表删除，并移动到链表的头部；如果key在hashmap不存在，则新建一个节点，并将节点放到链表的头部。当Cache存满的时候，将链表最后一个节点删除即可。

2. get(key)：如果key在hashmap中存在，则把对应的节点放到链表头部，并返回对应的value值；如果不存在，则返回-1。

LRU算法设计

1.数组。利用数组存储数据，给每一个数据元素标记一个访问时间戳，每次插入新数据的时候，将数组中已存在的数据的时间戳自增，并将新数据的时间戳置为0并放插入数组中，每次访问数组中的数据时（遍历查询），将被访问的数据的时间戳置0。当数组空间已满时，将时间戳最大的数据删掉。

2.单向链表。每次插入新数据到链表头部，每次命中缓存（访问数据），则将数据移到链表头。链表长度满时，丢弃链表尾部数据。

3.哈希表map+双向链表。插入新数据时将其插到链表头部，并用map记录；每次缓存命中后，将要访问的数据（节点）转移到链表头部；链表满时，将链表尾部丢弃，并将对应的map键删掉。

取舍：第一种方法需要不停的维护数据的时间戳，在插入、删除、访问数据时间复杂度都是O(n)，第二种方法，单链表访问数据时间复杂度是O(n)。第三种方法插入、删除、访问数据时间复杂度都是O(1)。

LRU算法实现

最佳方案：LRU实现采用 哈希表 + 双向链表 来进行实现。

• 双向链表按照被使用的顺序存储了这些键值对(K-V)，靠近头部的键值对是最近使用的，而靠近尾部的键值对是最久未使用的。

• 哈希表即为普通的哈希映射（HashMap），通过缓存数据的键（key）映射到其在双向链表中的位置。
  
  这里采用双向链表的原因是：如果采用普通的单链表，则删除节点的时候需要从表头开始遍历查找，效率为O(n)，采用双向链表可以直接改变节点的前驱的指针指向进行删除达到O(1) 的效率。使用Map来保存节点的key、value值便于能在O(logN) 忽略hash碰撞不计可以达到O(1) 的时间查找元素,对应get操作。

具体C++实现:
1.unorderer_map + list

利用C++的STL模板容器 unordered_map(内部实现哈希表，元素排列无序，查询效率高)辅以list(双向链表容器，快速删除元素，支持头插和尾插)来实现。

//利用已有双向链表 STL list
class LRUCache {
private:
    int capacity;
    list< pair<int,int> >cache;//自带双向链表容器list
    unordered_map<int, list< pair<int,int> >::iterator >map;//键值对，值存迭代器位置
public:
    LRUCache(int capacity):capacity(capacity) {
    }
    
    int get(int key) {
        if(map.find(key)==map.end())return -1;
        auto key_value = *map[key];
        cache.erase(map[key]);
        cache.push_front(key_value);
        map[key] = cache.begin();
        return key_value.second;
    }

    void put(int key, int value) {
        if(map.find(key)==map.end()){
            if(cache.size()==capacity){
                map.erase(cache.back().first);
                cache.pop_back();
            }
        }else{
            cache.erase(map[key]);
        }
        cache.push_front({key,value});
        map[key]=cache.begin();
    }
};

2.unordered_map + 自定义双向链表

//手动实现双向链表
struct DLinkedNode{
    int key,value;
    DLinkedNode* prev;//前向指针
    DLinkedNode* next;//后向指针
    DLinkedNode():key(0),value(0),prev(nullptr),next(nullptr){}//无参构造函数
    DLinkedNode(int _key,int _value):key(_key),value(_value),prev(nullptr),next(nullptr){}//有参构造函数
};
class LRUCache {
private:
    unordered_map<int,DLinkedNode*>cache; //map key映射链表的节点
    // 使用伪头部和伪尾部节点
    DLinkedNode* head;//链表头
    DLinkedNode* tail;//链表尾
    int size;
    int capacity;
public:
    //构造函数
    LRUCache(int capacity):capacity(capacity),size(0) {
        head = new DLinkedNode();
        tail = new DLinkedNode();
        head->next = tail;
        tail->prev = head;
    }
    
    int get(int key) {
        if(!cache.count(key))//不存在返回-1
            return -1;
        DLinkedNode* node = cache[key];
        moveToHead(node);//先删后加（哈希表不动）
        return node->value;
    }
    
    void put(int key, int value) {
        if(!cache.count(key)){//key不存在的话，新增加入链表，并且加入哈希表
            DLinkedNode* node = new DLinkedNode(key,value);
            cache[key] = node;//通过key标志node，放入哈希表
            addToHead(node);//放入链表头
            ++size;
            if(size > capacity){//判断链表实际大小和容器规定大小
                DLinkedNode* removed = removeTail();
                cache.erase(removed->key);//根据key删除node
                delete removed;//释放指针防止泄露
                --size;
            }
        }else{//key已存在的话(需要更新值value)，先删后加入链表头（哈希表不动）
            DLinkedNode* node = cache[key];
            node->value = value;//更新原来的value
            moveToHead(node);   
        }
    }

    void addToHead(DLinkedNode* node){
        node->prev = head;
        node->next = head->next;
        head->next->prev = node;
        head->next = node;
    }
    void removeNode(DLinkedNode* node){
        node->prev->next = node->next;
        node->next->prev = node->prev;
    }
    void moveToHead(DLinkedNode* node){
        removeNode(node);
        addToHead(node);
    }
    DLinkedNode* removeTail(){
        DLinkedNode* node = tail->prev;
        removeNode(node);
        return node;
    }
};

java实现：使用java中的LinkedHashMap实现。

LinkedHashMap底层就是用的HashMap加双链表实现的，而且本身已经实现了按照访问顺序的存储。此外，LinkedHashMap中本身就实现了一个方法removeEldestEntry用于判断是否需要移除最不常读取的数，方法默认是直接返回false，不会移除元素，所以需要重写该方法。 即当缓存满后就移除最不常用的数。

public class LRU<K,V> {
 
  private static final float hashLoadFactory = 0.75f;
  private LinkedHashMap<K,V> map;
  private int cacheSize;
 
  public LRU(int cacheSize) {
    this.cacheSize = cacheSize;
    int capacity = (int)Math.ceil(cacheSize / hashLoadFactory) + 1;
    map = new LinkedHashMap<K,V>(capacity, hashLoadFactory, true){
      private static final long serialVersionUID = 1;
 
      @Override
      protected boolean removeEldestEntry(Map.Entry eldest) {
        return size() > LRU.this.cacheSize;
      }
    };
  }
 
  public synchronized V get(K key) {
    return map.get(key);
  }
 
  public synchronized void put(K key, V value) {
    map.put(key, value);
  }
 
  public synchronized void clear() {
    map.clear();
  }
 
  public synchronized int usedSize() {
    return map.size();
  }
 
  public void print() {
    for (Map.Entry<K, V> entry : map.entrySet()) {
      System.out.print(entry.getValue() + "--");
    }
    System.out.println();
  }
}

扩展 LRU-K

LRU-K中的K代表最近使用的次数，因此LRU可以认为是LRU-1。LRU-K的主要目的是为了解决LRU算法“缓存污染”的问题，其核心思想是将“最近使用过1次”的判断标准扩展为“最近使用过K次”。
相比LRU，LRU-K需要多维护一个队列，用于记录所有缓存数据被访问的历史。只有当数据的访问次数达到K次的时候，才将数据放入缓存。当需要淘汰数据时，LRU-K会淘汰第K次访问时间距当前时间最大的数据。
数据第一次被访问时，加入到历史访问列表，如果数据在访问历史列表中没有达到K次访问，则按照一定的规则（FIFO,LRU）淘汰；当访问历史队列中的数据访问次数达到K次后，将数据索引从历史队列中删除，将数据移到缓存队列中，并缓存数据，缓存队列重新按照时间排序；缓存数据队列中被再次访问后，重新排序，需要淘汰数据时，淘汰缓存队列中排在末尾的数据，即“淘汰倒数K次访问离现在最久的数据”。
LRU-K具有LRU的优点，同时还能避免LRU的缺点，实际应用中LRU-2是综合最优的选择。由于LRU-K还需要记录那些被访问过、但还没有放入缓存的对象，因此内存消耗会比LRU要多。