当前位置：首页 > news >正文

【Redis】数据的淘汰策略

news 来源：原创 2025/6/24 7:22:36

淘汰策略方案（8种）

LRU和LFU策略的区别

使用建议

手搓LRU算法

方式一

方式二

大家好，我是jstart千语。今天和大家回来聊一下redis，这次要讲的是它的淘汰策略。为什么需要淘汰策略呢，就是当redis里面的内存占满后，存不下数据了，那么新加入的数据该如何处理呢？这种处理的方式不同，就称为不同的数据淘汰策略。redis支持8种不同的淘汰策略。

淘汰策略方案（8种）

noeviction	默认策略，不淘汰，当内存满时写入会报错（OOM）。适合读多写少的缓存场景
volatile-ttl	从设置了过期时间的 key 中，优先淘汰即将过期的。
allkey-random	随机淘汰一个 key。适用于不关心数据使用频率的场景。
volatile-random	从设置了过期时间的 key 中随机淘汰一个。
allkeys-lru	（最近最少使用）从所有 key 中淘汰最少使用的（LRU：Least Recently Used）。
volatile-lru	（最近最少使用）从设置了过期时间的 key 中，淘汰最少使用的。
allkeys-lfu	（频率）从所有 key 中淘汰最不常用的（LFU：Least Frequently Used）。
volatile-lfu	（频率）从设置了过期时间的 key 中，淘汰最不常用的。

LRU和LFU策略的区别

LRU：最近最少使用，用当前时间减去最后一次访问的时间，这个值越大越先被淘汰。

例如：key1是5秒前被访问，key2是10秒前被访问，那么就是key2优先被淘汰。

LFU：最少频率使用，统计每个key的访问频率，值越小越先被淘汰。

例如：key1在5秒内被访问了3次，key2在10秒内被访问了5次。那么key2优先被淘汰。

使用建议

        1、优先使用allkeys-lru策略。充分利用LRU算法的优势，把最近最常访问的数据留在缓存中。如果业务中有明显的冷热数据区分，建议使用该策略。

为什么这里不使用LFU呢？：

因为数据使用频率可能是不固定的，在某一段时间内访问频率高，另外一段时间访问频率低，可能导致误删。具体还要看业务需求

        2、如果业务中数据访问频率区别不大，没有明显的冷热数据区分，建议使用allkeys-random，随机选择淘汰。

        3、如果业务中有置顶需求，可以使用volatile-lru策略，同时置顶数据不设置过期时间，这些置顶的数据就一直不被删除，会淘汰其他设置过期时间的数据。

        4、如果业务中有短时高频访问的数据，可以使用allkeys-lfu或者volatile-lfu策略。

手搓LRU算法

方式一

利用Java的LinkedHashMap天然支持按访问顺序排序，通过重写removeEldestEntry方法可实现LRU逻辑。

public class LRUCache<K, V> extends LinkedHashMap<K, V> {
    private final int capacity;

    public LRUCache(int capacity) {
        // 初始容量，负载因子，accessOrder=true表示按访问顺序排序
        super(capacity, 0.75f, true);
        this.capacity = capacity;
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        // 当大小超过容量时移除最旧元素
        return size() > capacity;
    }
}

使用示例：

LRUCache<String, String> cache = new LRUCache<>(3);
cache.put("a", "1");
cache.put("b", "2");
cache.get("a"); // 访问"a"使其变为最近使用
cache.put("c", "3");
cache.put("d", "4"); // 插入"d"时，容量超限，淘汰最久未使用的"b"

注意：非线程安全，需在单线程环境使用或通过Collections.synchronizedMap包装。

方式二

手动实现（哈希表 + 双向链表）。实现O(1)时间复杂度的get和put操作，需结合哈希表与双向链表。

步骤：

定义节点结构：包含前后指针及键值。
维护双向链表：头部放最新访问节点，尾部为待淘汰节点。
哈希表映射：快速定位节点位置。

import java.util.HashMap;
import java.util.Map;

public class ManualLRUCache<K, V> {
    static class Node<K, V> {
        K key;
        V value;
        Node<K, V> prev;
        Node<K, V> next;
        Node(K key, V value) {
            this.key = key;
            this.value = value;
        }
    }

    private final int capacity;
    private final Map<K, Node<K, V>> cache = new HashMap<>();
    private Node<K, V> head; // 虚拟头节点
    private Node<K, V> tail; // 虚拟尾节点

    public ManualLRUCache(int capacity) {
        this.capacity = capacity;
        head = new Node<>(null, null);
        tail = new Node<>(null, null);
        head.next = tail;
        tail.prev = head;
    }

    public V get(K key) {
        Node<K, V> node = cache.get(key);
        if (node == null) return null;
        moveToHead(node); // 访问后移至头部
        return node.value;
    }

    public void put(K key, V value) {
        Node<K, V> node = cache.get(key);
        if (node != null) {
            node.value = value;
            moveToHead(node);
        } else {
            node = new Node<>(key, value);
            cache.put(key, node);
            addToHead(node);
            if (cache.size() > capacity) {
                Node<K, V> removed = removeTail();
                cache.remove(removed.key);
            }
        }
    }

    private void moveToHead(Node<K, V> node) {
        removeNode(node);
        addToHead(node);
    }

    private void addToHead(Node<K, V> node) {
        node.prev = head;
        node.next = head.next;
        head.next.prev = node;
        head.next = node;
    }

    private void removeNode(Node<K, V> node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    private Node<K, V> removeTail() {
        Node<K, V> res = tail.prev;
        removeNode(res);
        return res;
    }
}

线程安全优化：