在当今高并发系统中，缓存（如Redis, Memcached）几乎是必不可少的组件。它通过将热点数据存放在内存中，极大地减轻了数据库的压力，提升了系统的响应速度。然而，引入缓存的同时，我们也引入了新的复杂性——如何保证缓存里的数据和数据库里的数据是同步的？这就是经典的缓存一致性问题。

免费影视、动漫、音乐、游戏、小说资源长期稳定更新！ 👉 点此立即查看 👈

作为一名开发者，我们很可能都遇到过这样的场景：电商平台的运营同学火急火燎地跑过来，说某个商家的logo、名称或活动信息明明已经更新了，但前端APP和页面上还是显示着旧数据，用户投诉不断。

你心里“咯噔”一下，立刻去数据库查，发现数据确实已经更新为正确的了。那么问题出在哪？很可能，就是缓存与数据库之间的数据不一致了。

在当今高并发系统中，缓存（如Redis, Memcached）几乎是必不可少的组件。它通过将热点数据存放在内存中，极大地减轻了数据库的压力，提升了系统的响应速度。然而，引入缓存的同时，我们也引入了新的复杂性——如何保证缓存里的数据和数据库里的数据是同步的？这就是经典的缓存一致性问题。

本文将深入探讨这个问题，并从简单到复杂，介绍几种行之有效的解决方案。

一、问题根源：我们为什么会需要缓存？

在深入问题之前，我们先达成一个共识：缓存是数据库的一个副本，而不是替代品。它的核心价值在于性能。

想象一下，一个热门商家主页，每秒有数万次请求。如果每次请求都直接去查询数据库：

1. 数据库的CPU和IO压力巨大。

2. 查询速度相对较慢（毫秒级 vs 内存的微秒级），用户体验差。

因此，我们引入缓存。当第一个用户请求商家信息时，系统会：

1. 检查缓存中是否存在该数据（cacheKey = “shop:123”）。

2. 如果不存在（我们称之为缓存未命中，Cache Miss），则去数据库中查询。

3. 将查询到的数据写入缓存，并设置一个过期时间（TTL）。

4. 返回数据给用户。

后续的用户请求，都会直接在缓存中找到数据（缓存命中，Cache Hit），快速返回。这被称为“Cache-Aside”或“Lazy Loading”模式。

那么，不一致是如何产生的？

问题出在“更新”操作上。当我们更新商家信息时，如果只更新了数据库，而没有妥善处理缓存，就会出现不一致。

二、初探解决方案：常见的策略与陷阱

1. 先更新数据库，再删除缓存（Cache-Aside）

这是最常用、也最被推荐的策略之一。流程如下：

写请求：更新数据库中的商家信息。写请求：删除缓存中对应的key（如DEL shop:123）。读请求：后续的读请求发现缓存中不存在（Cache Miss），于是从数据库读取最新数据，并重新写入缓存。

代码示例（伪代码）：

public voidupdateShop(Shop shop) { // 1. 更新数据库 shopMapper.updateById(shop); // 2. 删除缓存 redisClient.del("shop:" + shop.getId());}public Shop getShopById(Long id) { // 1. 先查缓存 StringcacheKey="shop:" + id; Shopshop= redisClient.get(cacheKey); if (shop != null) { return shop; // 缓存命中，直接返回 } // 2. 缓存未命中，查数据库 shop = shopMapper.selectById(id); if (shop != null) { // 3. 将数据库数据写入缓存 redisClient.setex(cacheKey, 300, shop); // 设置300秒过期 } return shop;}

这个策略的优点：

•简单有效：逻辑清晰，易于理解和实现。

•容错性较好：即使第二步删除缓存失败，也只是一个“脏数据”暂时存在的风险，可以通过设置缓存的过期时间（TTL）来最终兜底。

但它并非完美，存在一个经典的不一致场景：假设在并发极高的情况下：

请求A（读）查询缓存，未命中，于是去查数据库（此时读到的是旧数据）。请求B（写）更新了数据库。请求B（写）删除了缓存。请求A（读）将步骤1中读到的旧数据写入了缓存。

这样一来，缓存里就是旧数据，数据库里是新数据，不一致发生了。虽然这个条件比较苛刻（读请求必须在写请求更新数据库之后、删除缓存之前完成数据库查询，并且其写缓存操作还要在最晚发生），但在理论上是存在的。

2. 先删除缓存，再更新数据库

这个策略的目的是解决上述的并发问题，但同样会引入新问题。

写请求：删除缓存。写请求：更新数据库。

在并发情况下：

请求A（写）删除了缓存。请求B（读）发现缓存不存在，去数据库查询此时还是旧数据，并将旧数据写入缓存。请求A（写）才更新数据库。

结果：缓存是旧数据，数据库是新数据，不一致再次发生。这个概率比第一种策略的场景要高。

三、进阶方案：如何应对高并发苛刻场景

对于大多数业务，第一种“先更新数据库，再删除缓存”的策略，配合合理的重试机制和TTL，已经足够。但如果你的业务对一致性要求极高，无法忍受哪怕一瞬间的旧数据，可以考虑以下方案。

方案一：延迟双删

这是在“先更新数据库，再删除缓存”基础上做的增强。既然在并发下有可能在删除缓存后，又被一个旧的读请求塞入脏数据，那我们再删一次不就行了？

流程：

1. 写请求：删除缓存。

2. 写请求：更新数据库。

3. 写请求：休眠一个短暂的时间（如500毫秒到1秒），再次删除缓存。

这第二次删除，目的就是清除掉在“更新数据库”这个时间窗口内，可能被其他读请求写入的脏数据。

代码示例：

public void updateShopWithDoubleDelete(Shop shop) { String cacheKey = "shop:" + shop.getId(); // 1. 先删除缓存 redisClient.del(cacheKey); // 2. 更新数据库 shopMapper.updateById(shop); // 3. 休眠一段时间，确保读请求已经完成了“读数据库 -> 写缓存”的操作 Thread.sleep(500); // 4. 再次删除缓存 redisClient.del(cacheKey);}

如何确定休眠时间？这个时间需要根据你项目的读请求平均耗时来估算。目的是确保所有在第一步删除缓存后、第二步更新数据库前发起的读请求，都已经完成了它们的“写缓存”操作。

缺点：

• 降低了写操作的吞吐量，因为强行休眠了。

• 时间难以精确设定，设短了可能删不干净，设长了影响性能。

方案二：异步串行化与缓存队列

这是更复杂但也更严谨的一种方案，核心思想是让对同一个数据的读写请求串行化。

我们可以使用一个内存队列（或分布式消息队列）来实现。

1. 系统为每一个商家ID（例如shop:123）维护一个队列。

2. 所有对这个商家的写请求（更新、删除）和读请求（在缓存未命中时），都封装成任务，按顺序放入对应的队列。

3. 一个后台的工作线程，从队列中顺序取出任务并执行。

• 如果是写任务：执行更新DB -> 删除缓存。

• 如果是读任务：执行查DB -> 写缓存。

这样做，就保证了对于同一个商家的操作是严格有序的，不可能出现一个写操作还在更新数据库，一个读操作就去读了旧数据并写入缓存的情况。

缺点：

• 系统复杂度急剧上升，需要维护队列和 worker。

• 因为串行化，性能会受一定影响。如果某个商家是超级热点，其队列可能会积压。

这个方案通常只在极端场景下使用，比如“秒杀商品”的库存更新。

四、终极武器：监听数据库Binlog，异步淘汰缓存

上面所有的方案，都要求应用层在代码里显式地处理缓存删除逻辑。如果项目很庞大，团队很多，很难保证每一个写数据库的地方都正确地配上了删缓存的操作。有没有一种更解耦、更通用的方式？

有！我们可以把自己伪装成一个数据库的“从库”，去监听数据库的二进制日志（Binlog，如MySQL）或变更流（Change Stream，如MongoDB）。当数据库有任何数据变更时，我们都能近乎实时地接收到这个事件，然后根据变更的内容去删除缓存。

技术选型：

•Canal：阿里巴巴开源的MySQL Binlog增量订阅&消费组件。

•Debezium：一个开源项目，为CDC（Change Data Capture）而生，支持多种数据库。

•MaxWell：另一个轻量级的MySQL Binlog解析工具。

架构流程：

1. 你的业务应用正常更新数据库，完全不用关心缓存。

2. Canal等服务连接到MySQL，模拟从库，接收Binlog。

3. Canal解析Binlog，获取到哪个表、哪行数据、发生了何种变更（增/删/改）。

4. Canal的客户端（你写的程序）接收到这些变更事件。

5. 客户端根据变更的行数据，生成对应的缓存Key，然后调用Redis进行删除。

// 这是一个Canal客户端的示例逻辑@EventListenerpublicvoidonDataChange(DataChangeEvent event) { if (event.getTableName().equals("t_shop")) { LongshopId= event.getData().getLong("id"); StringcacheKey="shop:" + shopId; redisClient.del(cacheKey); log.info("通过Binlog清除缓存: {}", cacheKey); }}

优点：

•彻底解耦：应用层代码变得非常干净，只需关注业务和DB。

•通用性强：无论通过什么途径（后台管理、API、数据库直接操作）更新的数据，都能触发缓存删除。

•性能优秀：异步处理，对主业务链路几乎没有性能影响。

缺点：

•架构复杂：引入了新的中间件，增加了运维成本。

•时效性：虽然近乎实时，但依然有极短的延迟。

五、总结与选型建议

没有放之四海而皆准的银弹，选择哪种方案取决于你的业务场景和技术要求。

给你的实践建议：

1.从简单的开始：首先尝试“先更新数据库，再删除缓存”。在99%的场景下，它已经足够好。

2.务必设置缓存过期时间（TTL）：这是最后的兜底策略。即使所有删除方案都失败了，数据最终也会因过期而消失，然后被正确的数据填充。这被称为“最终一致性”。

3.增加删除失败的重试机制：如果删除缓存这一步失败了，可以将删除操作放入一个重试队列（或用消息队列），不断重试直到成功。这能极大提高方案的健壮性。

4.评估成本：不要为了0.01%的不一致概率，去投入100%的复杂架构。技术决策永远是权衡的艺术。

希望这篇文章能帮助你彻底理解并解决缓存一致性问题，让你的用户永远看到最新的商家信息。

相关攻略

热门推荐