Redis算法（二）LRU数据淘汰算法

Redis算法（二）LRU数据淘汰算法

Redis淘汰策略：

当Reis使用的内存超过配置的maxmemory时，便会触发数据淘汰策略
数据淘汰策略：
volatile-lru: 最近最少使用算法，从设置了过期时间的键中选择空转时间最长的键值对清除掉
volatile-lfu: 最近最不经常使用算法，从设置了过期时间的键中选择某段时间之内使用频次最小的键值对清除掉
volatile-ttl: 从设置了过期时间的键中选择过期时间最早的键值对清除
volatile-random: 从设置了过期时间的键中，随机选择键进行清除
allkeys-lru: 最近最少使用算法，从所有的键中选择空转时间最长的键值对清除
allkeys-lfu: 最近最不经常使用算法，从所有的键中选择某段时间之内使用频次最少的键值对清除
allkeys-random: 所有的键中，随机选择键进行删除
noeviction: 不做任何的清理工作，在redis的内存超过限制之后，所有的写入操作都会返回错误；但是读操作都能正常的进行（默认） maxmemory-policy noeviction

LRU原理

LRU工作原理 ：
假设只能容纳3个页大小，按照下面70120304次序访问页，从上到下，按照最近访问时间

基于HashMap和双向链表实现LEU
使用 HashMap 存储 key，这样可以做到 save 和 get key的时间都是 O(1)，而 HashMap 的 Value 指向双向链表实现的 LRU 的 Node 节点


核心步骤：

1. save(key, value)，首先在 HashMap 找到 Key 对应的节点，如果节点存在，更新节点的值，并把这个节点移动队头。如果不存在，需要构造新的节点，并且尝试把节点塞到队头，如果LRU空间不足，则通过 tail 淘汰掉队尾的节点，同时在 HashMap 中移除 Key。
2. get(key)，通过 HashMap 找到 LRU 链表节点，因为根据LRU 原理，这个节点是最新访问的，所以要把节点插入到队头，然后返回缓存的值。
   注意节点的头尾指向的变动

完整基于 Java 的代码参考如下

class DLinkedNode {
        String key;
        int value;
        DLinkedNode pre;
        DLinkedNode post;
}

LRU Cache

public class LRUCache {

    private Hashtable<Integer, DLinkedNode>
            cache = new Hashtable<Integer, DLinkedNode>();
    private int count;
    private int capacity;
    private DLinkedNode head, tail;
    public LRUCache(int capacity) {
        this.count = 0;
        this.capacity = capacity;
        head = new DLinkedNode();
        head.pre = null;
        tail = new DLinkedNode();
        tail.post = null;
        head.post = tail;
        tail.pre = head;
    }
    public int get(String key) {
        DLinkedNode node = cache.get(key);
        if(node == null){
            return -1; // should raise exception here.
        }
        // move the accessed node to the head;
        this.moveToHead(node);
        return node.value;
    }
    
    public void set(String key, int value) {
        DLinkedNode node = cache.get(key);
        if(node == null){
            DLinkedNode newNode = new DLinkedNode();
            newNode.key = key;
            newNode.value = value;
            this.cache.put(key, newNode);
            this.addNode(newNode);
            ++count;
            if(count > capacity){
                // pop the tail
                DLinkedNode tail = this.popTail();
                this.cache.remove(tail.key);
                --count;
            }
        }else{
            // update the value.
            node.value = value;
            this.moveToHead(node);
        }
    }
    /**
     * Always add the new node right after head;
     */
    private void addNode(DLinkedNode node){
        node.pre = head;
        node.post = head.post;
        head.post.pre = node;
        head.post = node;
    }
    /**
     * Remove an existing node from the linked list.
     */
    private void removeNode(DLinkedNode node){
        DLinkedNode pre = node.pre;
        DLinkedNode post = node.post;
        pre.post = post;
        post.pre = pre;
    }
    /**
     * Move certain node in between to the head.
     */
    private void moveToHead(DLinkedNode node){
        this.removeNode(node);
        this.addNode(node);
    }
    // pop the current tail.
    private DLinkedNode popTail(){
        DLinkedNode res = tail.pre;
        this.removeNode(res);
        return res;
    }
}

Redis LRU

Redis会基于server.maxmemory_samples配置选取固定数目的key，然后比较它们的lru访问时间，然后淘汰最近最久没有访问的key，maxmemory_samples的值越大，Redis的近似LRU算法就越接近于严格LRU算法，但是相应消耗也变高，对性能有一定影响，样本值默认为5
代码主要是获取样本缓存对象的排序权值 idle，如果使用 LRU淘汰算法，那么就调用函数获取排序权值， estimateObjectIdleTime() 函数用于获取缓存对象有多长时间没有被访问。排序按照 idle 的值升序排序，就是说 idle 的值越大，就排到越后
淘汰数据时只是从样本中找到最优的淘汰缓存对象，并不是从所有缓存对象集合中查找。由于前面介绍的 LRU算法 需要维护一个LRU链表，而维护一个LRU链表的成本比较大，所以Redis才出此下策
数据采样过程：

总结：

Redis 使用的是一种近似 LRU 算法：
1、key增加最近访问时间戳字段
2、选取一定数量的key（默认5，server.maxmemory_samples进行配置），比较最近访问时间。按照LRU算法淘汰key。
当 Redis 执行写操作时，发现内存超出 maxmemory，就会执行一次 LRU 淘汰算法。
注意：maxmemory_samples的值越大，Redis的近似LRU算法就越接近于严格LRU算法（队列结构重排，批量非热点数据缓存垃圾），但是相应消耗也变高，对性能有一定影响，样本值默认为5

参考：
https://zhuanlan.zhihu.com/p/34133067
https://juejin.im/entry/5d0898aaf265da1ba25260f5