1.1、淘汰机制分析简介

我们知道，redis的性能很高，有很大的原因是因为数据是存储在内存中的。

但是，如果我们长期使用redis, key不断的增加的情况，我们的物理内存终究会满的，并且要满的时候也会与会是内存与磁盘做swap交换，频繁的IO操作将会使得性能极具下降。

所以我们需要存在缓存淘汰机制，去保证机器不至于因为太多key导致内存撑爆。

1.2、redis的最大内存设置

内存设置在redis.conf中的maxmemory

1.2.1、不设置最大内存

Redis的key是固定的，不会增加

如果redis作为db使用，为了保证数据的完整性，不能够淘汰。此时可以做集群，横向扩展，增大存储key的数据。

此时的缓存淘汰策略：禁止驱逐（默认）

1.2.2、设置最大内存

设置为0

Redis作为缓存使用，key的数量是不断增加的。

maxmemory设置为0 表示不限制，也是默认值。

存在问题：超过物理内存性能急剧下降，频繁IO性能更加下降。

设置指定大小

具体设置多少一般与业务有关，比如你就存储几个或几十个key, 你是怎样的方式都无所谓啦。

一般一个redis实例，去除1G内存保证系统稳定运行，剩下的就可以设置redis。一般情况设置为物理内存的3/4。

# 设置最大内存 在redis.conf中
maxmemory 1024mb

命令获取和设置maxmemory

# 获取最大内存 默认是0 表示不限制
127.0.0.1:6379> config get maxmemory
1) "maxmemory"
2) "0"
# 设置为1024mb
127.0.0.1:6379> config set maxmemory 1024mb
OK
# 重新获取
127.0.0.1:6379> config get maxmemory
1) "maxmemory"
2) "1073741824"

如果设置了maxmemory之后，如果趋近maxmemory时，通过缓存淘汰机制，从内存中删除对象。

1.3、expire数据结构

如果看过上一篇文章《redis底层数据结构分析》就会知道，在redisDb对象中存在一个expires的字典，用于保存缓存过期的key或者客户端对象。再次看一看这个对象。

typedef struct redisDb {
    dict *dict;                 /* 存储所有的key-value */
    dict *expires;              /* 存储key的过期时间 */
    dict *blocking_keys;        /* blpop存储阻塞key和客户端对象*/
    dict *ready_keys;           /* 阻塞后push,响应阻塞的那些客户端和key */
    dict *watched_keys;         /* 存储watch监控的key和客户端对象 WATCHED keys for MULTI/EXEC CAS */
    int id;                     /* 数据库的ID为0-15，默认redis有16个数据库 */
    long long avg_ttl;          /* 存储对象的额平均ttl(time in live)时间用于统计 */
    unsigned long expires_cursor; /* Cursor of the active expire cycle. */
    list *defrag_later;         /* List of key names to attempt to defrag one by one, gradually. */
    clusterSlotToKeyMapping *slots_to_keys; /* Array of slots to keys. Only used in cluster mode (db 0). */
} redisDb;

既然存储了过期key的过期时间这些数据，那么我们过期的key怎么处理呢？

1.4、redis的数据删除策略

redis的删除策略有定时，惰性，主动删除三种方式。默认采用的是惰性+主动的组合删除方式。

1.4.1、定时删除

在设置键和过期时间时，同时创建一个定时器，不断的扫描哪些key过期了，立即执行山粗操作。

需要创建定时器，定时器的扫描频率越快，消耗的CPU就越严重，一般不会这样使用。

1.4.2、惰性删除

平时不删除key, 只有当访问key时，发现key已经过期了，那么就删除它吧。

就是调用的expireIfNeeded方法：读取数据之前检查一下它有没有失效，如果失效了就删除它。

int expireIfNeeded(redisDb *db, robj *key, int force_delete_expired) {
    // 如果没有失效，返回0
    if (!keyIsExpired(db,key)) return 0;
    if (server.masterhost != NULL) {
        if (server.current_client == server.master) return 0;
        if (!force_delete_expired) return 1;
    }

    if (checkClientPauseTimeoutAndReturnIfPaused()) return 1;

    // 失效了 删除这个key
    deleteExpiredKeyAndPropagate(db,key);
    return 1;
}

如何判断失效

int keyIsExpired(redisDb *db, robj *key) {
    // 获取key的失效时间
    mstime_t when = getExpire(db,key);
    // 当前时间
    mstime_t now;

    // 失效时间小于0 表示默认值-1 不过期 返回没有过期
    if (when < 0) return 0; /* No expire for this key */

    // 如果服务正在加载 返回未过期
    if (server.loading) return 0;
    
    // 获取当前时间
    if (server.script_caller) {
        now = scriptTimeSnapshot();
    }
    else if (server.fixed_time_expire > 0) {
        now = server.mstime;
    }
    else {
        now = mstime();
    }

    // 当前时间大于过期时间，表示没有过期 否则就时过期了
    return now > when;
}

1.4.3、主动删除

在redis.conf文件中可以配置主动删除策略, 默认是no-enviction（不删除）

使用命令查看策略

127.0.0.1:6379> config get maxmemory-policy
1) "maxmemory-policy"
2) "noeviction"

普通删除算法LRU

LRU (Least recently used) 最近最少使用，算法根据数据的历史访问记录来进行淘汰数据，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高”。

最常见的实现是使用一个链表保存缓存数据，详细算法实现如下：

1. 新数据插入到链表头部；
2. 每当缓存命中（即缓存数据被访问），则将数据移到链表头部；
3. 当链表满的时候，将链表尾部的数据丢弃。
4. 在Java中可以使用LinkHashMap（哈希链表）去实现LRU

举个例子帮助理解LRU算法

比如我们使用hash链表来存储用户信息，目前缓存了3个用户，这三个用户按照创建时间依次加入链表

此时，业务方访问用户004，哈希链表中不存在，从数据库取出，插入到缓存，此时用004处于链表最右端，最左端是最近最少访问的用户001。

接下来，业务方访问用户003，哈希链表中存在用户003的数据，此时把用户003从它的前驱

节点和后继节点之间移除，重新插入到链表最右端。

这时候，链表中最右端变成了最新访问到的用户003，最左端仍然是最近最少访问的用户1。

也就是说，我们访问谁，谁就会在右边来，越是不访问谁，谁就在左边。

如果我们数据满了，不能再存储了，此时又来了数据，那么是不是应该删除最近最少使用的用户001呢？

答案是yes

Redis中的删除策略

LRU

从 struct redisObject 中可以发现，每一个 redis 对象都会设置相应的 lru。可以想象的是，每一

次访问数据的时候，会更新 redisObject.lru。

LRU 数据淘汰机制如下：

• 在数据集中随机挑选几个键值对，取出其中 lru 最大的键值对淘汰。
• 不可能遍历所有的key 用当前时间-最近访问越大说明访问间隔时间越长

# 从已设置过期时间的数据集（server.db[i].expires）中挑选最近最少使用的数据淘汰
volatile-lru
# 从数据集（server.db[i].dict）中挑选最近最少使用的数据淘汰
allkeys-lru

LFU

LFU (Least frequently used) 最不经常使用，如果一个数据在最近一段时间内使用次数很少，那么在将来一段时间内被使用的可能性也很小。

volatile-lfu
allkeys-lfu

random随机

# 从已设置过期时间的数据集（server.db[i].expires）中任意选择数据淘汰
volatile-random
# 从数据集（server.db[i].dict）中任意选择数据淘汰
allkeys-random

ttl

TTL 数据淘汰机制：从过期时间的表中随机挑选几个键值对，取出其中 ttl 最小的键值对淘汰。

# 从已设置过期时间的数据集（server.db[i].expires）中挑选将要过期的数据淘汰
volatile-ttl

noenviction

禁止驱逐数据，不删除默认

1.5、如何选择缓存淘汰机制？

1.5.1、不确定业务

allkeys-lru 所有的key都使用LRU最近最少使用算法淘汰

volatile-lru 比allkeys-lru性能差，会存储过期时间

1.5.2、符合平均的分布

allkeys-random 随机淘汰策略，每个元素淘汰的概率都是一样的

1.5.3、自己控制

volatile-ttl 自己在程序中设置过期时间来处理。存在缓存穿透，缓存击穿等问题需要自己处理。

1.6、小结

Redis的淘汰策略已经需要我们根据不同的业务场景去设置，以达到更加合适的效果。

2、相关文章

本人还写了Redis的其他相关文章，有兴趣的可以点击查看！

• <<Redis弱事务性与Lua脚本原子性分析>>
• <<Redis持久化机制分析>>
• <<Redis的事件处理机制分析>>
• <<Redis客户端和服务端如何通信？>>
• <<Redis的淘汰机制分析>>
• <<Redis的底层数据结构分析>>
• <<Redis的8种数据类型，什么场景使用？>>
• <<缓存是什么？缓存有哪些分类？使用它的代价是什么？>>
• <<缓存的6种常见的使用场景>>