第二十一章_Redis的缓存过期淘汰策略

Redis内存满了怎么办

redis 一共有 4 个命令来设置键的生存时间（可以存活多久）或过期时间（什么时候被删除）

• expire ：将 key 的生存时间设置为 ttl 秒
• pexpire ：将 key 的生存时间设置为 ttl 毫秒
• expireat ：将 key 的过期时间设置为 timestamp 所指定的秒数时间戳
• pexpireat ：将 key 的过期时间设置为 timestamp 所指定的毫秒数时间戳

上述四种命令本质上都是通过 pexpireat 命令来实现的。

例子：
127.0.0.1:6379> set a test
OK
127.0.0.1:6379> EXPIRE a 5
(integer) 1
127.0.0.1:6379> get a // 距离设置生存时间命令的 5 秒内执行
"test"
127.0.0.1:6379> get a // 距离设置生存时间命令的 5 秒后执行
(nil)

127.0.0.1:6379> set b 12
OK
127.0.0.1:6379> EXPIREAT b 1545569500
(integer) 1
127.0.0.1:6379> time
1) "1545569486"
2) "108616"
127.0.0.1:6379> get b // 距离设置 1545569500 所指定的秒数时间戳内执行
"12"
127.0.0.1:6379> time
1) "1545569506"
2) "208567"
127.0.0.1:6379> get b // 距离设置 1545569500 所指定的秒数时间戳后执行
(nil)

如果自己不小心设置错了过期时间，那么可以删除先前的过期时间。

persist 命令可以移除一个键的过期时间，举个例子：

127.0.0.1:6379> EXPIRE c 1000
(integer) 1
127.0.0.1:6379> ttl c   // 有过期时间
(integer) 9996
127.0.0.1:6379> PERSIST c
(integer) 1
127.0.0.1:6379> ttl c  // 无过期时间
(integer) -1

PS：ttl 是以秒为单位，返回键的剩余生存时间；同理还有 pttl 命令是以毫秒为单位，返回键的剩余生存时间

此时，如果没有移除过期时间，那么如果一个键过期了，那它什么时候会被删除呢？

这个问题就会有以下三种答案了，它们分别代表三种不同的删除策略（定时删除、惰性删除、定期删除）。

redis默认内存多少？在哪里查看?如何设置修改?

查看Redis最大占用内存

打开redis配置文件，设置maxmemory参数，maxmemory是bytes字节类型，注意转换。

redis默认内存多少可以用？

注意，在 64bit 系统下，maxmemory 设置为 0 表示不限制 Redis 内存使用

一般生产上你如何配置？

一般推荐Redis设置内存为最大物理内存的四分之三。

如何修改redis内存设置

通过修改文件配置

通过命令修改

什么命令查看redis内存使用情况?

info memory

config get maxmemory

真要打满了会怎么样？如果Redis内存使用超出了设置的最大值会怎样？

改改配置，故意把最大值设为1个byte试试

结论

设置了maxmemory的选项，假如redis内存使用达到上限

没有加上过期时间就会导致数据写满maxmemory为了避免类似情况，引出下面内存淘汰策略。

Redis在设置缓存数据时指定了过期时间，到了过期时间数据就失效了，那Redis是怎么处理这些失效的数据的呢？这就用到了Redis的过期策略——"定期删除+惰性删除" 。Redis使用过期删除+惰性删除的策略，在合理使用CPU和避免内存浪费之间平衡。

往redis里写的数据是怎么没了的?它如何删除的

redis过期键的删除策略

如果一个键是过期的，那它到了过期时间之后是不是马上就从内存中被被删除呢？？

如果回答yes，立即删除，那是错误的？

如果不是，那过期后到底什么时候被删除呢？？是个什么操作？

三种不同的删除策略

立即删除

在设置key的过期时间时设置定时器，当key过期时通过定时器删除key。

Redis不可能时时刻刻遍历所有被设置了生存时间的key，来检测数据是否已经到达过期时间，然后对它进行删除。

立即删除能保证内存中数据的最大新鲜度，因为它保证过期键值会在过期后马上被删除，其所占用的内存也会随之释放。但是立即删除对cpu是最不友好的。因为删除操作会占用cpu的时间，如果刚好碰上了cpu很忙的时候，比如正在做交集或排序等计算的时候，就会给cpu造成额外的压力，让CPU心累，时时需要删除，忙死。。。。。。。

这会产生大量的性能消耗，同时也会影响数据的读取操作。

总结：对CPU不友好，用处理器性能换取存储空间 （拿时间换空间）

惰性删除

数据到达过期时间，不做处理。等下次访问该数据时，

如果未过期，返回数据 ；

发现已过期，删除，返回不存在。

惰性删除策略的缺点是，它对内存是最不友好的。

如果一个键已经过期，而这个键又仍然保留在redis中，那么只要这个过期键不被删除，它所占用的内存就不会释放。

在使用惰性删除策略时，如果数据库中有非常多的过期键，而这些过期键又恰好没有被访问到的话，那么它们也许永远也不会被删除(除非用户手动执行FLUSHDB)，我们甚至可以将这种情况看作是一种内存泄漏–无用的垃圾数据占用了大量的内存，而服务器却不会自己去释放它们，这对于运行状态非常依赖于内存的Redis服务器来说,肯定不是一个好消息。

总结：对memory不友好，用存储空间换取处理器性能（拿空间换时间）

"定期删除+惰性删除"就能保证过期的key最终一定会被删掉 ，但是只能保证最终一定会被删除，要是定期删除遗漏的大量过期key，在很长的一段时间内也没有再访问这些key，那么这些过期key不就一直会存在于内存中吗？不就会一直占着我们的内存吗？这样不还是会导致redis内存耗尽吗？由于存在这样的问题，所以redis又引入了“内存淘汰机制”来解决。

开启憜性淘汰，lazyfree-lazy-eviction=yes

上面两种方案都走极端

定期删除

定期删除是指Redis默认每隔 100ms 就 随机抽取 一些设置了过期时间的key，检测这些key是否过期，如果过期了就将其删除。

※ 100ms怎么来的？

在Redis的配置文件redis.conf中有一个属性"hz"，默认为10，表示1s执行10次定期删除，即每隔100ms执行一次，可以修改这个配置值。

※ 随机抽取一些检测，一些是多少？

同样是由redis.conf文件中的maxmemory-samples属性决定的，默认为5。

 

※ 为什么是随机抽取部分检测，而不是全部？

因为如果Redis里面有大量key都设置了过期时间，全部都去检测一遍的话CPU负载就会很高，会浪费大量的时间在检测上面，甚至直接导致redis挂掉。所有只会抽取一部分而不会全部检查。

正因为定期删除只是随机抽取部分key来检测，这样的话就会出现大量已经过期的key并没有被删除，这就是为什么有时候大量的key明明已经过了失效时间，但是redis的内存还是被大量占用的原因 ，为了解决这个问题，Redis又引入了“惰性删除策略”。

定期删除策略是前两种策略的折中：

定期删除策略每隔一段时间执行一次删除过期键操作并通过限制删除操作执行时长和频率来减少删除操作对CPU时间的影响。周期性轮询redis库中的时效性数据，采用随机抽取的策略，利用过期数据占比的方式控制删除频度

特点1：CPU性能占用设置有峰值，检测频度可自定义设置
特点2：内存压力不是很大，长期占用内存的冷数据会被持续清理

总结：周期性抽查存储空间 （随机抽查，重点抽查）

每秒执行server.hz次serverCorn()->databaseCorn()->activeExpireCycle()

其中activeExpireCycle()对每个Expires[*]逐一检测，每次执行时间为250ms/server.hz

对某个Expires[*]检测时，随机挑选几个key检测：

    如果key超时，删除key
    如果一轮中删除key的数量>W*25%，循环该过程(重点抽查)
    如果一轮中删除key的数量
    其中W取值=ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP的属性值

举例：
redis默认每隔100ms检查是否有过期的key，有过期key则删除。 注意：redis不是每隔100ms将所有的key检查一次而是随机抽取进行检查( 如果每隔100ms,全部key进行检查，redis直接进去ICU)。因此，如果只采用定期删除策略，会导致很多key到时间没有删除。

定期删除策略的难点是确定删除操作执行的时长和频率：如果删除操作执行得太频繁或者执行的时间太长，定期删除策略就会退化成立即删除策略，以至于将CPU时间过多地消耗在删除过期键上面。如果删除操作执行得太少，或者执行的时间太短，定期删除策略又会和惰性删除束略一样，出现浪费内存的情况。因此，如果采用定期删除策略的话，服务器必须根据情况，合理地设置删除操作的执行时长和执行频率。

定期抽样key，判断是否过期

但是会存在漏网之鱼

上述步骤都过堂了，还有漏洞吗?

1 定期删除时，从来没有被抽查到

2 惰性删除时，也从来没有被点中使用过

上述两个步骤======>  大量过期的key堆积在内存中，导致redis内存空间紧张或者很快耗尽

删除策略对比

必须要有一个更好的兜底方案。。。。。。

redis缓存淘汰策略登场。。。。。。O(∩_∩)O哈哈~

redis缓存淘汰策略

内存淘汰机制就能保证在redis内存占用过高的时候，去进行内存淘汰，也就是删除一部分key，保证redis的内存占用率不会过高，那么它会淘汰哪些key呢？Redis目前共提供了8种内存淘汰策略，含Redis 4.0版本之后又新增的两种LFU模式：volatile-lfu和allkeys-lfu。

※ 什么时候会执行内存淘汰策略，内存占用率过高的标准是什么？

    redis.conf配置文件中的 maxmemory 属性限定了 Redis 最大内存使用量，当占用内存大于maxmemory的配置值时会执行内存淘汰策略。

※ 内存淘汰策略的配置

    内存淘汰机制由redis.conf配置文件中的maxmemory-policy属性设置，没有配置时默认为no-eviction模式。

※ 淘汰策略的执行过程

    > 客户端执行一条命令，导致Redis需要增加数据（比如set key value）；

    > Redis会检查内存使用情况，如果内存使用超过 maxmemory，就会按照配置的置换策略maxmemory-policy删除一些key；

    > 再执行新的数据的set操作；

redis配置文件

【MEMORY MANAGEMENT】

lru和lfu算法的区别是什么

区别

LRU：最近最少使用页面置换算法，淘汰最长时间未被使用的页面，看页面最后一次被使用到发生调度的时间长短，首先淘汰最长时间未被使用的页面。

LFU：最近最不常用页面置换算法，淘汰一定时期内被访问次数最少的页，看一定时间段内页面被使用的频率，淘汰一定时期内被访问次数最少的页

举个例子

某次时期Time为10分钟,如果每分钟进行一次调页,主存块为3,若所需页面走向为2 1 2 1 2 3 4

假设到页面4时会发生缺页中断

若按LRU算法,应换页面1(1页面最久未被使用)，但按LFU算法应换页面3(十分钟内,页面3只使用了一次)

可见LRU关键是看页面最后一次被使用到发生调度的时间长短,而LFU关键是看一定时间段内页面被使用的频率!

有哪些(redis7版本)

1.noeviction: 不会驱逐任何key，表示即使内存达到上限也不进行置换，所有能引起内存增加的命令都会返回error

2.allkeys-lru: 对所有key使用LRU算法进行删除，优先删除掉最近最不经常使用的key，用以保存新数据

3.volatile-lru: 对所有设置了过期时间的key使用LRU算法进行删除

4.allkeys-random: 对所有key随机删除

5.volatile-random: 对所有设置了过期时间的key随机删除

6.volatile-ttl: 删除马上要过期的key

7.allkeys-lfu: 对所有key使用LFU算法进行删除

8.volatile-lfu: 对所有设置了过期时间的key使用LFU算法进行删除

上面总结

2 * 4 得8

2个维度（过期键中筛选、所有键中筛选）

4个方面（LRU、LFU、random、ttl）

8个选项

你平时用哪一种？

如何配置、修改

直接用config命令

直接redis.conf配置文件

其他场景对过期key的处理

1、快照生成RDB文件时

    过期的key不会被保存在RDB文件中。

2、服务重启载入RDB文件时

    Master载入RDB时，文件中的未过期的键会被正常载入，过期键则会被忽略。Slave 载入RDB 时，文件中的所有键都会被载入，当主从同步时，再和Master保持一致。

3、AOF 文件写入时

    因为AOF保存的是执行过的Redis命令，所以如果redis还没有执行del，AOF文件中也不会保存del操作，当过期key被删除时，DEL 命令也会被同步到 AOF 文件中去。

4、重写AOF文件时

    执行 BGREWRITEAOF 时 ，过期的key不会被记录到 AOF 文件中。

5、主从同步时

    Master 删除 过期 Key 之后，会向所有 Slave 服务器发送一个 DEL命令，Slave 收到通知之后，会删除这些 Key。

    Slave 在读取过期键时，不会做判断删除操作，而是继续返回该键对应的值，只有当Master 发送 DEL 通知，Slave才会删除过期键，这是统一、中心化的键删除策略，保证主从服务器的数据一致性。

redis缓存淘汰策略配置性能建议

避免存储bigkey

开启憜性淘汰，lazyfree-lazy-eviction=yes

面试题总结

生产上你们的redis内存设置多少?

如何配置、修改redis的内存大小？

如果内存满了你怎么办？

redis清理内存的方式？定期删除和惰性删除了解过吗？

redis缓存淘汰策略有哪些？分别是什么？你用那个？

redis的LRU了解过吗？请手写LRU？

如何利用已有的 JDK 数据结构实现一个 Java 版的 LRU。

//自定义LRU规则设置
public class LRUCache extends LinkedHashMap {

    private final int CACHE_SIZE;
 
    /**
     * 传递进来最多能缓存多少数据
     *
     * @param cacheSize 缓存大小
     */
    public LRUCache(int cacheSize) {
        //true表示让linkedHashMap 按照访问顺序来进行排序，最近访问的放在头部，最老访问的放在尾部。
        super((int) Math.ceil(cacheSize / 0.75) + 1, 0.75f, true);
        CACHE_SIZE = cacheSize;
    }
 
    @Override
    protected boolean removeEldestEntry(Map.Entry eldest) {
        // 当 map中的数据量大于指定的缓存个数的时候，就自动删除最老的数据。
        return size() > CACHE_SIZE;
    }
}

lru和lfu算法的区别是什么？

。。。。。。