← 返回首页 📚 实战课程
📑 本篇章节导航 (共5章,点击直达)
本节目标(学完能回答的面试题)核心知识面试模拟实操练习本节小结

P2-02 - Redis实战场景与缓存问题

本节目标(学完能回答的面试题)

1. 缓存穿透、击穿、雪崩分别是什么?各自的解决方案?

2. 布隆过滤器的原理是什么?有什么局限性?替代方案?

3. Cache Aside模式的双删策略是什么?为什么需要双删?

4. Redisson的看门狗机制解决了什么问题?

5. RedLock算法的争议点在哪里?生产环境怎么用?

核心知识

一、缓存穿透

定义: 查询一个数据库和缓存中都不存在的数据,每次请求都打到数据库。

场景: 恶意攻击用不存在的ID大量请求;业务产生的无效查询。

1.1 布隆过滤器方案


原理:位数组 + 多个哈希函数
添加元素:将元素的多个哈希值对应位置为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;
    }
}

1.2 缓存空值方案


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过期的瞬间,大量并发请求同时打到数据库。

2.1 互斥锁方案


@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();
            }
        }
    }
}

2.2 逻辑过期方案(不设TTL)


@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);
    }
}

四、缓存一致性

4.1 Cache Aside 模式


读:先读缓存 → 缓存未命中 → 读数据库 → 写入缓存
写:先更新数据库 → 再删除缓存

为什么是删除缓存而不是更新缓存?


1. 复杂场景下缓存计算代价高(多表关联),不如用时再算
2. 并发场景下更新缓存容易产生数据不一致
3. 缓存可能被频繁更新但很少被读取,浪费资源

4.2 延迟双删策略


@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();
            }
        });
    }
}

4.3 基于Canal的缓存同步


/**
 * 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());
    }
}

五、分布式锁进阶

5.1 Redisson看门狗机制


@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. 客户端宕机时,定时任务停止,锁自动过期释放

5.2 RedLock算法


/**
 * 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个实例的运维成本

面试模拟

Q1:缓存穿透、击穿、雪崩的区别和解决方案?

答:

Q2:先删缓存还是先更新数据库?

答:

推荐先更新数据库再删缓存(Cache Aside),因为:

Q3:Redisson看门狗解决了什么问题?

答:

解决了锁过期时间不好设定的问题。如果设太短,业务没执行完锁就释放了;设太长,客户端宕机后锁迟迟不释放。看门狗机制在持有锁期间自动续期,客户端正常时持续续期,宕机时自动停止,锁自然过期释放。

Q4:如何保证缓存和数据库最终一致性?

答:

1. Cache Aside模式 + 延迟双删,覆盖大部分场景

2. Canal监听binlog异步删除缓存,作为兜底

3. 设置合理的缓存过期时间,即使删除失败也会最终过期

4. 对一致性要求极高的数据,可通过MQ确保删除成功(失败重试)

5. 定时任务对账,发现不一致时修复

Q5:布隆过滤器的局限性?

答:

1. 有误判率:判断存在可能不准确(false positive),判断不存在一定准确

2. 不支持删除:置位后无法清除,Counting Bloom Filter可以但空间翻倍

3. 容量需要预估:元素数量超出预期后误判率急剧上升

4. 替代方案:Cuckoo Filter(支持删除)、RocksDB(精确但更重)

实操练习

练习1:实现完整的缓存防护


// 要求:整合布隆过滤器 + 互斥锁 + 随机TTL,实现一个防穿透+防击穿的缓存服务
// 1. 商品创建时加入布隆过滤器
// 2. 查询时先过布隆过滤器,再查缓存
// 3. 缓存未命中时用分布式锁重建
// 4. TTL加随机值

练习2:Canal环境搭建


// 1. MySQL开启binlog(ROW模式)
// 2. 部署Canal Server
// 3. 编写Canal Client监听商品表变更
// 4. 验证:修改数据库数据,检查Redis缓存是否同步删除

练习3:分布式锁对比测试


// 1. 使用Redisson单实例锁实现库存扣减
// 2. 模拟高并发场景(100线程抢10个库存)
// 3. 观察是否有超卖
// 4. 对比setnx手动实现的锁,分析看门狗的优势

本节小结

问题核心方案关键技术
缓存穿透布隆过滤器 + 空值缓存Guava/Redis BloomFilter
缓存击穿互斥锁 + 逻辑过期Redisson RLock
缓存雪崩随机TTL + 多级缓存Caffeine + Redis
缓存一致性延迟双删 + CanalBinlog监听
分布式锁Redisson看门狗自动续期、RedLock