缓存一致性
Redis 方案上线一周后,用户开始反馈问题。
【用户反馈】用户ID: 5678
问题:点赞后又取消,但点赞数没有变化
时间:2023-08-22 14:30:15
【用户反馈】用户ID: 1234
问题:刷新页面后,点赞数和之前不一样
时间:2023-08-22 14:35:22
我赶紧查看数据:
数据不一致!Redis 显示 152,实际只有 150。
我分析了代码,找到了问题原因:
问题在哪里?
场景:用户点赞后立即取消
时间线:
T1: 用户点击点赞
T2: Redis INCR → 151
T3: 数据库 INSERT → 成功
T4: 数据库 UPDATE → 成功
T5: 用户点击取消点赞
T6: Redis DECR → 150
T7: 数据库 DELETE → 成功
T8: 数据库 UPDATE → 成功
看起来没问题?
但如果 T7 失败了呢?
T7: 数据库 DELETE → 失败(网络错误)
T8: 数据库 UPDATE → 未执行
结果:
- Redis:150(已取消)
- 数据库:151(未取消)
→ 数据不一致!
核心问题:Redis 和数据库的更新不是原子操作。
我研究了各种缓存一致性方案。
方案 1:Cache Aside Pattern(旁路缓存)
读操作:
写操作:
为什么删除而不是更新?
更新缓存的问题:
- 并发写时,可能导致缓存覆盖
- 多个线程同时更新,缓存可能不正确
删除缓存的优势:
- 下次读取时,会从数据库加载最新值
- 避免并发写导致的缓存不一致
示例:
线程 A:更新数据库 → like_count = 101
线程 A:更新缓存 → cache = 101
线程 B:更新数据库 → like_count = 102
线程 B:更新缓存 → cache = 102
看起来没问题?
如果线程 A 先更新数据库,后更新缓存:
线程 A:更新数据库 → like_count = 101
线程 B:更新数据库 → like_count = 102
线程 B:更新缓存 → cache = 102
线程 A:更新缓存 → cache = 101 ← 覆盖了新值!
如果使用删除缓存:
线程 A:更新数据库 → like_count = 101
线程 A:删除缓存
线程 B:更新数据库 → like_count = 102
线程 B:删除缓存
下次读取:从数据库加载 → 102(正确)
Cache Aside Pattern 的问题:
问题 1:并发读写
时间线:
T1: 线程 A 读取缓存 → 未命中
T2: 线程 B 更新数据库
T3: 线程 B 删除缓存
T4: 线程 A 从数据库读取(旧值)
T5: 线程 A 写入缓存(旧值)
结果:缓存中是旧数据
问题 2:双写不一致
如果有两个服务都更新缓存:
服务 A:更新数据库 → 更新 Redis
服务 B:更新数据库 → 更新 Redis
可能顺序错乱,导致不一致
方案 2:Write Through(写穿透)
原理:
- 写操作同时更新缓存和数据库
- 缓存和数据库同步更新
实现:
问题:
- 缓存和数据库仍然是两个操作
- 无法保证原子性
- 性能较差(每次都要等数据库)
方案 3:Write Behind(异步写)
原理:
- 写操作只更新缓存
- 异步批量写入数据库
- 性能最好
实现:
问题:
- 数据库可能丢失数据(Redis 宕机)
- 数据库和缓存不一致(写入延迟)
- 复杂度高
方案 4:延迟双删(推荐)
原理:
- 更新数据库前删除缓存
- 更新数据库
- 延迟一段时间后再删除缓存
实现:
为什么延迟双删有效?
场景:并发读写
时间线:
T1: 线程 A 删除缓存
T2: 线程 B 读取缓存 → 未命中
T3: 线程 B 读取数据库 → 100(旧值)
T4: 线程 A 更新数据库 → 101
T5: 线程 B 写入缓存 → 100(旧值)
T6: 线程 A 延迟删除缓存
T7: 线程 C 读取缓存 → 未命中
T8: 线程 C 读取数据库 → 101(新值)
T9: 线程 C 写入缓存 → 101(正确)
延迟删除的作用:
- 删除线程 B 写入的旧缓存
- 保证最终一致性
延迟时间如何设置?
延迟时间 = 读取数据库时间 + 写入缓存时间 + 安全余量
示例:
- 读取数据库:50ms
- 写入缓存:5ms
- 安全余量:100ms
- 延迟时间:155ms(可设置为 200ms)
建议:
- 一般场景:200ms ~ 500ms
- 高并发场景:500ms ~ 1s
- 可以根据实际情况调整
结合点赞场景的特点,我选择了延迟双删 + 数据对账的方案。
完整方案
把前面的分析组合起来,写路径用”先更新数据库 → 再删缓存 → 延迟再删一次”,读路径用”缓存未命中则回源数据库并回填”。
import threading
class LikeCountRepository:
"""点赞计数:数据库是最终真值,Redis 是缓存"""
DELAY = 0.5 # 延迟双删的间隔(秒)
def __init__(self, db, redis_client):
self.db = db
self.redis = redis_client
def _count_key(self, article_id):
return f"article:{article_id}:like_count"
# ---------- 读路径:Cache Aside ----------
def get_like_count(self, article_id):
"""读:先读缓存,未命中回源数据库并回填"""
key = self._count_key(article_id)
value = self.redis.get(key)
if value is not None:
return int(value)
# 缓存未命中:读数据库
row = self.db.query(
"SELECT like_count FROM articles WHERE id = %s", (article_id,)
)
count = row[0]["like_count"] if row else 0
# 回填缓存
self.redis.set(key, count)
return count
# ---------- 写路径:延迟双删 ----------
def like(self, article_id, user_id):
"""点赞:更新数据库 → 删缓存 → 延迟再删"""
self.db.execute(
"INSERT INTO article_likes (article_id, user_id, created_at) "
"VALUES (%s, %s, NOW())",
(article_id, user_id),
)
self.db.execute(
"UPDATE articles SET like_count = like_count + 1 WHERE id = %s",
(article_id,),
)
self.db.commit()
self._delete_cache_twice(article_id)
return self.get_like_count(article_id)
def unlike(self, article_id, user_id):
"""取消点赞:同样走延迟双删"""
self.db.execute(
"DELETE FROM article_likes WHERE article_id = %s AND user_id = %s",
(article_id, user_id),
)
self.db.execute(
"UPDATE articles SET like_count = like_count - 1 WHERE id = %s",
(article_id,),
)
self.db.commit()
self._delete_cache_twice(article_id)
return self.get_like_count(article_id)
def _delete_cache_twice(self, article_id):
"""延迟双删:立刻删一次,延迟后再删一次"""
key = self._count_key(article_id)
# 第一次删除:挡住"读到旧缓存"的并发读
self.redis.delete(key)
# 第二次删除:异步延迟执行,挡住"回填旧值"的并发读
timer = threading.Timer(self.DELAY, self.redis.delete, args=(key,))
timer.daemon = True
timer.start()
为什么这个方案能解决前面那个”Redis 是 150、数据库是 151”的问题?
原问题:
Redis DECR 成功 → 数据库 DELETE 失败
→ Redis 和数据库永久不一致
现在的写路径:
数据库是唯一的写入点
→ 数据库写成功了,Redis 一定会被删(至少第一次删除会执行)
→ 下次读会从数据库回源,得到正确的值
→ 延迟的第二次删除再兜一次底
注意:写路径现在把数据库放在前面,代价是响应变慢。
原来的写路径(Redis 优先):
Redis INCR → 返回 响应 0.5ms
数据库写入(异步) 不阻塞用户
现在的写路径(数据库优先):
数据库 INSERT + UPDATE → 返回 响应 50ms
Redis 删除
对于要求最终一致的系统,应该保留”Redis 优先 + 异步落库”的写法(见《合并写入》一章),延迟双删主要用在”数据库是主、Redis 是从”的场景。这两种方案要按业务对实时性的要求来选。
延迟双删的两次删除分别在防什么?
第一次删除(同步,在数据库提交后):
防止后续的读请求读到旧缓存
→ 保证"删完之后,缓存里没有旧值"
第二次删除(延迟 DEL 秒后):
防止并发读在"第一次删除之后、数据库提交之前"回填了旧值
时间线:
T0 A 更新数据库(未提交)
T1 A 删除缓存 ← 第一次删除
T2 B 读缓存 → 未命中
T3 B 读数据库 → 旧值 100 ← B 读到了未提交前的值
T4 A 提交数据库 → 101
T5 B 回填缓存 → 100(旧值污染)
T6 A 延迟删除缓存 ← 第二次删除,把污染清掉
第二次删除必须是”延迟”而不是”立刻”。
如果两次删除紧挨着执行,T3~T5 的窗口依然存在。延迟时间要覆盖”读数据库 + 回填缓存”的耗时。
延迟双删的两个常见错误:
1. 延迟时间设置得太短。
延迟时间 = 读数据库耗时 + 写缓存耗时 + 安全余量
示例:
读数据库:50ms
写缓存:5ms
安全余量:100ms
→ 至少 155ms,建议设 200ms ~ 500ms
2. 用了 threading.Timer 这种进程内定时器。
应用重启会导致所有待执行的延迟删除丢失。生产上更可靠的做法是用 Redis 的延迟队列、消息队列的延迟消息,或者独立的定时任务来执行第二次删除。
读路径也要防”缓存击穿”。
热门文章刚被删除缓存,1000 个并发请求同时回源数据库
→ 数据库被 1000 次相同的查询打穿
解决办法是在回源路径上加互斥锁(只让一个请求真正查库),或者给缓存加一个”空值占位”防止不存在的 key 反复回源。
数据对账
为了进一步保证一致性,我添加了定时对账任务。
监控告警
一致性方案不可能做到 100% 一致,所以监控是最后一道防线。要监控的核心指标是不一致率。
# 对账任务的核心指标
def collect_consistency_metrics(db, redis_client):
"""采集一致性指标"""
total = 0
inconsistent = 0
diffs = []
for article_id in db.query("SELECT id FROM articles LIMIT 1000"):
article_id = article_id["id"]
total += 1
redis_count = int(redis_client.get(f"article:{article_id}:like_count") or 0)
db_count = db.query(
"SELECT COUNT(*) AS c FROM article_likes WHERE article_id = %s",
(article_id,),
)[0]["c"]
if redis_count != db_count:
inconsistent += 1
diffs.append({
"article_id": article_id,
"redis_count": redis_count,
"db_count": db_count,
"diff": redis_count - db_count,
})
return {
"checked": total,
"inconsistent": inconsistent,
"inconsistent_rate": round(inconsistent / total * 100, 4) if total else 0,
"diffs": diffs,
}
要监控的指标清单:
| 指标 | 含义 | 告警阈值 |
|---|---|---|
| 不一致率 | Redis 与数据库不一致的比例 | > 0.5% |
| 单篇最大偏差 | 最严重的文章差了多少 | > 10 |
| 偏差方向 | diff 是正还是负 | 持续为正说明计数虚高 |
| 对账耗时 | 一次对账跑了多久 | > 30 分钟 |
| 死信队列长度 | 重试耗尽的积压量 | > 100 |
| 延迟双删失败数 | 第二次删除没执行成功 | > 0 |
偏差的”方向”比偏差的”大小”更能定位问题。
diff > 0(Redis 比数据库多):
→ 多半是 INCR 成功但落库失败
→ 检查异步落库的失败率和死信队列
diff < 0(Redis 比数据库少):
→ 多半是 DECR 成功但落库失败
→ 或者 Redis 缓存过期后回源时读到了旧数据
diff 忽正忽负:
→ 延迟双删的时序问题,或者有并发覆盖
告警规则要分级。
P0(立即处理):
不一致率 > 5%
→ 说明同步链路整体失效,用户正在看到错误数据
P1(当天处理):
不一致率 > 0.5%
死信队列长度 > 1000
P2(观察):
不一致率 > 0.1%
单篇偏差 > 100
除了不一致率,还要监控常规的健康指标。
1. Redis 连接数
突然飙升 → 可能有连接泄漏
2. Redis 内存使用率
超过 80% → 准备扩容,否则会触发淘汰策略
3. 数据库 QPS
写路径如果改成数据库优先,QPS 会明显上升
4. 缓存命中率
命中率骤降 → 可能是大量 key 同时过期(缓存雪崩)
5. 延迟双删的定时器数量
堆积说明事件循环被阻塞
监控数据要能直接指导排查。
每个不一致的文章都要记录:
- article_id
- Redis 计数 / 数据库计数 / 差值
- 发现时间
- 是否已自动修复
有了这份清单,排查时可以直接按差值和发现时间聚类,
很快就能定位到是"某个时间段的问题"还是"某批文章的问题"。
最后要有一个”一键对账修复”的运维入口。
POST /admin/reconcile?dry_run=true # 只报告不修改
POST /admin/reconcile # 执行修复
dry_run 模式非常重要——修复操作会覆盖线上数据,必须先能预演。
一致性提升
优化前:
- 数据不一致率:约 5%
- 用户投诉:每天 3-5 条
优化后:
- 数据不一致率:约 0.1%
- 用户投诉:几乎为 0
性能影响
延迟双删的影响:
- 点赞接口响应时间:从 0.5ms 增加到 2ms
- 仍然远快于数据库方案(50ms)
- 用户无感知
对账任务的影响:
- 每小时运行一次
- 运行时间:约 30 秒
- 对数据库压力小
最终效果
系统运行一周:
- 处理点赞:约 350,000 次
- 数据不一致:约 350 次(0.1%)
- 自动修复:350 次
- 用户投诉:0 条
虽然不能保证 100% 一致,但通过延迟双删 + 定期对账,实现了最终一致性。
练习 1
如何选择合适的一致性策略?
解题思路:
这道题问的是『四种一致性策略怎么选』,要给出可操作的决策路径而不是背结论,并落到点赞场景的具体选择上。
详细步骤:
一致性策略对比:
| 策略 | 一致性 | 性能 | 复杂度 | 适用场景 |
|---|---|---|---|---|
| Cache Aside | 最终一致 | 高 | 低 | 一般业务 |
| Write Through | 强一致 | 中 | 中 | 读多写少 |
| Write Behind | 最终一致 | 最高 | 高 | 写多读少 |
| 延迟双删 | 最终一致 | 高 | 中 | 高并发读写 |
选择决策树:
1. 数据是否绝对不能丢?
是 → Write Through / 延迟双删 + 对账
否 → 继续
2. 写入频率如何?
高 → Write Behind / 延迟双删
低 → Cache Aside / Write Through
3. 读写比例如何?
读多写少 → Cache Aside
写多读少 → Write Behind
4. 性能要求如何?
极高 → Write Behind
一般 → Cache Aside / 延迟双删
5. 复杂度要求如何?
简单 → Cache Aside
可接受复杂 → 延迟双删 + 对账点赞场景分析:
特点:
- 写入频繁(用户点赞)
- 读取频繁(查看点赞数)
- 性能要求高
- 可容忍短暂不一致
推荐:延迟双删 + 定期对账
- 性能好(异步删除)
- 一致性好(延迟删除 + 对账)
- 复杂度可接受最终答案:
用决策树选:数据不能丢 → Write Through 或延迟双删 + 对账;写多读少 → Write Behind;读多写少 → Cache Aside;性能要求极高 → Write Behind;想简单 → Cache Aside。点赞场景写入频繁、读取频繁、性能要求高且可容忍短暂不一致,因此推荐『延迟双删 + 定期对账』:性能好(异步删除)、一致性好(延迟删除 + 对账兜底)、复杂度可接受。
练习 2
延迟双删中的延迟时间如何设置?
解题思路:
这道题问的是延迟时长的取值依据,要把它拆成『读库、写缓存、网络、安全余量』四段耗时相加,再按并发量分档给建议值。
详细步骤:
延迟时间计算公式:
延迟时间 = 读取数据库时间 + 写入缓存时间 + 网络延迟 + 安全余量
详细计算:
1. 读取数据库时间
- SELECT 查询时间
- 索引扫描时间
- 数据返回时间
- 一般:10ms ~ 50ms
2. 写入缓存时间
- Redis SET 操作时间
- 一般:1ms ~ 5ms
3. 网络延迟
- 应用到数据库:1ms ~ 5ms
- 应用到 Redis:1ms ~ 2ms
- 总计:2ms ~ 7ms
4. 安全余量
- 考虑并发情况
- 考虑 GC 暂停
- 考虑网络抖动
- 建议:100ms ~ 200ms
总延迟时间:10 + 5 + 7 + 100 = 122ms(可设置为 200ms)动态调整策略:
不同场景的推荐值:
低并发场景(< 100 ops/s):
- 延迟时间:200ms ~ 300ms
- 原因:并发少,简单的延迟即可
中并发场景(100 ~ 1000 ops/s):
- 延迟时间:300ms ~ 500ms
- 原因:并发增多,需要更长延迟
高并发场景(> 1000 ops/s):
- 延迟时间:500ms ~ 1000ms
- 原因:并发高,需要更长的安全窗口测试验证:
最终答案:
延迟时间 = 读数据库时间 + 写缓存时间 + 网络延迟 + 安全余量。按经验值是 1050ms + 15ms + 27ms + 100200ms,合计约 122ms,因此通常设置为 200ms。更重要的是按并发分档:低并发 200300ms,中并发 300500ms,高并发 500~1000ms;并配合动态调整与实测验证(模拟读写并发观察脏读窗口)。
练习 3
如何处理分布式系统中的缓存一致性问题?
解题思路:
这道题问的是『单机那套放到多实例、多分片之后额外多了什么问题』,要先说清分布式环境新增的难点,再给出三种应对手段。
详细步骤:
分布式环境的一致性挑战:
单机环境:
- 一个 Redis 实例
- 一个数据库实例
- 相对简单
分布式环境:
- 多个 Redis 实例(分片)
- 多个数据库实例(分库分表)
- 数据分布在多台服务器
- 一致性更难保证方案 1:分布式锁
方案 2:消息队列(最终一致性)
方案 3:版本号(乐观锁)
最终答案:
分布式的额外难点是:数据分布在多个 Redis 实例和多个数据库实例上,跨实例的读写顺序无法保证,一致性更难保证。应对手段三条:分布式锁(串行化同一 key 的更新,强一致但有性能损耗与死锁风险)、消息队列(把删除/更新动作异步化,靠重试保证最终一致,可靠性高)、版本号乐观锁(更新时校验版本,不匹配则重试,避免加锁)。
练习 4
如何监控缓存一致性,及时发现问题?
解题思路:
这道题问的是『怎么发现缓存和数据库已经不一致了』,核心是『必须有可量化的对比口径和告警线』。
详细步骤:
监控指标设计:
实时监控面板:
配置要点
- 配置表达的是环境差异和运行参数,不是业务规则本身。
- 队列、缓存、存储和服务参数决定系统在高峰期的缓冲能力。
具体指标项:
- 实时指标:缓存命中率、请求量、回源 QPS、延迟双删任务的执行成功率与延迟
- 对账指标:比对样本数、不一致条数、不一致比例
- 下钻维度:按文章/用户维度定位不一致集中的对象
对账流程:
- 定期(如每小时)抽样比对缓存值与数据库值
- 发现不一致 → 删除缓存 key,让下次请求回源重建
- 重建失败 → 告警并转人工
告警建议:
- 不一致比例 > 0.1% → 告警
- 对账任务连续失败 → 告警
最终答案:
监控分两层:一是实时指标,看缓存命中率、回源 QPS、延迟双删任务的执行成功率;二是对账校验,定期抽样或全量比对缓存值与数据库值,统计不一致比例并按文章维度下钻,差异超阈值就告警并触发自动修复(删除缓存让它回源重建)。实时监控面板要能看到命中率、脏数据比例和对账任务状态。
练习 5
在读写都很多的情况下,如何优化缓存一致性方案?
解题思路:
这道题问的是高读写并发下的一致性方案怎么调,核心是『把串行化换成异步 + 对账 + 减少操作次数』。
详细步骤:
高并发读写优化方案:
具体做法:
- 异步化:更新数据库后投递消息,由消费者执行删缓存,请求线程不等待
- 延迟双删:第一次删同步,第二次删延迟执行,覆盖并发读回填旧值的问题
- 减少写放大:同一篇文章的多次点赞合并成一次计数更新 + 一次删缓存
- 乐观校验:用版本号判断缓存是否过期,冲突才重试,避免全局加锁
- 对账兜底:定期比对并修复
注意:
- 异步化会引入『刚写完读不到』的窗口,需要产品确认可接受
- 消息要可重试且幂等,避免重复删除造成额外压力
最终答案:
高并发读写下的优化方向有四个:把『更新后删缓存』改成延迟双删并异步化,避免请求线程同步等待;用批量合并写与 Pipeline 减少更新次数;引入版本号做乐观校验,冲突时只重试受影响的那一个 key 而不是全量加锁;再加定期对账作为最终兜底。核心思路是用异步和重试换掉锁,用对账换掉强一致。
-
如果数据库是分库分表的,如何保证缓存一致性?
-
如何实现”强一致性”的缓存方案(不使用分布式锁)?
-
缓存一致性和性能之间如何平衡?
💡 提示:这些问题没有标准答案,建议结合实际情况深入思考。
发现内容有问题?
告诉我们哪里需要改进。
