有趣的Redis：缓存被我写满了，该怎么办？

转载：blog.csdn.net/zzti\_erlie…node

介绍

Redis是一个内存数据库，当Redis使用的内存超过物理内存的限制后，内存数据会和磁盘产生频繁的交换，交换会致使Redis性能急剧降低。因此在生产环境中咱们经过配置参数maxmemoey来限制使用的内存大小。算法

当实际使用的内存超过maxmemoey后，Redis提供了以下几种可选策略。数据库

noeviction：写请求返回错误缓存

volatile-lru：使用lru算法删除设置了过时时间的键值对
volatile-lfu：使用lfu算法删除设置了过时时间的键值对
volatile-random：在设置了过时时间的键值对中随机进行删除
volatile-ttl：根据过时时间的前后进行删除，越早过时的越先被删除安全

allkeys-lru：在全部键值对中，使用lru算法进行删除
allkeys-lfu：在全部键值对中，使用lfu算法进行删除
allkeys-random：全部键值对中随机删除markdown

咱们来详细了解一下lru和lfu算法，这是2个常见的缓存淘汰算法。由于计算机缓存的容量是有限的，因此咱们要删除那些没用的数据，而这两种算法的区别就是断定没用的纬度不同。数据结构

LRU算法

lru（Least recently used，最近最少使用）算法，即最近访问的数据，后续很大几率还会被访问到，便是有用的。而长时间未被访问的数据，应该被淘汰dom

lru算法中数据会被放到一个链表中，链表的头节点为最近被访问的数据，链表的尾节点为长时间没有被访问的数据ide

lru算法的核心实现就是哈希表加双向链表。链表能够用来维护访问元素的顺序，而hash表能够帮咱们在O(1)时间复杂度下访问到元素。函数

至于为何是双向链表呢？主要是要删除元素，因此要获取前继节点。数据结构图示以下

使用双向链表+HashMap

双向链表节点定义以下

public class ListNode<K, V> {
    K key;
    V value;
    ListNode pre;
    ListNode next;

    public ListNode() {}

    public ListNode(K key, V value) {
        this.key = key;
        this.value = value;
    }
} 
复制代码

封装双向链表的经常使用操做

public class DoubleList {

    private ListNode head;
    private ListNode tail;

    public DoubleList() {
        head = new ListNode();
        tail = new ListNode();
        head.next = tail;
        tail.pre = head;
    }

    public void remove(ListNode node) {
        node.pre.next = node.next;
        node.next.pre = node.pre;
    }

    public void addLast(ListNode node) {
        node.pre = tail.pre;
        tail.pre = node;
        node.pre.next = node;
        node.next = tail;
    }

    public ListNode removeFirst() {
        if (head.next == tail) {
            return null;
        }
        ListNode first = head.next;
        remove(first);
        return first;
    }
} 
复制代码

封装一个缓存类，提供最基本的get和put方法。须要注意，这两种基本的方法都涉及到对两种数据结构的修改。

public class MyLruCache<K, V> {

    private int capacity;
    private DoubleList doubleList;
    private Map<K, ListNode> map;

    public MyLruCache(int capacity) {
        this.capacity = capacity;
        map = new HashMap<>();
        doubleList = new DoubleList();
    }

    public V get(Object key) {
        ListNode<K, V> node = map.get(key);
        if (node == null) {
            return null;
        }
        // 先删除该节点，再接到尾部
        doubleList.remove(node);
        doubleList.addLast(node);
        return node.value;
    }

    public void put(K key, V value) {
        // 直接调用这边的get方法，若是存在，它会在get内部被移动到尾巴，不用再移动一遍,直接修改值便可
        if ((get(key)) != null) {
            map.get(key).value = value;
            return;
        }

        // 若是超出容量，把头去掉
        if (map.size() == capacity) {
            ListNode listNode = doubleList.removeFirst();
            map.remove(listNode.key);
        }

        // 若不存在，new一个出来
        ListNode node = new ListNode(key, value);
        map.put(key, node);
        doubleList.addLast(node);
    }
} 
复制代码

这里咱们的实现为最近访问的放在链表的尾节点，不常常访问的放在链表的头节点

测试一波，输出为链表的正序输出（代码为了简洁没有贴toString方法）

MyLruCache<String, String> myLruCache = new MyLruCache<>(3);
// {5 : 5}
myLruCache.put("5", "5");
// {5 : 5}{3 : 3}
myLruCache.put("3", "3");
// {5 : 5}{3 : 3}{4 : 4}
myLruCache.put("4", "4");
// {3 : 3}{4 : 4}{2 : 2}
myLruCache.put("2", "2");
// {4 : 4}{2 : 2}{3 : 3}
myLruCache.get("3"); 
复制代码

由于LinkedHashMap的底层实现就是哈希表加双向链表，因此你能够用LinkedHashMap替换HashMap和DoubleList来改写一下上面的类。

我来演示一下更骚的操做，只须要重写一个构造函数和removeEldestEntry方法便可。

使用LinkedHashMap实现LRU

public class LruCache<K, V> extends LinkedHashMap<K, V> {

    private int cacheSize;


    public LruCache(int cacheSize) {
        /**
         * initialCapacity: 初始容量大小
         * loadFactor: 负载因子
         * accessOrder: false基于插入排序（默认），true基于访问排序
         */
        super(cacheSize, 0.75f, true);
        this.cacheSize = cacheSize;
    }

    /**
     * 当调用put或者putAll方法时会调用以下方法，是否删除最老的数据，默认为false
     */
    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return size() > cacheSize;
    }
} 
复制代码

注意这个缓存并非线程安全的，能够调用Collections.synchronizedMap方法返回线程安全的map

LruCache<String, String> lruCache = new LruCache(3);
Map<String, String> safeMap = Collections.synchronizedMap(lruCache); 
复制代码

Collections.synchronizedMap实现线程安全的方式很简单，只是返回一个代理类。代理类对Map接口的全部方法加锁

public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {
    return new SynchronizedMap<>(m);
} 
复制代码

LFU算法

LRU算法有一个问题，当一个长时间不被访问的key，偶尔被访问一下后，可能会形成一个比这个key访问更频繁的key被淘汰。

即LRU算法对key的冷热程度的判断可能不许确。而LFU算法（Least Frequently Used，最不常用）则是按照访问频率来判断key的冷热程度的，每次删除的是一段时间内访问频率较低的数据，比LRU算法更准确。

使用3个hash表实现lfu算法

那么咱们应该如何组织数据呢？

为了实现键值的对快速访问，用一个map来保存键值对.

private HashMap<K, Integer> keyToVal; 
复制代码

还须要用一个map来保存键的访问频率

private HashMap<K, Integer> keyToFreq; 
复制代码

固然你也能够把值和访问频率封装到一个类中，用一个map来替代上述的2个map

接下来就是最核心的部分，删除访问频率最低的数据。

为了能在O(1)时间复杂度内找到访问频率最低的数据，咱们须要一个变量minFreq记录访问最低的频率
每一个访问频率有可能对应多个键。当空间不够用时，咱们要删除最先被访问的数据，因此须要以下数据结构，Map<频率, 有序集合>。每次内存不够用时，删除有序集合的第一个元素便可。而且这个有序集合要能快速删除某个key，由于某个key被访问后，须要从这个集合中删除，加入freq+1对应的集合中
有序集合不少，可是能知足快速删除某个key的只有set，可是set插入数据是无序的。幸好Java有LinkedHashSet这个类，链表和集合的结合体，链表不能快速删除元素，可是能保证插入顺序。集合内部元素无序，可是能快速删除元素，完美

下面就是具体的实现。

public class LfuCache<K, V> {

    private HashMap<K, V> keyToVal;
    private HashMap<K, Integer> keyToFreq;
    private HashMap<Integer, LinkedHashSet<K>> freqTokeys;

    private int minFreq;
    private int capacity;

    public LfuCache(int capacity) {
        keyToVal = new HashMap<>();
        keyToFreq = new HashMap<>();
        freqTokeys = new HashMap<>();
        this.capacity = capacity;
        this.minFreq = 0;
    }

    public V get(K key) {
        V v = keyToVal.get(key);
        if (v == null) {
            return null;
        }
        increaseFrey(key);
        return v;
    }

    public void put(K key, V value) {
        // get方法里面会增长频次
        if (get(key) != null) {
            // 从新设置值
            keyToVal.put(key, value);
            return;
        }

        // 超出容量，删除频率最低的key
        if (keyToVal.size() >= capacity) {
            removeMinFreqKey();
        }

        keyToVal.put(key, value);
        keyToFreq.put(key, 1);
        // key对应的value存在，返回存在的key
        // key对应的value不存在，添加key和value
        freqTokeys.putIfAbsent(1, new LinkedHashSet<>());
        freqTokeys.get(1).add(key);
        this.minFreq = 1;
    }

    // 删除出现频率最低的key
    private void removeMinFreqKey() {
        LinkedHashSet<K> keyList = freqTokeys.get(minFreq);
        K deleteKey = keyList.iterator().next();
        keyList.remove(deleteKey);
        if (keyList.isEmpty()) {
            // 这里删除元素后不须要从新设置minFreq
            // 由于put方法执行完会将minFreq设置为1
            freqTokeys.remove(keyList);
        }
        keyToVal.remove(deleteKey);
        keyToFreq.remove(deleteKey);
    }

    // 增长频率
    private void increaseFrey(K key) {
        int freq = keyToFreq.get(key);
        keyToFreq.put(key, freq + 1);
        freqTokeys.get(freq).remove(key);
        freqTokeys.putIfAbsent(freq + 1, new LinkedHashSet<>());
        freqTokeys.get(freq + 1).add(key);
        if (freqTokeys.get(freq).isEmpty()) {
            freqTokeys.remove(freq);
            // 最小频率的set为空，key被移动到minFreq+1对应的set了
            // 因此minFreq也要加1
            if (freq == this.minFreq) {
                this.minFreq++;
            }
        }
    }
} 
复制代码

测试一下

LfuCache<String, String> lfuCache = new LfuCache(2);
lfuCache.put("1", "1");
lfuCache.put("2", "2");
// 1
System.out.println(lfuCache.get("1"));
lfuCache.put("3", "3");
// 1的频率为2，2和3的频率为1，但2更早以前被访问，因此被清除
// 结果为null
System.out.println(lfuCache.get("2")); 
复制代码

你们能够关注一下个人公众号，时不时分享文章，学习资料给你们！