定义: 查询数据库中不存在的数据,缓存永远不命中,请求全打到DB。
攻击场景:
客户端 → 请求userId=-1(不存在)
→ 缓存miss
→ 查DB → 不存在
→ 不写缓存
→ 下次请求还是miss
→ DB被打崩
正常场景:
客户端 → 请求userId=123(存在)
→ 缓存miss
→ 查DB → 存在
→ 写缓存+返回
→ 下次请求缓存hit
解决方案:
方案1: 布隆过滤器(前置拦截)
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────┐
│ 客户端 │──→│布隆过滤器 │──→│ 缓存 │──→│ DB │
│ │ │判断存在? │ │ │ │ │
│ │ │ ↓不存在 │ │ │ │ │
│ │ │ 直接返回 │ │ │ │ │
└──────────┘ └──────────┘ └──────────┘ └──────┘
布隆过滤器原理:
┌─────────────────────────────────────────┐
│ 位数组(初始全0): │
│ [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0] │
│ │
│ 添加"user:123": │
│ hash1("user:123")=3 → bit[3]=1 │
│ hash2("user:123")=7 → bit[7]=1 │
│ hash3("user:123")=11 → bit[11]=1 │
│ [0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0] │
│ │
│ 查询"user:999": │
│ hash1("user:999")=3 → bit[3]=1 ✓ │
│ hash2("user:999")=5 → bit[5]=0 ✗ │
│ → 一定不存在!直接返回 │
│ │
│ 特性: │
│ 说"不存在" → 一定不存在 │
│ 说"存在" → 可能存在(有误判率) │
└─────────────────────────────────────────┘
方案2: 空值缓存
查DB为空时也写缓存: SET user:-1 NULL EX 300
TTL设短(5分钟),浪费少量内存但简单有效
方案3: 参数校验(第一道防线)
userId<0直接拦截,非法参数不进系统
定义: 热点key过期瞬间,大量并发请求同时打到DB。
场景: 秒杀商品信息缓存,TTL=30分钟
10:00:00 缓存过期 → 1000个并发请求同时miss
→ 1000个请求同时查DB → DB压力突增
与穿透的区别:
穿透: 数据根本不存在(查什么都是miss)
击穿: 数据存在但缓存过期了(热点key过期瞬间)
解决方案:
// 方案1: 互斥锁(SETNX) — 推荐方案
public String getWithMutex(String key) {
String value = redisTemplate.opsForValue().get(key);
if (value != null) return value;
String lockKey = "lock:cache:" + key;
try {
// SETNX抢锁,TTL=10秒防死锁
boolean locked = redisTemplate.opsForValue()
.setIfAbsent(lockKey, "1", 10, TimeUnit.SECONDS);
if (locked) {
// 抢到锁: 查DB + 写缓存
value = queryFromDB(key);
long ttl = 1800 + ThreadLocalRandom.current().nextLong(600);
redisTemplate.opsForValue().set(key, value, ttl, TimeUnit.SECONDS);
} else {
// 没抢到: 短暂等待后重试
Thread.sleep(100);
return getWithMutex(key);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
redisTemplate.delete(lockKey);
}
return value;
}
// 方案2: 逻辑过期(不设TTL,数据中存过期时间)
public String getWithLogicalExpire(String key) {
String json = redisTemplate.opsForValue().get(key);
if (json == null) return null;
CacheData cacheData = JSON.parseObject(json, CacheData.class);
if (cacheData.getExpireTime().isAfter(LocalDateTime.now())) {
return cacheData.getData(); // 未过期,直接返回
}
// 逻辑过期了,异步更新
CompletableFuture.runAsync(() -> {
String lockKey = "lock:cache:" + key;
if (redisTemplate.opsForValue().setIfAbsent(lockKey, "1", 10, SECONDS)) {
try {
String newValue = queryFromDB(key);
CacheData newCache = new CacheData(newValue,
LocalDateTime.now().plusMinutes(30));
redisTemplate.opsForValue().set(key, JSON.toJSONString(newCache));
} finally {
redisTemplate.delete(lockKey);
}
}
});
return cacheData.getData(); // 先返回旧数据(高可用)
}
互斥锁 vs 逻辑过期对比:
| 维度 | 互斥锁(SETNX) | 逻辑过期 |
|---|---|---|
| 一致性 | 强一致(只返回最新数据) | 最终一致(可能返回旧数据) |
| 性能 | 等待锁有延迟 | 无等待,始终可用 |
| 实现 | 简单 | 稍复杂 |
| 适用 | 一致性要求高 | 高可用优先 |
定义: 大量key同时过期,或Redis宕机,请求全打到DB。
场景1: 缓存预热时,所有key的TTL都设为30分钟
→ 30分钟后全部过期 → 雪崩
场景2: Redis集群宕机 → 所有请求打到DB → DB也崩了
解决方案:
方案1: 随机TTL
TTL = 基础时间 + 随机偏移
例: TTL = 30min + random(0~10min)
避免大量key同时过期
方案2: 多级缓存
请求 → 本地缓存(Caffeine, 1min) → Redis(30min) → DB
↓ miss ↓ miss
← ← ← ← ← ← ← ← ← ← ←
写回本地+Redis
方案3: Redis高可用
哨兵/Cluster,确保Redis不宕机
方案4: 限流降级
Sentinel限流保护DB,降级返回默认值/排队
方案5: 永不过期 + 异步刷新
热点key不设TTL,后台定时刷新
// 企业级多级缓存代码
@Service
public class MultiLevelCacheService {
private final Cache<String, String> localCache = Caffeine.newBuilder()
.maximumSize(10_000)
.expireAfterWrite(60, TimeUnit.SECONDS)
.build();
@Autowired
private RedisTemplate<String, String> redisTemplate;
public Product getProduct(String productId) {
String key = "product:" + productId;
// Level 1: 本地缓存
String json = localCache.getIfPresent(key);
if (json != null) return JSON.parseObject(json, Product.class);
// Level 2: Redis
json = redisTemplate.opsForValue().get(key);
if (json != null) {
localCache.put(key, json);
return JSON.parseObject(json, Product.class);
}
// Level 3: DB
Product product = productMapper.selectById(productId);
if (product != null) {
json = JSON.toJSONString(product);
long ttl = 1800 + ThreadLocalRandom.current().nextLong(600); // 随机TTL
redisTemplate.opsForValue().set(key, json, ttl, TimeUnit.SECONDS);
localCache.put(key, json);
}
return product;
}
}
| 维度 | 穿透 | 击穿 | 雪崩 |
|---|---|---|---|
| 原因 | 数据不存在 | 热点key过期 | 大量key同时过期/Redis宕机 |
| 请求量 | 持续打到DB | 瞬时打到DB | 瞬时打到DB |
| 核心方案 | 布隆过滤器+空值缓存 | 互斥锁+逻辑过期 | 随机TTL+多级缓存+限流 |
| 关键区别 | 根本不存在 | 存在但过期 | 大面积失效 |
| 维度 | Redis SETNX | Redisson | RedLock | ZooKeeper | 数据库锁 |
|---|---|---|---|---|---|
| 性能 | 极高(10w+TPS) | 高(5w+TPS) | 中(需锁5个实例) | 中(1w TPS) | 低 |
| 可靠性 | 中(主从丢锁) | 高(看门狗) | 较高(多实例) | 极高(ZAB) | 高(ACID) |
| 可重入 | 不支持 | 支持(Hash) | 支持 | 支持 | 不支持 |
| 自动续期 | 不支持 | 看门狗 | 看门狗 | 临时节点 | 不需要 |
| 公平锁 | 不支持 | 支持 | 支持 | 天然FIFO | 不支持 |
| 适用场景 | 简单互斥 | 通用业务锁 | 强一致需求 | 金融级场景 | 低并发 |
加锁Lua脚本:
if (redis.call('exists', KEYS[1]) == 0) then -- 锁不存在
redis.call('hset', KEYS[1], ARGV[2], 1) -- Hash: {threadId: 1}
redis.call('pexpire', KEYS[1], ARGV[1]) -- 设过期时间
return nil
end
if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then -- 锁存在且是自己的
redis.call('hincrby', KEYS[1], ARGV[2], 1) -- 重入计数+1
redis.call('pexpire', KEYS[1], ARGV[1]) -- 刷新过期时间
return nil
end
return redis.call('pttl', KEYS[1]) -- 返回剩余TTL(加锁失败)
Redis存储结构:
Key: lock:order:123
Value (Hash): { "threadId-1": 2 } ← 线程1重入了2次
TTL: 30s
┌─────────────────┐
│ 加锁成功 │
│ leaseTime=30s │
└───────┬─────────┘
│
┌───────▼─────────┐
│ 启动看门狗 │
│ 每10s续期一次 │ ← leaseTime/3 = 10s
│ (后台定时任务) │
└───────┬─────────┘
│
┌─────────────────┼─────────────────┐
│ │ │
业务还在执行 业务还在执行 业务完成
续期到30s 续期到30s ┌─┴─┐
│ │ │解锁│ → 取消看门狗
... ... └───┘
关键参数:
- lockWatchdogTimeout = 30s (默认)
- 续期间隔 = 30s / 3 = 10s
- 客户端宕机 → 看门狗停止 → 30s后锁自动释放
⚠ 什么时候不生效?
指定leaseTime参数时,看门狗不会启动!
lock.tryLock(5, 30, TimeUnit.SECONDS); // 30s后锁一定释放
lock.tryLock(5, TimeUnit.SECONDS); // 看门狗生效,自动续期
@Service
public class OrderService {
@Autowired
private RedissonClient redissonClient;
public String createOrder(String productId) {
RLock lock = redissonClient.getLock("lock:order:" + productId);
try {
// 看门狗自动续期(不指定leaseTime)
boolean acquired = lock.tryLock(5, TimeUnit.SECONDS);
if (!acquired) {
throw new BizException("系统繁忙,请稍后重试");
}
return doCreateOrder(productId);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new BizException("创建订单被中断");
} finally {
if (lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}
}
解决: Redis主从切换丢锁问题
方法: 向N个独立Redis实例同时加锁,超过半数成功才算获取
客户端 R-1 R-2 R-3 R-4 R-5
│ │ │ │ │ │
│── set NX EX ────→│ ✓ │ │ │ │
│── set NX EX ───────────→│ ✗ │ │ │
│── set NX EX ──────────────────→│ ✓ │ │
│── set NX EX ─────────────────────────→│ ✓ │
│── set NX EX ────────────────────────────────→│ ✓
│ │ │ │ │ │
│ 4/5成功 > N/2+1 → 加锁成功(有效时间=30s-2s=28s)
Martin Kleppmann批评:
1. 时钟跳跃: Redis依赖系统时钟,跳跃导致锁提前过期
2. GC暂停: STW期间锁过期,恢复后仍认为持有锁
3. 建议: 用Fencing Token(递增令牌)保证安全性
Antirez反驳:
1. 时钟跳跃可通过合理部署避免
2. 实践中极少发生
3. 多数业务场景够用
企业建议:
- 非金融: Redisson单节点/主从即可
- 金融: 用ZooKeeper而非RedLock
原理: 临时顺序节点 + Watch机制
/locks/order-123/
├── lock-0000000000 ← 持有者
├── lock-0000000001 ← 等待者1 (Watch前一个节点)
└── lock-0000000002 ← 等待者2 (Watch前一个节点)
加锁: 创建临时顺序节点 → 判断是否最小序号 → 是则获取锁
解锁: 删除节点 → 下一个等待者收到Watch通知
宕机: 会话失效 → 临时节点自动删除 → 天然防死锁
ZK vs Redisson:
| 维度 | Redisson | ZooKeeper |
| 性能 | 高(内存) | 中(磁盘+网络) |
| 一致性 | 最终一致 | 强一致(ZAB) |
| 公平性 | 默认非公平 | 天然公平(FIFO) |
| 运维 | 低(已有Redis) | 高(独立ZK集群) |
面试话术: "缓存三大问题我们都有防范。穿透用布隆过滤器+空值缓存双层防护;击穿用互斥锁,只有拿到锁的线程查DB重建缓存;雪崩用随机TTL+多级缓存(Caffeine+Redis)+限流降级。分布式锁我们用Redisson,它通过Lua脚本保证原子性,Hash结构支持可重入,看门狗每10秒自动续期。金融场景考虑用ZooKeeper的临时顺序节点,天然公平锁+强一致。"
1. 缓存穿透和缓存击穿的区别是什么?分别给出一个触发场景的例子。
2. 布隆过滤器说"存在"时为什么不一定存在?说"不存在"时为什么一定不存在?
3. Redisson的看门狗续期间隔是leaseTime的1/3,为什么不是1/2或1/10?
4. 如果Redis主从切换时锁丢失了,会导致什么问题?RedLock如何解决?
5. ZooKeeper分布式锁为什么是天然公平锁?它是如何保证FIFO顺序的?