给 Redis 过期时间加抖动,分散回源压力
大量缓存键同时到期会使请求集中回源,可能耗尽数据库连接池并引发超时。文章介绍如何给 TTL 加入随机偏移,把过期时间分散开。
AI 深度解读
一批 Redis 缓存如果在同一秒写入,又用了相同的 TTL,就可能在同一秒失效。正赶上流量高峰,原本被缓存挡住的请求会一起回源,耗尽数据库连接池。作者给出的办法是给 TTL 加随机抖动,把失效和回填的压力摊到一段时间里。
这个办法改动小,适合排查批量预热、定时刷新造成的回源尖峰。原文还给了一段模拟脚本,但它的默认参数和断言互相打架。理解这个问题,比直接把脚本接进 CI 更有用。
为什么同一批缓存会把数据库打满
TTL 是缓存从写入到过期的存活时间。不同时间写入的键,即使用相同 TTL,过期时间也会自然错开。真正容易扎堆的是同一批写入的数据,比如 Node 服务启动时预热了一批缓存,或者定时任务集中刷新了一批列表。这样的任务如果反复执行,还可能把同一个流量尖峰带到下一个周期。
原文用 T=0 时 1,000,000 个键一起过期的时序图说明风险。图里的 Key_A、Key_B、Key_C 同时未命中,各自触发数据库查询。当回源请求超过连接池的承载能力,应用就可能出现 503 Service Unavailable 或超时。这里的一百万是示意规模,原文没有给出真实事故或压测的结果。
还有一种情况,原文把它说得太简单了。单个键过期后,如果回填完成前有多个请求同时读它,每个请求都可能发起查询。TTL 抖动能错开不同键的过期时间,但这个热点键仍然只有一个过期时刻。遇到这种问题,更直接的做法是请求合并,让并发请求共享同一次回源。
TTL 抖动加多大,脚本又验证了什么
作者最初考虑用 ttl + random.randint(0, 60)。这个写法会把过期时间最多推迟 60 秒。最终脚本改用按比例计算的双向抖动:先求 delta = int(base_ttl * jitter_ratio),再从 [-delta, delta] 取一个随机整数加到基础 TTL 上。比如 base_ttl=3600、jitter_ratio=0.1,结果在 3240 到 3960 秒之间,最早和最晚都偏离基础 TTL 360 秒。
下面是作者用来模拟同批写入、统计过期时间碰撞的完整脚本。
import random
import time
from typing import List
import orjson
from pydantic import BaseModel, Field, field_validator
class CacheEntry(BaseModel):
"""Metadata structure for a cache entry"""
key: str
ttl: int
expires_at: float
class SimulationConfig(BaseModel):
"""Simulation configuration: enforces strict type checking"""
base_ttl: int = Field(gt=0, description="Base TTL in seconds")
jitter_ratio: float = Field(ge=0.0, le=1.0, description="Jitter ratio (0.0 to 1.0)")
num_keys: int = Field(gt=0, description="Total number of keys to simulate")
@field_validator('jitter_ratio')
@classmethod
def validate_jitter(cls, v: float) -> float:
return v
def generate_jittered_ttl(base_ttl: int, jitter_ratio: float) -> int:
"""
Applies a randomized jitter ratio to the base TTL.
Example: base_ttl=3600, jitter_ratio=0.1 distributes values between 3240 and 3960.
"""
delta = int(base_ttl * jitter_ratio)
return base_ttl + random.randint(-delta, delta)
def run_simulation(config: SimulationConfig) -> List[CacheEntry]:
"""Generates cache entries based on the provided configuration"""
now = time.time()
entries = []
for i in range(config.num_keys):
ttl = generate_jittered_ttl(config.base_ttl, config.jitter_ratio)
entry = CacheEntry(
key=f"cache_key_{i}",
ttl=ttl,
expires_at=now + ttl
)
entries.append(entry)
return entries
def main():
# Config: 1-hour base TTL (3600s), 20% jitter, 1,000 keys
config = SimulationConfig(base_ttl=3600, jitter_ratio=0.2, num_keys=1000)
# Run simulation
results = run_simulation(config)
# Serialization performance matters in production (accelerated with orjson)
serialized_data = orjson.dumps([e.model_dump() for e in results])
# [Core] Assertion check: evaluate simultaneous expiration risk
# Count keys that share the exact same expires_at timestamp
expires_times = [e.expires_at for e in results]
unique_expires = len(set(expires_times))
print(f"--- Simulation Report ---")
print(f"Total Keys : {config.num_keys}")
print(f"Unique Expiry : {unique_expires}")
print(f"Collision Rate : {(1 - unique_expires/config.num_keys)*100:.2f}%")
# Verification: With effective jitter, unique expiration timestamps should exceed 90% of total keys
# (Guarantees that very few keys out of 1,000 expire at the exact same moment)
assert unique_expires > (config.num_keys * 0.9), "ERROR: Insufficient jitter distribution. High risk of load spikes."
print("Assertion PASSED: Cache stampede risk mitigated.")
print(f"Sample Entry: {orjson.loads(serialized_data)[0]}")
if __name__ == "__main__":
main()
先看 now = time.time() 这一行。它只执行一次,所以所有键共享同一个模拟写入时间,唯一过期时间的数量就等于抽到的不同 TTL 数量。默认配置是 3600 秒、20% 抖动、1,000 个键,delta 为 720,TTL 从 2880 到 4320 秒,一共 1,441 个整数取值。每次抽样都可能抽中已有的值。按均匀独立抽样计算,1,000 次平均只会占用约 721 个时间点,按脚本口径算出的碰撞率约为 28%。因此,要求唯一时间点严格超过 90%,默认配置通常过不了。这个数字来自对代码的推算,原文没有贴运行结果。
配置校验也还有边界。Pydantic 的 Field 能拦下 1.5、-0.1 这类越界比例,field_validator 在这里仅原样返回参数,模型也没显式开启严格类型模式。更要紧的是,jitter_ratio=1.0 合法,生成的 TTL 却可能是 0。写入 Redis 前,最终 TTL 的下限也得检查。
我的判断
把 TTL 策略收拢到同一个入口是对的。这样可以按缓存类型统一考虑过期下限、新鲜度上限和抖动范围。双向抖动会让一部分键更早回源,也会让另一部分数据留得更久。如果业务只允许提前失效,抖动窗口就要从最大可接受存活时间往前取。反过来,如果批任务本来就能分批执行,错峰写入同样能拉开过期时间,还能把写 Redis 的压力一起摊开。
判断雪崩风险时,最忙的一秒有多少回源请求,比全局碰撞率更重要。 脚本把每个时间点上第一把键之外的键都计为碰撞。同样多的碰撞可以集中在一秒,也可以分散在许多秒,前者给连接池的压力会更大。键过期后还得有人读才会回源,热点请求的并发量也会改变结果。模拟可以用来检查过期分布,数据库能否扛住则需要结合实际读取流量和回源耗时验证。
orjson 用来序列化模拟记录,碰撞统计只依赖内存里的过期时间。原文没有给出序列化性能对照,也没有给出百万键测试的耗时记录。「本地几秒跑完百万键」和「可用性超过 99.9%」都只能当作作者的经验判断,脚本本身无法验证这两项说法。
能拿来做什么
- 在 Node 服务的缓存写入入口统一计算 TTL。先给批量预热、定时刷新这些会集中写键的路径加抖动,再按业务允许的提前失效时间和最大存活时间定窗口。
- 把分布检查放进 CI 时,用固定随机种子让失败可以复现,并按秒统计过期键数。优先看最拥挤的时间桶,再用代表性的读取流量压测回填,观察数据库连接池的峰值和等待时间。
- 如果压力集中在某一个热门接口,检查并发未命中是否都在查询同一个键。同一 Node 进程内可以复用正在执行的回填 Promise,让后续请求共享这次查询。