Skip to content

4.2-6 过期策略与内存淘汰 ​

所属:04 数据存储 / 4.2 Redis 分级:A 状态:◐ 初稿 关联:4.2-1、4.2-2、4.2-4、4.2-5、4.2-8、4.2-9、4.2-12

  • 题型:原理 / 调优 / 排障

  • 一句话结论:Redis 有两条完全不同的链路:过期删除解决“key 到点该消失”,靠惰性删除 + 周期性主动删除,不是每个 key 一个定时器;内存淘汰解决“内存到上限该丢谁”,靠 maxmemory + 8 种 maxmemory-policy + 近似 LRU/LFU 采样。TTL 不保证精确到点删除,淘汰也不等于过期,二者要分开设计和监控。

  • 分层要点:

    1. 先分清两个问题:过期是“时间维度”的失效,淘汰是“容量维度”的取舍。key 没 TTL 也可能被淘汰(allkeys-*);key 有 TTL 也可能在到期前被淘汰(volatile-*);noeviction 下内存满时写命令报 OOM,但过期仍会发生。
    2. TTL 存在哪:每个 db 有一个 expires dict,key → 过期时间(毫秒时间戳)。TTL/PTTL 查这个 dict,O(1);SET 默认清 TTL,SET ... KEEPTTL 保留,PERSIST 删除 TTL,RENAME 会带走 TTL。过期时间是绝对时间,不是倒计时。
    3. 过期删除 = 惰性 + 主动:访问 key 时发现过期就删(惰性);serverCron 周期性随机采样带 TTL 的 key,删除其中过期的(主动)。hz 控制 cron 频率(默认 10),active-expire-effort 控制主动删除强度(1–10,默认 1);不是“到点立刻删”,所以 TTL 是近似语义。
    4. 内存淘汰 = maxmemory + policy:used_memory 超过 maxmemory 时触发 eviction;策略分 allkeys-*(所有 key)和 volatile-*(仅带 TTL 的 key),算法分 LRU/LFU/random/ttl。noeviction 不淘汰,写命令返回 OOM;volatile-* 在没有带 TTL key 时也可能 OOM。
    5. LRU 是近似的:redisObject.lru 存 24 位时钟(秒级),不维护完整链表;淘汰时随机采样 maxmemory-samples(默认 5)个 key,选最久未使用的放入 eviction pool(16 个候选),再淘汰最旧。采样越多越接近真实 LRU,但 CPU 越高。
    6. LFU 看访问频率:Redis 4.0+,lru 字段拆成 16 位“上次衰减时间(分钟)”+ 8 位对数计数器;计数随访问概率增长,按 lfu-decay-time 衰减,lfu-log-factor 控制增长斜率。allkeys-lfu/volatile-lfu 适合热点明显、偶发扫描多的场景。
    7. 大 key 与 lazyfree:DEL 大 key 同步释放会阻塞主线程;UNLINK 先摘链、后台释放;lazyfree-lazy-expire、lazyfree-lazy-eviction、lazyfree-lazy-server-del、lazyfree-lazy-user-del 可把释放放到后台。主动过期遇到大 key 也可能抖动,监控慢日志/延迟。
    8. 主从、持久化、集群:过期由主库驱动,主库删除后传播 DEL/UNLINK;从库不独立发起过期删除,读时按逻辑过期处理,但物理内存可能暂时保留。replica-ignore-maxmemory 默认让从库不自行淘汰,避免与主库分叉。RDB/AOF 重写按当前数据集处理;Cluster 的 maxmemory 是单节点,不是全局。
  • 图/流程:

text
TTL 存储:
  redisDb
    ├─ dict:key → value
    └─ expires:key → 过期时间戳(ms)
  TTL key → expires[key] - now
text
过期删除:
  访问 key
    └─ 惰性删除:发现过期 → 删除 + 传播 DEL/UNLINK
  serverCron(hz)
    └─ 主动删除:随机采样带 TTL 的 key
         ├─ 过期 → 删除
         └─ 过期比例高 → 继续采样
  TTL 是近似,不是定时器
text
内存淘汰:
  used_memory > maxmemory
    → 按 maxmemory-policy 选 victim
    → 删除/UNLINK
    → 传播 DEL 给从库
    → 若无法淘汰(noeviction/volatile 无 TTL)→ 写命令 OOM
text
近似 LRU:
  随机采样 maxmemory-samples 个 key
    → 比较 lru 时钟
    → 放入 eviction pool
    → 淘汰最久未使用
  不是完整链表,不精确
text
LFU:
  lru 字段:
    [16 位上次衰减时间][8 位对数计数器]
  访问 → 概率增加计数
  时间 → 按 lfu-decay-time 衰减
  OBJECT FREQ 查看
text
策略选择:
  缓存,所有 key 可丢 → allkeys-lru / allkeys-lfu
  缓存,只有部分 key 有 TTL → volatile-lru / volatile-lfu
  必须保留数据,不能丢 → noeviction + 监控/扩容
  随机/按 TTL → allkeys-random / volatile-random / volatile-ttl
  • 版本/源码锚点:

    • Redis 2.8/3.x:惰性 + 主动过期、近似 LRU、maxmemory-policy。
    • Redis 4.0:LFU(allkeys-lfu/volatile-lfu)、UNLINK、lazyfree、activedefrag。
    • Redis 6.0:SET ... KEEPTTL、ACL、TLS;6.2:GETEX;7.0:EXPIRE 的 NX/XX/GT/LT 选项。
    • Redis 7.0:EXPIRETIME/PEXPIRETIME、maxmemory-clients、sharded pub/sub。
    • 关键参数:maxmemory、maxmemory-policy、maxmemory-samples、hz、active-expire-effort、lfu-log-factor、lfu-decay-time、lazyfree-lazy-*、replica-ignore-maxmemory。
    • 源码:src/expire.c、src/evict.c、src/db.c、src/server.c、src/object.c、src/lazyfree.c。
  • TTL 常用命令:

命令作用注意
EXPIRE key seconds设置秒级 TTL负值删除 key
PEXPIRE key ms毫秒 TTL精度毫秒,删除仍近似
EXPIREAT/PEXPIREAT绝对时间过期适合跨时区/固定时间
TTL/PTTL剩余时间-1 无 TTL,-2 不存在
PERSIST移除 TTL变成永久 key
SET ... EX/PX设置值 + TTL默认清旧 TTL
SET ... KEEPTTL保留旧 TTL6.0+
GETEX读取并设置/清除 TTL6.2+
EXPIRETIME绝对过期时间7.0+
EXPIRE ... NX/XX/GT/LT条件设置 TTL7.0+
  • 过期删除对比:
机制触发优点缺点
惰性删除访问 key不浪费 CPU不访问就长期占内存
主动删除serverCron 周期采样清理冷 key采样/时间限制,非精确
定时器每个 key 一个 timer精确内存/CPU 开销大,Redis 不用
  • 淘汰策略:
策略候选范围算法适用
noeviction不淘汰写命令 OOM不能丢数据、靠扩容/报警
allkeys-lru所有 key近似 LRU通用缓存
allkeys-lfu所有 key近似 LFU热点明显、扫描多
allkeys-random所有 key随机访问均匀
volatile-lru有 TTL 的 key近似 LRU混合持久/缓存
volatile-lfu有 TTL 的 key近似 LFU混合 + 热点
volatile-random有 TTL 的 key随机简单
volatile-ttl有 TTL 的 key最早过期优先TTL 代表冷热
  • LRU vs LFU:
维度LRULFU
关注最近是否使用使用频率
字段24 位时钟16 位时间 + 8 位计数
优点实现简单、适应变化抗偶发扫描、保留热点
缺点扫描会污染新 key 冷启动、计数衰减
命令OBJECT IDLETIMEOBJECT FREQ
策略allkeys-lru/volatile-lruallkeys-lfu/volatile-lfu
  • 关键配置:
配置默认(常见)作用
maxmemory0(不限)内存上限
maxmemory-policynoeviction淘汰策略
maxmemory-samples5LRU/LFU 采样数
hz10cron 频率
active-expire-effort1主动过期强度 1–10
lfu-log-factor10LFU 计数增长
lfu-decay-time1 分钟LFU 衰减
lazyfree-lazy-expireno过期释放后台化
lazyfree-lazy-evictionno淘汰释放后台化
lazyfree-lazy-user-delnoDEL 后台化(仍建议 UNLINK)
replica-ignore-maxmemoryyes从库不自行淘汰
activedefragno主动碎片整理
  • 监控指标:
指标位置说明
used_memoryINFO memoryRedis 分配器口径
used_memory_rssINFO memory进程 RSS
mem_fragmentation_ratioINFO memory碎片率
maxmemory/maxmemory_policyINFO memory当前配置
evicted_keysINFO stats累计淘汰数
expired_keysINFO stats累计过期数
keyspace_hits/missesINFO stats命中率
dbX:keys/expiresINFO keyspace各 db key/TTL 数
latency/slowlogLATENCY/SLOWLOG大 key 删除抖动
  • 深挖点(面试官常追的 6 个):

    1. 为什么不用定时器:每个 key 一个定时器会带来巨大的内存和调度开销,Redis 单线程也承受不了海量 timer。惰性删除保证“访问时才付出成本”,主动删除用随机采样 + 时间上限清理冷 key;两者结合,用近似换吞吐。代价是 TTL 到点后 key 可能还占内存,TTL 也可能出现“已过期但还没删”的短暂状态。
    2. 主动过期的采样逻辑:每个 db 随机取一批带 TTL 的 key,删除其中过期的;如果过期比例超过 25%,继续采样;每轮有时间上限,避免阻塞。hz 提高频率、active-expire-effort 提高强度,都会增加 CPU;大 key 多时还要配合 lazyfree,否则删除本身会卡。
    3. 主从过期的一致性:主库负责过期删除,删除后向从库传播 DEL/UNLINK;从库不独立发起过期删除,避免主从各自删除造成分叉。从库读逻辑过期 key 通常按不存在处理,但物理内存要等主库的删除传播;所以从库 used_memory 可能高于主库,监控要看 expired_keys 和复制延迟。
    4. 近似 LRU 的采样:Redis 不维护全局 LRU 链表,只在 redisObject.lru 存 24 位时钟;淘汰时随机采样 maxmemory-samples 个 key,选 idle 最大的进 eviction pool,再淘汰最旧。采样数越大越接近真实 LRU,但每次淘汰的 CPU 越高;默认 5 是吞吐和精度的折中。
    5. LFU 的对数计数与衰减:8 位计数器最大 255,不是每次访问都 +1,而是按概率增加,lfu-log-factor 越大增长越慢;lfu-decay-time 控制每隔多久衰减。新 key 初始计数是 5(LFU_INIT_VAL),避免刚写入就被淘汰;但冷启动/突发流量仍可能误判。OBJECT FREQ 可观测。
    6. 淘汰策略没有“最好”:纯缓存用 allkeys-lru/allkeys-lfu;混合持久和缓存用 volatile-*,但必须保证可淘汰 key 有 TTL,否则内存满时无法淘汰;不能丢数据用 noeviction + 扩容/告警/降级。策略要结合命中率、淘汰量、TTL 比例、业务能否重建来选,不能只看内存曲线。
  • 追问链:

    1. Redis 过期键怎么删除? → 惰性删除 + 周期性主动删除。
    2. 为什么不用定时器? → 海量 key 的 timer 内存/调度开销太大。
    3. 惰性删除怎么做? → 访问时检查过期,删除并传播。
    4. 主动删除怎么做? → serverCron 随机采样带 TTL 的 key,删除过期的。
    5. hz 作用? → cron 频率,默认 10。
    6. active-expire-effort 作用? → 主动过期强度,1–10,越大越耗 CPU。
    7. TTL 到点一定删吗? → 不一定,近似删除,可能延迟。
    8. TTL 返回 -1/-2? → -1 无 TTL,-2 key 不存在。
    9. SET 会清 TTL 吗? → 默认会;KEEPTTL 保留。
    10. RENAME 会保留 TTL 吗? → 会带走 TTL。
    11. PERSIST 作用? → 移除 TTL。
    12. 过期 key 在主从怎么处理? → 主库删除并传播 DEL/UNLINK;从库不独立删。
    13. 从库内存为什么会高? → 逻辑过期但还没收到主库删除,物理 key 仍占内存。
    14. replica-ignore-maxmemory 作用? → 从库不自行淘汰,避免分叉。
    15. Redis 内存淘汰是什么? → 超过 maxmemory 按策略删除 key。
    16. 有哪些淘汰策略? → noeviction、allkeys/volatile × lru/lfu/random、volatile-ttl。
    17. noeviction 会怎样? → 不淘汰,写命令 OOM,读/删除可用。
    18. volatile-lru 淘汰范围? → 只淘汰带 TTL 的 key。
    19. volatile-* 没有 TTL key 会怎样? → 无法淘汰,可能 OOM。
    20. allkeys-lru 和 volatile-lru 区别? → 候选范围不同。
    21. LRU 是精确的吗? → 不是,近似采样。
    22. LRU 怎么实现? → 24 位时钟 + 随机采样 + eviction pool。
    23. maxmemory-samples 作用? → 采样数,越大越准越耗 CPU。
    24. LFU 是什么? → 按访问频率淘汰,4.0+。
    25. LFU 计数器怎么增长? → 对数概率增长,lfu-log-factor 控制。
    26. LFU 怎么衰减? → lfu-decay-time,按分钟衰减。
    27. OBJECT FREQ/IDLETIME 区别? → LFU 频率 / LRU 空闲时间。
    28. 新 key 会被立刻淘汰吗? → LFU 初始计数 5,降低概率但非绝对。
    29. 大 key 过期会卡吗? → 会,同步释放阻塞;用 lazyfree/UNLINK。
    30. UNLINK 和 DEL 区别? → UNLINK 后台释放,DEL 同步。
    31. lazyfree-lazy-expire 作用? → 过期释放后台化。
    32. lazyfree-lazy-eviction 作用? → 淘汰释放后台化。
    33. RDB/AOF 会保留过期 key 吗? → 重写按当前数据集处理,不保证保留。
    34. 过期事件可靠吗? → 不可靠,删除时触发,可能延迟;不能当定时器。
    35. keyspace notification 怎么开? → notify-keyspace-events Ex 等。
    36. 缓存雪崩和 TTL 关系? → 大量 key 同时过期;加随机 jitter。
    37. 缓存穿透/击穿? → 与过期/淘汰相关但不同,见 4.2-8。
    38. maxmemory 是全局吗? → 单实例/单节点;Cluster 每节点独立。
    39. used_memory 和 RSS 区别? → 分配器口径 vs 进程实际内存;碎片看 ratio。
    40. 碎片怎么处理? → activedefrag、重启、MEMORY PURGE。
    41. 淘汰会通知业务吗? → 不会;只能监控 evicted_keys/命中率。
    42. 怎么选策略? → 纯缓存 allkeys-lru/lfu;混合 volatile-*;不能丢 noeviction。
    43. TTL 能替代淘汰吗? → 不能;TTL 管时间,淘汰管容量。
    44. 淘汰和持久化关系? → 淘汰会删数据,RDB/AOF 记录删除;不能把缓存当存储。
    45. Cluster 内存倾斜? → 按节点 maxmemory/槽/大 key 监控,必要时 reshard。
  • 生产案例/取舍(示例,替换成你的项目):

    • 缓存集群 maxmemory 8GB + allkeys-lru,命中率 95%;扩容前先看 evicted_keys 和命中率。
    • noeviction 导致写命令 OOM;评估业务可丢后改 allkeys-lru。
    • volatile-lru 但大量 key 没 TTL,内存满无法淘汰;补 TTL 或改 allkeys-*。
    • 大 Hash 过期时主线程卡顿;开 lazyfree-lazy-expire,并用 UNLINK 清理。
    • 热点榜单用 allkeys-lfu,抗住了离线扫描;OBJECT FREQ 验证热点。
    • TTL 集中到期导致缓存雪崩;加随机 jitter + 多级缓存。
    • 从库内存高于主库,因为过期 DEL 还没追上;看复制延迟/expired_keys。
    • maxmemory-samples 从 5 调到 10,淘汰更准但 CPU 上升;压测后折中。
    • Cluster 某节点内存先满,槽/大 key 倾斜;reshard + 拆分大 key。
    • 取舍:精确过期换 CPU/内存,Redis 选近似;LRU 换简单,代价是扫描污染;LFU 换热点保留,代价是冷启动/衰减参数;noeviction 换不丢数据,代价是写入失败;lazyfree 换低延迟,代价是后台内存/CPU。
  • 易错点:

    • 认为 TTL 到点立即删除。
    • 认为 Redis 为每个 key 设定时器。
    • 认为 TTL 精确反映物理删除。
    • 认为从库会自己过期删除。
    • 认为从库内存一定等于主库。
    • 认为 maxmemory 只算 value。
    • 认为 noeviction 会淘汰。
    • 认为 volatile-lru 会淘汰所有 key。
    • 认为 volatile-* 没有 TTL key 也能淘汰。
    • 认为 LRU 是精确链表。
    • 认为 LFU 计数器每次 +1。
    • 认为新 key 一定不会被淘汰。
    • 认为淘汰会通知业务。
    • 认为过期事件是可靠定时器。
    • 认为 RDB/AOF 一定保留过期 key。
    • 忽略大 key 删除阻塞。
    • 忽略 lazyfree 配置。
    • 忽略 maxmemory-samples 的 CPU 成本。
    • 认为 used_memory 等于 RSS。
    • 忽略碎片率。
    • 认为 Cluster maxmemory 是全局。
    • 认为 TTL 可以替代淘汰策略。
  • 30 秒口述稿:

Redis 过期和淘汰是两件事。过期删除是惰性 + 主动:访问时删,serverCron 随机采样带 TTL 的 key 删,hz 和 active-expire-effort 控制强度,所以 TTL 是近似,不是定时器。内存淘汰是 maxmemory 超限后按策略选 victim:noeviction、allkeys/volatile 乘 lru/lfu/random、volatile-ttl;LRU 是 24 位时钟 + 采样近似,LFU 是 8 位对数计数 + 衰减。大 key 用 UNLINK/lazyfree,主从过期由主库传播,Cluster 的 maxmemory 是单节点。

  • 3 分钟展开顺序:结论(过期 vs 淘汰)→ TTL 存储/命令 → 惰性 + 主动过期(hz/effort)→ maxmemory/8 种策略 → 近似 LRU/LFU → 大 key/lazyfree → 主从/持久化/Cluster → 监控/选型 → 生产案例与取舍。