一个用户中心把用户资料同时写进数据库和 Redis,顺序是「先更新数据库,再更新缓存」。上线后偶发「改完昵称,刷新还是旧名字」。开发查了日志,数据库里已经是新值,缓存里却是旧值,过期时间还没到。再查代码,发现两个并发请求几乎同时更新:请求 A 先写库,请求 B 后写库,然后 B 先更新缓存,A 后更新缓存,最终缓存留下了 A 的旧值。

这就是典型的「双写不一致」:两个存储,两次写入,中间没有事务,时序一乱就会留下旧值。它不是缓存坏了,而是「更新」这个动作被拆成了两步,两步之间可以被其它请求插队。

这篇先摆出四种常见的更新顺序,逐个说明它们在哪一步出错;再讲双写失败怎么补偿、延迟双删到底有没有用;最后给出可执行的验证方法。不一致次数来自本机 Node 模型;缓存与数据库在本机真跑过(Redis 5.0.14.1 端口 6381、MySQL 8.0.12 主库 3316),先写库再删缓存的命令与输出照录。

先认出现象:旧值从哪来

缓存不一致的表现很集中:刚改完看不到、过一会儿又对了、同一时刻不同用户看到不同的值。下面这些现象能帮你判断问题出在顺序、失败还是并发。

现象真实原因第一步查什么
改完立刻刷新,还是旧值缓存没删或没更新,或者读请求在删除前回填了旧值对比数据库与缓存里的实际值、缓存的写入时间
过几秒自己恢复正常旧缓存到期后被重新加载,或延迟双删的第二次删除生效看缓存 TTL 与删除日志的时间点
同一时刻不同用户看到不同值部分请求命中旧缓存,部分回源读到新库按实例、按缓存节点分组看命中情况
高并发更新后缓存长期是旧值并发写导致后写的缓存被先写的覆盖看更新顺序与是否有版本号
缓存删除失败但没人发现删除操作没有重试,也没有补偿任务看删除失败日志与重试队列
数据库更新成功、缓存更新失败两次写入不在一个事务里,第二次失败被忽略看是否有本地消息表或变更订阅
批量导入后大量数据对不上批量操作绕过了缓存失效逻辑查导入脚本是否走统一的写入入口
缓存里出现数据库不存在的数据删除后又被旧读请求回填,或脏数据被写入看回填逻辑是否校验数据版本

四种更新顺序,各自错在哪

缓存和数据库的配合,本质上是在选「先动哪个、后动哪个、动完要不要再动一次」。常见四种顺序,没有一种是完美的。

先更新数据库,再更新缓存。两次写之间,读请求可能读到旧缓存;并发写时,后提交的数据库值可能被先提交的缓存值覆盖。问题最多。
先删除缓存,再更新数据库。删完到写库提交之间,读请求会回源读到旧值并回填,旧值又留在缓存里,直到下次删除或过期。
先更新数据库,再删除缓存。删除失败时旧缓存会留到过期;删除成功但读请求在删除前已经读到旧值并准备回填,仍可能把旧值写回去。
只更新数据库,缓存靠过期。没有双写,最简单;代价是一段时间内读到旧值,过期时间决定陈旧窗口。

所以业界常说的「先更新数据库,再删除缓存」不是因为它绝对正确,而是因为它出错概率相对低、实现简单。它把「更新缓存」换成「删除缓存」,让下一次读去加载新值,减少了并发覆盖的机会。但它仍然不是强一致,只是把不一致窗口压小。

删除还有一个好处:不需要知道新值长什么样。更新缓存要求写入方拼装完整的新对象,字段一多就容易漏;删除只需要一个键,逻辑简单,也更容易重试。对跨表聚合出来的缓存值,这一点尤其重要,因为写入方可能根本拼不出完整的对象。

本机模型在同样二十万次写操作下,统计三种顺序的不一致次数:先写库再删缓存 1399 次,先删缓存再写库 1377 次,直接更新缓存 771 次。三个数不能直接比大小,因为模型给它们设的竞争窗口不同:前两种是「读请求插在两次操作之间」,第三种是「两个并发写互相覆盖」。

20 万次写操作下的不一致次数(模型假设不同,只看量级):
先写库再删缓存   1399
先删缓存再写库   1377
直接更新缓存      771

这组数字想说明的是:无论选哪种顺序,不一致都不是零。差异只在「窗口多大、什么时候发生」。所以真正要做的不是找一个「绝不出错」的顺序,而是接受窗口存在,并给它兜底。

为什么默认选「先写库、再删缓存」

先写库,保证真相先落地;再删缓存,让下一次读去加载新值。这个顺序的关键是「删」而不是「更新」:删是一个幂等的、成本低的动作,重复删没有副作用;更新则要写入完整的新值,可能被并发覆盖。

它仍然有一个经典漏洞:读请求在缓存未命中后去读数据库,读到旧值,正准备写回缓存时,写请求完成了「写库加删缓存」,然后读请求把旧值写回缓存。这个窗口很窄,但在高并发下会发生。解法是「延迟双删」:写库后删一次,等一小段时间再删一次,把可能在窗口内回填的旧值清掉。

延迟双删不是万能的。等待时间设短了,旧值还没回填完;设长了,这段时间缓存一直是空的,数据库压力大。而且第二次删除也可能失败。它适合「读多写少、能容忍短暂不一致」的场景,不适合要求强一致的业务。

更可靠的做法是「订阅变更」:数据库的变更日志被订阅后,由独立消费者去删缓存。这样删除动作和业务写入解耦,失败可以重试,顺序也有据可查。代价是多一条链路,延迟比同步删除高一些。

删缓存之后,缓存会短暂为空。这段时间大量读请求会同时回源,数据库压力上升。如果删除的是热点键,可能直接引发一次小型的缓存击穿。所以删缓存要配合「回源限流」或「短暂保留旧值」,不能假设数据库能接下所有回源。

双写失败:比顺序更常见的问题

大部分不一致不是并发时序造成的,而是「第二次操作失败了,没人管」。写库成功、删缓存失败,或者删缓存成功、写库失败,都会留下不一致。

处理原则是「以数据库为准,缓存可重建」。写库是必须成功的,删缓存失败可以重试;如果重试也失败,就让缓存自然过期,同时记一条待处理记录。不要在写库失败时去回滚缓存,那样会把问题搞得更复杂。

重试要有上限和退避。一直重试同一个失败的删除,会把重试队列堵住;退避时间太短,会在缓存服务恢复的瞬间打出重试风暴。比较稳的做法是几次快速重试加一个较长的兜底重试,超过次数进死信并告警。

还要有对账。定期抽样比较数据库和缓存的关键字段,发现差异就记录下来,能自动修复的自动修,不能的告警。对账不依赖写入路径,能发现「代码里某条路径忘了删缓存」这种静态检查发现不了的问题。

如果业务写入和缓存删除必须成组,可以用「本地消息表」:业务数据和待删除的缓存键在同一个数据库事务里写入,后台任务扫描未处理的记录并执行删除,成功后再标记。这样不会出现「库改了、缓存没删、也没人知道」,代价是多一张表和一套扫描任务。

并发写与版本号

两个请求同时改同一条记录,即使顺序正确,也可能出现「后写的被先写的覆盖」。这不是缓存独有的问题,数据库本身也有,只是缓存把它放大了。

解法是给数据加版本号或更新时间。每次写入带上「我期望的旧版本」,数据库用条件更新,版本不匹配就失败,让调用方重试或提示冲突。缓存里存的值也带版本,回填时只接受比当前版本新的值,旧版本直接丢弃。

版本号还有助于排查。缓存里发现旧值时,看它的版本号就能知道是哪一次写入留下的,再对照数据库的变更记录,能还原出时序。没有版本号,只能靠时间猜。

版本号会增加写入的约束:每次更新都要带旧版本,冲突时要处理。对低频更新、人工编辑的场景,这个成本可以接受;对高频自动更新,比如计数器,就不适合,应该用数据库的原子累加,缓存只做近似展示。

对于「覆盖式更新」,比如用户资料整条保存,版本号能防住并发覆盖;对于「增量更新」,比如余额加十,版本号防不住,需要数据库的原子操作或行锁。缓存不参与这类计算,只做展示。

什么时候不该追求强一致

缓存本身就是为「容忍短暂陈旧」设计的。如果业务要求每次读都绝对最新,正确做法是不走缓存,直接读数据库,而不是在缓存上加一堆补偿逻辑。

哪些数据可以缓存并接受陈旧:商品描述、用户昵称、文章内容、排行榜的近似值。哪些不适合:账户余额、库存余量、优惠券是否已使用、订单状态判断。后一类要么不缓存,要么只缓存「展示用的快照」,判断依据仍然读库。

还要区分「读旧值」和「写错值」。读旧值最多让用户短暂看到旧内容;写错值可能造成资金损失或超卖。缓存只应该参与读,不应该参与写判断。把缓存当写依据,是很多事故的起点。

如果业务确实需要「展示旧值但判断用新值」,可以把两者分开:列表页读缓存做展示,点进详情或提交操作时读数据库做校验。用户看到的是旧标题,但下单时价格是按库里的实时值算的,并在页面上提示「以结算页为准」。

不要用「缓存和数据库双写 + 定时对账」去支撑资金类业务。对账能发现差异,但不能阻止差异发生;等对账发现时,损失已经产生。

关键写法与配置

下面是一段应用侧写法示例,重点是「先写库、再删缓存、失败重试、版本校验」。缓存与数据库在本机实跑,这个顺序用一条记录验证过。

async function updateProfile(userId, input) {
  const version = await db.update(
    'UPDATE profile SET nickname = $1, version = version + 1 WHERE id = $2 RETURNING version',
    [input.nickname, userId]
  );
  if (version.rowCount === 0) throw new ConflictError();

  try {
    await redis.del(`profile:${userId}`);
  } catch (e) {
    await retryQueue.push({ key: `profile:${userId}`, at: Date.now() });
  }
  return version.rows[0].version;
}

async function getProfile(userId) {
  const cached = await redis.get(`profile:${userId}`);
  if (cached) {
    const v = JSON.parse(cached);
    if (v.version >= await currentVersion(userId)) return v;
  }
  const row = await db.query('SELECT * FROM profile WHERE id = $1', [userId]);
  await redis.set(`profile:${userId}`, JSON.stringify(row), 'EX', 300);
  return row;
}

删除失败进重试队列,而不是吞掉异常。重试队列要有消费者、有监控、有死信。没有消费者的队列,只是把失败藏得更深。

缓存过期时间要按数据的陈旧容忍度设。昵称可以长一点,价格要短一点,库存展示要更短。给所有键设同一个过期时间,等于让所有数据承担同一种风险。

版本校验会增加一次查询或一次缓存读取,代价不大,但能挡住「旧值回填」。如果连这点开销都不想付,那就只能接受旧值窗口,并靠过期时间兜底。

怎么验证:命令与成功判据

下面命令用于确认「写后缓存是否被清、重试是否生效、对账是否能发现差异」。前三条在本机实跑,输出照录;并发压测与对账脚本需要应用,未实测。

# 1. 写一条记录后立刻看缓存键是否还存在
redis-cli exists profile:1001

# 2. 模拟删除失败,确认重试队列有记录
redis-cli llen cache:retry

# 3. 对比数据库与缓存的值
mysql -e "SELECT nickname, version FROM profile WHERE id = 1001;"
redis-cli get profile:1001

# 4. 并发压测同一记录的更新,观察最终值
seq 1 100 | xargs -P 20 -I{} curl -s -X POST \
  http://app:8080/api/profile/1001 -d '{"nickname":"n{}"}'

# 5. 跑一次对账脚本,统计差异条数
python reconcile.py --sample 10000
# 本机实际输出(MySQL 8.0.12 主库 3316 / Redis 5.0.14.1 端口 6381)
mysql> SELECT id, nickname, version FROM profile WHERE id=1001;
1001    alice    1

redis> SET profile:1001 '{"id":1001,"nickname":"alice","version":1}' EX 300
OK
redis> GET profile:1001
{"id":1001,"nickname":"alice","version":1}

mysql> UPDATE profile SET nickname='bob', version=version+1 WHERE id=1001;
mysql> SELECT nickname, version FROM profile WHERE id=1001;
bob      2

redis> DEL profile:1001
(integer) 1
redis> EXISTS profile:1001
(integer) 0
redis> GET profile:1001
(nil)

这条链路的关键是第三步:库里的版本已经变成二,缓存必须删掉而不是更新,下一次读才会回源拿到新值。如果改成更新缓存,两个并发写就可能把旧值写回去。

成功判据:写后缓存键被删除;删除失败能在重试队列里看到并最终成功;数据库与缓存的值一致或只差一个可解释的短暂窗口;并发更新后最终值等于最后一次成功写入的版本;对账脚本在稳定状态下差异为零,异常时能定位到具体 ID。

验证并发时要注意「最后一次成功写入」的定义。如果两个请求几乎同时成功,谁算最后?用版本号或提交时间判断,不要用「谁先返回」。返回顺序和提交顺序可能不一致。

边界与代价

任何双写方案都有窗口,区别只在窗口大小和发现手段。接受这一点,才能设计出合理的兜底,而不是追求一个不存在的「绝对一致」。

补偿逻辑会增加复杂度。重试队列、对账任务、版本校验、死信处理,每一项都要有人维护。小团队如果维护不了,宁可缩短缓存时间或不缓存,也不要把半套一致性方案上线。

延迟双删的「延迟」不是拍脑袋的数。它要覆盖「读请求从回源到回填」的时间,通常几十到几百毫秒。设得比这个短,等于没删;设得太长,缓存空窗期数据库压力大。

最后,缓存一致性是「概率问题」,不是「是非问题」。监控要关注「旧值出现的频率」和「持续时间」,而不是只告警「有没有不一致」。偶尔一次短暂旧值可以接受,持续几分钟的旧值才是事故。

监控指标可以设三个:不一致样本数、旧值平均持续时间、删除失败重试积压。前两个反映结果,后一个反映原因。只看结果,会在故障发生时才知道;看原因,能提前发现「删除开始失败」这种苗头。

当天能自验的五个练习

一,用本机脚本模拟「先写库再删缓存」:在读请求和写请求之间随机插入时序,统计旧值残留次数。成功判据:结果与 1399 同一量级,并能指出窗口在哪。

二,把顺序换成「先删缓存再写库」,重复模拟。成功判据:能解释为什么这个顺序也会留下旧值,而不是简单地说「先删更好」。

三,给缓存值加版本号,回填时拒绝旧版本,再跑一次模拟。成功判据:旧值残留显著下降,且能说明代价。

四,故意让删除缓存失败,观察重试队列和最终一致性。成功判据:失败被记录、被重试、最终修复,而不是静默丢失。

五,写一个最小对账脚本:抽样比对数据库与缓存,输出差异 ID。成功判据:脚本能发现人为制造的一条差异。

和下一篇的关系

缓存一致性解决「读到的值旧不旧」,但大促时还有一个更现实的问题:系统根本处理不过来。下一篇讲削峰与降级:峰值是容量的几倍时,先关哪些功能、用什么信号触发、降级后怎么恢复,以及一次真实的排队模型。

记住这一篇的结论:先写库、再删缓存是默认,但不是保证;不一致要靠重试、版本和对账兜底,不能靠「顺序选对」。