一 Redis设置过期时间

Redis有一个很实用的功能，可以为数据库的值设置过期时间。这在很多场景下都有用，例如一定时限内有效的验证码，一些登录信息。每次set key的时候，都可以使用expire time设置过期时间

二 Redis过期回收机制

那么Redis是如何回收过期的值的？有两种方式：定期删除和惰性删除

• 定期删除

  默认每隔100ms就抽取一些设置了过期时间的值检查，如果过期就删除

• 惰性删除

  设置了过期时间的值如果过期了，手动检查这些值才会被redis删除，这是一种比较懒的方式，所以叫惰性删除

• 为什么不直接删除所有过期值

  在高并发场景下，一瞬间可能产生很多值，想要删除所有过期值，就得遍历一遍所有设置了过期时间的值，这显然不可取，遍历几万甚至几十万几百万个值是很耗时的

三 Redis过期回收机制的问题

我们可以从回收机制的方式中看出来，随机抽取设置了过期时间的值判断是否删除，那肯定会有漏网之鱼，如果一瞬间数据量庞大，那么漏网之鱼会更多，那些没有被回收的过期值就这么堆积起来，堆积到一定数量就会导致内存不足了

四 解决Redis过期回收机制的问题（内存淘汰）

那我们如果解决上述问题呢？Redis引入了内存淘汰机制，提供了六种机制可供选择。从大类上主要分为最近最少删除和随机删除。
所谓内存淘汰，即在内存不足时，我们应该删除一部分可能用不到的值，把他们的空间腾出来给最新的值，这是因为在很多业务中，最新最热的操作或者用户总是优先级较高的

内存淘汰策略

• volatile-lru

  在已设置过期时间的值里删除最近最少使用的值

• volatile-ttl

  在已设置过期时间的值里删除将要过期的值

• volatile-random

  在已设置过期时间的值里随机删除值

• allkey-lru

  所有值里删除最近最少是使用的值

• allkey-random

  所有值里随机删除值

• no-eviction

  如果内存不够就不准写入值
  4.0版本之后增加了两种：

• volatile-lfu

  在已设置过期时间的值里删除最不经常使用的值

• allkey-lfu

  所有值里移除最不经常使用的key

一、设置Redis占用内存

Redis是基于内存的key-value数据库，因为系统内存大小有限，所以我们在使用Redis的时候可以配置Redis能使用的最大的内存大小。

• 通过redis.conf配置文件设置内存大小

//设置Redis最大占用内存大小为100M
maxmemory 100mb

• 通过命令修改，Redis支持运行时动态修改内存大小

//设置Redis最大占用内存大小为100M
127.0.0.1:6379> config set maxmemory 100mb
//获取设置的Redis能使用的最大内存大小
127.0.0.1:6379> config get maxmemory

如果不设置最大内存大小或者设置最大内存大小为0，在64位操作系统下不限制内存大小，在32位操作系统下最多使用3GB内存

二、Redis的内存淘汰策略

• noeviction(默认策略)：对于写请求不再提供服务，直接返回错误（DEL请求和部分特殊请求除外）
• allkeys-lru：从所有key中使用LRU算法进行淘汰
• volatile-lru：从设置了过期时间的key中使用LRU算法进行淘汰
• allkeys-random：从所有key中随机淘汰数据
• volatile-random：从设置了过期时间的key中随机淘汰
• volatile-ttl：在设置了过期时间的key中，根据key的过期时间进行淘汰，越早过期的越优先被淘汰

当使用volatile-lru、volatile-random、volatile-ttl这三种策略时，如果没有key可以被淘汰，则和noeviction一样返回错误

设置内存淘汰策略

• 通过命令设置淘汰策略

//获取当前内存淘汰策略
127.0.0.1:6379> config get maxmemory-policy
//设置淘汰策略
127.0.0.1:6379> config set maxmemory-policy allkeys-lru

• 通过redis.conf配置文件设置淘汰策略

maxmemory-policy allkeys-lru

LRU算法

LRU(Least Recently Used)，即最近最少使用，是一种缓存置换算法。在使用内存作为缓存的时候，缓存的大小一般是固定的。当缓存被占满，这个时候继续往缓存里面添加数据，就需要淘汰一部分老的数据，释放内存空间用来存储新的数据。
这个时候就可以使用LRU算法了。其核心思想是：如果一个数据在最近一段时间没有被用到，那么将来被使用到的可能性也很小，所以就可以被淘汰掉。

LRU在Redis中的实现

Redis使用的是近似LRU算法，它跟常规的LRU算法还不太一样。近似LRU算法通过随机采样法淘汰数据，每次随机出5（默认）个key，从里面淘汰掉最近最少使用的key。

可以通过maxmemory-samples参数修改采样数量：

例：maxmemory-samples 10

maxmenory-samples配置的越大，淘汰的结果越接近于严格的LRU算法

Redis为了实现近似LRU算法，给每个key增加了一个额外增加了一个24bit的字段，用来存储该key最后一次被访问的时间。

Redis3.0对近似LRU的优化

Redis3.0对近似LRU算法进行了一些优化。新算法会维护一个候选池（大小为16），池中的数据根据访问时间进行排序，第一次随机选取的key都会放入池中，随后每次随机选取的key只有在访问时间小于池中最小的时间才会放入池中，直到候选池被放满。当放满后，如果有新的key需要放入，则将池中最后访问时间最大（最近被访问）的移除。

当需要淘汰的时候，则直接从池中选取最近访问时间最小（最久没被访问）的key淘汰掉就行。

LFU算法

LFU算法是Redis4.0里面新加的一种淘汰策略。它的全称是Least Frequently Used，它的核心思想是根据key的最近被访问的频率进行淘汰，很少被访问的优先被淘汰，被访问的多的则被留下来。

LFU算法能更好的表示一个key被访问的热度。假如你使用的是LRU算法，一个key很久没有被访问到，只刚刚是偶尔被访问了一次，那么它就被认为是热点数据，不会被淘汰，而有些key将来是很有可能被访问到的则被淘汰了。如果使用LFU算法则不会出现这种情况，因为使用一次并不会使一个key成为热点数据。

LFU一共有两种策略：

• volatile-lfu：在设置了过期时间的key中使用LFU算法淘汰key

• allkeys-lfu：在所有的key中使用LFU算法淘汰数据

设置使用这两种淘汰策略跟前面讲的一样，不过要注意的一点是这两周策略只能在Redis4.0及以上设置，如果在Redis4.0以下设置会报错

Redis 过期策略和内存淘汰机制

众所周知，redis 是一个基于内存的，能够持久化到硬盘的缓存数据库，所以 redis 缓存服务器会配置较高的内存资源

一般而言，缓存总量小于数据总量，但如果对缓存数据不管不顾，内存资源总会有耗尽的时候，而为了节约成本，不能一直增加服务器的内存。因此在有限的资源下，为了支撑更多的业务，就必须将访问频率不高的缓存删掉，为新的缓存腾出内存空间

Redis 主要通过两种方式相互配合实现 key 的清理，即：过期策略和内存淘汰机制

过期策略

Redis 通过 Expire 命令设置 key 的过期时间，设置过期时间后， key 会被自动删除。通常称带有过期时间的 key 为易失的 (volatile)；过期时间的 key，可以调用 EXPIPE 重新设置

过期时间计算
key 的过期时间以绝对 Unix 时间戳的方式存储，也就是无论 Redis 是否进行，过期时间都会流逝。即要求服务器的时间必须准确，否则但两个时间相差较多的机器之间移动 RDB 文件，那么可能会出现所有的 key 在加载的时候都过期。

测试：运行的 Redis 会不停检查服务器的时间，如果设置一个带有 1k 秒过期时间的 key，然后把服务器的时间向前调 2k 秒，那么这个 key 就会立刻过期，而不是等待 1k 秒后过期

淘汰过期 key 方式

被动方式

在用户访问某个 key 的时候，Redis 会检测 key 是否过期，如果没有过期，则返回给用户；过期则删除 key。也就是等 key 被访问才会知道是否过期，这种方式对于那些永远不会再次访问的 key 没有效果，所以 Redis 还会周期性主动随机检测一部分被设置过期时间的 key，将已经过期的 key 从 key 空间删除

主动方式

Redis 每秒会执行10次以下操作：

1. 从带有过期时间的 key 集合中随机选 20 进行检查
2. 删除所有过期的 key
3. 如果里面超过 25% 的 key 过期，立刻继续执行步骤 1

一种狭义概率算法，假设选出来的样本 key 代表整个 key 空间，会一直执行过期检查直到 key 的比例降到 25% 以下；意味着在任意时刻已经过期但还占用内存 key 的数量，最多等于每秒最多写操作的 1/4

内存淘汰机制

Redis 的内存一般会根据 “八二原理” 进行配置，即80%的请求访问了20%的数据，将 Redis 内存大小设置为数据总量的20%。当然，对于不同的业务场景会有不一样的配置

当 redis 节点分配的内存使用到达最大值，Redis 会启动内存淘汰策略，Redis 4.0 之前主要是以下六种策略：

• noenviction：不清除数据，只是返回错误，这样会导致浪费掉更多的内存，对大多数写命令（DEL 命令和其他的少数命令例外）
• allkeys-lru：从所有的数据集（server.db[i].dict）中挑选最近最少使用的数据淘汰，以供新数据使用
• volatile-lru：从已设置过期时间的数据集（server.db[i].expires）中挑选最近最少使用的数据淘汰，以供新数据使用
• allkeys-random：从所有数据集（server.db[i].dict）中任意选择数据淘汰，以供新数据使用
• volatile-random：从已设置过期时间的数据集（server.db[i].expires）中任意选择数据淘汰，以供新数据使用
• volatile-ttl：从已设置过期时间的数据集（server.db[i].expires）中挑选将要过期的数据淘汰，以供新数据使用

Redis 4.0 新增了两种 LFU 淘汰策略:

• allkeys-lfu，淘汰整个键值中最少使用的键值，这也就是我们常说的LRU算法。
• volatile-lfu，淘汰所有设置了过期时间的键值中最少使用的键值。

LRU（Least Recently Used，最近最少使用），根据最近被使用的时间，离当前最远的数据优先被淘汰；在使用内存作为缓存的时候，缓存的大小一般是固定的。当缓存被占满，这个时候继续往缓存里面添加数据，就需要淘汰一部分老的数据，释放内存空间用来存储新的数据。这个时候就可以使用LRU算法了。其核心思想是：如果一个数据在最近一段时间没有被用到，那么将来被使用到的可能性也很小，所以就可以被淘汰掉
LFU（Least Frequently Used，最不经常使用），在一段时间内，缓存数据被使用次数最少的会被淘汰；根据key的最近被访问的频率进行淘汰，很少被访问的优先被淘汰，被访问的多的则被留下来

普适经验规则：

• 如果期望用户请求呈现幂律分布(power-law distribution)，也就是，期望一部分子集元素被访问得远比其他元素多时，可以使用allkeys-lru策略。在你不确定时这是一个好的选择
• 如果期望是循环周期的访问，所有的键被连续扫描，或者期望请求符合平均分布(每个元素以相同的概率被访问)，可以使用allkeys-random策略
• 如果你期望能让 Redis 通过使用你创建缓存对象的时候设置的TTL值，确定哪些对象应该是较好的清除候选项，可以使用volatile-ttl策略
• 当你想使用单个Redis实例来实现缓存和持久化一些键，allkeys-lru和volatile-random策略会很有用，但通常最好是运行两个Redis实例来解决这个问题

参考

[1] EXPIRE key seconds
[2] 使用Redis作为LRU缓存