Redis 核心机制 | 过期删除策略:惰性+定期+主动(二)
先把结论放前面:Redis 没有定时器,「过期」不等于「删除」。真正删键的只有三条通道 + 一条传播:访问触发的惰性删除、沿游标扫桶的键级定期删除、7.4 起的字段级定期删除;所谓「主动删除」,只是主库把删除动作传播给从库。把「什么时候删」写进 SLA,是最常见的架构错误。
本篇的角度与边界
只回答一个问题:键已经过期之后,谁在什么时候把它真正删掉。 不覆盖 TTL 命令语义、内存淘汰、Lazy Free 全量开关、键空间通知的可靠替代。基线固定为 Redis 8.10.3 单实例(非集群),客户端 StackExchange.Redis 2.8.37 / .NET 10。凡与流行说法冲突处,给实测反证,不给「据说」。
六个实验都在 8.10.3 单实例的独立端口上跑,一主一从,不碰业务实例;每组前 FLUSHDB,改过的参数在组末改回去。文中写「实测」的地方是本机跑出来的数字,写「源码」的地方对着 expire.c 逐行核过。
一、开篇:三组 5 秒能跑出来的反证
# 起一个专用实验实例:别连业务实例,本机映射 6379
# 镜像先拉主版本线 8.10;起来后用 INFO server 的 redis_version 核对小版本
docker run -d --name redis-expire -p 6379:6379 redis:8.10
# ① 单键已过期:三个读数必须同时成立,才算「真的删了」
# 预期输出:OK
redis-cli -p 6379 SET k v PX 300
# 等 1 秒(远超 300ms);用 shell 的 sleep,不要用 DEBUG SLEEP
# → DEBUG SLEEP 默认被禁,且它冻结的是整个事件循环,会把定期删除一起冻住,实验结论全废
sleep 1
# 读一次:预期空行(= nil)。这条读命令本身也触发了一次惰性删除
redis-cli -p 6379 GET k
# 是否还存在:预期 0
redis-cli -p 6379 EXISTS k
# 库大小:预期 0(说明物理删除已完成,不是「只剩逻辑过期」)
redis-cli -p 6379 DBSIZE
# ② 20 万个同时到期的键:清完要 2~3.5 秒,不是瞬间(采样脚本见第四节)
# 预期输出:200000
redis-cli -p 6379 EVAL "for i=1,200000 do redis.call('SET','big:'..i,'v','EX',2) end return 200000" 0
采样时刻 DBSIZE Δexpired_keys 说明
t+0.5s 200000 0 刚写完,几乎没开始清
t+1.0s 131210 45068
t+1.5s 49219 128750
t+2.0s 0 197053 收敛(另一台机器复跑是 t+3.04s,会漂 1 秒以上)
三组读数对应三个结论,缺一个就会走偏。
- ① 单个键「过期即消失」是假象。 它消失是因为你「读」了它:惰性删除的判定点就在
lookupKey,读命令自己把删除做完了。没人读的话,它还能继续躺在库里占着内存,等游标一圈一圈扫过来。 - ② 批量到期有秒级残留窗口。 20 万键要 2~3.5 秒(净减 6~14 万键/秒)。这段时间
used_memory还按旧值算,容量不能按「已过期」估,告警也别在这个窗口里炸。 - ③ 只读从库的键是「逻辑已死、物理还在」。
TTL返回-2、GET返回nil、EXISTS返回0,但DBSIZE仍能数到它——前提是主库此刻还没删它。主库删完会传播DEL/UNLINK,从库立刻跟着没有;想观察残留必须先把主库冻住(第四节验证 F 给了可复现写法)。
这类事故的链条我见过几回:活动资格缓存预热 10 万键,统一 EXPIRE 3600;整点一起到期,慢循环被吃满,主线程开始出毛刺,DBSIZE 高位不降;运维先加机器,再把 hz 调到 100,毛刺反而更密;一周后才查到根因是 TTL 没打散。每一步单看都有道理,因为每一步都在治症状。调参治症状,TTL 设计才是病因。
三条必须写进设计文档的不变量:
- 过期键在被删之前一直占内存,且计入
used_memory与淘汰判定,所以「过期」不能用来兜容量规划。 - 冷键(不被访问)完全依赖定期删除,而定期删除的一圈可能长达分钟级,所以「过期即清理」不能用来做数据可见性约束。
- 从库不保证「自己会删」,所以主从
DBSIZE不可直接对比,容量与有效性必须分开取数。
二、机制:三条通道,一条传播
2.1 一张表看清分工
| 通道 | 触发条件 | 执行者 | 有配额吗 | 什么时候才生效 |
|---|---|---|---|---|
| 惰性删除 | 任何读写命令 lookupKey 命中 |
主线程(调用者) | 无 | 该键被访问的那一刻 |
| 键级定期删除(慢循环) | serverCron 按 hz 到达 |
主线程 | 有,且每 16 轮才检查一次 | 游标扫到它的那一圈 |
| 键级定期删除(快循环) | beforeSleep,需前置条件 |
主线程 | 有,单次 ≤1000µs | 残留率超阈值时补刀 |
| 字段级定期删除(7.4+) | 挂在 activeExpireCycle 每轮开头 |
主线程 | 独立预算,不吃键的配额 | 每轮开头 |
| 传播 | 主库删除后写 DEL/UNLINK |
主库 → 从库 | 无 | 主库删完的下一批命令 |
三条通道全在主线程上跑。所以你那条 GET,很可能正好撞上它在删键。监控上看到的是尖刺,不是持续的高延迟:平均值一直好看,P99 一直难看。
惰性删除的执行细节值得单独说,因为它让「谁删的」这个问题在从库上直接失效。主库上,命令走到 lookupKey 判定已过期,就删掉这个键、返回「不存在」,再把 DEL/UNLINK 写进复制流和 AOF。同样一次判定,在从库上只返回「逻辑上过期」,不删也不写。所以在只读从库上问「这个键谁删的」是个伪问题:它没删,只是学会了撒谎。主从 DBSIZE 对不上、GET 却一致,就来自这里:读路径统一走逻辑过期,存储路径各走各的。
传播方向也要说清楚,它决定了「主库删了,从库什么时候删」。删除动作作为 DEL/UNLINK 写进复制流,也写进 AOF,这也是为什么 AOF 里看到的是删除记录,而不是「过期标记」。所以从库的键会不会消失,不取决于从库自己的过期循环,只取决于主库有没有删、命令有没有到。主从切换后新主库上还能看到几个「早就过期」的键,那不是数据错误,是异步复制本来就有的窗口。
CLIENT PAUSE 期间整条链都停(源码里 isPausedActionsWithUpdate(PAUSE_ACTION_EXPIRE) 直接 return),主从两侧一起冻住。切换和扩缩容窗口最容易踩这条:窗口内 DBSIZE 只增不减,而从库的 TTL 已经在说「这键不该存在」。
2.2 定期删除:沿游标扫桶,不是随机抽 20 个
真实逻辑只有一条:沿着 db->expires_cursor 做增量扫描,扫完一圈游标回到 0。
- 每轮从
expires取num = min(挂 TTL 键数, 20 + 5×(effort−1))个键尝试删除; - 扫描按桶走,桶上限
num × 20。空桶过得极快,所以每轮至少能啃 20 个键,配额允许时反复啃; - 一轮结束后,若「本轮命中过期键占比 >
acceptable_stale」(默认 10%,effort=10 收紧到 1%),就在同一 DB 上repeat再扫一轮; - 时间配额不是每轮都查,是每 16 轮查一次;超时就置
timelimit_exit退出,剩的留给下一轮或快循环。上一轮撞过配额,下一轮会把要处理的 DB 数放宽到全部。
为什么不是随机抽 20 个?随机抽样有两个绕不过去的毛病。一是可能永远抽不到某些桶,冷键就一直不删;二是给不出收敛上界,你没法回答「扫完一圈要多久」。游标扫描正好补这两点:dictScan 用反向二进制增量推游标,扩容缩容期间已经扫过的桶不重不漏,一圈也有明确终点(游标回到 0)。代价是没有优先级,它不管谁更该删,只按桶顺序走。所以「先到期的那批先被删」是错觉,expires 里谁先被扫到谁先死。
单键滞后时调 hz 几乎没用,原因在这:你提高的是每秒轮数,一圈的总时长只按比例缩短。想把「10 万键 8 分钟」压到 1 分钟,hz 得提到 80,代价是 serverCron 全套任务一起变密。
我一开始也以为「躺了几分钟不删」是抽样运气差,直到把一圈的耗时算出来:每轮 20 键、每秒 10 轮,10 万键就是 8 分钟,100 万键要 83 分钟。跟运气无关,是游标还在赶路。反过来,开篇 20 万键 3 秒清完也不神秘:残留率远超 10%,repeat 连成了链,CPU 配额被反复拉满。积压越多,清得越快,这是自适应算法的自觉设计。
还有两个线上常见的误判值得记一下。「加了从库以后主库过期变慢」多半是错觉,真实原因是主库的写量和 expires 规模都变了。「重启后内存掉了一大截」也不是过期生效,是启动加载时过期键根本不会被装进来(RDB/AOF 加载阶段的处理在 S5-5,这里不展开)。
2.3 快循环:有前置条件的补刀
快循环挂在每次事件循环的 beforeSleep 里,看着频率极高,其实有两道闸门:上轮慢循环没撞配额,且 expired_stale_perc×100 低于 acceptable_stale 时,直接 return;两次之间还要求间隔 ≥ 2 倍单次预算。所以残留很少的实例上,快循环几乎不干活。它不是保底机制,是残留已经偏多时的加速器。把它当成「后台线程一直在扫」,是最常见的源码级误读。
两档循环怎么配合,跑一次小规模突发到期就看清了。1000 个键同时到期,慢循环第一轮扫 20 个,命中率 100%,超过 10% 就 repeat;几轮后命中率掉到 10% 以下,慢循环停手,这时 expired_stale_perc 已经被推高;下一次 beforeSleep 的快循环发现超阈值,接着补刀;压回阈值以内,快循环立刻停。整个过程是先猛后缓、快慢交替,不是匀速。画一条 expired_stale_perc 曲线,这个呼吸节奏肉眼可见。
2.4 字段级:DBSIZE 看不见的第三条通道
7.4 起 Hash 支持字段级 TTL(HEXPIRE/HTTL/HPTTL/HPERSIST/HEXPIRETIME)。这类残留不改变键数、不改变 expires 的大小:一个 Hash 里 5 万个字段全部过期,DBSIZE 从头到尾只有一个数字 1。
字段级的预算也是独立的:每轮最多清 10000 / hz 个字段,hz=10 就是每轮 1000 个、折合 1 万/秒;连续撞上限会按累积超出次数放大,最多 32 倍。我实测 5 万字段的清理速率约 5 万字段/秒,正好是基础预算的 5 倍,说明放大机制真的在工作。
观测只能靠 INFO keyspace 的 subexpiry(挂着字段 TTL 的键数)和 INFO stats 的 expired_subkeys(累计过期字段数)。只盯 DBSIZE 和 expires 的监控,对字段级过期是瞎的。
字段级 TTL 最容易踩的是混用和覆盖写。同一个 Hash 上既设整键 TTL、又设若干字段 TTL 时,整键到期整个键被删,字段 TTL 一起消失;字段到期只摘字段,键还在。「会话某个属性先失效、整个会话后失效」是合理需求,但排障时要分清是哪一层在生效:TTL 看键,HTTL 看字段,两个命令给出的答案可能完全相反。
覆盖写更隐蔽,这是我在 8.10.3 上跑出来的:HSET h f v → HEXPIRE h 100 FIELDS 1 f(返回 1)→ HTTL 返回 100 → 再 HSET h f v2 覆盖同名字段 → HTTL 变 −1、HEXPIRETIME 变 −1。一次「只是更新了值」的写入,把字段 TTL 清掉了。 更麻烦的是 INFO keyspace 的 subexpiry 在该字段 TTL 被清掉后仍显示 1,连看 6 秒都没回落,它不是「当前有多少字段 TTL」的实时仪表。某个字段到底有没有 TTL,只能逐个 HTTL 查。
还有规模的问题:一个 Hash 存 10 万字段、给其中 5 万设 TTL,每轮预算只有 1000 个,靠放大也要好几秒才清完,这期间 DBSIZE 一动不动。
2.5 版本演进(决定你的断言在哪个版本成立)
| 版本 | 变化 | 对本篇结论的影响 |
|---|---|---|
| 7.0 | 新增 active-expire-effort |
终于有了「只调过期、不动全局」的旋钮 |
| 7.4 | expires 迁入 kvstore,改为游标扫桶;Hash 字段级 TTL 落地 |
「随机抽样 20 个」的旧描述彻底作废;多出第三条通道 |
| 8.10.3 | 本篇基线 | 全部断言以此为准 |
写评审材料时得注意:同一个数字在不同版本上可能不是一回事。7.2 及更早没有 expired_keys_active 与 expired_subkeys,用「expired_keys − expired_keys_active」拆惰性贡献这套方法,在旧版本上会直接算成 0。
三、旋钮:能干预的只有四个东西
| 旋钮 | 默认 | 作用范围 | 越界行为(两者相反,最易记反) |
|---|---|---|---|
hz |
10 | 全局节拍(连带 serverCron 全套) |
静默夹取:100000 → 500、501 → 500、0 → 1,命令都回 OK |
active-expire-effort |
1 | 只调过期,同调四个参数 | 直接报错:must be between 1 and 10 inclusive |
lazyfree-lazy-expire |
no | 只改「释放」方式,不改「判定与摘键」 | 布尔,无区间 |
CLIENT PAUSE |
— | 冻结写与过期动作 | 不是删除命令,却是切换窗口的常客 |
active-expire-effort 的四参数推导(n = 配置值,源码 expire.c,注意 20/4 是整数除法):
| 参数 | 公式 | n=1 | n=10 |
|---|---|---|---|
每轮键数 keys_per_loop |
20 + 20/4×(n−1) |
20 | 65 |
| 快循环单次预算 | 1000 + 1000/4×(n−1) µs |
1000µs | 3250µs |
| 慢循环 CPU 配额 | 25 + 2×(n−1) % |
25% | 43% |
继续扫阈值 acceptable_stale |
10 − (n−1) % |
10% | 1% |
第四行是大部分资料漏掉的:effort 会把快循环的单次时长一起放大,两个时间配额同时变松。所以调高 effort 是三重叠加:扫得更多、扫得更久、更不容忍残留。它唯一不改的是全局节拍,什么时候开始一轮,还是只由 hz 决定。
# ① hz 的超限是静默夹取:命令回 OK,值却被改小
# 预期输出:OK
redis-cli -p 6379 CONFIG SET hz 100000
# 预期输出两行:hz / 500(不是 100000)
redis-cli -p 6379 CONFIG GET hz
# ② 负数不夹取,直接报错;注意报错里的区间是 0~2147483647,不是 1~500
redis-cli -p 6379 CONFIG SET hz -1
# ③ effort 反过来:越界直接拒绝,不给你「看起来成功」的机会
# 预期输出:OK
redis-cli -p 6379 CONFIG SET active-expire-effort 2
# 预期输出:ERR ... argument must be between 1 and 10 inclusive
redis-cli -p 6379 CONFIG SET active-expire-effort 20
# ④ 热改后必须回读:hz 是运行时值,configured_hz 是配置值(dynamic-hz 会让两者不同)
redis-cli -p 6379 INFO server | grep -E 'hz:|configured_hz:'
# ⑤ 异步释放只影响「释放」:开了它,键照样要先被判定过期、从 expires 摘掉
redis-cli -p 6379 CONFIG GET lazyfree-lazy-expire
热改这里有个坑:CONFIG SET 回 OK 只说明参数名和类型合法,不说明值如你所愿。hz 会被夹取,effort 会报错,唯一可靠的确认手段是 CONFIG GET 或 INFO server 回读。Windows 原生 cmd 没有 grep,换 Select-String,或者 redis-cli --no-raw INFO server。
几个观测面容易被忽略,但排查时很好用。expired_stale_perc 是本轮过期占比的 5%/95% 滑动平均,快循环靠它决定要不要启动。expire_cycle_cpu_milliseconds 是过期循环的累计 CPU 毫秒。lazyfree_pending_objects 是异步释放的积压。LATENCY HISTORY expire-cycle 得先 CONFIG SET latency-monitor-threshold 1,否则永远是空数组,这一条经常被当成「没有毛刺」的证据。
调参顺序反了会白忙,我的排法是:先 active-expire-effort(只管过期,副作用最小),再 lazyfree-lazy-expire(削峰,不动判定),最后才动 hz(全局旋钮,副作用最大)。hz 提到 100,serverCron 的整套后台任务都跟着变密,不只是过期。
hz 的真实成本得说清楚。它控制 serverCron 的调用频率,而 serverCron 里排着的不只是过期:客户端超时检查、渐进式 rehash 的迁移步进、AOF 缓冲刷盘、从库心跳与超时判定、集群节点握手,一整套都在里面。从 10 提到 100,等于这一整套提速 10 倍,过期只是其中一项。这也是我把 hz 排在最后的原因:它从来不是「过期专用旋钮」。
还有一个容易看反的机制:dynamic-hz(默认开)会在连接数增多时临时提高 hz,于是 INFO server 里的 hz 可能大于 configured_hz。判断「配置有没有生效」看 configured_hz,判断「当前跑多快」看 hz,两个字段名字相近,结论却相反。
这两个旋钮怎么配,我只有三条经验。常态用默认,hz=10、effort=1 就够;只有 TTL 密度高、清理明显滞后时才动 effort,一次加 2 级观察一轮,别一步到 10。hz 我一般不超过 50,再往上 serverCron 的其他任务会先于过期暴露成本,心跳变密、rehash 步进变碎。永远不要靠 hz 解决「同时到期」,那是一次性冲击,抖动才是解。如果监控显示 expired_stale_perc 长期高位、cpu_ms 斜率却不高,说明有活干但没时间干,这时候提 effort(拉长单轮预算)比提 hz(增加轮次)对症。
四、六个断言,逐条实机验(8.10.3,独立端口)
| # | 断言 | 怎么验 | 实测结论 |
|---|---|---|---|
| A | 单键最终会被删,但不一定是「谁」删的 | SET PX 300 → 等 1s → GET/EXISTS/DBSIZE |
三个读数归零、expired_keys 比基线 +1(必须记基线,绝对值含前序实验) |
| B | 批量到期是秒级收敛,不是瞬间 | 20 万键 + 0.5s 采样 | 2~3.5 秒收敛,速率 6~14 万键/秒 |
| C | effort 调高会让 time_cap 下降 |
同脚本跑 effort=1 / 10 | 42 → 21;复跑 109 → 62(轮次变少、单次变长) |
| D | time_cap 不涨 ≠ 清理跟得上 |
hz=1 写 5 万键,只采样不访问 |
一轮 250ms 清掉近 4.9 万键,time_cap 全程 0,仍有秒级滞后 |
| E | 字段级过期要单独观测 | HEXPIRE + HTTL + INFO keyspace |
HTTL 返回秒、HPTTL 返回毫秒;subexpiry=1;不存在字段返回 −2 |
| F | 只读从库不自删、可写从库自删 | 冻结主库 + 暂停窗口 | 暂停中主从 DBSIZE 都是 1、从库 TTL=-2;replica-read-only no 后从库自己删、slave_expires_tracked_keys 1→0 |
验证 A 的坑不在读数,在计数。expired_keys 是累计量,绝对值毫无意义(本篇实例上前序实验已经累计到 40 万)。先读基线、再比增量是唯一正确的姿势;期间要还有别的键到期,增量可能是 +N,不是 +1。
4.1 采样脚本(验证 B / C 共用,一字不差)
# 清库 + 固定 hz=10 + 力度回到 1(作为 effort=10 那组的对照)
redis-cli -p 6379 FLUSHDB
redis-cli -p 6379 CONFIG SET hz 10
redis-cli -p 6379 CONFIG SET active-expire-effort 1
# 记基线:两个累计计数器跨实验只能比增量,不能比绝对值
BASE_EXP=$(redis-cli -p 6379 INFO stats | awk -F: '/^expired_keys:/{print $2+0}')
BASE_CAP=$(redis-cli -p 6379 INFO stats | awk -F: '/^expired_time_cap_reached_count:/{print $2+0}')
# 一次性写入 20 万个「2 秒后过期」的键;脚本自身约 1.9 秒,计时从它返回那一刻开始
# 预期输出:200000
redis-cli -p 6379 EVAL "for i=1,200000 do redis.call('SET','big:'..i,'v','EX',2) end return 200000" 0
# 每 0.5 秒采样一次,共 8 次;依赖 bash + awk + seq(Linux/macOS/WSL/Git Bash 均可)
for i in $(seq 1 8); do
# 读累计值,与基线相减得到本轮增量
EXP=$(redis-cli -p 6379 INFO stats | awk -F: '/^expired_keys:/{print $2+0}')
CAP=$(redis-cli -p 6379 INFO stats | awk -F: '/^expired_time_cap_reached_count:/{print $2+0}')
SIZE=$(redis-cli -p 6379 DBSIZE)
# 换算标称采样时刻(单次采样本身有几十毫秒开销,实际会略晚)
T=$(awk -v i="$i" 'BEGIN{printf "%.1f", i*0.5}')
# 一行三个量:残留键数、过期总数增量、撞满配额次数增量
echo "t+${T}s DBSIZE=${SIZE} dExpired=$((EXP-BASE_EXP)) timeCap=$((CAP-BASE_CAP))"
# 采样间隔
sleep 0.5
done
# 跑完把力度改回默认,别把实验参数留给下一个实验
redis-cli -p 6379 CONFIG SET active-expire-effort 1
跑 effort=10 那组时,只改两行:把 active-expire-effort 设成 10,其余一字不动。这是控制变量:hz 与键名、TTL、数量完全一致,唯一的差异是力度。
采样精度得交代,不然数字会被过度解读。单次采样是三次 redis-cli 往返拼出来的(两次 INFO stats 加一次 DBSIZE),Windows 上要 30~60ms,所以「t+0.5s」是标称值,实际略晚,三个读数之间还差几十毫秒。这也就解释了为什么 Δexpired_keys 与 DBSIZE 之和有时略大于 200000:不是计数错了,是两次读取之间又删了几个。想更准就把三个字段一次读回,单条 INFO 已经含 db0 行,可以省掉 DBSIZE。
复现记录:上表是首跑的原始数据;换机复跑同一脚本得到 effort=1 收敛 2.0s / Δtime_cap 109,effort=10 收敛 1.5s / Δtime_cap 62。方向完全一致,绝对值会漂——同一台机器紧邻两轮,秒数都能差 1 秒以上。所以结论只能这么写:速率区间可比,绝对秒数与绝对计数不可跨环境引用。把「3 秒收敛」写进 SLA 的人,下一次换机器就会被打脸。
验证 C 最反直觉:effort 从 1 调到 10,expired_time_cap_reached_count 反而从 42 掉到 21。这个计数器数的是「本轮撞满配额提前退出」的次数。effort 越高,单轮预算越长(25% → 43%)、每轮扫得越多(20 → 65 键),轮次就变少、每次变长,撞配额的次数自然少了。「effort 高 ⇒ 配额吃紧 ⇒ time_cap 更高」看着合理,实测是反的。
4.2 从库两态(必须先冻住主库,否则复现不出来)
这里有个方法论陷阱。主库过期循环正常时,删完就把 DEL/UNLINK 传播给从库,所以「写完等 3 秒、从库 DBSIZE 仍包含该键」这种写法根本复现不出来,我实测 3 秒后从库 DBSIZE 已经是 0。想看到「只读从库不自删」,得先让主库来不及删。
# 前置:6380 是 6379 的从库(已配置 replicaof 127.0.0.1 6379);实验用独立端口,别碰生产主从
# 预期输出:role:slave
redis-cli -p 6380 INFO replication | grep role
# 确认从库仍是默认的只读状态
# 预期输出两行:replica-read-only / yes
redis-cli -p 6380 CONFIG GET replica-read-only
# 主库写一个 1 秒过期的键
# 预期输出:OK
redis-cli -p 6379 SET third v EX 1
# 立刻冻结主库的写与过期动作 4 秒:不冻结的话,主库删完即传播,从库根本留不住
# 预期输出:OK
redis-cli -p 6379 CLIENT PAUSE 4000 WRITE
# 在暂停窗口内、TTL 已过之后采样(1.8s > 1s)
sleep 1.8
# 主库键数:预期 1(主库自己被冻结,没删)
redis-cli -p 6379 DBSIZE
# 从库键数:预期 1(键仍躺在从库键空间里)
redis-cli -p 6380 DBSIZE
# 从库 TTL:预期 -2(逻辑上已过期)
redis-cli -p 6380 TTL third
# 从库 GET:预期空行(nil)
redis-cli -p 6380 GET third
# 从库 EXISTS:预期 0(读命令看到的是「不存在」)
redis-cli -p 6380 EXISTS third
# 暂停解除后再等 2.5 秒:主库删掉并传播,两边一起归 0
sleep 2.5
redis-cli -p 6379 DBSIZE
redis-cli -p 6380 DBSIZE
可写从库那一半更值得走一遍,结论更锋利:CONFIG SET replica-read-only no,在从库本地写 SET localk v EX 1(主库没这个键),INFO stats 的 slave_expires_tracked_keys 变 1,3 秒后 DBSIZE=0、expired_keys 与 expired_keys_active 同步 +1、tracked 回 0。可写从库有一份自己的过期键追踪表(slaveKeysWithExpire),会自己删本地写入的带 TTL 键。
这里有个必须记住的口径:「expired_keys − expired_keys_active = 惰性贡献」只在主库成立。从库上这个差值会把 expireSlaveKeys 的贡献算进「定期」,横跨主从对账必然对不上。
切换窗口的处置清单可以直接抄进 runbook。切前确认 replica-read-only 的取值。切换过程中别用 DBSIZE 做容量决策,暂停期间它只增不减。切完先等一轮传播落地(秒级),再看新主库 DBSIZE 是否收敛。新主库残留明显多于预期,查的是旧主库当时有没有删干净,不是新主库的 hz。
4.3 三条判据的口径
time_cap不是 CPU 指标,它数的是「本轮撞满配额而提前退出」的次数;CPU 占用看expire_cycle_cpu_milliseconds。expired_keys是累计量,跨实验只能比增量,且必须记基线。- 「刚到期」是暂态:秒级;持续数分钟仍高位,才去查
hz/ effort / 游标一圈的长度。 - 同一时刻的
DBSIZE与TTL可能互相矛盾:CLIENT PAUSE窗口里DBSIZE说有、TTL说没有。这不是 bug,是「物理存在」与「逻辑有效」两套语义没对齐。
4.4 如果结果和预期相反,说明什么
实验的价值一半在正着验证,另一半在反着排查。六个验证的反向判据列在下面,线上出异常可以直接对号:
- 验证 A 反向:
DBSIZE归零但expired_keys不涨——键是被别的路径删掉的(DEL、覆盖写、FLUSHDB),不是过期;这时查业务代码比查 Redis 有效。 - 验证 B 反向:几十分钟仍是高位——不是「清得慢」,而是根本没在清:先看
expired_keys是否在涨,不涨就查hz是不是被夹成 1、实例是不是只读从库、或者正处于CLIENT PAUSE窗口。 - 验证 C 反向:effort=10 反而更慢——多半是
hz没控制在同一档,或写入脚本本身吃满主线程(EVAL是阻塞的,脚本越慢,观测窗口越靠后)。 - 验证 D 反向:
hz=1却几乎没滞后——键总量太小,一轮就扫完了。这条结论只在「键数远大于每轮预算」时成立,这是实验设计的前提,不是结论的漏洞。 - 验证 E 反向:业务说「字段该过期了」但
HTTL仍是正数——查是不是被HSET覆盖写清了 TTL(见 2.4)。 - 验证 F 反向:暂停窗口内从库
DBSIZE也是 0——主库其实没被冻住(暂停前已有别的连接在写,或参数用了ALL以外的组合),或者这个键根本没写成功。
反向判据写进 runbook,比写「正常时应为 X」有用得多。排障时你面对的从来不是正常状态。
五、生产落地
5.1 六个问题,各配一条否决条件
- 这批键会同时到期吗? 会 → 先加 TTL 抖动,别调参。判据:同一秒到期的键数 × 单键删除成本 > 可接受延迟预算。
- 有没有大 value? 有(>1MB,或元素上万的集合)→ 开
lazyfree-lazy-expire yes并盯lazyfree_pending_objects;同时考虑拆 key。 - 键是冷数据吗? 是 → 只能靠定期删除,接受「分钟级滞后」;把「过期即不可见」的业务约束从设计里拿掉。
- 业务能接受逻辑过期吗? 能 → value 内嵌过期时刻,读时判定 + 后台重建,时机最可控,也最容易测。
- 需要准点触发业务动作吗? 需要 → 过期事件/键空间通知全部否决,改调度器、Stream 或延迟队列。
- 切换窗口里容量与有效性分别以什么为准? 容量看主库
DBSIZE,有效性只看GET/EXISTS;两者的差值就是残留窗口。
决策树最容易变成「全都选是」,所以每问后面都跟一条否决条件,答不上这条就跳过:
- Q1 否决条件:同时到期键数 × 单键删除成本 < 可接受延迟预算 → 抖动是过度设计,先别动。
- Q2 否决条件:用
MEMORY USAGE量出大 value 的删除本身就在 1ms 以内 → 开lazyfree收益有限,优先拆 key。 - Q3 否决条件:冷数据同时要求「准时不可见」→ Redis 过期机制根本不适用,换存储或加读时校验。
- Q4 否决条件:逻辑过期需要业务侧兜底重建,没有幂等重建路径就别用。
- Q5 否决条件:业务其实能容忍秒级延迟 → 调度器才是唯一解;容忍不了,说明需求本身错位(Redis 给不了这个保证)。
- Q6 否决条件:没有。这一问必须答出来,答不出来就别上主从切换方案。
5.2 三个高频场景
| 场景 | 方案 | 别做什么 |
|---|---|---|
| 过期风暴(批量预热、整点刷新) | TTL 随机抖动 3600 + rand(-60, 60);热点键改逻辑过期 |
别指望调 hz 根治;也别用「错峰预热」当唯一手段,写流量本身也会尖峰 |
| 大 key 过期毛刺(P99 尖刺) | lazyfree-lazy-expire yes + 拆分为多个小 key |
别把 lazyfree 当「判定更早」用,它只改释放 |
| 回收自检(跟不跟得上) | 四指标联判:expired_keys 增速 vs 写入速率、DBSIZE 趋势、cpu_ms 斜率、expired_subkeys |
别看单一瞬时值,也别用 time_cap 代替 CPU 口径 |
三个场景的参数别停在口号上,落地可以直接照抄。抖动用 base + rand(-spread, +spread),spread 取基础 TTL 的 2%~5%(3600 秒对应 ±60~180 秒),下限兜底 10 秒。大 key 先用 MEMORY USAGE 量单个 value,超过 1MB 就拆,拆完再开 lazyfree,否则只是把一次长阻塞换成多次短阻塞。自检每 30 秒采一次、只记增量,expired_keys 增速低于写入速率的 80% 且持续 3 分钟就告警。这个 80% 是经验阈值,用来吸收 TTL 渐次到期的天然滞后,不是精确线。
TTL 抖动只需要一处实现,别在业务代码里散落写 3600:
// 抖动的唯一入口:基础 TTL 与抖动区间集中在这里,业务只调用
static TimeSpan TtlWithJitter(int baseTtlSeconds, int spreadSeconds)
{
// Random.Shared 是 .NET 6+ 的线程安全共享实例,避免每次 new Random() 撞同一种子
int ttl = baseTtlSeconds + Random.Shared.Next(-spreadSeconds, spreadSeconds);
// 下限兜底 10 秒:防止抖动出 0 或负值,导致「设 TTL 的瞬间键就过期」
return TimeSpan.FromSeconds(Math.Max(10, ttl));
}
5.3 自检工具(接在前面连接之后可直接运行)
// 连接串用 SE.Redis 自己的格式 host:port,key=value;redis:// URL 不被接受
// 地址从环境变量 REDIS 取,换实验实例不用改代码
string endpoint = Environment.GetEnvironmentVariable("REDIS") ?? "127.0.0.1:6379";
// abortConnect=false:首次连不上不在构造阶段抛异常,交给后续命令超时处理
using IConnectionMultiplexer muxer = ConnectionMultiplexer.Connect($"{endpoint},abortConnect=false,connectTimeout=3000");
// 默认库(db 0);过期策略按库独立
IDatabase db = muxer.GetDatabase();
// INFO 只取一次,解析成字典后所有字段复用,保证同一时刻的口径
static Dictionary<string, string> ParseInfo(string info)
{
// Ordinal:INFO 字段名大小写敏感,别用区域性比较
var map = new Dictionary<string, string>(StringComparer.Ordinal);
// 服务端按 CRLF 输出:先按 \n 切行,再逐行 Trim 掉 \r
foreach (var raw in info.Split('\n'))
{
// 去掉行尾空白(主要是 \r)
string line = raw.Trim();
// 空行与节标题(# 开头)不是字段行
if (line.Length == 0 || line.StartsWith('#'))
continue;
// 只按第一个冒号切分,避免值里含冒号时切错
int idx = line.IndexOf(':');
// 没有冒号或冒号在首位,不是合法字段行
if (idx <= 0)
continue;
// 前半字段名、后半值;同名重复时后者覆盖前者
map[line[..idx]] = line[(idx + 1)..];
}
return map;
}
// 字段缺失返回 null 而不是 0:版本不认识该字段时必须能被看见(≤7.2 会走到这里)
static long? Counter(IReadOnlyDictionary<string, string> map, string key)
{
// 不存在 → null,与「存在但值为 0」区分开
if (!map.TryGetValue(key, out var v))
return null;
// InvariantCulture 解析,避免区域设置影响整数格式
return long.TryParse(v, NumberStyles.Integer, CultureInfo.InvariantCulture, out var n) ? n : (long?)null;
}
// 两次 INFO 各一个往返:stats 给计数,server 给 hz 口径
var stats = ParseInfo((string)(await db.ExecuteAsync("INFO", "stats"))!);
var server = ParseInfo((string)(await db.ExecuteAsync("INFO", "server"))!);
// 过期相关计数:前两个全版本都有,后三个 7.4 起才有(缺失时返回 null)
long? expired = Counter(stats, "expired_keys");
long? active = Counter(stats, "expired_keys_active");
long? timeCap = Counter(stats, "expired_time_cap_reached_count");
long? cpuMs = Counter(stats, "expire_cycle_cpu_milliseconds");
long? subKeys = Counter(stats, "expired_subkeys");
// hz 必须回读:configured_hz 是配置值,hz 是运行时值(dynamic-hz 开时两者可能不同)
string hzRuntime = server.GetValueOrDefault("hz", "N/A");
string hzConfig = server.GetValueOrDefault("configured_hz", "N/A");
// 当前键总数,用来判断是否堆积
long dbSize = (long)(await db.ExecuteAsync("DBSIZE"))!;
// 惰性贡献 = expired_keys − expired_keys_active(仅主库成立,见 4.2)
Console.WriteLine($"hz={hzRuntime}/{hzConfig}, expired={expired}, 定期={active}, " +
$"惰性≈{(expired is null || active is null ? "N/A" : (expired - active).ToString())}, " +
$"time_cap={timeCap}, cpu_ms={cpuMs}, subkeys={subKeys}, DBSIZE={dbSize}");
// 确定性回收:绕开游标与访问判定直接删已知键;UNLINK 走异步释放
// 2.8.37 的 IDatabase 没有 KeyUnlinkAsync,只能 ExecuteAsync(否则编译报 CS1061)
long removed = (long)(await db.ExecuteAsync("UNLINK", "goods:1001"))!;
Console.WriteLine($"UNLINK removed={removed}");
实测输出(8.10.3)。干净库首跑(刚起来、只写了 1 个字段 TTL 和 1 个 goods:1001):
hz=10/10, expired=0, 定期=0, 惰性≈0, time_cap=0, cpu_ms=0, subkeys=0, DBSIZE=2
UNLINK removed=1
同一实例跑过前序实验后(计数器已累计):hz=10/10, expired=400204, 定期=400204, 惰性≈0, time_cap=171, cpu_ms=1555, subkeys=1, DBSIZE=101。两行差别只在绝对计数上,说明「expired 与「定期」两列相等」才是判据,绝对数字只是历史。这套代码在 TreatWarningsAsErrors=true 下编译 0 警告 0 错误,上面两行都是真跑出来的。
输出怎么读,三种典型组合就够:
expired与「定期」相等、DBSIZE平稳:全部由定期删除完成、无读流量,健康。- 两者差值持续变大、
time_cap也涨:惰性删除在承担主要工作,说明这批键正被高频访问;要警惕「访问一停,残留立刻堆积」。 - 两者差值大、
time_cap不涨:惰性在干活、定期几乎不作为,通常是冷热极端分层(少数热键被反复访问,绝大多数冷键连游标都没扫到);这时看expires规模与hz,别去看 effort。
5.4 监控与告警
| 指标 | 告警判断 | 别踩的坑 |
|---|---|---|
expired_keys |
增速低于写入速率 → 回收跟不上 | 累计量,看斜率不看绝对值 |
expired_keys_active |
与上者差值 = 惰性贡献(仅主库) | 从库上口径失真 |
expired_time_cap_reached_count |
持续上涨 → 慢循环撞满配额 | 不涨不代表跟得上 |
expire_cycle_cpu_milliseconds |
增速接近 CPU 预算(hz=10 下约 250ms/秒) |
这才是 CPU 的正确口径 |
DBSIZE |
长期高位不降 | 先排除秒级暂态与 CLIENT PAUSE 窗口 |
subexpiry / expired_subkeys |
字段级残留是否在涨 | 键级指标看不见它 |
5.5 灰度与回滚
改动顺序固定:先上监控(一版只读看板)→ 再灰度 TTL 抖动(只改写入侧,最容易回滚)→ 观察一周 → 才动 effort → 最后才考虑 hz。回滚条件写死:expire_cycle_cpu_milliseconds 增速超过预期 1.5 倍、或 P99 延迟抬升超过 20%、或 lazyfree_pending_objects 持续上涨,任一命中即回滚上一步。别把三个旋钮一起改,否则你无法判断是哪一项带来的变化。
灰度期间要盯三张曲线,不是一个数值:expired_keys 的增速(对不对得上写入)、expire_cycle_cpu_milliseconds 的斜率(吃不吃得消)、P99 延迟(业务有没有感)。三者里任意一条恶化,就说明这一步的收益不抵成本——先回退,再分析,别在原地叠加第二个改动。
六、开销:三个可以直接引用的数字
① CPU 天花板:timelimit = slow_time_perc × 1e6 / hz / 100 微秒。hz=10、effort=1 → 每轮 25ms、每秒 10 轮 → 250ms/秒 = 单核 25%;effort=10 → 每轮 43ms → 43%。两个必须写进 SLO 的修正项:
- 配额每 16 轮才检查一次,实际占用会略超。effort=1 时最多少查
16×20=320键,effort=10 时最多16×65=1040键; - 快循环另算:每次 ≤1000µs(effort=10 为 3250µs),两次之间只要求间隔 2 倍时长,理论上限约 50%,与慢循环极端叠加可到 ~75%。「过期最多占 25%」只能当常态上界。
什么业务形态真会顶到 43%:TTL 密度高 + 写入持续的场景,会话、短链、限流计数都算,因为每轮都能扫到足量过期键、repeat 一直成立。反过来,TTL 稀疏的实例即使 effort=10,一轮扫 65 个键就结束了,预算根本用不满。判断很直接:看 expire_cycle_cpu_milliseconds 的增速是不是接近预算值。接近,说明打满了;远低于,说明没活干,这时候提 effort 是浪费。
② 清理吞吐:保守取 7 万键/秒(两次实测落在 6~14 万)。换算很好用:1 万键 ≈ 0.15s、10 万 ≈ 1.4s、100 万 ≈ 14s。注意这是净减速率,里面含到期和删除两部分,别当纯吞吐写进容量模型。
③ 内存:每个挂 TTL 的键,expires 额外约 26~32 字节(估 30)。测法只有一条——同一批键在「无 TTL / 有 TTL」两态各读一次 used_memory,差值除以键数:
# 清库并记基线(用 used_memory 字节数,不用 _human,避免单位换算误差)
redis-cli -p 6379 FLUSHALL
BASE=$(redis-cli -p 6379 INFO memory | awk -F: '/^used_memory:/{print $2+0}')
# 写 10 万个不带 TTL 的键(用 Lua 批量,避免 10 万次往返)
# 预期输出:1
redis-cli -p 6379 EVAL "for i=1,100000 do redis.call('SET','k'..i,'v') end return 1" 0
NO_TTL=$(redis-cli -p 6379 INFO memory | awk -F: '/^used_memory:/{print $2+0}')
# 只给这批键挂远期过期(PEXPIREAT 到 2100-01-01),其它一概不动
# 预期输出:1
redis-cli -p 6379 EVAL "for i=1,100000 do redis.call('PEXPIREAT','k'..i,4102444800000) end return 1" 0
WITH_TTL=$(redis-cli -p 6379 INFO memory | awk -F: '/^used_memory:/{print $2+0}')
# 差值除以键数 = 单键的 expires 开销
awk -v a="$NO_TTL" -v b="$WITH_TTL" 'BEGIN{printf "单键 %.1f 字节\n", (b-a)/100000}'
实测:同机紧邻两轮 25.7 / 26.0 字节,换机复跑 31.7 字节(10 万键差值 3,173,132)。我原先按 26 这个数写进文档,换台机器一跑成 31.7,只能把口径改成区间。差异来自 expires 桶数取整与 rehash 进度(主体是 dictEntry 24B + 桶指针 8B,取整余量 0~8B 浮动),所以按 26~32、估 30 更稳。100 万挂 TTL 的键,光 expires 就 约 25~32MB;MEMORY STATS 没有 expires 专项,只能差量测或按 30 字节估。跑完把键 PERSIST 掉,内存会回落到无 TTL 水平附近,差几 MB 分配器碎片属正常。
把三笔账合成一张预算表才算落地。举例:1 亿键、其中 5% 挂 TTL(500 万)、value 平均 200B:
| 账目 | 算法 | 结果 |
|---|---|---|
expires 额外内存 |
500 万 × 30B | ≈150MB |
| 全量删除耗时 | 500 万 ÷ 7 万每秒 | ≈71 秒 |
| 残留内存峰值 | 已过期未删的键 × 200B | ≈1GB 双重占用 |
三个数字里最容易被漏掉的是第三个:这 71 秒里键还占着内存,而容量规划通常按「已过期即释放」算,等于凭空多算了 1GB 余量。只算其中一个数字,等于没算。
这三笔账要直接进 SLO 与容量评审,而不是留在文章里:CPU 那笔写进「单实例后台开销上限」,吞吐那笔写进「过期风暴恢复时间」,内存那笔写进「高水位预留」。三笔都写成「与键数、TTL 比例相关」的公式,评审时才能随业务量一起滚。
说到底,惰性加定期这套东西,是用「删除时机不确定」换「CPU 开销可控」。接受这个不确定,用 TTL 抖动、active-expire-effort、Lazy Free 管副作用,比逼 Redis 准点删除现实得多。
七、最容易踩的八条坑
| # | 坑 | 纠正 |
|---|---|---|
| 1 | 「过期了内存就释放了」 | 逻辑过期 ≠ 物理删除,残留窗口内照占内存,且计入淘汰判定 |
| 2 | 「定期删除是随机抽 20 个」 | 沿游标扫桶,桶上限 num×20,一圈可能分钟级;积压越多清得越快 |
| 3 | 「调 hz 能加快过期」 |
优先 effort(只管过期);hz 全局且超 500 被静默夹取 |
| 4 | 「CONFIG SET 回 OK 就生效了」 |
必须 CONFIG GET / INFO 回读,两者在越界行为上完全相反 |
| 5 | 「time_cap 涨了才是跟不上」 |
反例:hz=1 全程 0 仍有秒级滞后;CPU 看 cpu_ms |
| 6 | 「effort 调高 time_cap 会更高」 |
实测反向(42 → 21):轮次变少、单次变长 |
| 7 | 「从库 DBSIZE 大就是有问题」 |
只读从库不自删(须冻住主库才观察得到);可写从库会自删;容量以主库为准 |
| 8 | 「过期事件可以当定时器」 | 只在真正被删时发、受游标周期影响、发后即忘;准点动作走调度器 |
这八条的共同点是不对着指标就发现不了,静态读文档读不出来。所以每条后面配一个发现方式,比记结论有用:① 看 used_memory 与 expires 是否同步下降;② 画 expired_stale_perc 曲线看呼吸节奏;③ 对比 hz 改动前后的 P99;④ 每次 CONFIG SET 后强制读一次 CONFIG GET 并留痕;⑤ 把 time_cap 与 cpu_ms 放进同一张图;⑥ 做一次 effort 前后对照实验;⑦ 主从 DBSIZE 分开看板,容量告警只挂主库;⑧ 搜业务代码里有没有 keyspace 订阅。
还有六个流传很广的说法,实测都不成立:①「hz 最大 500,所以填 1000 也行」——填 100000 也回 OK,但值是 500;②「effort 越界也会被夹取」——恰恰相反,直接报错;③「HTTL 返回毫秒」——返回秒,毫秒看 HPTTL;④「HEXPIRE 只返回 0/1」——还会返回 −2(字段不存在),HPERSIST 成功返回 1 后 HTTL 变 −1;⑤「DEBUG SLEEP 可以模拟阻塞」——默认被禁且会冻结定期删除,实验结论全废;⑥「DBSIZE 就是内存里的键数」——只读从库、字段级过期、CLIENT PAUSE 都会让它失真。
八、小结与去向
- 没有定时器:三条清理通道 + 一条传播,全部在主线程,任何「准点删除」假设都站不住。
- 逻辑过期 ≠ 物理删除:残留窗口秒级(20 万键 2~3.5 秒,速率 6~14 万键/秒),看
expired_keys+DBSIZE且先排除暂态。 - 冷键靠定期,热键靠惰性;定期的周期由「游标一圈」决定,10 万键约 8 分钟、100 万约 83 分钟。
- 调参有优先级:
effort→lazyfree→ 最后才是hz;热改必须回读,且两者越界行为相反。 - 从库分两态:只读不自删、可写自删;
expired_keys − expired_keys_active只在主库成立。 - 过期风暴的病因在 TTL 设计:抖动打散、热点走逻辑过期;容量校验用「同时到期键数 ÷ 7 万/秒」。
- 过期事件不是定时器:准点动作走调度器 / Stream / 延迟队列。
- 成本三笔账:
expires每键 26~32 字节、残留窗口的双重占用、删除峰值 CPU(25%~43%,快循环另算)。
结论在什么条件下会被推翻,也写清楚,免得被当成永远成立的定律:
- 如果 Redis 引入基于定时器/时间轮的精确过期并默认开启,「删除时机不确定」这条就不再成立;
- 如果只读从库被允许自己执行惰性/定期删除(当前源码明确不允许),从库两态那一节作废;
- 如果
active-expire-effort的四个参数推导被改动(公式在expire.c顶部,改一行就变),第三章的表格需要重算; - 如果字段级过期的预算机制从「
10000/hz+ 最多 32 倍放大」换成别的策略,2.4 的速率断言需要重测。
只要这四条没动,文里的数字与判据就能直接引用,但要带上环境标注:8.10.3、单机、空库起步、单实例非集群。
下一篇讲淘汰:8 种淘汰策略怎么选才不丢数据。分界线很清楚:本篇讲「已过期的键什么时候被删」,下一篇讲「内存到顶时,没来得及过期的键里淘汰谁」。两者在 volatile-* 策略上交汇:淘汰依赖过期键的存在,但判定与执行是另一套机制。本篇留下的 expired_keys 与 evicted_keys 口径之别,正是下一篇的入口。

浙公网安备 33010602011771号