2024 年 11 月 6 日 · Redis 深度实践 03

缓存命中时,系统很容易显得设计得不错。真正检验方案的是另一刻:一个热门 Key 刚过期,十二个请求一起进来,Redis 都回答“没有”,于是数据库同时收到十二次查询。

如果这时候还叠加超时重试、连接池排队和整点批量过期,缓存层反而会放大流量。我的做法是先把未命中、写入失败和 Redis 不可用这三条路径设计完整,再讨论把命中率提高几个百分点。

下面围绕 Redis 7.2.6 展开。数据库部分用明确标注的模拟加载器演示并发关系,Redis 命令则在真实隔离实例上执行。

我会先给缓存写一份职责说明

同样是缓存,首页推荐和支付状态的容忍度很不一样。设计前先约定:允许旧多久,回源最多能吃多少并发,缓存不可用时返回什么。

业务 可以考虑的起点 必须单独定义的边界
文章详情 Cache Aside + 有界 TTL 更新后短暂旧值是否可接受
热门列表 旧值可读 + 后台刷新 旧值最长保留时间、刷新失败如何展示
无结果查询 短 TTL 的空值缓存 只缓存确定不存在,还是也缓存错误
库存、余额 权威存储校验 缓存不能自行决定最终扣减结果
限流状态 Redis 原子计数 Redis 故障时放行还是拒绝、误差如何处理

这张表里的 TTL 和降级是产品语义。它们需要业务明确接受,不能由中间件默认值替代。Josiah Carlson 的《Redis in Action》可以用来对照缓存、计数和应用组件的组织思路;具体一致性承诺仍然要回到自己的读写路径。

Cache Aside 的关键,是画出交错执行的顺序

基本读路径很直观:先查缓存,未命中再查数据库,得到结果后设置带 TTL 的缓存。基本写路径常用“先提交数据库,再删除缓存”。

我会选择这个顺序,因为先删缓存再改数据库时,两个动作之间来的请求可能读到旧数据库值,并把旧值重新写回缓存。可是调换顺序,并不代表所有竞争都消失了。

数据库更新和旧值回填之间的竞争

考虑这组顺序:加载器 A 已从数据库读到 v1,但还没写缓存;写请求 B 把数据库提交成 v2,并删除缓存;A 随后才把 v1 写回。最后,数据库是 v2,缓存却重新变成 v1。

配套实验严格按这个顺序执行,读出的结果就是 database_after_update=v2、late_cache_refill=v1。这里不是数据库压测,而是把交错顺序固定下来,证明“数据库更新后删缓存”本身没有堵住所有旧值回填。

我的选择取决于业务:

  • 能容忍短暂旧值:TTL 限定持续时间,更新后删除配合可靠重试,后台抽查一致性。
  • 需要可靠触发失效:数据库事务内写 outbox,提交后由消费者重试删除,避免“提交成功但通知丢失”。删除要幂等,积压要监控。
  • 需要阻止旧版本回填:给数据带版本,建立不会轻易丢失的版本屏障,并在原子写缓存时检查。光比较缓存中已有版本还不够,Key 被删后,旧加载器可能重新写入。
  • 不能容忍旧值决定结果:最终决策回到权威存储,或者专门设计有一致性保证的读写路径。

Outbox 解决通知的可靠投递,不会自动把数据库与 Redis 变成一个事务。版本屏障的保留时间、丢失后的行为和重启恢复也必须写清楚。所谓“延迟双删”,其等待时间若没有覆盖实际最长加载窗口,仍然只是降低概率。

热点过期时,先把回源数量压下来

我做了一个十二线程同时未命中的实验。每个加载器用 45 毫秒延迟模拟数据库查询,所有线程先确认缓存为空,再从屏障一起出发。

处理方式 并发请求 模拟数据库加载次数
每个未命中各自加载 12 12
进程内 singleflight,拿锁后再查缓存 12 1

第二行的关键是拿到合并请求的锁之后,再查一次缓存。前一个线程可能已经回填,后面等待的线程不需要重复访问数据库。

缓存命中、合并请求和有界回源

这个实验的锁是 Python 进程内互斥锁,只合并同一进程内的请求。部署十个应用实例,仍然可能同时产生十次加载。要继续合并,可以设计跨实例的短租约,但不能让等待时间无限增长,更不能在获取失败后立刻让所有请求回源。

我通常先限制全局或分实例的回源并发,再考虑进一步合并热点。这样即使 Redis 锁也出故障,数据库仍有一道明确的流量上界。缓存里有可接受的旧值时,可以直接返回旧值并异步刷新;没有旧值且回源预算耗尽,就返回业务接受的降级结果。

TTL 也不要整齐划一。比如基础 TTL 300 秒、额外随机 0—60 秒,是一个可供压测的示例,能分散批量装载后的集中失效;它不能解决某一个超热 Key 的重建问题。空结果可以用更短 TTL,但应区分“确实不存在”和“数据库超时”,后者不能被伪装成不存在。

分布式锁至少要避免删掉别人的锁

单实例租约通常从下面这条命令开始:

1
SET lock:rebuild:42 <本次请求的随机token> NX PX 3000

获取和设置有效期必须在同一条命令中完成。释放时也不能无条件 DEL:旧持有者可能暂停过久,锁已经到期,另一个请求拿到了新锁。SET 选项

1
2
3
4
5
-- KEYS[1]:锁 Key;ARGV[1]:本次获取锁的 token。
if redis.call('GET', KEYS[1]) == ARGV[1] then
return redis.call('DEL', KEYS[1])
end
return 0

实验里,A 的租约先过期,B 再用 token-B 获取锁,A 最后执行上述脚本。返回值为 0,锁仍属于 B。官方锁模式讨论

这只解决安全释放。A 租约过期后,原来的工作线程可能还在执行,仍然能把旧结果写到外部系统。续租也可能因暂停或网络问题失败。要保护外部写入,需要下游接受并检查 fencing token 或使用权威存储的条件更新;不能只在 Redis 中“有一把锁”就承诺绝不并发。

用 Redis INCR 生成编号,也还需要评估故障切换后编号回退的风险。令牌是否足够可靠,要由最终执行写入的系统来确认。

计数器加过期,需要放到一个原子步骤里

固定窗口限流的常见写法是 INCR 后再 EXPIRE。客户端若恰好在两条命令之间退出,计数器可能留下没有 TTL 的状态。下面的脚本把首次计数和过期放在一次执行里:

1
2
3
4
5
6
7
8
9
10
-- KEYS[1]:当前限流桶;ARGV[1]:额度;ARGV[2]:桶有效期(秒)。
local limit = tonumber(ARGV[1])
local ttl = tonumber(ARGV[2])
if not limit or limit < 1 or limit > 1000000000 or limit % 1 ~= 0 or
not ttl or ttl < 1 or ttl > 86400 or ttl % 1 ~= 0 then
return redis.error_reply('invalid limit or ttl')
end
local n = redis.call('INCR', KEYS[1])
if n == 1 then redis.call('EXPIRE', KEYS[1], ttl) end
return {n <= limit and 1 or 0, n, redis.call('TTL', KEYS[1])}

示例把额度限制在十亿以内、TTL 限制在一天以内,先检查范围再修改数据;上限应按业务明确配置。相同桶连续执行五次、额度设为 3,实验得到 1,1,1,0,0,且 TTL 都为正。这是一个“首次请求起算”的固定窗口示例,不是滑动窗口,也不是令牌桶;拒绝的请求同样计数。窗口边界仍然允许短时间出现两批额度,是否可接受要另算。

脚本应独占自己的 Key 命名空间,避免被其他逻辑改成错误类型。客户端超时后,脚本可能已经执行,重试会再次计数;涉及扣款等业务时,需要额外的请求 ID 和幂等机制。Lua 的原子执行不包含运行时错误回滚。官方脚本文档

容量和淘汰策略,需要跟数据职责配套

缓存能重建,不代表所有 Redis 数据都能随便淘汰。把可重建页面缓存和业务去重记录放在同一个会淘汰的实例里,内存压力可能先把去重记录删掉。

策略 我会考虑的用途 要接受的结果
allkeys-lru / allkeys-lfu 全部数据都可重建的缓存实例 任意业务 Key 都可能被淘汰
volatile 系列 只允许带 TTL 的 Key 参与淘汰 没有可淘汰 Key 时,仍可能写入失败
noeviction 不接受自动删除的状态 相关写命令会在内存不足时返回错误

LRU、LFU 的实现有采样和近似行为。调整策略前,要确认业务是否可以丢这些 Key,而不是只选命中率看上去更高的选项。官方淘汰策略说明

maxmemory 也不是进程 RSS 的硬上限。复制/AOF 的部分缓冲不纳入淘汰计算,分配器碎片、后台持久化的写时复制和操作系统也需要空间。我的容量表会分开列这些预算,再用真实写入和重写演练验证峰值。INFO 内存字段、管理建议

过期时间与淘汰是两件事:TTL 到了,业务上 Key 应视为不存在;实际清理结合访问时检查与主动周期清理。不要把 TTL 当成精确到某毫秒的外部任务调度器。过期机制说明

Redis 不可用时,也要有可执行的退路

连接超时要小于接口剩余预算,连接池有上限,重试有次数和退避。一次失败后同时创建大量新连接,很容易把一个短故障拖成连接风暴。写命令超时也不能直接当成“没执行”。

缓存上线前后的验证排期示例

我会在上线前验证以下几件事:停掉缓存时,回源并发是否仍受控;批量过期时数据库有没有超过预算;重建超时后能否返回约定结果;恢复连接时有没有集中重试;内存满时应用是否正确处理写入错误。这些场景比单独测一个 GET 的 QPS 更接近生产风险。

访问控制也要落到应用账号。Key 前缀限制、允许命令和管理权限分开设计;ACL 不等于链路加密,跨不可信网络还需要 TLS。授权调整后可先用 ACL DRYRUN 检查典型命令。ACL 历史文档

实验入口和观察指标

1
python3 lab/redis_lab.py production --redis-server "$REDIS_LAB_SERVER"

实验同时验证并发回源、过期锁释放、原子限流和旧值回填。完整完整实验代码(见文末)、原始结果(见文末实验记录)均随文保留。

并发回源、锁归属和限流的真实输出

生产上,我会把命中率、回源并发、回源耗时、连接池等待、淘汰数、超时率和重建失败一起观察。keyspace_hits/misses 是实例累计量,计算一段时间的命中率要用增量;实例整体命中率,也不能替代某个关键接口的命中率。

缓存方案有没有完成,最终看故障时系统还能不能按约定工作。命中路径只是其中最顺畅的一段。

实验环境与完整代码

先准备 Redis 7.2.6。以下操作只创建本机实验目录,需要 C 编译器、make 和 Python 3;Redis 实例仅监听回环地址。

1
2
3
4
5
6
7
8
9
10
11
mkdir -p /tmp/redis-deep-lab-build
cd /tmp/redis-deep-lab-build
curl -fLO https://download.redis.io/releases/redis-7.2.6.tar.gz
shasum -a 256 redis-7.2.6.tar.gz
# 应为 fb10d67a2fe2b4556f6cb840064dd6e6e3175ce8ca035f0726990ec2da9f3d0e
# 校验一致后再继续。
tar -xzf redis-7.2.6.tar.gz
cd redis-7.2.6
make -j4
export REDIS_LAB_SERVER="$PWD/src/redis-server"
export REDIS_LAB_CLI="$PWD/src/redis-cli"

在自己的实验项目中创建 lab/ 目录,把下面的 Python 代码保存为 lab/redis_lab.py,然后回到该项目根目录运行文中的命令。默认从 18379 端口开始;检测到已有服务会停止。脚本只关闭自己启动的进程,原始输出保存在项目的 assets/ 目录中。

展开本篇完整实验代码(Python 3,无第三方包)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
from pathlib import Path
import argparse, concurrent.futures, datetime, hashlib, json, os, platform
import random, shutil, signal, socket, statistics, subprocess, tempfile, threading, time

ROOT=Path(__file__).resolve().parents[1]

class RedisError(Exception): pass

class Client:
def __init__(self,port):
self.sock=socket.create_connection(('127.0.0.1',port),timeout=8)
self.file=self.sock.makefile('rb')
@staticmethod
def encode(args):
parts=[a if isinstance(a,bytes) else str(a).encode() for a in args]
return b'*'+str(len(parts)).encode()+b'\r\n'+b''.join(b'$'+str(len(x)).encode()+b'\r\n'+x+b'\r\n' for x in parts)
def read(self):
line=self.file.readline()
if not line: raise ConnectionError('Redis 连接已关闭')
kind=line[:1];data=line[1:-2]
if kind==b'+':return data.decode()
if kind==b'-':return RedisError(data.decode())
if kind==b':':return int(data)
n=int(data)
if n==-1:return None
if kind==b'$':
value=self.file.read(n);assert self.file.read(2)==b'\r\n';return value.decode()
if kind==b'*':return [self.read() for _ in range(n)]
raise ValueError(line)
def cmd(self,*args):
self.sock.sendall(self.encode(args));value=self.read()
if isinstance(value,RedisError):raise value
return value
def pipeline(self,commands):
self.sock.sendall(b''.join(self.encode(args) for args in commands))
return [self.read() for _ in commands]
def close(self):self.file.close();self.sock.close()
def __enter__(self):return self
def __exit__(self,*_):self.close()

def fields(raw):return dict(line.split(':',1) for line in raw.splitlines() if ':' in line and not line.startswith('#'))

def until(predicate,seconds=12):
start=time.monotonic()
while time.monotonic()-start<seconds:
try:
result=predicate()
if result:return result
except (OSError,RedisError,ConnectionError):pass
time.sleep(.05)
raise TimeoutError('实验等待条件未满足')

class Sandbox:
def __init__(self,binary,port):
self.binary=Path(binary).resolve();self.cli=self.binary.with_name('redis-cli');self.port=port
self.work=Path(tempfile.mkdtemp(prefix='redis-editorial-'));self.processes={}
version=subprocess.check_output([str(self.binary),'--version'],text=True)
assert 'v=7.2.6 ' in version, '必须指定 Redis 7.2.6'
self.version=version.strip()
def start(self,port,extra='',directory=None):
directory=directory or self.work/str(port);directory.mkdir(parents=True,exist_ok=True)
# 拒绝占用已有 Redis;不向其他进程发送任何写入或关闭命令。
with socket.socket() as check:
check.settimeout(.2)
if check.connect_ex(('127.0.0.1',port))==0:
raise RuntimeError(f'端口 {port} 已有监听进程')
with socket.socket() as probe:
probe.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
probe.bind(('127.0.0.1',port))
config=directory/'redis.conf'
config.write_text(f'bind 127.0.0.1\nprotected-mode yes\nport {port}\ndaemonize no\ndir "{directory}"\nsave ""\nappendonly no\nlogfile "{directory}/redis.log"\n'+extra+'\n')
process=subprocess.Popen([str(self.binary),str(config)],stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL)
self.processes[port]=process
def ready():
if process.poll() is not None:raise RuntimeError((directory/'redis.log').read_text())
with Client(port) as c:return c.cmd('PING')=='PONG'
until(ready)
return directory
def stop(self,port,kill=False):
process=self.processes.pop(port)
process.kill() if kill else process.terminate()
process.wait(timeout=8)
def close(self):
for port in list(self.processes):self.stop(port)
def __enter__(self):return self
def __exit__(self,*_):self.close()

UNLOCK="""if redis.call('GET',KEYS[1]) == ARGV[1] then
return redis.call('DEL',KEYS[1])
end
return 0"""
LIMIT="""local limit = tonumber(ARGV[1])
local ttl = tonumber(ARGV[2])
if not limit or limit < 1 or limit > 1000000000 or limit % 1 ~= 0 or
not ttl or ttl < 1 or ttl > 86400 or ttl % 1 ~= 0 then
return redis.error_reply('invalid limit or ttl')
end
local n = redis.call('INCR', KEYS[1])
if n == 1 then redis.call('EXPIRE', KEYS[1], ttl) end
return {n <= limit and 1 or 0, n, redis.call('TTL', KEYS[1])}"""

def production(s):
port=s.port;s.start(port)
counts={};workers=12
for mode in ['uncoordinated','local_singleflight']:
barrier=threading.Barrier(workers);lock=threading.Lock();counter=0;counter_lock=threading.Lock()
key='lab:cache:'+mode
def load(c):
nonlocal counter
if c.cmd('GET',key) is not None:return
with counter_lock:counter+=1
time.sleep(.045)
c.cmd('SET',key,'db-value','EX',60)
def worker(_):
with Client(port) as c:
assert c.cmd('GET',key) is None
barrier.wait()
if mode=='local_singleflight':
with lock:load(c)
else:load(c)
with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as pool:list(pool.map(worker,range(workers)))
counts[mode]=counter
with Client(port) as c:
c.cmd('SET','lab:lock','token-A','NX','PX',80);time.sleep(.12)
assert c.cmd('SET','lab:lock','token-B','NX','PX',30000)=='OK'
old=c.cmd('EVAL',UNLOCK,1,'lab:lock','token-A');owner=c.cmd('GET','lab:lock')
requests=[c.cmd('EVAL',LIMIT,1,'lab:limit',3,60) for _ in range(5)]
try:c.cmd('EVAL',LIMIT,1,'lab:invalid-limit',3,86401)
except RedisError:pass
else:raise AssertionError('越界 TTL 必须在写入前拒绝')
assert c.cmd('EXISTS','lab:invalid-limit')==0
c.cmd('SET','lab:cache-aside','v1')
stale_loader='v1' # 模拟读数据库已得到旧值、尚未回填的加载器。
authoritative='v2';c.cmd('DEL','lab:cache-aside')
c.cmd('SET','lab:cache-aside',stale_loader,'EX',60)
stale=c.cmd('GET','lab:cache-aside')
result={'workers':workers,'database_loads':counts,'expired_owner_unlock_deleted':old,'lock_owner_after_old_unlock':owner,'limit_allowed':[r[0] for r in requests],'limit_ttl_positive':all(r[2]>0 for r in requests),'database_after_update':authoritative,'late_cache_refill':stale}
assert counts['local_singleflight']==1 and counts['uncoordinated']==workers
assert old==0 and owner=='token-B' and [r[0] for r in requests]==[1,1,1,0,0]
return result

def main():
parser=argparse.ArgumentParser();parser.add_argument('experiment',choices=['production','all']);parser.add_argument('--redis-server',default='/private/tmp/redis-editorial-7.2.6/redis-7.2.6/src/redis-server');parser.add_argument('--base-port',type=int,default=18379);args=parser.parse_args()
experiments=[('production', '03-production')]
for name,slug in experiments:
if args.experiment not in ('all',name):continue
dest=ROOT/'assets'/slug;dest.mkdir(parents=True,exist_ok=True)
with Sandbox(args.redis_server,args.base_port) as sandbox:
result=globals()[name](sandbox)
record={'experiment':name,'executed_at':datetime.datetime.now(datetime.timezone.utc).isoformat(),'runtime':sandbox.version,'os':platform.platform(),'architecture':platform.machine(),'work_directory':str(sandbox.work),'command':f'python3 lab/redis_lab.py {name} --redis-server /path/to/redis-7.2.6/src/redis-server','result':result}
(dest/'result.json').write_text(json.dumps(record,ensure_ascii=False,indent=2))
transcript=sandbox.version+'\n$ '+record['command']+'\n\n'+json.dumps(result,ensure_ascii=False,indent=2)+'\n'
(dest/'execution.txt').write_text(transcript)
print(json.dumps({'experiment':name,'result':result},ensure_ascii=False),flush=True)
# Redis 日志和实际配置留档;不包含凭据。
logs=ROOT/'lab/logs'/slug;logs.mkdir(parents=True,exist_ok=True)
for file in sandbox.work.glob('*/redis.*'):
if file.suffix in ('.log','.conf'):shutil.copy2(file,logs/(file.parent.name+'-'+file.name))

if __name__=='__main__':main()
展开本篇实验记录
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
{
"workers": 12,
"database_loads": {
"uncoordinated": 12,
"local_singleflight": 1
},
"expired_owner_unlock_deleted": 0,
"lock_owner_after_old_unlock": "token-B",
"limit_allowed": [
1,
1,
1,
0,
0
],
"limit_ttl_positive": true,
"database_after_update": "v2",
"late_cache_refill": "v1"
}

参考资料