Redis 为何使用近似 LRU 算法淘汰数据,而不是真实 LRU?

Posted CSDN云计算

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Redis 为何使用近似 LRU 算法淘汰数据,而不是真实 LRU?相关的知识,希望对你有一定的参考价值。


作者 | 码哥呀

来源 | CSDN博客

在《Redis 数据缓存满了怎么办?》我们知道 Redis 缓存满了之后能通过淘汰策略删除数据腾出空间给新数据。

淘汰策略如下所示:

redis内存淘汰

设置过期时间的 key

volatile-ttl、volatile-random、volatile-lru、volatile-lfu 这四种策略淘汰的数据范围是设置了过期时间的数据。

所有的 key

allkeys-lru、allkeys-random、allkeys-lfu 这三种淘汰策略无论这些键值对是否设置了过期时间,当内存不足都会进行淘汰。

这就意味着,即使它的过期时间还没到,也会被删除。当然,如果已经过了过期时间,即使没有被淘汰策略选中,也会被删除。

volatile-ttl 和 volatile-randon 很简单,重点在于 volatile-lru 和 volatile-lfu,他们涉及到 LRU 算法 和 LFU 算法。

今天带大家一起搞定 Redis 的 LRU 算法…

近似 LRU 算法

❝ 什么是 LRU 算法呢?

LRU 算法的全程是 Least Rencently Used,顾名思义就是按照最近最久未使用的算法进行数据淘汰。

核心思想「如果该数据最近被访问,那么将来被访问的几率也更高」。

我们把所有的数据组织成一个链表:

  • MRU:表示链表的表头,代表着最近最常被访问的数据;

  • LRU:表示链表的表尾,代表最近最不常使用的数据。

LRU 算法

可以发现,LRU 更新和插入新数据都发生在链表首,删除数据都发生在链表尾

被访问的数据会被移动到 MRU 端,被访问的数据之前的数据则相应往后移动一位。

❝ 使用单链表可以么?

如果选用单链表,删除这个结点,需要 O(n) 遍历一遍找到前驱结点。所以选用双向链表,在删除的时候也能 O(1) 完成。

❝ Redis 使用该 LRU 算法管理所有的缓存数据么?

不是的,由于 LRU 算法需要用链表管理所有的数据,会造成大量额外的空间消耗。

除此之外,大量的节点被访问就会带来频繁的链表节点移动操作,从而降低了 Redis 性能。

所以 Redis 对该算法做了简化,Redis LRU 算法并不是真正的 LRU,Redis 通过对少量的 key 采样,并淘汰采样的数据中最久没被访问过的 key。

这就意味着 Redis 无法淘汰数据库最久访问的数据。

Redis LRU 算法有一个重要的点在于可以更改样本数量来调整算法的精度,使其近似接近真实的 LRU 算法,同时又避免了内存的消耗,因为每次只需要采样少量样本,而不是全部数据。

配置如下:

maxmemory-samples 50

运行原理

大家还记得么,数据结构 redisObject 中有一个 lru 字段, 用于记录每个数据最近一次被访问的时间戳

typedef struct redisObject 
    unsigned type:4;
    unsigned encoding:4;
    /* LRU time (relative to global lru_clock) or
     * LFU data (least significant 8 bits frequency
     * and most significant 16 bits access time).
     */
    unsigned lru:LRU_BITS;
    int refcount;
    void *ptr;
 robj;

Redis 在淘汰数据时,第一次随机选出 N 个数据放到候选集合,将 lru 字段值最小的数据淘汰。

再次需要淘汰数据时,会重新挑选数据放入第一次创建的候选集合,不过有一个挑选标准:进入该集合的数据的 lru 的值必须小于候选集合中最小的 lru 值。

如果新数据进入候选集合的个数达到了 maxmemory-samples 设定的值,那就把候选集合中 lru 最小的数据淘汰。

这样就大大减少链表节点数量,同时不用每次访问数据都移动链表节点,大大提升了性能。

Java 实现 LRU Cahce

LinkedHashMap 实现

完全利用 Java 的LinkedHashMap实现,可以采用组合或者继承的方式实现,在这里使用组合的形式完成。

public class LRUCache<K, V> 
    private Map<K, V> map;
    private final int cacheSize;

    public LRUCache(int initialCapacity) 
        map = new LinkedHashMap<K, V>(initialCapacity, 0.75f, true) 
            @Override
            protected boolean removeEldestEntry(Map.Entry<K, V> eldest) 
                return size() > cacheSize;
            
        ;
        this.cacheSize = initialCapacity;
    

重点在于 LinkedHashMap的第三个构造函数上,要把这个构造参数accessOrder设为 true,代表LinkedHashMap内部维持访问顺序。

另外,还需要重写removeEldestEntry(),这个函数如果返回true,代表把最久未被访问的节点移除,从而实现淘汰数据。

自己实现

其中代码是从 LeetCode 146. LRU Cache 上摘下来的。代码里面有注释。

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 在链头放最久未被使用的元素,链尾放刚刚添加或访问的元素
 */
class LRUCache 
    class Node 
        int key, value;
        Node pre, next;

        Node(int key, int value) 
            this.key = key;
            this.value = value;
            pre = this;
            next = this;
        
    

    private final int capacity;// LRU Cache的容量
    private Node dummy;// dummy节点是一个冗余节点,dummy的next是链表的第一个节点,dummy的pre是链表的最后一个节点
    private Map<Integer, Node> cache;//保存key-Node对,Node是双向链表节点

    public LRUCache(int capacity) 
        this.capacity = capacity;
        dummy = new Node(0, 0);
        cache = new ConcurrentHashMap<>();
    

    public int get(int key) 
        Node node = cache.get(key);
        if (node == null) return -1;
        remove(node);
        add(node);
        return node.value;
    

    public void put(int key, int value) 
        Node node = cache.get(key);
        if (node == null) 
            if (cache.size() >= capacity) 
                cache.remove(dummy.next.key);
                remove(dummy.next);
            
            node = new Node(key, value);
            cache.put(key, node);
            add(node);
         else 
            cache.remove(node.key);
            remove(node);
            node = new Node(key, value);
            cache.put(key, node);
            add(node);
        
    

    /**
     * 在链表尾部添加新节点
     *
     * @param node 新节点
     */
    private void add(Node node) 
        dummy.pre.next = node;
        node.pre = dummy.pre;
        node.next = dummy;
        dummy.pre = node;
    

    /**
     * 从双向链表中删除该节点
     *
     * @param node 要删除的节点
     */
    private void remove(Node node) 
        node.pre.next = node.next;
        node.next.pre = node.pre;
    

参考文献

https://redis.io/docs/manual/eviction/

http://antirez.com/news/109

https://time.geekbang.org/column/article/294640 

https://halfrost.com/lru_lfu_interview/

https://blog.csdn.net/csdlwzy/article/details/95635083

往期推荐

Kubernetes 上调试 distroless 容器

Kubernetes 上容器的启动顺序如何把控?

Redis 内存满了怎么办?这样置才正确!

用 Spring boot 简单搭建一个微服务项目

点分享

点收藏

点点赞

点在看

以上是关于Redis 为何使用近似 LRU 算法淘汰数据,而不是真实 LRU?的主要内容,如果未能解决你的问题,请参考以下文章

吃透Redis:缓存淘汰篇-LRU算法

吃透Redis:缓存淘汰篇-LRU算法

吃透Redis:缓存淘汰篇-LRU算法

缓存数据库Redis之三:内存淘汰策略及优化

缓存数据库Redis之三:内存淘汰策略及优化

缓存数据库Redis之三:内存淘汰策略及优化