Redis -LRU
当 Redis 内存超出物理内存时,内存的数据会开始喝磁盘产生频繁的交换(swap)交换会让 Redis 的性能急剧下降,对于访问量比较频繁的 Redis 来说这样龟速的存取效率基本上等于不可用。
在生产环境下我们是不允许 Redis 出现交互行为的,为了限制最大使用内存,Redis 提供了配置参数 maxmemory 来限制最大内存
当实际内存超出 maxmemory 时,Redis 提供了集中可选策略
策略 | 介绍 |
---|---|
no-eviction | 当内存不足以容纳新写入数据时,新写入操作会报错,无法写入新数据,一般不采用。 |
allkeys-lru | 当内存不足以容纳新写入数据时,移除最近最少使用的key,这个是最常用的 |
allkeys-random | 当内存不足以容纳新写入的数据时,随机移除key |
volatile-lru | 当内存不足以容纳新写入数据时,在设置了过期时间的键空间中,移除最近最少使用的key(这个一般不太合适) |
volatile-random | 当内存不足以容纳新写入数据时,在设置了过期时间的键空间中,随机移除某个key |
volatile-ttl | 当内存不足以容纳新写入数据时,在设置了过期时间的键空间中,有更早过期时间的key优先移除 |
选择正确的回收策略是非常重要的,这取决于你的应用的访问模式,不过你可以在运行时进行相关的策略调整,并且监控缓存命中率和没命中的次数,通过Redis INFO 命令输出以便调优。
如果你只是使用 Redis 做缓存,那你就应该使用 allkeys-lru | allkeys-random,如果你还想同时使用持久化的功能,那就使用 volatile-lru | volatile-random 它们是永久的 key 不会被 LRU 算法淘汰。
回收是如何工作的
- 一个客户端运行了新的命令,添加新的数据
- Redis 检查内存使用情况,如果大于 maxmemory 的限制,则根据设定好的策略回收
- 一个新的命令被执行,等等
所以我们不断地越过内存限制的边界,越过它,然后通过驱逐键返回到限制之下。
如果某个命令导致使用大量内存(例如存储到新键中的大集合交集)一段时间,内存限制可能会被明显超过。
LRU 算法
实现 LRU 算法除了需要 key/value 字典外,还需要附加一个链表,链表中的元素按照一定的顺序进行排列。当空间满的时候,会踢掉链表尾部的元素,当字典的某个元素被访问时,它在链表中的位置会被移动到表头,所以链表的元素排列顺序就是元素最近被访问的时间顺序。
位于链表尾部的元素就是不被重用的元素,所以会被踢掉,位于表头的元素就是最近被人用过的元素,所以暂时不会踢
利用 Java 的 LinkedHashMap 来实现 LRU 算法
class LRUCache {
class Node{
Object key;
Object value;
Node pre;
Node next;
public Node(Object key, Object value){
this.key = key;
this.value = value;
}
}
int capacity;
HashMap<Object, Node> map = new HashMap<Object, Node>();
Node head=null;
Node end=null;
public LRUCache(int capacity) {
this.capacity = capacity;
}
public Object get(Object key){
if(map.containsKey(key)){
Node n = map.get(key);
remove(n);
setHead(n);
return n.value;
}
return -1;
}
public void remove(Node n){
if(n.pre !=null){
n.pre.next = n.next;
}else{
head = n.next;
}
if(n.next!=null){
n.next.pre = n.pre;
}else{
end = n.pre;
}
}
public void setHead(Node n){
n.next = head;
n.pre = null;
if(head!=null) {
head.pre = n;
}
head = n;
if(end ==null){
end = head;
}
}
public void set(Object key, Object value) {
if(map.containsKey(key)){
Node old = map.get(key);
old.value = value;
remove(old);
setHead(old);
}else{
Node created = new Node(key, value);
if(map.size()>=capacity){
map.remove(end.key);
remove(end);
setHead(created);
}else{
setHead(created);
}
map.put(key,created);
}
}
@Override
public String toString(){
StringBuilder sb = new StringBuilder();
Node node = head;
while(node != null){
sb.append(String.format("%s:%s ", node.key,node.value));
node = node.next;
}
return sb.toString();
}
public static void main(String[] args) {
LRUCache lruCache = new LRUCache(3);
lruCache.set("1","123");
lruCache.set("2","123");
lruCache.set("3","123");
System.out.println(lruCache.toString());
lruCache.set("4","123");
System.out.println(lruCache.toString());
}
}
近似 LRU 算法
Redis 使用的是一种近似 LRU 算法,他跟 LRU 算法还不太一样,只所以不使用 LRU 算法,是因为需要消耗大量额外的内存,需要对现有的数据结构进行很大的改造,近似 LRU 算法则很简单,在现有数据结构的基础上采用随机采样法来淘汰元素,能达到和 LRU 算法非常近似的效果,Redis 为实现近似算法,他给每个 key 增加了个额外的小字段,这个字段的长度是 24个bit,也就是最后一次被访问的时间戳
Redis LRU有个很重要的点,你通过调整每次回收时检查的采样数量,以实现调整算法的精度。这个参数可以通过以下的配置指令调整:
maxmemory-samples 5
Redis为什么不使用真实的LRU实现是因为这需要太多的内存。不过近似的LRU算法对于应用而言应该是等价的。使用真实的LRU算法与近似的算法可以通过下面的图像对比。
你可以看到三种点在图片中, 形成了三种带.
- 浅灰色带是已经被回收的对象。
- 灰色带是没有被回收的对象。
- 绿色带是被添加的对象。
从图中可以看出采样数量越大,近似 LRU 算法的效果越接近严格 LRU 算法。同时 Redis3.0 在算法中增加了淘汰池,进一步提升了近似 LRU 算法的效果。
淘汰池是一个数组,它的大小是 maxmemory_samples,在每一次淘汰循环中,新随机出来的 key 列表会和淘汰池中的 key 列表进行融合,淘汰掉最旧的一个 key 之后,保留剩余较旧的 key 列表放入淘汰池中留待下一个循环。