Redis缓存失效策略思考

桃扇骨 2021-09-24 09:12 342阅读 0赞

> 欢迎大家关注公众号「JAVA前线」查看更多精彩分享文章，主要包括源码分析、实际应用、架构思维、职场分享、产品思考等等，同时欢迎大家加我微信「java\_front」一起交流学习

# 1 删除过期数据 #

我们在设置Redis元素时可以指定超时时间，那么Redis如何删除这些超时元素？Redis采用了两种策略：定期删除和惰性删除。

## **1.1 定期删除** ##

Redis每隔一段时间就检查哪些KEY已经过期，如果过期就删除。但是我们来设想一个问题：如果Redis存储KEY非常多，仅仅超时检查这项工作就会非常耗费资源并严重影响服务能力。为了解决这个问题Redis并不是检查全量KEY而只是检查部分，同时引入了惰性删除策略。

## **1.2 惰性删除** ##

假设当KEY1已经过期，但是由于没有被检查到而未被删除。那么当程序访问KEY1时，Redis会检查KEY1是否过期，如果过期则删除并不返回该值，这就是惰性删除策略。结合定期删除和惰性删除两种策略，就可以保证过期数据可以被删除。

# 2 内存淘汰 #

当内存不足时Redis会选择一些缓存元素进行删除，那么哪些缓存元素会被删除？删除规则就是Redis内存淘汰策略，常见内存淘汰策略如下：

no-enviction
    禁止驱逐数据，新写入操作会报错
    
    volatile-lru
    从已设置过期时间的数据集选择最近最少使用的数据淘汰
    
    volatile-ttl
    从已设置过期时间的数据集选择将要过期的数据淘汰
    
    volatile-random
    从已设置过期时间的数据集选择任意的数据淘汰
    
    allkeys-lru
    从数据集选择最近最少使用的数据淘汰
    
    allkeys-random
    从数据集选择任意的数据淘汰

LRU（Least Recently Used）最近最少使用是比较常用的策略，我们使用JAVA代码实现一个简单LRU策略，代码原理并不复杂：使用一个链表存储元素，表头存储最近访问的元素，这样存储的结果是表尾存储最早访问的元素，表头存储最近访问的元素，当超出链表容量时删除表尾元素即可。

/**
     * 元素对象
     *
     * @author 今日头条号「IT徐胖子」
     *
     */
    public class CacheElement {
    	private String key;
    	private Object value;
    
    	public CacheElement(String key, Object value) {
    		this.key = key;
    		this.value = value;
    	}
    
    	public String getKey() {
    		return key;
    	}
    
    	public Object getValue() {
    		return value;
    	}
    
    	@Override
    	public String toString() {
    		return "Element [key=" + key + ", value=" + value + "]";
    	}
    }
    
    
    /**
     * LRU缓存策略
     *
     * @author 今日头条号「IT徐胖子」
     *
     */
    public class LRUCache {
    	private int capacity;
    	private LinkedList<CacheElement> cache;
    
    	public LRUCache(int capacity) {
    		this.capacity = capacity;
    		this.cache = new LinkedList<>();
    	}
    
    	/**
    	 * 获取缓存元素
    	 *
    	 * 找到元素后将元素从原位置删除并插入到链表头部（最近）
    	 */
    	public CacheElement get(String key) {
    		Iterator<CacheElement> iterator = cache.iterator();
    		while (iterator.hasNext()) {
    			CacheElement element = iterator.next();
    			if (element.getKey().equals(key)) {
    				iterator.remove();
    				System.out.println("获取到元素=" + element);
    				put(element.getKey(), element.getValue());
    				return element;
    			}
    		}
    		return null;
    	}
    
    	/**
    	 * 存储缓存元素
    	 *
    	 * 新元素插入到链表头部（最近）
    	 */
    	public boolean put(String key, Object value) {
    		Iterator<CacheElement> iterator = cache.iterator();
    		while (iterator.hasNext()) {
    			CacheElement element = iterator.next();
    			if (element.getKey().equals(key)) {
    				iterator.remove();
    				break;
    			}
    		}
    		if (capacity == cache.size()) {
    			CacheElement deleteElement = cache.removeLast();
    			System.out.println("容量已满删除尾部元素=" + deleteElement);
    		}
    		CacheElement element = new CacheElement(key, value);
    		cache.addFirst(element);
    		System.out.println("插入头部元素=" + element);
    		return Boolean.TRUE;
    	}
    
    	@Override
    	public String toString() {
    		return "LRUCache [capacity=" + capacity + ", cache=" + cache + "]";
    	}
    }
    /**
     * LRU测试实例
     *
     * @author 今日头条号「IT徐胖子」
     *
     */
    public class TestCache {
    	public static void main(String[] args) {
    		System.out.println("==================存储缓存元素==================");
    		LRUCache cache = new LRUCache(2);
    		CacheElement element0 = new CacheElement("k0", "v0");
    		CacheElement element1 = new CacheElement("k1", "v1");
    		CacheElement element2 = new CacheElement("k2", "v2");
    		cache.put(element0.getKey(), element0.getValue());
    		cache.put(element1.getKey(), element1.getValue());
    		cache.put(element2.getKey(), element2.getValue());
    
    		System.out.println("==================获取缓存元素==================");
    		System.out.println("获取元素之前缓存对象=" + cache);
    		cache.get("k1");
    		System.out.println("获取元素之后缓存对象=" + cache);
    	}
    }

==================存储缓存元素==================
    插入头部元素=Element [key=k0, value=v0]
    插入头部元素=Element [key=k1, value=v1]
    容量已满删除尾部元素=Element [key=k0, value=v0]
    插入头部元素=Element [key=k2, value=v2]
    
    ==================获取缓存元素==================
    获取元素之前缓存对象=LRUCache [capacity=2, cache=[Element [key=k2, value=v2], Element [key=k1, value=v1]]]
    获取到元素=Element [key=k1, value=v1]
    插入头部元素=Element [key=k1, value=v1]
    获取元素之后缓存对象=LRUCache [capacity=2, cache=[Element [key=k1, value=v1], Element [key=k2, value=v2]]]

# 3 文章总结 #

本文我们分析了Redis缓存失效策略：删除过期数据和内存淘汰，并且使用JAVA代码模拟了LRU策略实现。这里我们可以做一个引申：Redis分布式锁是否可靠。因为Redis存在着内存淘汰机制，那么作为分布式锁的KEY从概率上会被淘汰，从而导致分布式锁失效。所以仅仅有分布式锁是不够的，我们还需要其它方法，例如设置数据库层唯一索引，防止重复数据产生。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dvc2hpeHV5ZQ_size_16_color_FFFFFF_t_70][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dvc2hpeHV5ZQ_size_16_color_FFFFFF_t_70]: /images/20210923/6e46874dc0804f22aef8f6597be2dc82.png