知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 06 - 缓存设计与常见问题 ## 缓存读写模式 ``` 设计缓存时,面试里经常会先问一句: 你们系统采用的到底是哪种缓存模式? 常见模式有 4 种: ``` ### Cache Aside(旁路缓存,最常用)  *图:Cache-Aside 的读流程与写流程* ``` 读流程(Cache-Aside Read): 客户端请求 │ ↓ ┌──────────┐ Hit ┌──────────┐ │ 查缓存 │───────────→│ 返回数据 │ └────┬─────┘ └──────────┘ │ Miss ↓ ┌──────────┐ ┌──────────┐ │ 查数据库 │───────────→│ 写回缓存 │──→ 返回数据 └──────────┘ └──────────┘ 写流程(Cache-Aside Write): 客户端请求 │ ↓ ┌──────────┐ ┌──────────┐ │ 更新数据库│───────────→│ 删除缓存 │──→ 返回成功 └──────────┘ └──────────┘ 关键原则: 1. 缓存只存储"数据库的副本",数据库是唯一真相来源 2. 写操作删缓存而不是更新缓存(避免并发写导致的不一致) 3. 先写数据库再删缓存(推荐),而不是反过来 ``` ### Read Through(穿透读) ``` 应用只访问缓存层 缓存层负责: 缓存命中直接返回 缓存未命中时自动查询数据库并回填 优点: 业务代码更简单 缺点: 对缓存组件能力要求更高 业务灵活性通常不如 Cache Aside ``` ### Write Through(穿透写) ``` 应用写数据时先写缓存 缓存层再同步写数据库 优点: 缓存和数据库更新路径统一 缺点: 写链路更长 对缓存层一致性和可用性要求高 ``` ### Write Behind / Write Back(回写) ``` 应用先写缓存 缓存异步批量刷回数据库 优点: 写性能最好,适合写多读多场景 缺点: 数据丢失风险更高 一致性和恢复逻辑更复杂 ``` ### 生产上最常见的选择 ``` 大多数互联网业务用的是 Cache Aside: 1. 读:缓存未命中再查库 2. 写:先更新数据库,再删除缓存 因为它最符合"数据库是最终真相来源,缓存负责提速"的工程习惯 后面讲缓存一致性时,默认也是在这个模式下讨论 ``` ## 三大缓存问题全景对比  *图:缓存穿透、击穿、雪崩的现象、根因与应对方案* ``` 缓存穿透 缓存击穿 缓存雪崩 ┌─────────────────────────────────────────────────────────────────────────┐ │ 现象 查询不存在的数据 热点 key 过期瞬间 大量 key 同时过期 │ 每次都穿到数据库 大量并发查数据库 或 Redis 宕机 │ │ │ 根因 DB 中根本没有该数据 单个热点 key TTL=0 批量 key TTL 相同 │ 缓存也无法命中 大量请求同时回源 或缓存服务不可用 │ │ │ 后果 数据库压力骤增 数据库瞬时峰值 数据库被打垮 │ 恶意攻击可打垮 DB 可能拖垮整个服务 级联故障 │ │ │ 方案 ① 布隆过滤器 ① 互斥锁 ① TTL + 随机值 │ ② 缓存空值 ② 逻辑过期 ② 高可用(集群) │ ③ 参数校验 ③ 永不过期 ③ 多级缓存 │ │ │ 典型场景 攻击者扫不存在的用户 ID 秒杀商品过期瞬间 全量缓存预热 │ │ └─────────────────────────────────────────────────────────────────────────┘ ```   ## 缓存穿透 ### 什么是缓存穿透 ``` 查询一个数据库中根本不存在的数据,缓存中也没有, 每次请求都直接打到数据库。 场景: 正常请求:查 user:1001 → 缓存命中 → 返回 穿透请求:查 user:-1(不存在)→ 缓存未命中 → 查数据库 → 数据库也没有 如果攻击者用大量不存在的 key 发起请求,数据库会被打垮 ``` ### 解决方案 **方案 1:缓存空值** ```java // 查询结果为 null 时,也缓存一个空值 String value = redis.get(key); if (value == null) { value = db.query(key); if (value == null) { redis.set(key, "NULL", 300); // 缓存空值,TTL 设短一点(5 分钟) } else { redis.set(key, value, 3600); } } return "NULL".equals(value) ? null : value; // 缺点:大量不同的不存在 key 会占用缓存空间 ``` **方案 2:布隆过滤器(推荐)**  *图:布隆过滤器的 bit 数组置位与误判原因* ``` 布隆过滤器:用极小的内存判断一个元素是否可能存在于集合中 判断"不存在":100% 准确(一定不存在) 判断"存在":有一定误判率(可能不存在) 布隆过滤器原理: 用多个哈希函数 + 一个 bit 数组 初始化(空数组): bit[0] bit[1] bit[2] bit[3] bit[4] bit[5] bit[6] bit[7] ... bit[m-1] ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐ │ 0 │ 0 │ 0 │ 0 │ 0 │ 0 │ 0 │ 0 │...│ 0 │ 0 │ 0 │ 0 │ 0 │ └───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘ 添加 key = "user:1001": hash1("user:1001") % m = 2 → bit[2] = 1 hash2("user:1001") % m = 5 → bit[5] = 1 hash3("user:1001") % m = 9 → bit[9] = 1 bit[0] bit[1] bit[2] bit[3] bit[4] bit[5] bit[6] bit[7] bit[8] bit[9] ... ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐ │ 0 │ 0 │ 1 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 1 │...│ 0 │ 0 │ 0 │ └───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘ 查询 key = "user:9999"(不存在): hash1("user:9999") % m = 3 → bit[3] = 0 → 只要有一个 bit 是 0,key 一定不存在 ✓ 查询 key = "user:8888"(不存在,但误判): hash1("user:8888") % m = 2 → bit[2] = 1 hash2("user:8888") % m = 5 → bit[5] = 1 hash3("user:8888") % m = 9 → bit[9] = 1 → 所有 bit 都是 1,误判为"可能存在" ✗ (误判率 ≈ 1%~3%,可通过增加 bit 数量和哈希函数数降低) 使用方式: 启动时将所有合法 key 加入布隆过滤器 请求来时先查布隆过滤器: 不存在 → 直接返回 null,不查缓存和数据库 可能存在 → 正常查缓存和数据库 Redis 实现(使用 RedisBloom 模块): BF.ADD users user:1001 BF.EXISTS users user:9999 # 返回 0 表示一定不存在 ``` ## 缓存击穿 ### 什么是缓存击穿 ``` 一个热点 key 过期的瞬间,大量并发请求同时打到数据库。 场景: 热点商品 product:1001 的缓存在 12:00:00 过期 12:00:00 时有 10000 个并发请求同时查询 缓存全部未命中 → 10000 个请求同时查数据库 → 数据库崩溃 ``` ### 解决方案 **方案 1:互斥锁(Mutex Lock)** ```java String value = redis.get(key); if (value == null) { // 只有一个线程能获取锁 if (redis.setnx("lock:" + key, "1", 10)) { // 10 秒超时 try { value = db.query(key); redis.set(key, value, 3600); } finally { redis.del("lock:" + key); } } else { // 获取锁失败,等待后重试 Thread.sleep(50); return get(key); // 递归重试 } } return value; // 优点:数据库只被查询一次 // 缺点:等待期间其他线程阻塞,响应变慢 ``` **方案 2:逻辑过期(推荐热点数据)** ```java // 不设置真实的 TTL,在 value 中存储逻辑过期时间 class CacheValue { String data; long expireTime; // 逻辑过期时间 } String get(String key) { CacheValue cv = redis.get(key); if (cv == null) return null; if (cv.expireTime > System.currentTimeMillis()) { return cv.data; // 未过期,直接返回 } // 逻辑过期,异步更新 if (redis.setnx("lock:" + key, "1", 10)) { // 获取到锁,异步重建缓存 executor.submit(() -> { String newData = db.query(key); redis.set(key, new CacheValue(newData, now + 3600)); redis.del("lock:" + key); }); } // 返回旧数据(不阻塞) return cv.data; } // 优点:不阻塞,始终有数据返回(返回旧数据) // 缺点:短暂返回旧数据(最终一致性) ``` ## 缓存雪崩 ### 什么是缓存雪崩 ``` 大量缓存在同一时间集中过期,或者 Redis 宕机, 导致大量请求同时打到数据库。 场景 1:集中过期 系统启动时批量加载了 10 万条缓存,TTL 都设为 1 小时 1 小时后,10 万条缓存同时过期 大量请求同时打到数据库 场景 2:Redis 宕机 Redis 服务不可用,所有请求直接打到数据库 ``` ### 解决方案 **针对集中过期:** ```java // 在基础 TTL 上加随机值,避免同时过期 int baseTTL = 3600; int randomTTL = new Random().nextInt(600); // 0~600 秒随机 redis.set(key, value, baseTTL + randomTTL); // 这样 10 万条缓存的过期时间分散在 1 小时到 1 小时 10 分钟之间 // 不会同时过期 ``` **针对 Redis 宕机:** ``` 1. Redis 高可用:主从 + 哨兵 或 集群,避免单点故障 2. 服务降级:Redis 不可用时,返回默认值或提示"服务繁忙" 不要让所有请求都打到数据库 3. 限流:对数据库访问加限流,超过阈值直接拒绝 Guava RateLimiter 或 Sentinel 4. 多级缓存:本地缓存(Caffeine)+ Redis Redis 宕机时,本地缓存还能抗一部分流量 ``` ## 缓存一致性 ### 问题 ``` 缓存和数据库的数据如何保持一致? 常见操作顺序: 方案 A:先更新数据库,再更新缓存 方案 B:先更新缓存,再更新数据库 方案 C:先更新数据库,再删除缓存(推荐) 方案 D:先删除缓存,再更新数据库 ``` ### 为什么推荐"先更新数据库,再删除缓存"?  *图:四种缓存更新顺序的并发分析,推荐先更库再删缓存* ``` 四种方案并发分析: 方案 A:先更新数据库,再更新缓存 线程1 线程2 DB Cache ───────────────────────────────────────────────────────────────── updateDB(v=100) updateDB(v=200) 200 ? updateCache(200) 200 200 updateCache(100) ← 线程1写回旧值! 200 100 ❌ 不一致! 问题:并发写时,缓存可能是旧值 方案 B:先更新缓存,再更新数据库 线程1 线程2 DB Cache ───────────────────────────────────────────────────────────────── updateCache(100) updateCache(200) ? 200 updateDB(200) 200 200 updateDB(100) ← DB 是旧值! 100 200 ❌ 不一致! 问题:DB 更新失败时,缓存已是新值 方案 C:先删除缓存,再更新数据库(不推荐) 线程1(读) 线程2(写) DB Cache ───────────────────────────────────────────────────────────────── cache.get() → null delCache() 200 (删除) db.query() → 旧值200 updateDB(v=300) 300 (删除) cache.set(200) 300 200 ❌ 不一致! 问题:写操作删缓存后,读操作可能把旧值写回缓存 方案 D:先更新数据库,再删除缓存(推荐!) 线程1(读) 线程2(写) DB Cache ───────────────────────────────────────────────────────────────── cache.get() → null updateDB(v=300) 300 ? db.query() → 旧值200 delCache() 300 (删除) cache.set(200) ← 极小概率! 300 200 ❌ 这个并发窗口极其狭窄(读操作的 DB 查询必须比写操作还慢) 实际概率极低,且有 TTL 兜底,是工程上的最优方案 推荐方案 C(先更新数据库,再删除缓存)的原因总结: 1. 并发导致不一致的概率极低(需要"读 DB 比写 DB 慢") 2. 即使出现不一致,也有 TTL 兜底最终一致 3. 删除缓存比更新缓存更简单(不需要反序列化→修改→序列化) 4. 缓存删除失败的概率比更新失败低 ``` ### 延迟双删时序  *图:延迟双删的时序与两次删缓存的理由* ``` 延迟双删 = 先删除缓存 → 再更新数据库 → 延迟后再删除缓存 时序图: 线程1(写) DB Cache ───────────────────────────────────────────────────────────────── delCache() (删除) updateDB(v=300) 300 (删除) sleep(N ms) ← 等并发读完成 delCache() ← 第二次删除,清除并发读写入的旧值 300 (删除) 为什么第一次先删缓存? 如果先写 DB 成功但删缓存失败 → 数据不一致 先删缓存成功,写 DB 失败 → 缓存没了但 DB 也没改,没问题 为什么第二次再删缓存? 防止在"DB 更新完成→缓存重建"之间,其他线程读到旧 DB 值并写入缓存 第二次删除清除这个并发窗口写入的脏数据 缺点: sleep 时间不好把握(太短无效,太长影响性能) 引入了写操作的延迟 ``` ### 为什么是删除缓存而不是更新? ``` 1. 更新缓存的动作比较复杂,容易出错: 缓存中的数据可能不只是简单的字符串,还可能是大 JSON、Map 等 需要取出来 → 反序列化 → 修改字段 → 序列化 → 放回去,比较费事 2. 更新缓存还是会出现数据不一致: 缓存更新和数据库更新不是原子操作 并发场景下两个线程同时更新,可能导致缓存中是旧值 ``` ### 先写数据库还是先删缓存? ``` 先删缓存,再更新数据库: 无形中放大了并发读写导致的数据不一致问题 但读操作很快(十几毫秒),在此期间另一个线程执行耗时写操作的概率较低 先更新数据库,再删缓存(推荐): 缓存删除失败的概率较低(除非网络问题或缓存服务器宕机) 先更新数据库能确保数据先写入持久层,保证可靠性和一致性 即使删除缓存失败,数据库中已有最新数据 问题:如果第二步失败,数据库是新值但缓存是旧值 ``` ### 延迟双删 ``` 延迟双删 = 先删除缓存 → 再更新数据库 → 再删除一次缓存 第一次删缓存的原因: 如果先写数据库成功但删缓存失败,就会导致数据不一致 而先删缓存成功后更新数据库失败,缓存删了就删了 不会有错误数据,也没有不一致问题 第二次删除的原因: 缓存在更新后,可能被其他线程把脏数据覆盖进去 第二次删除用来清除并发写入的旧值 有了第二次删除,第一次还有意义吗? 有。第二次删除也可能失败 第一次删除保底,第二次删除尽可能降低并发导致不一致的概率 ``` ```java // 延迟双删示例 redis.del(key); db.update(key, newValue); // 延迟 500ms 再删一次,清除并发写入的旧值 Thread.sleep(500); redis.del(key); // 适用于读多写少、对一致性要求较高的场景 ``` ## 热点 key 问题 ``` 问题:某个 key 访问量极高(如热门商品、明星微博), 单个 Redis 节点承受不了这么大的压力 解决方案: 1. 本地缓存(JVM 缓存) 热点数据缓存在应用服务器的内存中(Caffeine) 不经过 Redis,直接从本地返回 缺点:多实例数据不一致,内存占用 2. key 分散(热点 key 复制) 将热点 key 复制为多个:hot_key_1, hot_key_2, ..., hot_key_N 请求时随机选一个访问,分散到不同节点 更新时同时更新所有副本 3. Redis Cluster 读从节点 开启 READONLY 模式,从节点也可以处理读请求 ``` ## 面试常见问题 **Q:缓存穿透、击穿、雪崩分别是什么?怎么解决?** A: - 穿透:查询不存在的数据,每次都打到数据库。解决:布隆过滤器过滤非法请求,或缓存空值。 - 击穿:热点 key 过期瞬间大量并发打到数据库。解决:互斥锁(只让一个请求查数据库)或逻辑过期(不设真实 TTL,异步更新)。 - 雪崩:大量缓存同时过期或 Redis 宕机。解决:TTL 加随机值避免集中过期,Redis 高可用,服务降级限流。 **Q:缓存更新策略推荐哪种?为什么?** A:推荐"先更新数据库,再删除缓存"(Cache-Aside 模式)。先更新数据库保证数据持久化,删除缓存而不是更新缓存,避免并发写导致缓存脏数据。下次读取时重新从数据库加载最新数据到缓存。 --- 上一篇:[05 - 集群模式](./05-cluster.md) | 下一篇:[07 - 分布式锁](./07-distributed-lock.md)
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入