开篇:四组输出,两条铁律

多数人理解的 EXPIRE key 60 是「60 秒后这个键消失」。语义层面大致对,实现层面完全错:Redis 登记的是「这个键在哪个绝对时刻到期」,不是「还剩多少秒」。这一个设计决定派生出了后面所有的坑,也决定了 TTL、EXPIRETIME、主从复制、过期事件这些看似无关的东西为什么互相咬合。

先看四组输出,每组都能推翻一个想当然。

现象一:两个负数,两件完全不同的事

# 键不存在:TTL 返回 -2
TTL not-exist:key

# 键存在但没有过期:先写一个不带 EX 的键
SET keep:me v

# 返回 -1:键在,永久驻留
TTL keep:me

线上最常见的误判是把 -1 当成「查不到」。它其实是「查到了、没有过期」;-2 也常被当成异常抛出去,其实是「这个键确实没了」。这两个值在监控口径里必须分开统计。

现象二:能直接读出那个绝对时刻

# 写一个约 27.8 小时后到期的键
SET kk vv
EXPIRE kk 100000

# 服务端登记的到期秒戳:此后固定不变
EXPIRETIME kk

# 同一时刻的毫秒表示,末三位为 000
PEXPIRETIME kk

# 由「到期时刻 − 当前时刻」算出,此刻约 99999879
PTTL kk

返回的是一个 Unix 时间戳(实测 1794848482),不是「还剩 100000 秒」。隔几秒再查,两个 *EXPIRETIME 纹丝不动,只有 PTTL 在变小:一个写死的时刻,一次实时减法。

EXPIRETIME 是 7.0 才有的只读命令,价值在于「审计而不打扰」:想确认某个键到底登记了哪个时刻,用它回读一次就够,不需要开 AOF、再去增量片段里翻 PEXPIREAT 那一行、把 13 位毫秒戳换算回秒。线上排查「这个键为什么提前没了」时,先 EXPIRETIME 回读、再和下发值比对,能立刻区分「下发时就算错了」和「存进去之后被改过」。

现象三:没人碰它,剩余时间照样变少

# 100 秒过期,立刻读
SET rr vv EX 100
TTL rr

# 让服务端单线程阻塞 2 秒:期间不处理任何命令
DEBUG SLEEP 2

# 醒来再读:期望 98,不是 100
TTL rr

DEBUG SLEEP 期间没有任何后台任务在递减,剩余时间却少了 2 秒。同一个结论可以用停机实验复核:写一个 100 秒过期的键,SAVE 落一次盘再 SHUTDOWN,等几秒重启,TTL 会正好少掉停机的那段时间(前提是开了 RDB 或 AOF,否则键直接丢失)。停机期间没有任何进程在跑,时间却计入了。唯一解释是:一头存着绝对时刻,一头拿当前系统时间做减法。

这也是「时钟回拨」成为真实故障的原因:把系统时间往回调 5 分钟,一批本该失效的键会重新「活过来」。Redis 对此不做特殊处理,时钟正确性属于基础设施的职责。

现象四:从库上 TTL 已经是 -2,DBSIZE 却还把它算进去

这个要额外条件才能稳定复现,留到第二节用 DEBUG SET-ACTIVE-EXPIRE 拆开看。

四组现象收束成两条铁律:

  1. 存的是绝对到期时刻,不是剩余秒数。 所以停机照走、主从靠同一个时刻对齐、TTL 每次都要现算。
  2. 「判定为过期」与「物理删除」是两件事。 读命令先判定后返回,删除另有一套触发路径;从库只判定、不删除。

这几条可以直接写进设计文档:

  • 到期判定绑定系统时钟:时钟由基础设施负责(NTP 监控 + 回拨告警),这一条 Redis 不保证。
  • 过期只保证回收,不保证准点:删除可能延迟,过期事件可能延迟甚至丢失,把它当定时器早晚出事。
  • 需要「到点必失效」的正确性:在值里再存一个业务过期字段,读取时二次校验;TTL 只当回收手段。

这篇只解一个链条上的问题:从执行 EXPIRE 到键消失,中间存了什么、算了什么、传了什么。删除策略与 CPU 代价是 S3-2 的范围;淘汰策略(maxmemory-policy)是另一种「键消失」的原因,S3-3 单独讲;DEL 大键的代价在 S3-4;持久化加载阶段的过期处理在 S5-5。读本篇时如果出现「键怎么突然没了」的疑问,先分清是过期、淘汰还是被显式删除。三者的现象很像,排查入口完全不同。

一、机制:存的是一个时刻,判的是一个差值

1.1 存什么:一个 64 位毫秒戳

EXPIRE k 60 执行时,主线程算出 now + 60 秒 的绝对毫秒时刻,写进 db->expires 字典:键名 → when。没有定时器对象,没有每秒回调,也不存在「剩余秒数」这个字段。

由此能直接看出几件事:设置与查询都是 O(1)(一次哈希查表);重启后时间戳依然有效,不存在「内存里的计时器被清空」的问题;TTL 每次都要现算,读的不是某个递减中的计数器。

代价是每个带过期的键会在 expires 字典里多占一个条目:一次哈希表登记的开销,加上 8 字节时间戳。这部分成本与 TTL 长短无关,只与「多少键设了过期」线性相关;也正因为它是独立字典,清 TTL 才只是删一条记录,而不是去改值对象。

1.2 判什么:判定与删除是两条路径

读命令拿到 -2、nil,是判定结果;DBSIZE 还把它算进去,是物理状态。两者不一致是设计如此,故障排查时别把它当成主从不一致。

那没人访问的键谁来删?定期删除。它按 hz 频率触发,每次只抽一部分带过期的键,抽样比例与上限都是硬编码的,命中过期就删、删完继续抽,直到这一轮的时间预算用完。所以过期键的清除本质上是概率行为:采样没扫到的键会继续占着内存,等下一次触发或等一次读命中。这一点直接决定了「批量到期」时主线程会出现毛刺,代价的量级见第五节。

加载路径另有一套规则:RDB / AOF 加载阶段的过期键处理,主库与从库的行为并不相同(从库不主动删,因此加载时会保留业务上已过期的键,等主库传播删除)。这块属于持久化篇章的范围,本篇只提醒一句:别用「加载后键还在」来反推 TTL 没生效。

1.3 传什么:同一个绝对时刻

主库把相对时长改写成绝对时刻写进复制流与 AOF:EXPIRE 家族 → PEXPIREAT k <绝对毫秒>;SET ... EX → SET k v PXAT <绝对毫秒>。这不是转述,是在从库上 MONITOR 抓到的原文:

# 主库执行 SET m1 v EX 60,从库收到:
"SET" "m1" "v" "PXAT" "1794747852026"

# 主库执行 EXPIRE m1 100,从库收到:
"PEXPIREAT" "m1" "1794747892062"

为什么非改写不可:如果传的是 EXPIRE k 60,主从两端会因为网络时延各自得到不同的到期时刻,从库的时间线就和主库错开了。传同一个时刻,从库不需要知道「这条命令走了多少毫秒」。

其余会进复制流的动作只有三类:清 TTL(PERSIST,传播为 PERSIST 本身)、删除(DEL / UNLINK)、改名(RENAME,改名后新键名继承原时刻)。由此可以估出复制放大:每条续期命令对应一条复制流记录,每秒续一次的会话在百万活跃会话下就是每秒百万条写命令,这个数字在设计评审时就要算出来,而不是等 master_repl_offset 曲线打脸。观测手段是现成的:INFO replication 看连接与延迟,连续两次采样 master_repl_offset 做差,差值就是这段时间写进复制流的字节量。

1.4 状态流转:四种态,三类终点

四个态是:键不存在(TTL = -2)、存在无过期(-1)、存在且登记了过期(正整数)、已过期但未被删除(TTL 读作 -2、物理记录仍在)。第一、二、三态之间的迁移由显式命令驱动,第四态是「判定已过期、物理还留着」的中间态,只在主库「到期但尚未被删」和从库「等主库传播删除」时出现。

这个状态图用来排查:TTL 读 -2 却 DBSIZE 还在计数,说明处在第四态的前半段;TTL 从 100 突然跳到 -1,说明中途被裸写覆盖过;TTL 一直是固定值不变、PTTL 也不变,说明读的根本不是同一个键名。三种现象分别对应三类不同的问题,用同一张图就能定位到具体环节。

二、主从:-2 与 DBSIZE 打架的那几秒

现象四的复现需要关掉主库的主动过期,否则后台任务会在你观察之前就把键删掉:

# 空库起步,否则下面的 DBSIZE 绝对值对不上(相对变化仍一致)
FLUSHALL

# 主库:关闭主动过期,让到期键留在内存里
DEBUG SET-ACTIVE-EXPIRE 0

# 写一个 2 秒后到期的键
SET rt hello PX 2000

# 等 4 秒不读它,然后看主库计数:仍是 1,没人删
DBSIZE

# 从库读:逻辑上已过期,返回 nil
GET rt

# 从库 TTL:-2,命令视角键不存在
TTL rt

# 但物理记录还在:从库计数仍是 1
DBSIZE

# 回主库读一次,触发惰性删除,删除命令随后传播
TTL rt

# 稍等再查从库:计数降到 0
DBSIZE

同一个键,命令视角已经没了,物理记录还在,为什么?实测结果与注释中的期望值一致(空库起步):主库 DBSIZE 为 1,从库 GET 返回 nil、TTL 返回 -2、DBSIZE 仍为 1;主库读一次 TTL 触发惰性删除,一秒后两端 DBSIZE 都归零。实验结束务必恢复 DEBUG SET-ACTIVE-EXPIRE 1,否则测试实例的过期键会一直堆积。

这几条要落进流程:

  • 业务有效性一律用 GET / EXISTS 判,不要用 DBSIZE 反推;容量监控要把「逻辑已过期但物理还在」的那部分偏差单独扣掉。
  • 一致性敏感的读走主库,从库读到 nil 不代表主库也没有。
  • 过期事件同理不可靠:expired 事件在键被真正删除的那一刻才发,删除可能来自一次读命中,也可能来自后台抽样,与到期时刻不是同一件事;Pub/Sub 又是发后即忘,订阅端断连期间的事件全部丢失。

主从这块还有两件事要说明。故障转移:从库被提升为主库时,expires 里登记的时刻是随复制流一起同步过来的,所以提升之后 TTL 不需要重新设置,也不会因为「换了主」而延长或缩短;但那些「逻辑已过期、物理还在」的键会在新主库上继续存在,直到被读到或被抽样到。写入侧:expires 条目由主库写入、从库被动接收,从库自己不会因为「时间到了」去改这个字典,这也是从库 DBSIZE 长期偏大的根源。

需要「续期命令必须到达至少一个从库」的强一致场景,可以在续期后跟一条 WAIT 1 100(等待 1 个副本确认,超时 100 毫秒),但代价是每次续期多一个往返的等待时间;会话类场景通常不需要,因为会话丢了重新登录即可恢复。

复制延迟带来的偏差也要说清楚:从库上的 TTL 是按从库自己的时钟、对同一条登记时刻计算出来的,因此一旦有复制延迟,从库就会比主库更早判定过期,链路越慢提前得越多;但只要主库还没删,从库的 DBSIZE 仍会计数。这个偏差在秒级内通常无害,在跨机房链路(几十到几百毫秒延迟)上会让「缓存还有 1 秒」变成「从库已经读不到」,从而触发缓存击穿。缓存击穿的防护属于 S11-5 的范围,这里只给判断依据:到期前的那一小段窗口,别让流量打到从库。

三、命令怎么写,才不会把 TTL 弄丢

先把命令认全,再谈规则。下表只留与键生命周期相关的部分,版本列为起点版本:

表里 SET ... EXAT/PXAT 那一行容易漏看。绝对时刻这条路在写入侧就能落地,不必「先 SET 再 EXPIRE」两步。

3.1 条件选项比的是到期时刻

EXPIRE k 秒 [NX|XX|GT|LT] 是 7.0 新增的能力。「更晚才生效」这类业务语义,用 GT 表达最省事,但它的比较基准常被误解:

# 先造一个 100 秒过期的键
SET k3 v EX 100

# NX:只在键没有过期时间时才设置,此处失败,返回 0
EXPIRE k3 200 NX

# GT:新到期时刻更晚才生效,返回 1,TTL 变成 300
EXPIRE k3 300 GT

# GT:60 秒比现有的 300 秒更早,拒绝,返回 0,TTL 仍 300
EXPIRE k3 60 GT

# 换一个没有过期时间的键:GT 把它视为「无限远」,返回 0
SET k4 v
EXPIRE k4 100 GT

# LT 与无限远比较必然成立,返回 1,TTL 变 100
EXPIRE k4 100 LT
TTL k4

最后两条要留意:GT 对没有过期时间的键视为无限 TTL,所以永远返回 0。麻烦的是这恰恰是线上最常见的场景——别的服务一次裸 SET k v,TTL 没了,你这边的续期代码执行 EXPIRE ... GT,返回 0,日志里什么都看不出来,会话到点失效。开篇那个「从库 -2、主库还在」的现象,在业务层就是这个样子。四个选项互斥,一次只能给一个。

补救的办法是把 NX 挂在 GT 失败之后:

# 裸写冲掉 TTL:覆盖写会把过期时间一并清掉
SET se:v v2
TTL se:v

# 此时用 GT:无过期时间,返回 0,续期失败
EXPIRE se:v 1800 GT

# 改用 NX:键没有过期时间,条件成立,返回 1
EXPIRE se:v 1800 NX
TTL se:v

NX 在「本来就没有 TTL」的键上成功,在「已有更长 TTL」的键上失败,正好接住 GT 漏掉的那一类。反过来不行:XX 在无 TTL 的键上返回 0,拿它当补挂手段只会静默失败。因此续期逻辑的标准写法是「先 GT,返回 0 再 NX」,而不是依赖客户端自己判断。

3.2 TTL 是四舍五入到秒

TTL 的计算口径是 (剩余毫秒 + 500) / 1000 向下取整,即四舍五入。由此得出两个反直觉的边界:剩余毫秒少于 500 时返回 0,但键还在;剩余 500 到 1499 毫秒时返回 1。把 TTL == 0 当成「已过期」是线上误删缓存的高发原因。

# 400 毫秒:TTL 返回 0,但键仍然可读
SET t1 v
PEXPIRE t1 400
TTL t1

# 900 毫秒:TTL 返回 1,四舍五入的结果
SET t2 v
PEXPIRE t2 900
TTL t2

# 1400 毫秒:PTTL 约 1362,TTL 仍是 1
SET t3 v
PEXPIRE t3 1400
PTTL t3
TTL t3

判读规则记两条:要判断「还剩多少」用 PTTL,不要用 TTL;要判断「还在不在」用 EXISTS 或 GET,不要用 TTL。TTL = 0 是一个 1 秒以内的窗口,不是一个终态。

3.3 覆盖写会清掉 TTL,KEEPTTL 留得住

SET 重建整个键,过期时间一并丢失。缓存更新逻辑里最常见的漏 TTL 就是这一下。6.0 给了 KEEPTTL,6.2 给了 EXAT / PXAT,两种都能避开这个坑:

# 有 100 秒过期,覆盖写之后 TTL 归 -1
SET c1 v1 EX 100
SET c1 v2
TTL c1

# 带上 KEEPTTL:TTL 保持 100
SET c2 v1 EX 100
SET c2 v2 KEEPTTL
TTL c2

# 只改内容的 INCR 完全不碰 TTL
SET c3 1 EX 60
INCR c3
TTL c3

# PERSIST:无过期时返回 0,有则返回 1 且 TTL 变 -1
PERSIST c3
PERSIST c3
TTL c3

机制上并不神秘:SET 的实现路径是「删掉旧键、写入新键」,删键顺带清掉 expires 里的条目;KEEPTTL 只是让它在写入前先把旧时刻读出来,写完再登记回去。INCR、APPEND、HSET、LPUSH、SADD、ZADD 这类原地修改完全不重建键,因此 TTL 天然不受影响(这一点逐个实测确认过)。

3.4 按「是否重建键」归类

两个容易忽略的返回值:EXPIRE k 0、EXPIRE k -1、以及指向过去时刻的 EXPIREAT,都返回 1 并立即删键。这里的 1 表示「命令成功」,不表示「键进入了倒计时」。这类删除发出的是 del 事件而不是 expired 事件,靠 expired 做业务补偿的链路会漏掉这一批。

还有两个单位陷阱:EXPIREAT 吃秒、PEXPIREAT 吃毫秒,传错会把「若干年后过期」变成「刚才已过期」,键当场消失;EXPIRE 与 PEXPIRE 同理。跨服务传时间戳时,要么全程毫秒,要么在字段名里把单位写出来。

3.5 工程侧容易出错的地方

GETEX 的实际用法两者都验证过:GETEX k PERSIST 之后 TTL 为 -1,GETEX k EX 500 之后 TTL 为 500。它适合「读会话时顺手续期」,省一次往返。

# 写入 100 秒过期的会话键
SET gx v EX 100

# 读并清掉过期:TTL 变 -1
GETEX gx PERSIST
TTL gx

# 读并把过期重设为 500 秒:TTL 变 500
GETEX gx EX 500
TTL gx

SET 一侧还有一处容易忽略:NX 与 XX 互斥,KEEPTTL 与 EX/PX/EXAT/PXAT 互斥(同时给会报语法错误,而不是悄悄忽略其中一个)。「只在不存在时创建、并带过期」的标准写法是单条 SET k v NX EX 300(判定与登记压在一个原子动作里),比 SETNX 再 EXPIRE 两步可靠。

3.6 一次往返还是两条命令:SET ... EX 的取舍

写入并设过期有两种写法:SET k v EX 60 一条,或者 SET k v 之后再来一条 EXPIRE k 60。两者的差别不在语法,而在这条键在两次往返之间的状态:

  • 单条命令:键要么不存在,要么带着完整的 TTL 存在,不存在「已写入但还没过期时间」的中间态。并发读者不会读到永久键。
  • 两条命令:两次命令之间,键已经可读、且 TTL 为 -1。窗口很短(一个 RTT),但对「读到一个本应 60 秒后失效却永久驻留」的缓存来说,足以留下脏数据;如果第二条命令因为客户端异常而没发出去,这个键就永久留下来了。

因此默认选单条:能用 SET ... EX 就不要拆两步,能用 SET ... EXAT 就不要「写完之后再算时刻」。后者还要多做一次时钟换算,凭空引入一层时钟偏差。只有在「写入与设置过期分属不同代码路径」(例如写入在数据访问层、过期策略在缓存层)时才拆开,这时应显式补上 EXPIRE ... NX 兜底,并对「返回 0」的情况打日志,而不是静默略过。

四、落到业务:几个场景里的取舍

4.1 会话滑动续期:GT 优先,NX 兜底

会话续期的语义是「至少活到 N 秒后,更长的保留更长的」,对应 EXPIRE ... GT。但裸写会冲掉 TTL,GT 随后必然失败,所以代码里要显式处理两种状态:

using StackExchange.Redis;

/// 
/// 会话 TTL 的操作封装。核心是「续期只延长不缩短」,以及裸写之后的自愈。
/// 
public sealed class RedisSessionStore
{
    private readonly IDatabase _db;
    private readonly TimeSpan _window;

    public RedisSessionStore(IConnectionMultiplexer mux, TimeSpan window)
    {
        // 连接串取自配置,形如 127.0.0.1:6379;StackExchange.Redis 不接受 redis:// 前缀
        _db = mux.GetDatabase();
        _window = window;
    }

    /// 
    /// 续期会话:到期时刻只会被推迟,不会被提前。
    /// 
    public async Task TouchAsync(string sessionId)
    {
        var key = $"sess:{sessionId}";

        // 优先用 GT:只有在「新到期时刻更晚」时才改写,避免并发续期互相缩短
        var extended = await _db.KeyExpireAsync(key, _window, ExpireWhen.GreaterThanCurrentExpiry);

        // 返回 false 有两种可能:键不存在,或键存在但没有 TTL(裸写冲掉过)
        if (!extended)
        {
            // 用 NX 补挂:对「没有 TTL 的键」生效;键不存在时同样返回 false
            extended = await _db.KeyExpireAsync(key, _window, ExpireWhen.HasNoExpiry);
        }

        return extended;
    }
}

这段代码有两个判断点:GreaterThanCurrentExpiry 保证并发续期时不会被后到的小窗口截短;HasNoExpiry 接住「其它服务裸写导致 TTL 丢失」这一类故障,让 TTL 自愈而不是等会话失效。实测路径:同值续期返回 True,从 60 秒续到 1800 秒返回 True 且 TTL 为 1800,裸写之后走 NX 分支把 TTL 补回 1800,键不存在时返回 False;反过来把 3000 秒的键「续」成 1800 秒会返回 False、TTL 保持 3000。这就是「只延长不缩短」的直接证据。

续期失败的三种处理方式,按业务容忍度选,不要混用:重试:网络抖动导致的失败,隔几十毫秒重试一次通常能成功,但要设上限,避免把偶发失败变成放大流量。降级:续期失败即视为会话不可续,让用户重新登录,比「假装成功」安全。告警:键不存在(而不是条件不满足)大量出现,说明上游写入路径出了问题,这类要打点上报,不能只返回 False。线上最危险的做法是忽略返回值:调用方以为续上了,用户却在十分钟后被踢出登录。

4.2 缓存更新:默认带上 KEEPTTL

缓存更新走 SET 就会丢 TTL,于是「刚写的热点数据永不过期」这类问题反复出现。更隐蔽的是另一个变体:写的时候带了 EX 600,看着没问题,但这条 SET 把「原本还剩 3000 秒」改成了「现在起 600 秒」。更新动作意外缩短了缓存寿命,低峰期表现为缓存命中率断崖。

using StackExchange.Redis;

/// 
/// 缓存写入的统一入口:默认保留既有 TTL,只在首次创建时设过期。
/// 
public static class CacheWriter
{
    /// 
    /// 写入缓存值。已存在的键保留原 TTL,新键按 ttl 登记过期。
    /// 
    public static async Task WriteAsync(IDatabase db, string key, string value, TimeSpan ttl)
    {
        // 先用 SET ... KEEPTTL 覆盖:已存在的键保留原到期时刻,不会因为更新而延长或缩短
        await db.StringSetAsync(key, value, keepTtl: true);

        // KEEPTTL 只在键已存在时才有意义;返回值无法区分「新建」与「更新」,因此再判一次 TTL
        var ttlNow = await db.KeyTimeToLiveAsync(key);

        // TTL 为 null 说明键没有过期时间(新建或曾被裸写),此时补挂
        if (ttlNow is null)
        {
            await db.KeyExpireAsync(key, ttl);
        }
    }
}

这段代码没有追求「一次往返搞定」,因为 KEEPTTL 与 EX 互斥,无法合并成一条命令。真正的取舍在于:更新保留原寿命,是为了让缓存的过期时刻由首次写入决定,不被后续更新反复推后。否则热点数据会因持续更新而永不失效,退化成「缓存即数据库」。若业务确实需要「更新即续期」,那是滑动过期语义,应显式用 EXPIRE ... GT,而不是在 SET 里随手带 EX。

4.3 验证码:一次性消费靠 GETDEL,不靠 TTL

验证码的正确性要求是「读一次即失效」;TTL 只负责「过期回收」,两者不是一回事。GETDEL(6.2+)把读与删合成一个原子动作:

# 写入验证码,5 分钟有效
SET sms:13800000000 849201 EX 300

# 第一次读:返回值并删除键,天然防重放
GETDEL sms:13800000000

# 第二次读:键已不在,返回 nil
GETDEL sms:13800000000

实测第一次返回 "849201",第二次 (nil)。若目标版本低于 6.2,退回 MULTI/EXEC 包住 GET + DEL,或写一段 Lua 脚本;用 GET 之后再 DEL 的两条独立命令会在并发下被重放。TTL 在这里只是清理残留(用户没来验证时别让键永久占内存),不是安全边界。

4.4 跨服务对齐:下发绝对时刻,不下发秒数

多服务协同的场景(活动开始/结束、库存释放、对账单截止),各服务时钟不一致,下相对秒数会让各端得到不同到期时刻。正确做法是统一在服务端算好绝对时刻:

# 先写入键(这里给 60 秒,稍后被绝对时刻覆盖)
SET promo:double11:stock 120 EX 60

# 业务日界:次日 00:00 的 Unix 秒戳,由调用方按业务时区算出
# 下面这个值对应 2026-11-17 00:00(Asia/Shanghai)
EXPIREAT promo:double11:stock 1794844800

# 回读:与下发值完全一致,证明存的就是这个时刻
EXPIRETIME promo:double11:stock

# PEXPIRETIME 末三位 000,说明秒级时刻被存成毫秒
PEXPIRETIME promo:double11:stock

实测中 EXPIRETIME 回读正是下发的那个秒数,PEXPIRETIME 是它的毫秒形式。要点是:调用方算日界必须用业务时区(如 Asia/Shanghai),而不是服务器本地时区;服务端只负责登记,不参与换算。

4.5 过期事件:只做旁路通知,不做补偿

过期事件是「删除之后的通知」,不是「到期时刻的闹钟」。要收到它,服务端得开启通知:CONFIG SET notify-keyspace-events "Ex"(E 是键事件、x 是过期类),回读会看到 xE。订阅端写法如下:

using System;
using StackExchange.Redis;

/// 
/// 订阅过期事件的示例:只做旁路通知,不做业务补偿。
/// 
public static class ExpiredEventSubscriber
{
    /// 
    /// 订阅 __keyevent@0__:expired 通道,回调里只做轻量通知。
    /// 
    public static void Subscribe(IConnectionMultiplexer mux)
    {
        var sub = mux.GetSubscriber();

        // 通道名是固定格式:__keyevent@<库号>__:<事件名>,库号必须与业务使用的库一致
        sub.Subscribe(RedisChannel.Literal("__keyevent@0__:expired"), (channel, key) =>
        {
            // 回调跑在客户端线程池里,耗时操作必须转队列,否则拖慢整个订阅连接
            Console.WriteLine($"键已删除:{key}");

            // 这里不要写「补偿库存」「发送通知」之类的业务动作:事件可能丢失、可能重复、可能晚到
        });
    }
}

还有三种情况要留意。事件在真正删除的那一刻才发,而删除由「读命中」或「后台抽样」触发,因此与到期时刻不是同一件事;Pub/Sub 是发后即忘,订阅端断连期间的键事件全部丢失,重连后也不会补发;单个键的删除可能被 DEL 触发,此时发出的是 del 而非 expired(EXPIRE 传非正数就属于这一类)。所以让它做缓存失效通知、做审计流水;承担「必须执行」的业务补偿,得用延迟队列加幂等消费。

4.6 什么时候可以放心依赖 TTL

四个问题全答「是」,TTL 就可以放心用;有一条答否,就得在值里加业务字段兜底。这套判断比记「TTL 设多少秒」更有用。TTL 的长度是业务参数,上面四条才是机制边界。

五、这套用法要付多少内存和带宽

机制讲完,落地前得知道自己要付什么。TTL 的成本不在设置那一刻(登记一条记录几乎免费),而在内存的常驻开销、复制流的持续增量、批量到期时的主线程毛刺。

内存:每个带过期的键在 expires 字典里多一条记录,与 TTL 长短无关,只与「多少键设了过期」线性相关。想看本环境的真实单键开销,用三次采样:空库记一次 used_memory,批量写入 N 个不带 TTL 的键记第二次,再给同一批键批量 PEXPIREAT 记第三次;第三与第二次的差值除以 N,就是本环境的单键过期登记开销。

复制:每条续期命令对应一条复制流记录(PEXPIREAT 或 SET ... PXAT),键被删除时再加一条 DEL。续期频率乘以活跃会话数就是每秒写命令量,这是复制带宽的主要放大器。

毛刺:大量键在同一时刻到期时,删除动作与传播命令集中出现,主线程会出现可观测的延迟尖刺。缓解手段是给 TTL 加随机抖动打散到期时刻,把「同时到期」变成「一段窗口内陆续到期」。

# 内存基线:空库时的已用内存
INFO memory

# 键空间与过期数量:expires 是登记了过期的键数
INFO keyspace

# 过期与删除的累计计数(8.x 还多一个 expired_keys_active)
INFO stats

# 复制偏移量:隔一段时间再采一次,差值即增量字节数
INFO replication

# 抽样遍历键空间,估带过期键的占比(COUNT 只是提示,不保证一次扫完)
SCAN 0 COUNT 100

INFO keyspace 的输出形如 db0:keys=12,expires=9,avg_ttl=78032864,subexpiry=0:avg_ttl 在 7.x 上恒为 0、8.x 会给出一个采样估算值(实测就是这个八位数量级),两个版本对不上属正常,别拿它当「精确剩余时间」;subexpiry 同样是 8.x 新增字段,7.x 上不会出现。

上线前把三个数写进设计文档:① 带 TTL 的键数峰值(决定 expires 字典常驻内存);② 每秒续期次数(决定复制流写命令量,约等于会话 QPS × 续期频率);③ 到期键数的峰均比(决定抖动窗口,目标压到 2 以内)。这三个数比「TTL 设多少秒」更影响稳定性。

毛刺怎么观测,给两个不要压测也能拿到的信号:SLOWLOG GET 10 看删除与续期命令是否进入慢日志;LATENCY HISTORY expire-cycle 看过期循环的延迟分布(前提是开启了 latency-monitor-threshold)。这两个都是被动观测,不改变生产行为,比造一轮峰值流量安全得多。若确实要做受控实验,做法是写入 10 万个同刻到期的键、在到期前打开 INFO commandstats 前后采样、对比 expire-cycle 相关计数与 P99 延迟。本篇不给数字,因为不同硬件与键大小下差距很大,抄数字比不抄更危险。

三项成本随 TTL 长度的变化方向并不一致,设计时不要只盯着其中一项:

短 TTL 的隐性成本是「写命令多」:每次续期都是一条复制流记录,会话类场景的写放大会被 TTL 长度直接放大;长 TTL 的隐性成本是「到期集中」:所有键在同一个业务时刻失效,尖刺来得越晚但越猛。中间档通常最省心,代价是缓存的新鲜度。

六、线上真会踩的坑与版本差异

6.1 高频坑

坑 7 再说细一点。锁的租期意思是「我还活着」,续期失败就等于这句话不再成立,业务动作要停,不能接着干。TTL 回答不了「这把锁是不是我的」,它只说还剩几秒;要知道是不是自己的,只能比对 value 里的标识。

坑 4 的口径要单独说清楚:DBSIZE 统计的是物理键数,逻辑上已过期的键仍被计入。容量报表用 DBSIZE 会偏大,用 INFO keyspace 的 expires 只能看「登记了过期的键数」,两者都不能回答「有多少键业务上还有效」。

6.2 结论与它们的失效条件

6.3 版本差异速查

版本基线之外的一句话:文中所有返回值都在 8.10.3 上实测,与 7.2 的命令语义一致;差异只在观测字段(上表最后一行)。如果你的目标版本是 7.2,把 INFO 的输出对照着看即可,不必改命令。

6.4 上线前检查清单

这张表可以当评审时的提问清单用:八条里有任意一条答不上来,就说明这套 TTL 用法还没有闭环。

七、怎么选:TTL 与其它失效机制的边界

TTL 只是「让数据自己消失」的一种手段,和它竞争的做法有三类。判断标准不是「哪个更强」,而是「你需要的是回收,还是必须发生的动作」:

四类的组合方式很固定:TTL 负责回收内存,业务字段负责正确性,延迟队列负责必须执行的动作,扫表负责兜底对账。拿 TTL 顶替后两者是线上事故的常见起点。TTL 只承诺「最终会被回收」,从不承诺「在某一刻执行了什么」。

反过来的误用也存在:给每个键都加业务字段、都上延迟队列,成本翻几倍,收益只是把一个「可以晚几秒」的场景做成「精确到毫秒」。判据是第一条:能接受延迟失效的,就只用 TTL;需要到点动作的,就不要指望它。

八、下一篇

过了「什么时候该失效」,接下来的问题是「到点之后谁去删、删得多快、花多少 CPU」:惰性删除只在有人读的时候触发,定期删除靠抽样,抽样比例与 hz 直接决定内存能不能及时回收,也决定主库在批量到期时会出现多大的毛刺。下一篇 S3-2 用同一套实测方法,把三套删除策略的触发条件、代价与调参边界逐条拆开。

本篇能带走的东西:两条铁律与三条不变量(可直接写进设计文档)、四组可复现的命令输出(含主从对照实验)、一段能跑的续期与更新代码(GT + NX 兜底、KEEPTTL + 补挂)。需要速查卡的,私信「TTL速查」。


原文地址: https://www.cveoy.top/t/topic/qHX9 著作权归作者所有。请勿转载和采集!

免费AI点我,无需注册和登录