139｜缓存穿透、击穿、雪崩：根因及布隆过滤器、互斥、限流等治理

public User getUserById(Long id) {
    String cacheKey = "user:" + id;
    User user = redis.get(cacheKey);
    if (user != null) {
        return user == NULL_PLACEHOLDER ? null : user;
    }
    user = db.queryById(id);
    if (user == null) {
        redis.set(cacheKey, NULL_PLACEHOLDER, 300, TimeUnit.SECONDS);
    } else {
        redis.set(cacheKey, user, 1800, TimeUnit.SECONDS);
    }
    return user;
}

// 使用 Redisson 的布隆过滤器
RBloomFilter<Long> bloomFilter = redisson.getBloomFilter("user:bloom");
// 初始化：预计 1000 万用户，误判率 0.01
bloomFilter.tryInit(10_000_000L, 0.01);

// 预热：将所有存在的用户 ID 加入布隆过滤器
List<Long> allUserIds = db.queryAllUserIds();
allUserIds.forEach(bloomFilter::add);

// 查询时先过布隆过滤器
public User getUserById(Long id) {
    if (!bloomFilter.contains(id)) {
        return null; // 一定不存在，直接返回
    }
    // 可能存在，继续查缓存和数据库
    String cacheKey = "user:" + id;
    User user = redis.get(cacheKey);
    if (user != null) return user;
    user = db.queryById(id);
    if (user != null) {
        redis.set(cacheKey, user, 1800, TimeUnit.SECONDS);
    }
    return user;
}

// 网关层拦截
if (id <= 0 || id > MAX_VALID_ID || String.valueOf(id).length() > 10) {
    return Response.fail("非法请求参数");
}

请求 → 布隆过滤器（不存在则直接返回）→ 缓存（命中则返回）→ 数据库（空则缓存空对象）

public User getHotUser(Long id) {
    String cacheKey = "user:" + id;
    User user = redis.get(cacheKey);
    if (user != null) return user;

    // 互斥锁：同一时刻只有一个线程能重建缓存
    String lockKey = "lock:user:" + id;
    String lockValue = UUID.randomUUID().toString();
    try {
        // 自旋等待获取锁，最多等待 10 秒
        while (!redis.setnx(lockKey, lockValue, 10, TimeUnit.SECONDS)) {
            // 等待期间再次检查缓存是否已被其他线程重建
            user = redis.get(cacheKey);
            if (user != null) return user;
            Thread.sleep(50);
        }

        // 获取锁成功，再次检查缓存（双重检查）
        user = redis.get(cacheKey);
        if (user != null) return user;

        // 重建缓存
        user = db.queryById(id);
        if (user != null) {
            redis.set(cacheKey, user, 1800, TimeUnit.SECONDS);
        }
        return user;
    } finally {
        // 释放锁（用 Lua 脚本保证原子性）
        String lua = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        redis.eval(lua, Collections.singletonList(lockKey), Collections.singletonList(lockValue));
    }
}

@Data
static class CacheWrapper<T> {
    private T data;             // 实际数据
    private long expireAt;      // 逻辑过期时间戳（毫秒）
}

public User getHotUserLogical(Long id) {
    String cacheKey = "user:" + id;
    CacheWrapper<User> wrapper = redis.get(cacheKey);
    if (wrapper == null) {
        // 缓存不存在，同步加载
        return loadAndCache(id);
    }
    if (wrapper.getExpireAt() > System.currentTimeMillis()) {
        return wrapper.getData(); // 未过期，直接返回
    }
    // 逻辑过期，异步刷新
    String lockKey = "lock:user:" + id;
    if (redis.setnx(lockKey, "1", 10, TimeUnit.SECONDS)) {
        threadPool.submit(() -> {
            try {
                User user = db.queryById(id);
                CacheWrapper<User> newWrapper = new CacheWrapper<>();
                newWrapper.setData(user);
                newWrapper.setExpireAt(System.currentTimeMillis() + 1800_000);
                redis.set(cacheKey, newWrapper);
            } finally {
                redis.del(lockKey);
            }
        });
    }
    // 返回旧值，保证可用性
    return wrapper.getData();
}

maxmemory-policy volatile-lfu

redis> OBJECT FREQ hotkey
(integer) 127

大量缓存过期 → 数据库压力骤增 → 数据库响应变慢 → 请求积压 → 连接池耗尽
→ 服务线程阻塞 → 上游服务超时 → 级联故障 → 整个系统雪崩

public void setWithRandomExpire(String key, Object value, long baseSeconds, long randomRange) {
    long actualExpire = baseSeconds + ThreadLocalRandom.current().nextLong(randomRange);
    redis.set(key, value, actualExpire, TimeUnit.SECONDS);
}

// 使用示例：基础 30 分钟，随机偏移 ±5 分钟
setWithRandomExpire("user:" + id, user, 1800, 600);

// 同一份数据，不同过期时间
redis.set("user:" + id + ":t1", user, 1800, TimeUnit.SECONDS);  // 30 分钟
redis.set("user:" + id + ":t2", user, 2400, TimeUnit.SECONDS);  // 40 分钟
redis.set("user:" + id + ":t3", user, 3000, TimeUnit.SECONDS);  // 50 分钟

// Caffeine 本地缓存作为兜底
private final Cache<String, User> localCache = Caffeine.newBuilder()
    .maximumSize(10_000)
    .expireAfterWrite(60, TimeUnit.SECONDS)
    .build();

public User getUserWithFallback(Long id) {
    String cacheKey = "user:" + id;
    try {
        User user = redis.get(cacheKey);
        if (user != null) {
            localCache.put(cacheKey, user); // 更新本地缓存
            return user;
        }
    } catch (Exception e) {
        log.warn("Redis 不可用，降级使用本地缓存", e);
    }
    // 从本地缓存读取
    User user = localCache.getIfPresent(cacheKey);
    if (user != null) return user;
    // 本地缓存也未命中，查数据库
    user = db.queryById(id);
    if (user != null) {
        localCache.put(cacheKey, user);
    }
    return user;
}

// Sentinel 限流 + 熔断
@SentinelResource(value = "getUser", fallback = "getUserFallback")
public User getUser(Long id) {
    // 正常的缓存+数据库查询逻辑
}

public User getUserFallback(Long id, Throwable t) {
    // 降级逻辑：返回兜底数据或空对象
    log.warn("查询用户触发降级, id={}", id);
    return new User(id, "默认用户", "系统繁忙，请稍后重试");
}

请求 → 本地缓存 → Redis 集群 → 布隆过滤器 → 互斥锁 → 数据库
                ↑ 失败降级       ↑ 穿透防护   ↑ 击穿防护
        ↓ 限流熔断（Sentinel / Hystrix 保护数据库）