缓存一致性


数据不一致的发现

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

如何监控缓存一致性,及时发现问题?

监控告警运维

解题思路:

这道题问的是『怎么发现缓存和数据库已经不一致了』,核心是『必须有可量化的对比口径和告警线』。

详细步骤:

监控指标设计:

实时监控面板:

配置要点

  • 配置表达的是环境差异和运行参数,不是业务规则本身。
  • 队列、缓存、存储和服务参数决定系统在高峰期的缓冲能力。

具体指标项:

  1. 实时指标:缓存命中率、请求量、回源 QPS、延迟双删任务的执行成功率与延迟
  2. 对账指标:比对样本数、不一致条数、不一致比例
  3. 下钻维度:按文章/用户维度定位不一致集中的对象

对账流程:

  1. 定期(如每小时)抽样比对缓存值与数据库值
  2. 发现不一致 → 删除缓存 key,让下次请求回源重建
  3. 重建失败 → 告警并转人工

告警建议:

  • 不一致比例 > 0.1% → 告警
  • 对账任务连续失败 → 告警

最终答案:

监控分两层:一是实时指标,看缓存命中率、回源 QPS、延迟双删任务的执行成功率;二是对账校验,定期抽样或全量比对缓存值与数据库值,统计不一致比例并按文章维度下钻,差异超阈值就告警并触发自动修复(删除缓存让它回源重建)。实时监控面板要能看到命中率、脏数据比例和对账任务状态。

练习 5

在读写都很多的情况下,如何优化缓存一致性方案?

高并发缓存优化性能

解题思路:

这道题问的是高读写并发下的一致性方案怎么调,核心是『把串行化换成异步 + 对账 + 减少操作次数』。

详细步骤:

高并发读写优化方案:

具体做法:

  1. 异步化:更新数据库后投递消息,由消费者执行删缓存,请求线程不等待
  2. 延迟双删:第一次删同步,第二次删延迟执行,覆盖并发读回填旧值的问题
  3. 减少写放大:同一篇文章的多次点赞合并成一次计数更新 + 一次删缓存
  4. 乐观校验:用版本号判断缓存是否过期,冲突才重试,避免全局加锁
  5. 对账兜底:定期比对并修复

注意:

  • 异步化会引入『刚写完读不到』的窗口,需要产品确认可接受
  • 消息要可重试且幂等,避免重复删除造成额外压力

最终答案:

高并发读写下的优化方向有四个:把『更新后删缓存』改成延迟双删并异步化,避免请求线程同步等待;用批量合并写与 Pipeline 减少更新次数;引入版本号做乐观校验,冲突时只重试受影响的那一个 key 而不是全量加锁;再加定期对账作为最终兜底。核心思路是用异步和重试换掉锁,用对账换掉强一致。


思考题

  1. 如果数据库是分库分表的,如何保证缓存一致性?

  2. 如何实现”强一致性”的缓存方案(不使用分布式锁)?

  3. 缓存一致性和性能之间如何平衡?

💡 提示:这些问题没有标准答案,建议结合实际情况深入思考。

发现内容有问题?

告诉我们哪里需要改进。