Skip to content

数据一致性:缓存双写与最终一致 ​

本篇要点:能说清一次“更新数据库 + 处理缓存”里有几个可能出错的时间点,会用量化实验测出自己系统的不一致概率,并能设计对账作业兜住残留。前置:《数据存储选型:关系库、NoSQL 与检索》确立了“主库只有一个、其余都是派生副本”,这一章处理派生副本跟不上主库时怎么办。

一、为什么需要它 ​

2026 年 4 月,一个做本地生活的团队改了商品调价功能。上线第三天,运营反馈“后台改成 99 元,用户端还显示 129 元,刷新也不变,等十几分钟才好”。

代码是课本级的 Cache-Aside(旁路缓存):读的时候先查 Redis,没有再查 MySQL 并回填;写的时候先 UPDATE 数据库,再 DEL 缓存。团队里每个人都觉得这个顺序是对的——先保证数据落地,再让缓存失效,听起来无懈可击。

那为什么会不一致?因为“先写库后删缓存”只覆盖了一种交错,还有另一种:读请求在缓存失效之后回源,但它的回填发生在删除之后。时间线是这样:

  1. 缓存恰好失效(过期或被上一次写删掉),读请求 A 查库拿到旧值 129;
  2. A 还没把 129 写回缓存,写请求 B 把库改成 99 并删除缓存(此时缓存本来就是空的,删除是空操作);
  3. A 把 129 写回缓存。缓存里躺着的 129 会一直留到下次过期。

第 3 步里,A 写回的是它读到的旧值,B 的删除发生在它之前。删除无法阻止一个已经在路上的回填。

截至 2026 年 11 月的版本坐标:MySQL 8.4 LTS 线在 8.4.13,创新版 26.10.0;Redis 最新稳定线 8.10.3(8.10 于 2026-07-29 发布);Debezium 最新 GA 是 3.7.1.Final,仓库里有 3.8.0.Alpha1 的 tag 但那是预发布。下面的实验跑在 MySQL 8.4.6 与 Redis 8.2.2 上。

二、核心概念 ​

2.1 双写与旁路缓存 ​

双写指业务代码同时维护两个存储。旁路缓存是其中最常见的一种:缓存不参与写,只在读路径上被回填、在写路径上被失效。它的优点是缓存故障不影响写,缺点是失效与回填是两个独立动作,中间有窗口。

类比:图书馆有两本目录,一本在柜台(缓存),一本在书库(数据库)。读者改书名时你先改书库那本,再把柜台那本抽走让人重抄。问题是有人在抽走之前已经开始抄了,抄完放回去的还是旧书名。

反例:把“删缓存”换成“更新缓存”更糟。两个人同时写,A 写库 99、B 写库 89,到达缓存顺序可能是 B 再 A,缓存最后停在 99,库是 89。删除操作是幂等的(删两次等于删一次),更新不是。

2.2 三种写顺序的真实差别 ​

顺序做法挡得住什么挡不住什么
先删缓存,再写库DEL → UPDATE无删除与写库之间的读会回填旧值,且没有第二次删除,必然残留
先写库,再删缓存UPDATE → DEL大多数交错回填晚于删除的那一次(就是上面那条时间线)
先写库,再删缓存 + 延迟双删UPDATE → DEL → sleep → DEL回填窗口小于延迟量的情形延迟量拍不准、第二次删除失败、sleep 占着线程

表 5-1 三种写顺序各自挡得住与挡不住的失败形态

延迟双删(delayed double delete)在工程里被讲得最多,效果也最被高估。它把第二次删除放在几百毫秒后,赌“回填一定在这个时间之前完成”。这个赌注在缓存回填需要跨机房查库时经常输。

2.3 版本水位 ​

更好的做法是不让旧值有机会覆盖新值:给每条数据一个单调递增的版本号,回填时带上版本,缓存端只接受不小于已见版本的值。

关键是版本水位要单独存一个 key,不能和缓存内容放在一起。放在一起的话,“删除缓存”会把水位一起删掉,旧回填又有机会进来——这个坑我实测踩到了,详见动手实践。

2.4 CDC 与对账:把窗口挪走,把残差兜住 ​

变更数据捕获(change data capture,CDC)从 binlog 读变更,让缓存失效由日志驱动,而不是由业务代码驱动。它不能消灭窗口,但把窗口从“业务代码的执行时间”缩小到“日志消费延迟”。

对账(reconciliation)是最后一道兜底:定期把主库和派生副本逐条比对,把差异修回去。它回答的问题不是“怎么不发生”,而是“发生了多久能发现”。

图 5-1 从写请求到残差兜底的完整路径:能消掉的窗口在前两步消,消不掉的交给对账

如图 5-1 所示,四个环节里没有任何一个能单独保证一致。工程上的做法是每层都做一点,让最后的残差小到对账能扛住。

三、动手实践 ​

环境是 MySQL 8.4.6(独立端口 3406,binlog_format=ROW、binlog_row_image=FULL)加 Redis 8.2.2(端口 6389),客户端 Python 3.14 + redis 8.1.0 + PyMySQL 2.2.8。每一步的脚本都能直接跑。

3.1 复现那个“必然残留”的时间线 ​

python
import pymysql, redis, threading, time

SOCK = "/tmp/mysql.sock"          # 换成本机 socket 路径
r = redis.Redis(port=6389, decode_responses=True)
def db():
    return pymysql.connect(unix_socket=SOCK, user="root", database="ch5",
                           autocommit=True, cursorclass=pymysql.cursors.DictCursor)

r.delete("product:1")             # 缓存为空,读请求必然回源

def reader():
    v = r.get("product:1")
    if v is None:
        with db().cursor() as cur:
            cur.execute("SELECT price FROM product WHERE id=1")
            v = str(cur.fetchone()["price"])
        print(f"[读] 未命中,DB 读到 {v},准备回填", flush=True)
        time.sleep(0.40)                      # 回填前的处理耗时
        r.set("product:1", v)
        print(f"[读] 已回填 {v}", flush=True)

def writer():
    time.sleep(0.15)                          # 写请求在回填之前到达
    print("[写] 先删缓存", flush=True)
    r.delete("product:1")                     # 先删缓存
    time.sleep(0.10)
    with db().cursor() as cur:
        cur.execute("UPDATE product SET price=299.00 WHERE id=1")
    print("[写] DB 已更新为 299.00", flush=True)

tw = threading.Thread(target=writer); tr = threading.Thread(target=reader)
tw.start(); tr.start(); tw.join(); tr.join()
with db().cursor() as cur:
    cur.execute("SELECT price FROM product WHERE id=1")
    dbv = str(cur.fetchone()["price"])
print(f"最终 DB = {dbv} | 缓存 = {r.get('product:1')}")

运行结果(连跑三次都一样):

text
[读] 未命中,DB 读到 399.00,准备回填
[写] 先删缓存
[写] DB 已更新为 299.00
[读] 已回填 399.00
最终 DB = 299.00 | 缓存 = 399.00

这就是“先删缓存再写库”的形态:删除发生在回填之前,回填照样把旧值放大。而且这里没有第二次删除,399.00 会一直留到 key 过期。

3.2 用 300 轮实验量化两种方案 ​

一次复现说明不了概率。把上面这个过程做成对照实验:每轮先把库和缓存都重置成 100.00 并清空缓存,读请求必定回源,写请求的到达时刻在 5ms 到 50ms 之间随机,读的回填耗时也在同样的区间随机,统计“结束后缓存与数据库是否一致”。两种模式各跑 300 轮。

python
FILL_CAS = """
local wm = tonumber(redis.call('GET', KEYS[2]) or '0')
if tonumber(ARGV[2]) < wm then return 0 end
redis.call('SET', KEYS[1], ARGV[1])
redis.call('SET', KEYS[2], ARGV[2])
return 1
"""
fill_cas = r.register_script(FILL_CAS)

def writer_cas():
    time.sleep(random.uniform(0.005, 0.050))
    with db().cursor() as cur:
        cur.execute("UPDATE trial SET price=200.00, version=version+1 WHERE id=1")
        cur.execute("SELECT version FROM trial WHERE id=1")
        ver = cur.fetchone()["version"]
    pipe = r.pipeline(transaction=True)
    pipe.set("trial:1:ver", ver)      # 水位先推高
    pipe.delete("trial:1")            # 再删内容
    pipe.execute()

trial:1:ver 就是水位,独立于内容 key。写请求提交后先把它推到新版本,再删内容;回填脚本先读水位,版本比水位低的直接 return 0 拒绝。

运行结果(每种模式跑三轮 300 次,共 1800 次交错):

text
plain: 152/300 (51%), 135/300 (45%), 145/300 (48%)
cas  : 0/300 (0%),   0/300 (0%),    0/300 (0%)

同一台机器、同一段随机逻辑,三次跑下来 plain 是 45% 到 51%,cas 三次全部是 0。回填时先用 Lua 脚本做一次比较并写入(compare-and-set,CAS),旧值就进不来。

这里有个我踩到的坑,值得单独说。第一版我把版本号存在哈希字段里(HSET key price ... version ...),删除时整个 key 一起没了,水位跟着消失,旧回填畅通无阻,实测 300 轮里仍然出现残留。第二次改成“写库后回写缓存而不是删除”,同样没解决——因为回写本身也可能被更晚的回填覆盖,靠时序碰运气。直到把水位拆成独立 key,才稳定在 0。

3.3 划出窗口的边界 ​

不一致只发生在特定时刻。固定读回填耗时 50ms,把写请求的到达时刻从 5ms 扫到 70ms,每档 20 次:

写请求到达结束不一致 / 20 次
5ms / 10ms / 20ms / 30ms / 40ms20 / 20
45ms19 / 20
55ms / 70ms0 / 20

表 5-2 固定回填耗时 50ms 时,写请求到达时刻与终态是否一致

分界线在回填完成的那一刻:写请求在回填之前到达并删除,旧回填就会在之后写入;在回填之后到达,删除就是最后一次动作,缓存为空,正确。这解释了延迟双删为什么要“延迟”——它赌第二次删除落在回填之后。但你看表就知道,这个赌注的分界线取决于回填耗时,而回填耗时在跨机房、GC 停顿、冷启动时根本不是常数。

3.4 CDC 与对账 ​

binlog 消费的最小可运行版本(pymysqlreplication 库,模拟 Debezium 做的事)在我这台机器上从提交到缓存写入的延迟是:中位 1.4ms,P95 6.6ms,最大 24.1ms。这是本机 loopback 加单表 20 次更新的数字,生产环境跨网络、带 Kafka 中转时会到几十到几百毫秒——但量级上仍然比“业务代码两行之间的窗口”可控,因为它不依赖业务线程的调度。

对账作业按主键分页比对。预置 200 行、缓存 192 个 key、其中 11 个是人为制造的旧值、8 个 key 缺失:

python
from decimal import Decimal
def same(a, b):
    """数值比较要按 Decimal 规范化,别拿字符串比"""
    return Decimal(str(a)).quantize(Decimal("0.01")) == Decimal(str(b)).quantize(Decimal("0.01"))

scan = db()                        # 单独一条连接,避免长事务
BATCH, last, mismatch, missing = 50, 0, [], []
while True:
    with scan.cursor() as cur:
        cur.execute("SELECT id,price FROM sku WHERE id > %s ORDER BY id LIMIT %s", (last, BATCH))
        batch = cur.fetchall()
    if not batch:
        break
    pipe = r.pipeline(transaction=False)          # 一批只发一次往返
    for row in batch:
        pipe.hget(f"sku:{row['id']}", "price")
    cached = pipe.execute()
    for row, cv in zip(batch, cached):
        last = row["id"]
        if cv is None:                       missing.append(row["id"])
        elif not same(cv, row["price"]):     mismatch.append(row["id"])

print(f"扫描 {last} 行,缺 key {len(missing)} 个,值不一致 {len(mismatch)} 个")

运行结果:

text
预置:DB 200 行,缓存 192 个 key,其中 11 个是旧值
对账结果:扫描 200 行,缺 key 8 个,值不一致 11 个
  id=17 缓存=30.5 DB=35.50
 缺失 key: [23, 46, 69, 92, 115, 138, 161, 184]

11 个和 8 个,一个不差,全部找出来了。第一版脚本报“值不一致 192 个”,原因是拿 '11.5' 和 '11.50' 做字符串相等判断——DECIMAL(10,2) 读出来是 Decimal('11.50'),Redis 里存的是 str(Decimal('11.5'))。对账作业的第一个 bug 往往就在这里,把全量报成不一致,然后又被人关掉。

四、常见误解 ​

误解一:先写库后删缓存就不会不一致了。 上面那个实验里,plain 模式用的就是“先写库后删缓存”,三次 300 轮分别有 51%、45%、48% 收尾成旧值。这个顺序能挡住“删除早于提交导致读回旧值”的一类交错,但挡不住“回填晚于删除”。判断一个双写方案是否安全,不能看它写了几行代码,要看它在什么时刻会留下旧值。

误解二:延迟双删能解决一致性问题。 它只是把第二次删除推后,赌回填在此之前完成。窗口边界取决于回填耗时,而回填耗时不是常数。更现实的问题是你得给 sleep 选一个数值:选小了没用,选大了占线程,异步化之后还要处理任务丢失。把同一个实验里的 plain 换成“删两次”,只要第二次删除仍在回填之前,结果不变。

误解三:上了 CDC 就不需要业务侧兜底。 CDC 保证的是“日志里有的变更最终会被消费”,不保证“消费一定成功”。消费者重启期间的位点、反序列化失败被跳过的消息、下游写入超时后的重试——每一条都会让某个 key 停在旧值。工业界的实际做法是 CDC 加对账两条腿一起走,前者把不一致的时间压到秒级,后者保证天级内一定被发现。指望单条链路绝对一致,代价是端到端串行,那等于放弃了缓存。

五、小结 ​

《数据存储选型:关系库、NoSQL 与检索》我们把数据放到了合适的存储里,这一章处理了副本之间“暂时不一样”的问题。

  1. 缓存双写的不一致发生在“回填晚于删除”这一个窗口里。每次 300 轮的随机实验,“先写库后删缓存”有 45% 到 51% 收尾成旧值,三次重复都在这个区间。
  2. 版本水位(version watermark)把概率降到 0,但水位必须单独存 key。和内容放在同一个哈希里,删除会把水位一起删掉,方案立刻失效。
  3. 窗口边界在回填完成时刻:回填 50ms 时,写请求在 45ms 到达有 19/20 残留,55ms 到达是 0/20。延迟双删赌的就是这个边界,而边界不是常数。
  4. CDC 把窗口从业务线程的调度挪到日志消费延迟,本机实测中位 1.4ms、P95 6.6ms,生产环境按几十到几百毫秒估。
  5. 对账是对最后残差的兜底,能精确定位 11 个旧值与 8 个缺失 key。比对数值要先规范化,字符串比较会把差异全量报成不一致。

六、相关文章 ​

相关文章把单个组件的故障放大到机房级别:可用性的数字怎么换算成停机分钟、故障域怎么划、同城双活与异地多活的差别在哪里,以及怎么用演练验证你以为的切换真的能切。

继续阅读:[《高可用:冗余、故障域与多活容灾》 高可用:冗余、故障域与多活容灾](/guide/architecture/high-availability-multi-active.html)