1. 缓存穿透、击穿、雪崩分别是什么?各自的解决方案?
2. 布隆过滤器的原理是什么?有什么局限性?替代方案?
3. Cache Aside模式的双删策略是什么?为什么需要双删?
4. Redisson的看门狗机制解决了什么问题?
5. RedLock算法的争议点在哪里?生产环境怎么用?
定义: 查询一个数据库和缓存中都不存在的数据,每次请求都打到数据库。
场景: 恶意攻击用不存在的ID大量请求;业务产生的无效查询。
原理:位数组 + 多个哈希函数
添加元素:将元素的多个哈希值对应位置为1
查询元素:检查所有对应位是否为1
判断结果:
- 所有位都是1 → 可能存在(有误判率)
- 任一位是0 → 一定不存在
Java实现(Guava BloomFilter):
// 本地布隆过滤器(单机)
BloomFilter<Long> productIdFilter = BloomFilter.create(
Funnels.longFunnel(),
1_000_000, // 预期元素数量
0.01 // 误判率 1%
);
Redis布隆过滤器(分布式):
@Service
@Slf4j
public class BloomFilterService {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
private static final String BLOOM_KEY = "bloom:product:ids";
/**
* 添加元素到布隆过滤器
*/
public void add(Long id) {
long[] offsets = getOffsets(id);
for (long offset : offsets) {
redisTemplate.opsForValue().setBit(BLOOM_KEY, offset, true);
}
}
/**
* 判断元素是否可能存在
*/
public boolean mightExist(Long id) {
long[] offsets = getOffsets(id);
for (long offset : offsets) {
Boolean bit = redisTemplate.opsForValue().getBit(BLOOM_KEY, offset);
if (bit == null || !bit) {
return false;
}
}
return true;
}
/**
* 使用多个哈希函数计算偏移量
*/
private long[] getOffsets(Long id) {
long[] offsets = new long[7]; // 7个哈希函数
long hash = id;
for (int i = 0; i < 7; i++) {
hash = hash * 31 + i;
offsets[i] = Math.abs(hash % 10_000_000); // 位数组大小
}
return offsets;
}
}
public Product getProduct(Long productId) {
String cacheKey = "product:" + productId;
// 1. 查缓存
String cached = redisTemplate.opsForValue().get(cacheKey);
if (cached != null) {
if ("NULL".equals(cached)) {
return null; // 命中空值标记
}
return JSON.parseObject(cached, Product.class);
}
// 2. 查数据库
Product product = productMapper.selectById(productId);
if (product == null) {
// 缓存空值,短TTL防止占用过多内存
redisTemplate.opsForValue().set(cacheKey, "NULL", 5, TimeUnit.MINUTES);
return null;
}
// 3. 写入缓存
redisTemplate.opsForValue().set(cacheKey, JSON.toJSONString(product),
getRandomTTL(), TimeUnit.MINUTES);
return product;
}
定义: 一个热点key过期的瞬间,大量并发请求同时打到数据库。
@Service
@Slf4j
public class CacheBreakdownService {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
@Autowired
private RedissonClient redissonClient;
/**
* 使用Redisson分布式锁解决缓存击穿
*/
public Product getHotProduct(Long productId) {
String cacheKey = "product:" + productId;
// 1. 查缓存
String cached = (String) redisTemplate.opsForValue().get(cacheKey);
if (cached != null) {
return JSON.parseObject(cached, Product.class);
}
// 2. 获取分布式锁(只允许一个线程重建缓存)
RLock lock = redissonClient.getLock("lock:cache:product:" + productId);
try {
// 等待3秒获取锁,锁定10秒
boolean locked = lock.tryLock(3, 10, TimeUnit.SECONDS);
if (!locked) {
// 获取锁失败,短暂等待后重试查缓存
Thread.sleep(100);
return getHotProduct(productId);
}
// 3. Double Check:获取锁后再查一次缓存
cached = (String) redisTemplate.opsForValue().get(cacheKey);
if (cached != null) {
return JSON.parseObject(cached, Product.class);
}
// 4. 查数据库
Product product = productMapper.selectById(productId);
if (product != null) {
// 热点数据设置较长过期时间 + 随机偏移
long ttl = 60 + ThreadLocalRandom.current().nextLong(-10, 10);
redisTemplate.opsForValue().set(cacheKey,
JSON.toJSONString(product), ttl, TimeUnit.MINUTES);
}
return product;
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException("获取缓存锁被中断", e);
} finally {
if (lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}
}
@Data
public class CacheData<T> {
private T data;
private LocalDateTime expireTime;
}
/**
* 逻辑过期:缓存永不过期,在数据中存储过期时间
* 过期后返回旧数据,异步线程更新缓存
*/
public Product getWithLogicalExpire(Long productId) {
String cacheKey = "product:logical:" + productId;
String cached = (String) redisTemplate.opsForValue().get(cacheKey);
if (cached == null) {
return null; // 不存在直接返回
}
CacheData<Product> cacheData = JSON.parseObject(cached,
new TypeReference<CacheData<Product>>() {});
// 未过期,直接返回
if (cacheData.getExpireTime().isAfter(LocalDateTime.now())) {
return cacheData.getData();
}
// 已过期,尝试获取锁异步更新
RLock lock = redissonClient.getLock("lock:logical:" + productId);
if (lock.tryLock()) {
// 获取锁成功,异步更新
CompletableFuture.runAsync(() -> {
try {
Product product = productMapper.selectById(productId);
CacheData<Product> newData = new CacheData<>();
newData.setData(product);
newData.setExpireTime(LocalDateTime.now().plusMinutes(60));
redisTemplate.opsForValue().set(cacheKey,
JSON.toJSONString(newData));
} finally {
lock.unlock();
}
});
}
// 返回旧数据(无论是否获取锁)
return cacheData.getData();
}
定义: 大量缓存key同时过期,或Redis集群宕机,请求全部打到数据库。
解决方案:
1. 随机TTL:过期时间加随机值,避免同时过期
set key value ex base_ttl + random(0, 300)
2. 多级缓存:本地缓存(Caffeine) + Redis + 数据库
本地缓存作为第一道防线
3. 熔断降级:数据库前加Sentinel/Hystrix熔断
缓存不可用时返回默认值或排队
4. Redis高可用:Sentinel/Cluster避免整体宕机
多级缓存实现:
@Service
@Slf4j
public class MultiLevelCacheService {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
// L1 本地缓存
private final Cache<String, String> localCache = Caffeine.newBuilder()
.maximumSize(10_000)
.expireAfterWrite(5, TimeUnit.MINUTES)
.build();
/**
* L1(本地) → L2(Redis) → DB,逐级回填
*/
public Product getProduct(Long productId) {
String cacheKey = "product:" + productId;
// Level 1: 本地缓存
String cached = localCache.getIfPresent(cacheKey);
if (cached != null) {
return JSON.parseObject(cached, Product.class);
}
// Level 2: Redis
cached = (String) redisTemplate.opsForValue().get(cacheKey);
if (cached != null) {
localCache.put(cacheKey, cached);
return JSON.parseObject(cached, Product.class);
}
// Level 3: 数据库
Product product = productMapper.selectById(productId);
if (product != null) {
String json = JSON.toJSONString(product);
long randomTTL = 60 + ThreadLocalRandom.current().nextLong(0, 30);
redisTemplate.opsForValue().set(cacheKey, json,
randomTTL, TimeUnit.MINUTES);
localCache.put(cacheKey, json);
}
return product;
}
/**
* 随机TTL,防止雪崩
*/
private long getRandomTTL() {
return 60 + ThreadLocalRandom.current().nextLong(-10, 30);
}
}
读:先读缓存 → 缓存未命中 → 读数据库 → 写入缓存
写:先更新数据库 → 再删除缓存
为什么是删除缓存而不是更新缓存?
1. 复杂场景下缓存计算代价高(多表关联),不如用时再算
2. 并发场景下更新缓存容易产生数据不一致
3. 缓存可能被频繁更新但很少被读取,浪费资源
@Service
@Slf4j
public class CacheConsistencyService {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
@Autowired
private ProductMapper productMapper;
/**
* 延迟双删:更新数据库前后各删一次缓存
*
* Thread-A: 删除缓存 → 更新DB → 等待500ms → 再删缓存
* Thread-B: 读缓存miss → 读DB(旧值) → 写缓存(旧值)
*
* 双删确保Thread-B写入的旧值被清除
*/
@Transactional
public void updateProduct(Product product) {
String cacheKey = "product:" + product.getId();
// 第一次删除
redisTemplate.delete(cacheKey);
// 更新数据库
productMapper.updateById(product);
// 延迟双删(异步执行,不阻塞主线程)
CompletableFuture.runAsync(() -> {
try {
Thread.sleep(500); // 等待读线程完成缓存回填
redisTemplate.delete(cacheKey);
log.info("延迟双删成功,key={}", cacheKey);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
}
}
/**
* Canal监听MySQL binlog,异步更新缓存
* 架构:MySQL → Canal → MQ → 消费者 → 更新Redis
*/
@Component
@Slf4j
@CanalTable("t_product")
public class ProductCanalListener implements EntryListener<Product> {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
@Override
public void insert(Product product) {
String cacheKey = "product:" + product.getId();
redisTemplate.opsForValue().set(cacheKey, JSON.toJSONString(product),
60, TimeUnit.MINUTES);
log.info("Canal同步:新增产品缓存,id={}", product.getId());
}
@Override
public void update(Product before, Product after) {
String cacheKey = "product:" + after.getId();
// 更新后直接删缓存,让下次查询重建
redisTemplate.delete(cacheKey);
log.info("Canal同步:删除产品缓存,id={}", after.getId());
}
@Override
public void delete(Product product) {
String cacheKey = "product:" + product.getId();
redisTemplate.delete(cacheKey);
log.info("Canal同步:删除产品缓存,id={}", product.getId());
}
}
@Configuration
public class RedissonConfig {
@Bean
public RedissonClient redissonClient() {
Config config = new Config();
config.useSingleServer()
.setAddress("redis://127.0.0.1:6379")
.setPassword("your_password")
.setConnectionPoolSize(20)
.setConnectionMinimumIdleSize(5);
// 看门狗配置(默认已开启)
// lockWatchdogTimeout = 30秒
// 每隔 30/3 = 10秒 续期一次
config.setLockWatchdogTimeout(30000L);
return Redisson.create(config);
}
}
@Service
@Slf4j
public class DistributedLockService {
@Autowired
private RedissonClient redissonClient;
/**
* 看门狗自动续期
*/
public void processOrder(String orderId) {
RLock lock = redissonClient.getLock("lock:order:" + orderId);
try {
// 不设置过期时间,看门狗自动续期
// leaseTime=-1(默认),看门狗生效
boolean locked = lock.tryLock(5, -1, TimeUnit.SECONDS);
if (!locked) {
throw new RuntimeException("获取锁失败: " + orderId);
}
// 执行业务逻辑(可能耗时较长)
doBusinessLogic(orderId);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
if (lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}
private void doBusinessLogic(String orderId) {
// 业务逻辑...
}
}
看门狗原理:
1. 加锁时不设置leaseTime,默认30秒
2. 后台启动一个定时任务(netty的HashedWheelTimer)
3. 每隔 lockWatchdogTimeout/3 = 10秒 检查锁是否还被持有
4. 如果是,自动续期到 lockWatchdogTimeout
5. 客户端宕机时,定时任务停止,锁自动过期释放
/**
* RedLock:在多个独立的Redis实例上同时加锁
* 超过半数加锁成功才算成功
*/
public boolean tryRedLock(String resourceId, long waitTime, long leaseTime) {
RLock lock1 = redissonClient1.getLock("lock:" + resourceId);
RLock lock2 = redissonClient2.getLock("lock:" + resourceId);
RLock lock3 = redissonClient3.getLock("lock:" + resourceId);
RedissonRedLock redLock = new RedissonRedLock(lock1, lock2, lock3);
try {
return redLock.tryLock(waitTime, leaseTime, TimeUnit.SECONDS);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return false;
} finally {
redLock.unlock();
}
}
RedLock争议点(Martin Kleppmann vs Antirez):
争议1:时钟漂移问题
- 多个Redis实例的时钟可能不一致
- Antirez回应:Redis通过进程内计时,不依赖系统时钟
争议2:GC停顿导致锁被多人持有
- 客户端GC暂停期间锁过期,另一个客户端获取锁
- 实际上任何分布式锁都无法完全避免此问题
争议3:fencing token方案更可靠
- Martin建议用单调递增的token来保证互斥
- 适用于对正确性要求极高的场景
生产建议:
- 大多数场景用Redisson单实例锁+看门狗即可
- 极端场景考虑ZooKeeper或etcd(强一致性)
- RedLock可作为折中方案,但要评估3个实例的运维成本
答:
答:
推荐先更新数据库再删缓存(Cache Aside),因为:
答:
解决了锁过期时间不好设定的问题。如果设太短,业务没执行完锁就释放了;设太长,客户端宕机后锁迟迟不释放。看门狗机制在持有锁期间自动续期,客户端正常时持续续期,宕机时自动停止,锁自然过期释放。
答:
1. Cache Aside模式 + 延迟双删,覆盖大部分场景
2. Canal监听binlog异步删除缓存,作为兜底
3. 设置合理的缓存过期时间,即使删除失败也会最终过期
4. 对一致性要求极高的数据,可通过MQ确保删除成功(失败重试)
5. 定时任务对账,发现不一致时修复
答:
1. 有误判率:判断存在可能不准确(false positive),判断不存在一定准确
2. 不支持删除:置位后无法清除,Counting Bloom Filter可以但空间翻倍
3. 容量需要预估:元素数量超出预期后误判率急剧上升
4. 替代方案:Cuckoo Filter(支持删除)、RocksDB(精确但更重)
// 要求:整合布隆过滤器 + 互斥锁 + 随机TTL,实现一个防穿透+防击穿的缓存服务
// 1. 商品创建时加入布隆过滤器
// 2. 查询时先过布隆过滤器,再查缓存
// 3. 缓存未命中时用分布式锁重建
// 4. TTL加随机值
// 1. MySQL开启binlog(ROW模式)
// 2. 部署Canal Server
// 3. 编写Canal Client监听商品表变更
// 4. 验证:修改数据库数据,检查Redis缓存是否同步删除
// 1. 使用Redisson单实例锁实现库存扣减
// 2. 模拟高并发场景(100线程抢10个库存)
// 3. 观察是否有超卖
// 4. 对比setnx手动实现的锁,分析看门狗的优势
| 问题 | 核心方案 | 关键技术 |
|---|---|---|
| 缓存穿透 | 布隆过滤器 + 空值缓存 | Guava/Redis BloomFilter |
| 缓存击穿 | 互斥锁 + 逻辑过期 | Redisson RLock |
| 缓存雪崩 | 随机TTL + 多级缓存 | Caffeine + Redis |
| 缓存一致性 | 延迟双删 + Canal | Binlog监听 |
| 分布式锁 | Redisson看门狗 | 自动续期、RedLock |