Caffeine+Redis 双重缓存:原理、两类脏读、方案与选型
摘要:Caffeine+Redis 是业务层常用的多级缓存架构,很多人只知道它用来加速热点查询,却分不清两种脏读来源、不知道什么时候该上、什么时候坚决不能用。本文从架构链路、两类脏读(单机读写竞态 + 分布式跨节点脏读)、工程实现方案、适用边界完整梳理,附带可运行代码,适合开发学习、面试复盘。
一、先分清一个容易混淆的概念
很多同学会把它和 MyBatis 二级缓存搞混:
- MyBatis 二级缓存:框架内置的 Mapper/Namespace 层缓存,分布式场景极易脏读,线上大多关闭;
- Caffeine + Redis 双重缓存:业务主动设计的多级缓存架构,链路:
Caffeine(JVM本地缓存) → Redis(分布式基准缓存) → DB。
核心定位:Redis 作为全局权威数据源,Caffeine 作为热点加速层。
二、什么时候才需要引入这套架构?(不是必选项)
原则:单用 Redis 能扛住流量、延迟达标,就不要额外引入 Caffeine,复杂度会显著上升。
✅ 适合引入的条件(尽量同时满足)
- 存在超高热点 Key,读 QPS 极高,单用 Redis CPU / 连接 / 带宽容易打满;
- 接口对 RT 敏感,想要极致低延迟,消除 Redis 网络往返开销;
- 读多写少,热点集中,缓存命中率高;
- 共享 Redis 集群资源紧张,需要在应用层拦截流量、保护 Redis;
- 硬性前提:业务允许短暂不一致(几十 ms ~ 数秒脏读窗口)。
🎯 它解决的 3 个核心问题
- 降低查询 RT:Caffeine 命中直接读内存,没有网络 IO;
- 拦截热点流量,削峰,避免热点 Key 击穿 Redis;
- 提升系统吞吐,扩容实例时,不会同步放大 Redis 的压力。
❌ 不适合引入的场景
- 强一致性业务(库存、资金、钱包、订单、支付、优惠券核销),脏读会直接资损;
- QPS 低、Redis 压力很小,收益抵不上维护成本;
- 写非常频繁,缓存频繁失效,Caffeine 命中率极低;
- Key 极度分散、没有稳定热点,本地缓存留不住数据。
强一致业务缓存方案:去掉 Caffeine,只用 Redis;或者直接查 DB,必要时搭配分布式锁、Lua 脚本。
三、架构里的两类脏读(重点)
这套架构会遇到两种完全不同的脏读,成因、解决思路分开:
1. 单机读写竞态(单机、分布式所有实例内部都存在)
成因:同一个 JVM 内,读请求提前发起,但 DB 查询很慢;写请求先完成 DB 更新并清理缓存;等慢读请求拿到旧数据,回填缓存,脏数据驻留。 时序:
- T1(读线程):Caffeine miss → Redis miss → 发起慢 DB 查询
- T2(写线程):更新 DB 为新值 → 删除 Caffeine、Redis 缓存
- T1 返回旧数据,回填缓存,脏数据产生
特点:脏数据是回填动作写进去的;和是否多机器无关。
2. 跨节点脏读(分布式多实例独有)
成因:所有实例共用一套 Redis,但每个实例的 Caffeine 是独立隔离的内存。Redis 只能删自己的数据,无法远程清除其他 JVM 里的 Caffeine。 时序:
- A、B 实例本地 Caffeine 都缓存了同一个 key 的旧值,Redis 也是旧值
- 更新请求打到 A 实例:更新 DB、删除 Redis 缓存、发送失效广播消息
- 消息到达 B 实例之前,查询打到 B,直接读取本机 Caffeine 旧值,脏读
- B 收到消息,删除本机 Caffeine,脏读窗口结束
特点:脏数据本来就存在 B 节点本地缓存;通知机制只能缩小窗口,无法彻底消除短暂脏读,架构本身是最终一致。
四、单机读写竞态:4 套工程落地方案
前置约定:
- 读链路:Caffeine → Redis → DB
- 写顺序统一:先更新 DB,再清理缓存
- 公共基础工具类
public class CacheUtil {
public final LoadingCache<String, Object> caffeineCache;
public final RedisTemplate<String, Object> redisTemplate;
public final ExecutorService cacheDelExecutor = Executors.newSingleThreadExecutor();
public CacheUtil(RedisTemplate<String, Object> redisTemplate) {
this.redisTemplate = redisTemplate;
this.caffeineCache = Caffeine.newBuilder()
.expireAfterWrite(5, TimeUnit.MINUTES)
.build();
}
public void clearBothCache(String key) {
caffeineCache.invalidate(key);
redisTemplate.delete(key);
}
}
方案 1:异步延迟双删 + TTL 兜底(绝大多数项目首选)
✅ 适用:普通业务、读多写少、允许短暂不一致(商品图文、首页配置) ✅ 优点:无锁、性能高、实现简单 ❌ 缺点:无法 100% 杜绝;如果 DB 耗时超过延迟时间,依然会脏
@Service
public class BizDelayDeleteService {
private final CacheUtil cacheUtil;
private static final long DELAY_MILLIS = 300;
private static final long REDIS_TTL_SEC = 5 * 60;
public BizDelayDeleteService(CacheUtil cacheUtil) {
this.cacheUtil = cacheUtil;
}
public Object getBizData(String key) {
Object val = cacheUtil.caffeineCache.getIfPresent(key);
if (val != null) return val;
val = cacheUtil.redisTemplate.opsForValue().get(key);
if (val != null) {
cacheUtil.caffeineCache.put(key, val);
return val;
}
val = dbService.selectById(key);
if (val != null) {
cacheUtil.redisTemplate.opsForValue().set(key, val, REDIS_TTL_SEC, TimeUnit.SECONDS);
cacheUtil.caffeineCache.put(key, val);
}
return val;
}
public void updateBizData(String key, Object newData) {
dbService.updateById(key, newData);
cacheUtil.clearBothCache(key);
// 异步延迟二次删除,兜底单机慢读回填竞态,不阻塞写接口
cacheUtil.cacheDelExecutor.submit(() -> {
try {
Thread.sleep(DELAY_MILLIS);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
cacheUtil.clearBothCache(key);
});
}
}
方案 2:Key 粒度本地锁(单机热点 key,尽量不脏读)
✅ 适用:单机热点 key、不能接受脏读、并发可控 ✅ 优点:从根源杜绝时序竞态,保证一致 ❌ 缺点:热点 key 串行,并发下降;仅单机有效,分布式要换成 Redisson 分布式锁
@Service
public class BizLocalLockService {
private final CacheUtil cacheUtil;
private final ConcurrentHashMap<String, Object> keyLockMap = new ConcurrentHashMap<>();
private static final long REDIS_TTL_SEC = 5 * 60;
public BizLocalLockService(CacheUtil cacheUtil) {
this.cacheUtil = cacheUtil;
}
private Object getLock(String key) {
return keyLockMap.computeIfAbsent(key, k -> new Object());
}
public Object getBizData(String key) {
Object lock = getLock(key);
synchronized (lock) {
Object val = cacheUtil.caffeineCache.getIfPresent(key);
if (val != null) return val;
val = cacheUtil.redisTemplate.opsForValue().get(key);
if (val != null) {
cacheUtil.caffeineCache.put(key, val);
return val;
}
val = dbService.selectById(key);
if (val != null) {
cacheUtil.redisTemplate.opsForValue().set(key, val, REDIS_TTL_SEC, TimeUnit.SECONDS);
cacheUtil.caffeineCache.put(key, val);
}
return val;
}
}
public void updateBizData(String key, Object newData) {
Object lock = getLock(key);
synchronized (lock) {
dbService.updateById(key, newData);
cacheUtil.clearBothCache(key);
}
}
}
优化:读多写少可替换为 StampedLock 乐观读,减少锁竞争。
方案 3:取消读侧自动回填,采用预热加载(老系统稳优先)
✅ 适用:老系统、不想承担回填竞态风险、追求稳定 ✅ 优点:不存在滞后回填竞态,逻辑稳定 ❌ 缺点:冷 key 缓存命中率低,需要维护预热任务
@Service
public class BizPreLoadService {
private final CacheUtil cacheUtil;
private static final long REDIS_TTL_SEC = 5 * 60;
public BizPreLoadService(CacheUtil cacheUtil) {
this.cacheUtil = cacheUtil;
}
public Object getBizData(String key) {
Object val = cacheUtil.caffeineCache.getIfPresent(key);
if (val != null) return val;
val = cacheUtil.redisTemplate.opsForValue().get(key);
if (val != null) {
cacheUtil.caffeineCache.put(key, val);
return val;
}
// DB查询后,不自动回填缓存
return dbService.selectById(key);
}
public void updateBizData(String key, Object newData) {
dbService.updateById(key, newData);
cacheUtil.clearBothCache(key);
}
@Scheduled(fixedRate = 60 * 1000)
public void preLoadHotKey() {
List<String> hotKeys = hotKeyManager.getHotKeyList();
for (String key : hotKeys) {
Object data = dbService.selectById(key);
if (data != null) {
cacheUtil.redisTemplate.opsForValue().set(key, data, REDIS_TTL_SEC, TimeUnit.SECONDS);
cacheUtil.caffeineCache.put(key, data);
}
}
}
}
方案 4:版本号校验回填(优雅无锁,业务表带有 version 字段)
✅ 适用:新业务,表自带 version 版本字段,想要无锁实现 ✅ 优点:无锁,精准拦截滞后旧数据回填 ❌ 缺点:业务侵入,老表需要新增 version 字段
@Data
public class VersionCacheDTO {
private Object data;
private Long version;
}
@Service
public class BizVersionCheckService {
private final CacheUtil cacheUtil;
private static final long REDIS_TTL_SEC = 5 * 60;
public BizVersionCheckService(CacheUtil cacheUtil) {
this.cacheUtil = cacheUtil;
}
public Object getBizData(String key) {
VersionCacheDTO cacheDto = (VersionCacheDTO) cacheUtil.caffeineCache.getIfPresent(key);
if (cacheDto != null) return cacheDto.getData();
cacheDto = (VersionCacheDTO) cacheUtil.redisTemplate.opsForValue().get(key);
if (cacheDto != null) {
cacheUtil.caffeineCache.put(key, cacheDto);
return cacheDto.getData();
}
BizEntity entity = dbService.selectById(key);
if (entity == null) return null;
long newVersion = entity.getVersion();
VersionCacheDTO newDto = new VersionCacheDTO();
newDto.setData(entity);
newDto.setVersion(newVersion);
// 回填前版本校验,旧版本直接丢弃
VersionCacheDTO exist = (VersionCacheDTO) cacheUtil.redisTemplate.opsForValue().get(key);
if (exist == null || newVersion > exist.getVersion()) {
cacheUtil.redisTemplate.opsForValue().set(key, newDto, REDIS_TTL_SEC, TimeUnit.SECONDS);
cacheUtil.caffeineCache.put(key, newDto);
}
return entity;
}
public void updateBizData(String key, Object newData) {
dbService.updateWithVersion(key, newData); // update set version = version + 1
cacheUtil.clearBothCache(key);
}
}
单机竞态方案选型汇总表
表格
| 方案 | 一致性 | 性能 | 改造成本 | 适用场景 |
|---|---|---|---|---|
| 异步延迟双删 + TTL | 短暂不一致 | 很高 | 低 | 绝大多数读多写少业务 |
| Key 粒度本地锁 | 强一致 | 热点 key 会降速 | 低 | 单机热点 key,不能脏读 |
| 取消读回填 + 预热 | 强一致 | 冷 key 命中率低 | 中 | 老系统,追求稳定 |
| 版本号校验回填 | 强一致 | 高 | 高(需要 version 字段) | 新业务,无锁优先 |
五、跨节点脏读:分布式失效工程方案
核心目标:更新完成后,通知集群内所有其他实例,删除它们本机 Caffeine 缓存,缩小脏读窗口。 注意:Redis 本身无法远程操作其他 JVM 的 Caffeine,只能依靠消息通知,所有方案都要搭配 TTL 兜底。
方案 1:Redis PubSub(轻量方案,中小项目首选)
原理:更新完成后,往固定 channel 推送失效 key;所有服务实例启动时订阅该 channel,收到消息,只删除本机 Caffeine。 优点:无需额外中间件,接入简单、延迟低; 缺点:PubSub 发后即忘,无持久化、无重试,服务离线期间消息丢失,依赖 TTL 兜底。
/**
* 写侧:更新后发送失效消息
*/
@Service
public class PubSubCacheService {
private final CacheUtil cacheUtil;
private final RedisTemplate<String, Object> redisTemplate;
private static final String INVALIDATE_CHANNEL = "cache:caffeine:invalidate";
private static final long DELAY_MILLIS = 300;
public PubSubCacheService(CacheUtil cacheUtil) {
this.cacheUtil = cacheUtil;
this.redisTemplate = cacheUtil.redisTemplate;
}
public Object getBizData(String key) {
// 读逻辑和上面【异步延迟双删】一致
Object val = cacheUtil.caffeineCache.getIfPresent(key);
if (val != null) return val;
val = redisTemplate.opsForValue().get(key);
if (val != null) {
cacheUtil.caffeineCache.put(key, val);
return val;
}
val = dbService.selectById(key);
if (val != null) {
redisTemplate.opsForValue().set(key, val, 5, TimeUnit.MINUTES);
cacheUtil.caffeineCache.put(key, val);
}
return val;
}
public void updateBizData(String key, Object newData) {
dbService.updateById(key, newData);
// 1. 清除当前实例的Caffeine + Redis
cacheUtil.clearBothCache(key);
// 2. 广播失效key,通知其他节点清本地Caffeine
redisTemplate.convertAndSend(INVALIDATE_CHANNEL, key);
// 3. 异步延迟双删,兜底单机慢读回填竞态
cacheUtil.cacheDelExecutor.submit(() -> {
try {
Thread.sleep(DELAY_MILLIS);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
cacheUtil.clearBothCache(key);
});
}
}
/**
* 订阅监听器:所有实例统一注册,收到消息只清本机Caffeine
*/
@Component
public class CaffeineInvalidateListener implements MessageListener {
private final CacheUtil cacheUtil;
public CaffeineInvalidateListener(CacheUtil cacheUtil, RedisMessageListenerContainer container) {
this.cacheUtil = cacheUtil;
// 订阅频道
container.addMessageListener(this, new ChannelTopic("cache:caffeine:invalidate"));
}
@Override
public void onMessage(Message message, byte[] pattern) {
String cacheKey = new String(message.getBody(), StandardCharsets.UTF_8);
// 只清本机Caffeine!Redis已经在写流程删除过了,不需要重复删Redis
cacheUtil.caffeineCache.invalidate(cacheKey);
}
}
方案 2:MQ 可靠通知方案(RocketMQ/Kafka,核心业务)
原理:更新成功,发送可靠消息到 MQ;所有消费端收到消息,删除本机 Caffeine。 优点:消息持久化、支持重试、死信队列,消息不会丢失; 缺点:引入中间件,运维、接入成本更高。
@Service
public class MqCacheService {
private final CacheUtil cacheUtil;
private final RocketMQTemplate rocketMQTemplate;
private static final String INVALIDATE_TOPIC = "cache_caffeine_invalidate_topic";
public MqCacheService(CacheUtil cacheUtil, RocketMQTemplate rocketMQTemplate) {
this.cacheUtil = cacheUtil;
this.rocketMQTemplate = rocketMQTemplate;
}
public void updateBizData(String key, Object newData) {
dbService.updateById(key, newData);
cacheUtil.clearBothCache(key);
// 发送可靠消息
rocketMQTemplate.syncSend(INVALIDATE_TOPIC, MessageBuilder.withPayload(key).build());
// 异步延迟双删兜底单机竞态
cacheUtil.cacheDelExecutor.submit(() -> {
try {
Thread.sleep(300);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
cacheUtil.clearBothCache(key);
});
}
}
/**
* MQ消费者,所有实例部署,收到消息清除本地Caffeine
*/
@RocketMQMessageListener(topic = "cache_caffeine_invalidate_topic", consumerGroup = "cache-invalidate-group")
@Component
public class CacheInvalidateConsumer implements RocketMQListener<String> {
private final CacheUtil cacheUtil;
public CacheInvalidateConsumer(CacheUtil cacheUtil) {
this.cacheUtil = cacheUtil;
}
@Override
public void onMessage(String key) {
cacheUtil.caffeineCache.invalidate(key);
}
}
方案 3:纯 TTL 兜底,不做消息广播(极简方案)
不引入任何订阅、MQ,只依靠 Caffeine 设置较短过期时间。
- 优点:代码最简单,没有消息组件;
- 缺点:脏读窗口等于 TTL 时长,适合字典、静态配置这类容忍长时间脏读的数据。
实现:不需要额外写通知代码,只在构建 Caffeine 的时候设置 expireAfterWrite 即可。
跨节点失效方案对比表
表格
| 方案 | 可靠性 | 实时性 | 接入成本 | 适用场景 |
|---|---|---|---|---|
| Redis PubSub | 低,消息丢失无重试 | 高 | 低 | 中小项目、非核心业务 |
| MQ(RocketMQ/Kafka) | 高,持久化 + 重试 | 较高 | 高 | 核心业务,要求消息不丢失 |
| 仅依赖 Caffeine TTL | 一般 | 差(窗口 = TTL) | 极低 | 静态配置、字典,容忍长时间脏读 |
重要提醒:无论 PubSub 还是 MQ,都必须搭配 TTL 兜底,防止消息丢失造成永久脏数据。
六、分布式生产标准完整写流程(整合两类脏读处理)
- 更新数据库
- 删除当前实例 Caffeine + 删除 Redis 缓存
- 发送失效消息(PubSub/MQ)广播 key,解决跨节点脏读
- 其他实例消费消息,删除本机 Caffeine
- 异步延迟双删(兜底单机内部慢查询回填竞态)
- Caffeine、Redis 统一设置 TTL 兜底,防止极端情况永久脏数据
七、典型业务落地清单
✅ 适合:商品图文、系统字典、功能开关、首页推荐、活动海报、用户头像昵称、行政区划等静态基础数据 ❌ 禁止:库存、资金、账户余额、订单状态、支付、优惠券核销
八、总结
Caffeine+Redis 是面向热点读的性能加速方案,不是通用缓存方案。 它的收益:本地内存低延迟、拦截热点流量、保护 Redis; 它的代价:引入最终一致,同时要处理两类脏读:
- 单机读写竞态:JVM 内部读写时序错乱,靠延迟双删、锁、版本号、预热方案解决;
- 跨节点脏读:多实例本地缓存不同步,靠 PubSub / MQ 广播失效缩小脏读窗口。
选型一句话:有巨大热点、单用 Redis 扛不住、业务允许短暂不一致,才上双层缓存;不能接受脏读,直接放弃 Caffeine 本地缓存。
浙公网安备 33010602011771号