java-redis-雪崩

Redis 雪崩问题

Redis雪崩 是指在 Redis 缓存系统中，当大量缓存同时失效时，所有请求直接打到数据库，导致数据库瞬间压力激增，甚至崩溃的现象。雪崩问题通常出现在高并发的系统中，因为缓存的失效导致后端数据库承受不了巨大的请求量。

具体表现：

• 大量缓存同时失效后，所有流量直接访问数据库。
• 数据库承载过大的并发量，导致性能急剧下降，甚至崩溃。
• 之后，当 Redis 缓存恢复正常时，由于数据库崩溃或者性能下降，依然无法正常服务。

一、Redis 雪崩的原因

1. 大批量缓存同时失效：当 Redis 中的大批量缓存设置了相同的过期时间，并且过期后没有及时重新生成，所有原本应从缓存中获取的数据都会直接从数据库中请求，导致数据库压力瞬间增加。

2. 缓存服务器宕机：如果 Redis 缓存服务器因为某种原因宕机，所有请求将直接访问数据库，这可能会导致数据库无法承受高并发的请求，进而崩溃。

3. 网络问题：Redis 服务在某些时段因为网络原因无法连接，导致缓存服务不可用，所有请求也直接打到数据库上，可能引发类似雪崩的情况。

二、Redis 雪崩的解决方案

1. 缓存预热：在系统上线之前，可以提前将一些常用数据缓存到 Redis 中，避免上线后大量请求直接打到数据库。这可以通过后台线程预先加载一些热门数据，也可以手动设置缓存。

2. 设置不同的缓存过期时间：如果所有的缓存数据设置相同的过期时间，当缓存到期后，可能会出现大量缓存同时失效的情况。为了避免这种情况，可以为不同的缓存设置不同的过期时间，或者在设置缓存时加上一个随机的时间差。

3. 缓存永不过期：对于一些热点数据，特别是经常被访问但又很少变化的数据，可以设置缓存永不过期，同时在后台更新缓存。

4. 缓存降级：当 Redis 宕机或者出现异常时，可以使用缓存降级策略，允许某些非核心数据的读取失败。也可以通过服务降级手段，限制对数据库的访问，从而保护数据库。

5. 互斥锁（防止击穿）：当大量缓存同时失效时，如果多个线程同时请求数据库并写入缓存，可能会导致数据库压力剧增。可以使用互斥锁的方式，确保只有一个线程能够更新缓存，其他线程等待缓存更新完成后再读取缓存。

6. 数据持久化与集群：使用 Redis 的持久化机制（如 RDB、AOF）或搭建 Redis 集群来保证缓存的高可用性。当某个节点失效时，可以自动切换到其他节点，避免缓存服务器宕机导致雪崩。

7. 请求限流和熔断：对系统进行限流和熔断保护，当缓存失效时，限制对数据库的请求数量，防止数据库过载。

三、解决方案的具体实现

1. 缓存预热

通过提前加载一些常用的缓存数据，避免在系统刚启动时，所有请求直接打到数据库。这可以通过手动加载或者后台任务实现。

@Service
public class CachePrewarmService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public void preloadCache() {
        // 假设我们要预热一些数据
        String key = "hot_data_key";
        Object data = loadDataFromDB();  // 从数据库加载数据
        redisTemplate.opsForValue().set(key, data, 1, TimeUnit.HOURS); // 设置缓存，并设定1小时过期
    }

    private Object loadDataFromDB() {
        // 模拟从数据库加载数据
        return new Object();  // 返回数据库中的数据
    }
}

2. 随机过期时间（解决大规模缓存同时失效）

我们可以通过在设置缓存过期时间时，给每个缓存增加一个随机值，避免同时过期导致雪崩。

@Service
public class CacheService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public void setCacheWithRandomTTL(String key, Object value) {
        // 设置基础的缓存时间，比如1小时
        long baseTime = 60 * 60;
        // 添加一个随机的过期时间，避免同一时间大量缓存同时失效
        long randomTime = new Random().nextInt(300);  // 随机增加0~300秒
        redisTemplate.opsForValue().set(key, value, baseTime + randomTime, TimeUnit.SECONDS);
    }
}

3. 使用互斥锁防止缓存击穿

缓存击穿是指某个热点数据的缓存失效后，瞬间大量请求直接打到数据库，导致数据库压力骤增。可以使用分布式锁，确保在缓存失效时，只有一个线程能请求数据库，其他线程等待缓存重新生成。

@Service
public class CacheWithLockService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // 获取数据时，使用分布式锁
    public Object getCacheWithLock(String key) {
        Object value = redisTemplate.opsForValue().get(key);

        if (value == null) {
            // 使用 Redis 的 setIfAbsent (NX) 命令实现分布式锁
            String lockKey = key + "_lock";
            Boolean lockAcquired = redisTemplate.opsForValue().setIfAbsent(lockKey, "LOCK", 5, TimeUnit.SECONDS);

            if (lockAcquired != null && lockAcquired) {
                try {
                    // 缓存失效且获得锁，查询数据库并更新缓存
                    value = loadDataFromDB();
                    redisTemplate.opsForValue().set(key, value, 60, TimeUnit.SECONDS);
                } finally {
                    // 释放锁
                    redisTemplate.delete(lockKey);
                }
            } else {
                // 未获得锁，等待缓存更新
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return redisTemplate.opsForValue().get(key);  // 再次尝试获取缓存
            }
        }
        return value;
    }

    private Object loadDataFromDB() {
        // 模拟从数据库加载数据
        return new Object();  // 返回数据库中的数据
    }
}

4. 缓存降级

当 Redis 不可用时，系统可以通过降级策略，直接访问数据库或者返回一些默认值。我们可以通过 try-catch 捕获 Redis 异常，来实现降级逻辑。

@Service
public class CacheDegradeService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public Object getData(String key) {
        try {
            Object value = redisTemplate.opsForValue().get(key);
            if (value != null) {
                return value;
            }
        } catch (Exception e) {
            // Redis 发生异常时，执行降级逻辑
            System.out.println("Redis不可用，执行降级策略");
        }
        // Redis不可用或者缓存失效，直接从数据库获取数据
        return loadDataFromDB();
    }

    private Object loadDataFromDB() {
        // 模拟从数据库加载数据
        return new Object();  // 返回数据库中的数据
    }
}

5. 数据持久化与集群

Redis 提供了 RDB 和 AOF 的持久化机制来保证数据不会因为 Redis 崩溃而丢失。同时，通过 Redis 的集群模式，我们可以将数据分布在多个节点上，提升系统的可靠性和可用性。

# 开启 AOF 持久化
appendonly yes
# 每秒同步一次 AOF 文件
appendfsync everysec

# Redis Cluster 配置，启动多个节点，配置集群
cluster-enabled yes
cluster-config-file nodes-6379.conf
cluster-node-timeout 5000

四、总结

1. Redis 雪崩 是在缓存失效后，大量请求直接打到数据库，导致数据库压力骤增甚至崩溃的问题。在高并发场景下，Redis 雪崩可能会带来严重后果。

2. 为了避免 Redis 雪崩，可以采取多种措施，如 缓存预热、设置不同过期时间、使用互斥锁防止缓存击穿、缓存降级、限流与熔断机制 等。

3. 持久化与集群 是提升 Redis 可用性的关键，确保即便在单个节点失效的情况下，服务依然能够正常工作。

通过合理的策略和设计，开发者可以大大降低 Redis 雪崩的风险，保障系统的高可用性和稳定性。