缓存击穿/雪崩治理

// 本地滑动窗口热点探测（基于时间槽）
public class HotspotDetector {
    private static final int SLOT_MS = 1000;
    private static final int WINDOW_SLOTS = 10;          // 10 秒窗口
    private final ConcurrentHashMap<String, int[]> counters = new ConcurrentHashMap<>();

    public boolean isHot(String key) {
        int now = (int) (System.currentTimeMillis() / SLOT_MS);
        int[] slots = counters.computeIfAbsent(key, k -> new int[WINDOW_SLOTS]);
        synchronized (slots) {
            slots[now % WINDOW_SLOTS]++;
            int sum = 0;
            for (int s : slots) sum += s;
            return sum >= HOT_THRESHOLD;    // 近 10s 超过阈值视为热点
        }
    }

    public void reset(String key) {
        counters.remove(key);
    }
}

func (c *CacheService) GetWithSingleFlight(ctx context.Context, key string) (string, error) {
    // 1) 先读缓存
    if v, ok := c.cache.Get(ctx, key); ok {
        return v, nil
    }
    // 2) 单飞：同 key 并发只执行一个 fn，其余等待
    v, err, _ := c.group.Do(key, func() (any, error) {
        // 再次检查缓存（双检），防止已重建
        if vv, ok := c.cache.Get(ctx, key); ok {
            return vv, nil
        }
        value, err := c.loadFromDB(ctx, key)   // 真正回源
        if err != nil {
            return nil, err
        }
        c.cache.Set(ctx, key, value, c.expire(key))
        return value, nil
    })
    if err != nil {
        return "", err
    }
    return v.(string), nil
}

public String getWithLock(String key) throws Exception {
    // 1) 缓存命中直接返回
    String value = cache.get(key);
    if (value != null) return value;

    // 2) 单 key 级联锁：只有拿到锁的线程回源，其余等待后重读缓存
    Lock lock = keyLocks.computeIfAbsent(key, k -> new ReentrantLock());
    lock.lock();
    try {
        // 3) 双检：拿到锁后再次读缓存（可能已被重建）
        value = cache.get(key);
        if (value != null) return value;
        // 4) 真正回源 + 写回
        value = db.load(key);
        cache.set(key, value, expireTime);
        return value;
    } finally {
        lock.unlock();
        keyLocks.remove(key);   // 避免 key 锁泄漏
    }
}

// 过期时间 = 基础时间 + 随机偏移
long expire = 3600 * 1000 + ThreadLocalRandom.current().nextLong(0, 600 * 1000);
cache.set(key, value, expire);

public String getGuarded(String key) {
    String v = cache.get(key);
    if (v != null) return v;
    // 回源限流：令牌桶，超出容量的回源请求降级
    if (!originLimiter.tryAcquire()) {
        return fallbackValue(key);   // 降级：返回默认值 / 过期数据 / 提示稍后
    }
    v = db.load(key);
    if (v != null) cache.set(key, v, expireWithJitter());
    return v;
}

// Caffeine 本地缓存，热点 key 短 TTL
LoadingCache<String, String> local = Caffeine.newBuilder()
    .maximumSize(10_000)
    .expireAfterWrite(30, TimeUnit.SECONDS)   // 本地缓存 TTL 更短，容忍脏读
    .build(key -> remoteCache.get(key));       // miss 时走 Redis

// 请求路径：本地缓存 → Redis → DB

@Scheduled(fixedRate = 60_000)
public void refreshHotspots() {
    for (String key : hotspotDetector.currentHotKeys()) {
        executor.submit(() -> {
            String v = db.load(key);
            cache.set(key, v, hotspotExpire(key));   // 热点 key 更长 TTL
        });
    }
}

public String getWithFallback(String key) {
    try {
        return cache.get(key);          // Redis
    } catch (RedisConnectionException e) {
        // 1) 本地缓存兜底
        String local = localCache.getIfPresent(key);
        if (local != null) return local;
        // 2) 缓存整体不可用时，限流回源 + 短熔断，防止打爆 DB
        if (cacheBreaker.isOpen()) {
            return fallbackValue(key);
        }
        String v = db.load(key);
        // 3) 回源成功后写本地缓存，不写 Redis（避免重建风暴）
        localCache.put(key, v);
        return v;
    }
}

// 半开探测：允许少量请求试读缓存
public String getRecovering(String key) {
    if (cacheBreaker.allowHalfOpenProbe()) {
        try {
            String v = cache.get(key);
            cacheBreaker.recordSuccess();
            return v;
        } catch (Exception e) {
            cacheBreaker.recordFailure();
            return localCache.getIfPresent(key);
        }
    }
    return localCache.getIfPresent(key);   // 熔断打开，走本地
}