Redis 的过期数据如何处理，淘汰机制都有那些？

Redis 的过期数据会被立马删除么？

并不会立马删除。Redis 有两种删除过期数据的策略：

• 定期选取部分数据删除；
• 惰性删除；

从 Redis 版本 7.0.0 开始：EXPIRE 添加了选项：NX、XX和GT、LT 选项。

• NX：当 key 没有过期时才设置过期时间；
• XX：只有 key 已过期的时候才设置过期时间；
• GT：仅当新的到期时间大于当前到期时间时才设置过期时间；
• LT：仅在新到期时间小于当前到期时间才设置到过期时间。

主从或者集群架构中，两台机器的时钟严重不同步，会有什么问题么？

key 过期信息是用 Unix 绝对时间戳表示的。

为了让过期操作正常运行，机器之间的时间必须保证稳定同步，否则就会出现过期时间不准的情况。

比如两台时钟严重不同步的机器发生 RDB 传输， slave 的时间设置为未来的 2000 秒，假如在 master 的一个 key 设置 1000 秒存活，当 Slave 加载 RDB 的时候 key 就会认为该 key 过期（因为 slave 机器时间设置为未来的 2000 s），并不会等待 1000 s 才过期。

惰性删除

惰性删除很简单，就是当有客户端的请求查询该 key 的时候，检查下 key 是否过期，如果过期，则删除该 key。

比如当 Redis 收到客户端的GET movie:小泽#玛……利亚.rmvb 请求，就会先检查 key = movie:小泽#玛……利亚.rmvb 是否已经过期，如果过期那就删除。

删除过期数据的主动权交给了每次访问请求。

定期删除

仅仅靠客户端访问来判断 key 是否过期才执行删除肯定不够，因为有的 key 过期了，但未来再也没人访问，这些数据要怎么删除呢？

不能让这些数据「占着茅坑不拉屎」。

所谓定期删除，也就是 Redis 默认每 1 秒运行 10 次（每 100 ms 执行一次），每次随机抽取一些设置了过期时间的 key，检查是否过期，如果发现过期了就直接删除。过期的 key 超过 25%，则继续执行

注意：并不是一次运行就检查所有的库，所有的键，而是随机检查一定数量的键。

不管是定时删除，还是惰性删除。当数据删除后，master 会生成删除的指令记录到 AOF 和 slave 节点。

如果过期的数据太多，定时删除无法删除完全（每次删除完过期的 key 还是超过 25%），同时这些 key 也再也不会被客户端请求，也就是无法走惰性删除，会怎样？会不会导致 Redis 内存耗尽，怎么破？

当 redis 节点分配的内存使用到达最大值，Redis 会启动内存淘汰策略，Redis 4.0 之前主要是以下六种策略：

• noenviction：不清除数据，只是返回错误，这样会导致浪费掉更多的内存，对大多数写命令（DEL 命令和其他的少数命令例外）
• allkeys-lru：从所有的数据集（server.db[i].dict）中挑选最近最少使用的数据淘汰，以供新数据使用
• volatile-lru：从已设置过期时间的数据集（server.db[i].expires）中挑选最近最少使用的数据淘汰，以供新数据使用
• allkeys-random：从所有数据集（server.db[i].dict）中任意选择数据淘汰，以供新数据使用
• volatile-random：从已设置过期时间的数据集（server.db[i].expires）中任意选择数据淘汰，以供新数据使用
• volatile-ttl：从已设置过期时间的数据集（server.db[i].expires）中挑选将要过期的数据淘汰，以供新数据使用

Redis 4.0 新增了两种 LFU 淘汰策略:

• allkeys-lfu，淘汰整个键值中最少使用的键值，这也就是我们常说的LRU算法。
• volatile-lfu，淘汰所有设置了过期时间的键值中最少使用的键值。

LRU（Least Recently Used，最近最少使用），根据最近被使用的时间，离当前最远的数据优先被淘汰；在使用内存作为缓存的时候，缓存的大小一般是固定的。当缓存被占满，这个时候继续往缓存里面添加数据，就需要淘汰一部分老的数据，释放内存空间用来存储新的数据。这个时候就可以使用LRU算法了。其核心思想是：如果一个数据在最近一段时间没有被用到，那么将来被使用到的可能性也很小，所以就可以被淘汰掉
LFU（Least Frequently Used，最不经常使用），在一段时间内，缓存数据被使用次数最少的会被淘汰；根据key的最近被访问的频率进行淘汰，很少被访问的优先被淘汰，被访问的多的则被留下来

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

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

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

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

---

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

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

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

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

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

配置如下：

maxmemory-samples 50

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;
    }
}