缓存淘汰策略

Posted 2021-04-14 Alleria Windrunner

前面几篇我们介绍了Redis的数据结构，本篇我们一起来看一下Redis的缓存淘汰策略。

在 redis 中，允许用户设置最大使用内存大小maxmemory，默认为0，没有指定最大缓存，如果有新的数据添加，超过最大内存，则会使redis崩溃，所以一定要设置。而当redis 内存数据集大小上升到一定大小的时候,就会实行数据淘汰策略。

redis 提供 6种数据淘汰策略:

1. voltile-lru：从已设置过期时间的数据集(server.db[i].expires)中挑选最近最少使用的数据淘汰。

2. volatile-ttl：从已设置过期时间的数据集(server.db[i].expires)中挑选将要过期的数据淘汰。

3. volatile-random：从已设置过期时间的数据集(server.db[i].expires)中任意选择数据淘汰。

4. allkeys-lru:从数据集(server.db[i].dict)中挑选最近最少使用的数据淘汰

5. allkeys-random：从数据集(server.db[i].dict)中任意选择数据淘汰。

6. no-enviction(驱逐)：禁止驱逐数据。

LRU(Least recently used，最近最少使用)算法根据数据的历史访问记录来进行淘汰数据，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高”。

最常用的是使用一个链表保存缓存数据，参考实现如下：

class LRUCache {
 private HashMap<Integer, Node> map;
 private DoubleLinkedList cache;
 private int capacity;
 public LRUCache(int capacity) { map = new HashMap<Integer, Node>(); cache = new DoubleLinkedList(); this.capacity = capacity; }  public int get(int key) { if (!map.containsKey(key)) { return -1; } int value = map.get(key).value; put(key, value); return value; }  public void put(int key, int value) { Node x = new Node(key, value); if (map.containsKey(key)) { cache.remove(map.get(key)); } else { if (capacity == cache.size()) { Node last = cache.removeLast(); map.remove(last.key); } } cache.addFirst(x); map.put(key, x); }
 private class Node { int key, value; Node prev, next; Node(int key, int value) { this.key = key; this.value = value; } }
 private class DoubleLinkedList { private Node head, tail; private int size; DoubleLinkedList() { head = new Node(0, 0); tail = new Node(0, 0); head.next = tail; tail.prev = head; size = 0; }
 private void addFirst(Node x) { x.next = head.next; x.prev = head; head.next.prev = x; head.next = x; size ++; }
 private void remove(Node x) { x.prev.next = x.next; x.next.prev = x.prev; size --; }
 private Node removeLast() { if (head.next == tail) { return null; } Node last = tail.prev; remove(last); return last; }
 private int size() { return size; } }}

关于缓存淘汰策略就介绍到这里。