← 返回首页 📚 实战课程
📑 本篇章节导航 (共5章,点击直达)
本节目标(学完能回答的面试题)核心知识(1小时精讲内容)面试速记卡(考前30秒速看)练习题(自测)学习资料

L15 - Redis缓存三大问题与分布式锁

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

核心知识(1小时精讲内容)

一、缓存穿透

定义: 查询数据库中不存在的数据,缓存永远不命中,请求全打到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 SETNXRedissonRedLockZooKeeper数据库锁
性能极高(10w+TPS)高(5w+TPS)中(需锁5个实例)中(1w TPS)低
可靠性中(主从丢锁)高(看门狗)较高(多实例)极高(ZAB)高(ACID)
可重入不支持支持(Hash)支持支持不支持
自动续期不支持看门狗看门狗临时节点不需要
公平锁不支持支持支持天然FIFO不支持
适用场景简单互斥通用业务锁强一致需求金融级场景低并发

六、Redisson深度解析

6.1 核心原理(Lua脚本保证原子性)


加锁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

6.2 看门狗机制


                     ┌─────────────────┐
                     │   加锁成功       │
                     │   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);     // 看门狗生效,自动续期

6.3 企业级代码


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

七、RedLock算法


解决: 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

八、ZooKeeper分布式锁


原理: 临时顺序节点 + 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的临时顺序节点,天然公平锁+强一致。"

面试速记卡(考前30秒速看)

练习题(自测)

1. 缓存穿透和缓存击穿的区别是什么?分别给出一个触发场景的例子。

2. 布隆过滤器说"存在"时为什么不一定存在?说"不存在"时为什么一定不存在?

3. Redisson的看门狗续期间隔是leaseTime的1/3,为什么不是1/2或1/10?

4. 如果Redis主从切换时锁丢失了,会导致什么问题?RedLock如何解决?

5. ZooKeeper分布式锁为什么是天然公平锁?它是如何保证FIFO顺序的?

学习资料