48. 什么是Redis的缓存雪崩？如何在Java中防止缓存雪崩？

PangHu大约 4 分钟

1. 什么是 Redis 的缓存雪崩？

缓存雪崩 是指在某一时刻，大量缓存数据同时失效或者不可用，导致大量的请求直接打到后端数据库或服务上，进而引发后端服务的压力激增，甚至可能导致服务崩溃的现象。缓存雪崩通常发生在以下场景中：

缓存失效时间相近：如果大量缓存的失效时间设定过于集中，当这些缓存同时失效时，所有的请求将会绕过缓存直接访问后端服务。
缓存服务器宕机：当 Redis 等缓存服务器不可用时，所有的缓存请求都会直接访问后端数据库或服务，导致后端服务的压力瞬间增加。
高并发：在高并发场景中，突然的大量请求可能会导致缓存未命中，直接冲击后端服务。

2. 如何在 Java 中防止缓存雪崩？

防止缓存雪崩需要从多个层面进行设计和优化。以下是几种常见的防范措施：

2.1 设置缓存失效时间的随机化

为避免大量缓存同时失效，可以对缓存的失效时间进行随机化处理，使得缓存过期时间分布更加均匀，避免同一时刻大量缓存同时失效。

实现方式：

在设置缓存时，为每个缓存的失效时间加上一个随机值。

import java.util.Random;
import java.util.concurrent.TimeUnit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

@Service
public class CacheService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public void setCacheWithRandomExpire(String key, Object value) {
        // 设定基础过期时间（例如 10 分钟）
        long expireTime = 10 * 60;

        // 添加一个随机时间（例如 0-5 分钟）
        long randomTime = new Random().nextInt(5 * 60);

        // 最终过期时间
        long finalExpireTime = expireTime + randomTime;

        redisTemplate.opsForValue().set(key, value, finalExpireTime, TimeUnit.SECONDS);
    }
}

2.2 缓存预热

缓存预热是在系统启动或高峰期到来之前，提前将热点数据加载到缓存中，避免在高并发时大量缓存未命中导致后端服务压力骤增。

实现方式：

在系统启动时，手动将一些热点数据加载到缓存中。

@Service
public class CachePrewarmService {

    @Autowired
    private CacheService cacheService;

    public void prewarmCache() {
        // 假设我们有一些常用的数据
        cacheService.setCacheWithRandomExpire("hotKey1", "hotValue1");
        cacheService.setCacheWithRandomExpire("hotKey2", "hotValue2");
        // 可以根据业务需求预热更多数据
    }
}

2.3 限流与降级

在高并发情况下，合理的限流与降级机制可以保护后端服务不被突发流量打垮。限流机制可以控制单位时间内的请求量，降级则是在缓存失效或访问量过大时，返回默认值或部分服务降级。

实现方式：

可以使用诸如 Guava 的 RateLimiter 实现限流，或者使用 Spring Cloud 的限流组件。

import com.google.common.util.concurrent.RateLimiter;
import org.springframework.stereotype.Service;

@Service
public class RateLimitingService {

    // 创建一个限流器，每秒最多允许处理 10 个请求
    private final RateLimiter rateLimiter = RateLimiter.create(10.0);

    public String getDataWithRateLimit(String key) {
        if (rateLimiter.tryAcquire()) {
            // 获取数据，或者从数据库获取
            return "data";
        } else {
            // 降级处理，例如返回默认值或错误信息
            return "fallback data";
        }
    }
}

2.4 使用多级缓存

多级缓存是在缓存层之上再加一层本地缓存（如 Guava Cache 或 Caffeine），当 Redis 缓存失效时，可以先尝试从本地缓存中获取数据，从而减少对后端数据库的访问。

实现方式：

可以在 Redis 缓存失效后，从本地缓存中尝试获取数据。

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class MultiLevelCacheService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    private final Cache<String, Object> localCache = Caffeine.newBuilder()
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .maximumSize(1000)
            .build();

    public Object get(String key) {
        // 先从本地缓存获取
        Object value = localCache.getIfPresent(key);
        if (value == null) {
            // 如果本地缓存没有，则从 Redis 获取
            value = redisTemplate.opsForValue().get(key);
            if (value != null) {
                // 将数据放入本地缓存
                localCache.put(key, value);
            }
        }
        return value;
    }

    public void set(String key, Object value, long expireTime) {
        // 设置 Redis 缓存
        redisTemplate.opsForValue().set(key, value, expireTime, TimeUnit.SECONDS);
        // 同步到本地缓存
        localCache.put(key, value);
    }
}

2.5 使用Redis集群或分片

通过使用 Redis 集群或分片机制，将数据分布到多个 Redis 实例上，可以有效提升 Redis 的整体吞吐量，减少单个节点的压力，防止缓存雪崩的发生。

3. 总结

缓存雪崩是分布式系统中常见的问题，尤其是在高并发的场景下。通过设置缓存失效时间的随机化、预热缓存、限流与降级、多级缓存和使用 Redis 集群或分片等手段，可以有效防止缓存雪崩，保证系统的稳定性和高可用性。在 Java 应用中，可以结合这些策略，根据具体的业务需求，设计和实现合理的缓存方案，防止缓存雪崩的发生。