游哇游哇游头像
Redis 过期删除与内存淘汰源码级详解:惰性+定期删除、近似 LRU/LFU、8 种策略与内存打满排查封面图

Redis 过期删除与内存淘汰源码级详解:惰性+定期删除、近似 LRU/LFU、8 种策略与内存打满排查

Redis 过期删除与内存淘汰源码级详解:惰性+定期删除、近似 LRU/LFU、8 种策略与内存打满排查

本文是 Redis 系列第 3 篇,回答两个高频问题:设置了过期时间的 key 到底是怎么被删掉的?内存满了之后 Redis 会怎么办? 很多人只背得下「惰性删除 + 定期删除」「8 种淘汰策略」,但被追问「为什么 Redis 的 LRU 是近似的?」「LFU 的计数器为什么只有 8 位?」就答不上来。本文深入到源码层面,讲清过期删除与内存淘汰的机制,并附一套可直接照做的「内存打满排查流程」,是内存治理、生产调优与面试的完整答案。

TL;DR 速查卡

速查项一句话要点
过期删除两条通道惰性删除(访问时 expireIfNeeded 才删)+ 定期删除(activeExpireCycle 按 hz 随机抽样,删比 >25% 继续下一轮)
8 种淘汰策略noeviction 报错;allkeys-lru/lfu/random 全库淘汰;volatile-lru/lfu/random/ttl 只淘汰带 TTL 的 key
LRU 的 24bit整个 24bit 存「最近访问时间戳」,LRU_CLOCK 每 1000ms 更新,约 194 天轮回
LFU 的 24bit拆成 16bit 高段(分钟级 last-decrement-time)+ 8bit 低段(Morris 对数计数器),新 key 初始值 5
生产必配maxmemory-policy 显式设为 allkeys-lru(纯缓存),别用默认 noeviction
默认采样数maxmemory-samples 默认 5(约 96% 逼近真实 LRU,可调 10)

目录

  1. 为什么要设置过期时间
  2. 过期键删除策略:惰性删除 + 定期删除
  3. 内存淘汰机制:8 种策略
  4. LRU 与 LFU 算法内部实现
  5. 实战排查:内存打满、大 key 与内存碎片
  6. 过期删除 vs 内存淘汰
  7. 经典面试题
  8. 总结

一、为什么要设置过期时间

作为缓存数据库,Redis 允许给 key 设置过期时间(TTL),典型场景:

  • 登录 token、短信验证码(有限期)
  • 限流计数(窗口期)
  • 临时会话、热点活动数据

设置命令:

SET key value EX 60          # 60 秒过期
EXPIRE key 60                # 给已有 key 设置过期
PEXPIRE key 60000            # 毫秒级
TTL key                      # 查看剩余时间
PERSIST key                  # 移除过期时间

过期键存在哪? Redis 内部维护了两张哈希表:dict 存所有键值对,expires 存「设置了过期时间的 key → 过期时间戳」。给 key 设 TTL 会往 expires 里多写一条记录,这也是为什么「给 key 设过期」本身有一点内存开销(官方文档明确提到:纯缓存用 allkeys-lru 比 volatile-* 更省内存,因为不需要维护 expires)。


二、过期键删除策略:惰性删除 + 定期删除

问题:一批 key 只存活 1 小时,1 小时后 Redis 如何删除它们?

Redis 没有定时器,真正的删除只有两条通道(另加一条「传播」):惰性删除和定期删除。二者互补,单用任何一种都不理想。

1. 惰性删除(expireIfNeeded)

任何读写命令执行前,Redis 在 lookupKey 里都会调用 expireIfNeeded 检查目标 key 是否过期,过期则删除并返回「不存在」。

源码核心逻辑(简化):

int expireIfNeeded(redisDb *db, robj *key) {
    if (!keyIsExpired(db,key)) return 0;      // 没过期,正常返回
    if (server.masterhost != NULL) return 1;  // 从库:不真正删除
    // 主库:传播删除到从库和 AOF,再同步/异步删除
    return server.lazyfree_lazy_expire ?
           dbAsyncDelete(db,key) : dbSyncDelete(db,key);
}
  • 优点:节省 CPU,只在访问时才判断,不会做无用功
  • 缺点:长期不被访问的过期 key 一直滞留内存,无法释放

关键细节(面试进阶):从库不会主动删除过期 key。从库读到过期 key 时只返回「逻辑上不存在」,但物理不删;真正的删除由主库把 DEL 写入复制流同步过来。所以主从切换后,新主库上可能短暂看到几个「早就过期」的 key,这是异步复制的正常窗口,不是数据错误。

版本补充:Redis 3.2 之前,从库在收到主库 DEL 前甚至可能把「自然过期但 DEL 未到」的 key 当活 key 返回;3.2 起改为从库返回「逻辑过期」,一致性更好。

2. 定期删除(activeExpireCycle)

惰性删除管不到「没人访问」的过期 key,所以需要定期删除兜底。Redis 周期性随机抽取一部分过期 key 检查,过期则删除。

  • 为什么不全量遍历? 几十万甚至更多 key 时,遍历所有过期 key 会严重占用 CPU
  • 执行频率:由 hz 参数控制,默认 10(每秒 10 次);官方建议不超过 100
  • 两种循环:
    • SLOW 慢循环:挂在 serverCron 定时任务里,按 hz 触发,每次随机抽 20 个 key(ACTIVE_EXPIRE_CYCLE_KEYS_PER_LOOP)
    • FAST 快循环:在每次事件循环的 beforeSleep 阶段执行,单次时间上限约 1000µs,用于「补刀」
  • 执行过程:从 expires 字典随机抽 20 个 key,删除已过期的;若本轮删除比例 > 25%,则继续下一轮,直到比例低于 25% 或达到单次扫描时间上限(约 25ms)

纠正旧笔记:「每隔 100ms」是不准确的,实际频率由 hz 决定(默认每秒 10 次)。

Redis 6 的优化:Redis 6 重写了主动过期循环,引入 radix tree(基数树) 缓存「即将过期」的 key。上一轮采样发现某个 key 快过期但还没到点,就把它存进 radix tree,下一轮直接从 radix tree 开始检查,大幅减少「已过期但仍占用内存」的隐藏内存。

3. 两者配合 + lazy free

定期删除兜底清理 + 惰性删除保证「被访问的 key 一定是有效的」,二者结合既能释放内存,又不至于 CPU 压力过大。

补充:Redis 4.0 引入 lazy free(惰性/异步删除)。大 key 删除用 UNLINK 代替 DEL,把内存回收交给后台线程(bio),避免阻塞主线程。过期键也可通过 lazyfree-lazy-expire 配置走异步删除。


三、内存淘汰机制:8 种策略

即使有过期删除,仍可能出现大量 key 堆积导致内存耗尽。此时需要内存淘汰机制:当内存达到 maxmemory 上限时,按策略淘汰数据。

1. 8 种策略

Redis 4.0 之前是 6 种,4.0 新增 LFU 两种,共 8 种:

策略作用范围淘汰规则
noeviction不淘汰内存不足时写操作直接报错(默认)
allkeys-lru所有 key最近最少使用(LRU)
allkeys-lfu所有 key最不经常使用(LFU)
allkeys-random所有 key随机
volatile-lru设了过期的 key最近最少使用
volatile-lfu设了过期的 key最不经常使用
volatile-random设了过期的 key随机
volatile-ttl设了过期的 key即将过期(TTL 最小)

三个关键细节:

  1. volatile-* 的退化行为:当没有任何 key 设置了过期时间时,volatile-* 系列会退化成 noeviction(写请求直接报错),这是很多人踩的坑。
  2. volatile-* 失效的实战案例:某实例 INFO keyspace 显示 keys=1834521, expires=31204,即只有约 1.7% 的 key 带 TTL。此时若配 volatile-lru,内存打满后只淘汰那 1.7% 的 key,剩余 98.3% 的「永久 key」占着内存却不动,结果命中率暴跌、写请求仍报 OOM。选 volatile-* 前先确认业务 key 都带了 TTL,否则改用 allkeys-*。
  3. 版本补充:Redis 8.6(2026 年 2 月)新增 allkeys-lrm、volatile-lrm(Least Recently Modified,最近最少修改),策略总数达到 10 种;Redis 8.4 及更早、以及 Valkey 仍是 8 种。本文标题沿用最主流的「8 种」说法。

2. 如何选择

场景推荐策略
纯缓存、数据可丢、访问符合二八法则allkeys-lru(最通用默认)
热点数据访问频繁且稳定allkeys-lfu
所有 key 访问频率均匀allkeys-random
部分 key 不能丢(混合存储)拆两个实例,或 volatile-*
数据绝对不能丢noeviction + 内存告警

实用建议:纯缓存先上 allkeys-lru,跑两周看命中率;有明确热点且确认是「高频」而非「最近访问」再换 allkeys-lfu。noeviction 是默认值,很多没显式配置的实例在缓存写满时直接报错,这是生产常见事故。


四、LRU 与 LFU 算法内部实现

这一章是本文最「源码级」的部分,也是面试能拉开差距的地方。

1. 为什么 Redis 的 LRU 是「近似」的?

真正的 LRU 需要维护一个有序链表/队列,每次 GET 都要移动节点——这会让每次读操作都附带一次写操作,代价太高。Redis 的选择是:用一个 24bit 字段做「概率性猜测」。

  • 每个 redisObject 里有一个 24bit 的 lru 字段,记录 key 最近被访问的时间戳
  • 全局维护一个 LRU_CLOCK,每 1000ms 更新一次(LRU_CLOCK_RESOLUTION)
  • 24bit 最多存 16777215 秒 ≈ 194 天,会轮回(对淘汰判断已足够)
  • 需要淘汰时,随机采样 maxmemory-samples(默认 5)个 key,淘汰其中最久未访问的
  • Redis 3.0 起还维护一个候选池(pool,最多 16 个),跨多轮保留好的淘汰候选,进一步逼近真实 LRU

近似程度:官方基准显示,采样 3 个约 92%、5 个约 96%、10 个约 99% 逼近真实 LRU。默认 5 个已经足够好,追求更准可把 maxmemory-samples 调到 10(代价是多一点 CPU)。

2. LFU 怎么塞进 24bit?(Morris 计数器)

LFU 要记录「访问频率」,但只剩这 24bit 可用。Redis 的方案是拆成两段:

24bit = 16bit 高段(last-decrement-time,分钟级时间戳) + 8bit 低段(访问计数器)

8bit 计数器最多 255,怎么够? 答案是用概率性对数计数器(Morris Counter)——计数器越大,增长越慢:

uint8_t LFULogIncr(uint8_t counter) {
    if (counter == 255) return 255;
    double r = (double)rand()/RAND_MAX;
    double baseval = counter - LFU_INIT_VAL;   // LFU_INIT_VAL = 5
    if (baseval < 0) baseval = 0;
    double p = 1.0 / (baseval * lfu_log_factor + 1);
    if (r < p) counter++;                       // 概率性 +1
    return counter;
}

默认 lfu-log-factor=10 时:访问 100 次计数约 10,1000 次约 18,10 万次约 142,100 万次才打满 255。

两个关键设计:

  • 新 key 初始值 = 5(LFU_INIT_VAL):给新 key 一个「新手保护期」,避免刚插入还没积累访问次数就被立刻淘汰(否则新 key 频率为 0,是最佳淘汰对象)。
  • 衰减(decay):老数据曾经很热不代表现在该保留。每 lfu-decay-time(默认 1 分钟)无访问,计数器减 1,是惰性衰减(访问时才计算),让算法能适应访问模式的变化。

一句话总结:LRU 记录「最近什么时候用过」,LFU 记录「大约用过多少次」;LFU 用 16bit 时间戳 + 8bit 对数计数器在同一个 24bit 字段里实现,靠概率增长 + 时间衰减。

3. 相关配置

maxmemory 4gb                     # 内存上限(0 表示不限制)
maxmemory-policy allkeys-lru      # 淘汰策略
maxmemory-samples 5               # 采样数量(默认 5,可调 10)
lfu-log-factor 10                 # LFU 计数器增长速率(越大增长越慢)
lfu-decay-time 1                  # LFU 衰减时间(分钟)

五、实战排查:内存打满、大 key 与内存碎片

机制懂了,落到生产就是「内存告警了怎么查」。下面是一套可直接照做的排查链路。

1. 先看 INFO memory 核心指标

redis-cli INFO memory | grep -E "used_memory|maxmemory|mem_fragmentation_ratio"
redis-cli INFO stats   | grep -E "evicted_keys|expired_keys|keyspace_hits|keyspace_misses"
指标含义关注点
used_memoryRedis 逻辑占用是否接近 maxmemory
used_memory_rssOS 视角物理占用与 used_memory 差距大说明有碎片/子进程
mem_fragmentation_ratiorss / used_memory>1.5 碎片严重;<1.0 说明在 swap
evicted_keys累计被淘汰的 key 数持续增长说明内存在频繁淘汰
expired_keys累计过期删除的 key 数判断过期是否正常

2. 内存碎片(mem_fragmentation_ratio)

mem_fragmentation_ratio = used_memory_rss / used_memory:

  • > 1.5:碎片严重,可评估开启主动碎片整理 activedefrag yes(Redis 4.0+),或低峰期重启
  • < 1.0:说明内存被 swap 到磁盘,性能会骤降,要立即加内存或降 maxmemory
  • 注意区分:mem_fragmentation_ratio 高但 allocator_frag_ratio 接近 1.0 时,碎片不在分配器内部,可能是 BGSAVE/AOF 重写的 fork 子进程占用,等子进程退出即可恢复

3. 找大 key

redis-cli --bigkeys              # 快速概览各类型最大 key(生产慎用,可能较慢)
redis-cli MEMORY USAGE key       # 精确看单个 key 内存
redis-cli --scan --pattern '*' | head -100

更稳妥的方式:用 redis-rdb-tool 等工具离线解析 RDB 快照,拿到每个 key 的类型、元素数、内存占用,不影响线上服务。

4. 大 key 安全删除

  • String 大 value:用 UNLINK 异步删除(4.0+)
  • Hash/Set/ZSet 大集合:不要一把 DEL,用 HSCAN/SSCAN/ZSCAN 分片读取后逐批删除,每次控制几百个元素,避免单次操作阻塞主线程

5. 五步排查流程(总结版)

  1. 看趋势:used_memory 与 used_memory_rss 是同步涨还是错峰涨(判断是业务写入还是 fork 子进程)
  2. 看 keyspace:INFO keyspace 判断键数是否在涨、有多少 TTL=-1 的永久 key
  3. 找大 key:--bigkeys / MEMORY USAGE / 离线 RDB 分析
  4. 核对策略:CONFIG GET maxmemory-policy,确认不是 noeviction、不是失效的 volatile-*
  5. 看碎片:mem_fragmentation_ratio 判断是否需要 activedefrag 或重启

根治三件事:给缓存 key 都设合理 TTL、按业务拆分实例避免一个坏 key 拖垮全实例、对内存使用率(建议 75%)和 evicted_keys 增速设告警。


六、过期删除 vs 内存淘汰(区别)

维度过期删除内存淘汰
触发条件key 到达 TTL 过期内存达到 maxmemory
针对对象只删「已过期」的 key可能删「没过期」的 key
策略惰性 + 定期8/10 种 maxmemory-policy
目的过期清理容量控制

一句话:过期删除管「时间到了没有」,内存淘汰管「空间够不够」。


七、经典面试题

Q1:Redis 内存满了怎么办?
答:先看 maxmemory-policy。默认 noeviction 会拒绝写请求并报错;生产一般设为 allkeys-lru 或 allkeys-lfu 淘汰数据;同时排查大 key、过期 key 未清理、内存碎片等问题。

Q2:MySQL 有 2000w 数据,Redis 只存 20w,如何保证都是热点数据?
答:设置 maxmemory 为能容纳 20w 数据的规模,淘汰策略用 allkeys-lru 或 allkeys-lfu,让 Redis 只保留最近/最常访问的热点数据,冷数据自动被淘汰。

Q3:过期删除和内存淘汰有什么区别?
答:过期删除针对「设置了 TTL 且已过期」的 key(惰性 + 定期删除);内存淘汰是「内存满了」时按策略挑 key 删除(可能删没过期的 key)。前者是过期清理,后者是容量控制。

Q4:为什么 Redis 的 LRU 不是精确的?
答:精确 LRU 需维护有序链表,每次读都要移动节点(读变成写),开销太大。Redis 用 24bit 时间戳 + 随机采样 + 候选池做近似,默认采样 5 个已约 96% 逼近真实 LRU。

Q5:LFU 的计数器只有 8bit,怎么表示高访问频率?
答:用 Morris 概率计数器(对数增长),计数器越大增长越慢,配合 lfu-log-factor 控制;并靠 16bit 时间戳做时间衰减,新 key 初始值 5 防止刚插入就被淘汰。

Q6:从库会删除过期 key 吗?
答:不会主动删。从库读到过期 key 只返回「不存在」但不物理删除,真正的删除由主库通过复制流把 DEL 传播过来。

Q7:volatile-lru 为什么可能失效?
答:volatile-* 只淘汰设了 TTL 的 key。若大部分 key 没设 TTL,内存打满时这些永久 key 无法被淘汰,volatile-* 形同虚设并退化成类似 noeviction。选它前务必确认业务 key 都带 TTL。


八、总结

  • 过期删除 = 惰性删除(expireIfNeeded)+ 定期删除(activeExpireCycle),平衡 CPU 与内存;
  • 过期键单独存在 expires 字典,从库不自删、由主库传播 DEL;
  • 内存淘汰有 8 种经典策略(Redis 8.6+ 增至 10 种),纯缓存首选 allkeys-lru;
  • LRU/LFU 都是「近似算法」:24bit 字段 + 随机采样 + 候选池 / 概率计数器;
  • 内存打满先看 INFO memory(水位、evicted_keys、碎片率),再定位大 key 与永久 key;
  • 关键红线:默认 noeviction 在生产会因缓存写满直接报错,务必按业务显式配置 maxmemory-policy。

下一篇讲解持久化机制(RDB/AOF/混合持久化)。

👍 一键三连
如果这篇笔记帮你理清了三范式、顺手拿下了面试题,麻烦来个三连支持一下~
💛 点赞 = 我学会了
⭐ 收藏 = 下次建表照着抄,面试前翻出来复习
💬 评论 = 留下你的疑问或想看的主题

参考资料

  1. Redis 官方文档 - Key eviction(LRU/LFU 淘汰策略)
  2. Redis 官方 - What Are the Impacts of the Redis Expiration Algorithm?
  3. antirez - Random notes on improving the Redis LRU algorithm(LFU 24bit 实现原文)
  4. 华为云 - Redis 内存淘汰策略怎么选
  5. 华为云 - Redis 内存告警排查:从 maxmemory-policy 到 key 命名空间
  6. 华为云 - Redis 内存持续增长排查手册
  7. 华为云 - Redis 主从架构下过期键是如何同步删除的
  8. 华为云 - Redis 内存打满导致写入失败排查实战
  9. 腾讯云 - Redis 内存淘汰机制详解
  10. 腾讯云 - Redis 源码剖析之内存淘汰策略(Evict)
  11. 腾讯云 - 详解 Redis 内存管理机制和实现
  12. 阿里云 - Redis 过期删除策略手术式源码刨析
  13. CSDN - Redis 内存淘汰策略全解:8 种策略、近似 LRU 采样、LFU 计数器
  14. 博客园 - Redis 核心机制:过期删除策略(惰性+定期+主动)
  15. 看云 - Redis 的过期策略和内存淘汰机制有什么区别
  16. 掘金 - Redis 源码解读之 expire 的时机

转载自 CSDN-专业IT技术社区

原文链接:https://blog.csdn.net/qq_36506963/article/details/171184449

文章来源转载

评论

评论列表

微信小程序
QQ小程序

关于作者

点赞数:0
关注数:0
粉丝:0
文章:0
关注标签:0
加入于:--