Redis - LRU

Redis -LRU

当 Redis 内存超出物理内存时，内存的数据会开始喝磁盘产生频繁的交换（swap）交换会让 Redis 的性能急剧下降，对于访问量比较频繁的 Redis 来说这样龟速的存取效率基本上等于不可用。

在生产环境下我们是不允许 Redis 出现交互行为的，为了限制最大使用内存，Redis 提供了配置参数 maxmemory 来限制最大内存

当实际内存超出 maxmemory 时，Redis 提供了集中可选策略

策略	介绍
no-eviction	当内存不足以容纳新写入数据时，新写入操作会报错，无法写入新数据，一般不采用。
allkeys-lru	当内存不足以容纳新写入数据时，移除最近最少使用的key，这个是最常用的
allkeys-random	当内存不足以容纳新写入的数据时，随机移除key
volatile-lru	当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，移除最近最少使用的key（这个一般不太合适）
volatile-random	当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，随机移除某个key
volatile-ttl	当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，有更早过期时间的key优先移除

选择正确的回收策略是非常重要的，这取决于你的应用的访问模式，不过你可以在运行时进行相关的策略调整，并且监控缓存命中率和没命中的次数，通过Redis INFO 命令输出以便调优。

如果你只是使用 Redis 做缓存，那你就应该使用 allkeys-lru ｜ allkeys-random，如果你还想同时使用持久化的功能，那就使用 volatile-lru ｜ volatile-random 它们是永久的 key 不会被 LRU 算法淘汰。

回收是如何工作的

1. 一个客户端运行了新的命令，添加新的数据
2. Redis 检查内存使用情况，如果大于 maxmemory 的限制，则根据设定好的策略回收
3. 一个新的命令被执行，等等

所以我们不断地越过内存限制的边界，越过它，然后通过驱逐键返回到限制之下。

如果某个命令导致使用大量内存（例如存储到新键中的大集合交集）一段时间，内存限制可能会被明显超过。

LRU 算法

实现 LRU 算法除了需要 key/value 字典外，还需要附加一个链表，链表中的元素按照一定的顺序进行排列。当空间满的时候，会踢掉链表尾部的元素，当字典的某个元素被访问时，它在链表中的位置会被移动到表头，所以链表的元素排列顺序就是元素最近被访问的时间顺序。

位于链表尾部的元素就是不被重用的元素，所以会被踢掉，位于表头的元素就是最近被人用过的元素，所以暂时不会踢

利用 Java 的 LinkedHashMap 来实现 LRU 算法

class LRUCache {


    class Node{
        Object key;
        Object value;
        Node pre;
        Node next;

        public Node(Object key, Object value){
            this.key = key;
            this.value = value;
        }
    }

    int capacity;
    HashMap<Object, Node> map = new HashMap<Object, Node>();
    Node head=null;
    Node end=null;

    public LRUCache(int capacity) {
        this.capacity = capacity;
    }


    public Object get(Object key){
        if(map.containsKey(key)){
            Node n = map.get(key);
            remove(n);
            setHead(n);
            return n.value;
        }
        return -1;
    }



    public void remove(Node n){
        if(n.pre !=null){
            n.pre.next = n.next;
        }else{
            head = n.next;
        }
        if(n.next!=null){
            n.next.pre = n.pre;
        }else{
            end = n.pre;
        }
    }



    public void setHead(Node n){
        n.next = head;
        n.pre = null;
        if(head!=null) {
            head.pre = n;
        }
        head = n;
        if(end ==null){
            end = head;
        }
    }


    public void set(Object key, Object value) {
        if(map.containsKey(key)){
            Node old = map.get(key);
            old.value = value;
            remove(old);
            setHead(old);
        }else{
            Node created = new Node(key, value);
            if(map.size()>=capacity){
                map.remove(end.key);
                remove(end);
                setHead(created);

            }else{
                setHead(created);
            }
            map.put(key,created);
        }
    }


    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();
        Node node = head;
        while(node != null){
            sb.append(String.format("%s:%s ", node.key,node.value));
            node = node.next;
        }

        return sb.toString();
    }


    public static void main(String[] args) {
        LRUCache lruCache = new LRUCache(3);
        lruCache.set("1","123");
        lruCache.set("2","123");
        lruCache.set("3","123");
        System.out.println(lruCache.toString());
        lruCache.set("4","123");
        System.out.println(lruCache.toString());
    }



}

近似 LRU 算法

Redis 使用的是一种近似 LRU 算法，他跟 LRU 算法还不太一样，只所以不使用 LRU 算法，是因为需要消耗大量额外的内存，需要对现有的数据结构进行很大的改造，近似 LRU 算法则很简单，在现有数据结构的基础上采用随机采样法来淘汰元素，能达到和 LRU 算法非常近似的效果，Redis 为实现近似算法，他给每个 key 增加了个额外的小字段，这个字段的长度是 24个bit,也就是最后一次被访问的时间戳

Redis LRU有个很重要的点，你通过调整每次回收时检查的采样数量，以实现调整算法的精度。这个参数可以通过以下的配置指令调整:

maxmemory-samples 5

Redis为什么不使用真实的LRU实现是因为这需要太多的内存。不过近似的LRU算法对于应用而言应该是等价的。使用真实的LRU算法与近似的算法可以通过下面的图像对比。

你可以看到三种点在图片中, 形成了三种带.

• 浅灰色带是已经被回收的对象。
• 灰色带是没有被回收的对象。
• 绿色带是被添加的对象。

从图中可以看出采样数量越大，近似 LRU 算法的效果越接近严格 LRU 算法。同时 Redis3.0 在算法中增加了淘汰池，进一步提升了近似 LRU 算法的效果。

淘汰池是一个数组，它的大小是 maxmemory_samples，在每一次淘汰循环中，新随机出来的 key 列表会和淘汰池中的 key 列表进行融合，淘汰掉最旧的一个 key 之后，保留剩余较旧的 key 列表放入淘汰池中留待下一个循环。