缓存雪崩导致的危害和解决办法

青旅半醒 2023-09-23 14:24 25阅读 0赞

### 1. Redis 数据失效导致的雪崩 ###

![44fa828676574058a214f82b6f9d059a.jpeg][]

因为**缓存失效**，从而导致大量请求导向数据库。

1.  大量请求，导致数据库处理不过来，整个系统依赖数据库的功能全部**崩溃**
2.  单系统挂掉，其他依赖于该系统的应用也会出现不稳定甚至**崩溃**

--------------------

### 2. Redis数据失效的场景 ###

![0c6301504f7a41038ad2b530737714fa.jpeg][]

*  最大内存控制  
    maxmemory 最大内存阈值  
    maxmemory-policy 到达阈值的执行策略

--------------------

### 3. 缓存雪崩解决方案 ###

![29d339aba9214d6db2b7aa9a07054252.jpeg][]

3.1 Semaphore信号量限流

*  **J.U.C包重要的并发编程工具类**  
    又称“信号量”，控制多个线程争抢许可。

> **核心方法**
> 
>  *  acquire:获取一个许可，如果没有就等待，
>  *  release:释放一个许可。

*  **典型场景∶**  
    1、代码并发处理限流;
 *  **例子**

package cn.lazyfennec.cache.redis.service;
    
    import cn.lazyfennec.cache.redis.annotations.NeteaseCache;
    import cn.lazyfennec.cache.redis.dao.UserDao;
    import cn.lazyfennec.cache.redis.pojo.User;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cache.annotation.CacheEvict;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.jdbc.core.JdbcTemplate;
    import org.springframework.stereotype.Service;
    
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.Semaphore;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.ReentrantLock;
    
    @Service // 默认 单实例
    public class UserService2 {
    
        @Autowired
        UserDao userDao;
    
        @Autowired
        RedisTemplate redisTemplate; // spring提供的一个redis客户端，底层封装了jedis等客户端
    
        // userId ---> lock 记录每一个userId当前的查询情况
        static Map<String, ReentrantLock> mapLock = new ConcurrentHashMap<>();
    
        static Semaphore semaphore = new Semaphore(50); // 信号量 50 -- 类似车票
    
        /**
         * 根据ID查询用户信息 (redis缓存，用户信息以json字符串格式存在(序列化))
         */
        public User findUserById(String userId) throws Exception {
    
            // 1\. 先读取缓存
            Object cacheValue = redisTemplate.opsForValue().get(userId); // redisTemplate是spring提供的redis客户端
            if (cacheValue != null) {
                System.out.println("###缓存命中:" + ((User) cacheValue).getUname());
                return (User) cacheValue;
            }
    
            // ---------------缓存miss之后流程--------------
            ReentrantLock reentrantLock = new ReentrantLock();
            try {
                if (mapLock.putIfAbsent(userId, reentrantLock) != null) { // 有返回值代表存在锁
                    reentrantLock = mapLock.get(userId);
                }
                Thread.sleep(3000);// TODO 停顿3秒，等下一个线程过来，模拟多个用户同时并发请求的场景
                reentrantLock.lock(); // 争抢锁,抢不到的排队---1个请求查询数据库 --- 599个等待
                Thread.sleep(3000);// TODO 停顿3秒，模拟lock获取之后业务处理时间
    
                // 再次查询缓存 -- 避免大量重复数据库查询
                cacheValue = redisTemplate.opsForValue().get(userId); // redisTemplate是spring提供的redis客户端
                if (cacheValue != null) {
                    System.out.println("###缓存命中:" + ((User) cacheValue).getUname());
                    return (User) cacheValue;
                }
    
                semaphore.acquire(); // 获取信号量 ，没有获取到
    
                // 2\. 如果缓存miss，则查询数据库
                User user = userDao.findUserById(userId);
                System.out.println("***缓存miss:" + user.getUname());
                // 3\. 设置缓存（重建缓存） // 主播信息查询缓存
                redisTemplate.opsForValue().set(userId, user);// set key value
                redisTemplate.expire(userId, 100, TimeUnit.SECONDS); // 需要手动设
    
                semaphore.release(); // 释放信号量
    
                return user;
            } finally {
                if (!reentrantLock.hasQueuedThreads()) { // 当锁最后一个释放的时候，删除掉
                    mapLock.remove(userId);
                }
                reentrantLock.unlock();
            }
    
        }
    
        @CacheEvict(value = "user", key = "#user.uid") // 方法执行结束，清除缓存
        public void updateUser(User user) {
            String sql = "update tb_user_base set uname = ? where uid=?";
            jdbcTemplate.update(sql, new String[]{user.getUname(), user.getUid()});
        }
    
        /**
         * 根据ID查询用户名称
         */
        // 我自己实现一个类似的注解
        @NeteaseCache(value = "uname", key = "#userId") // 缓存
        public String findUserNameById(String userId) {
            // 查询数据库
            String sql = "select uname from tb_user_base where uid=?";
            String uname = jdbcTemplate.queryForObject(sql, new String[]{userId}, String.class);
    
            return uname;
        }
    
        @Autowired
        JdbcTemplate jdbcTemplate; // spring提供jdbc一个工具（mybastis类似）
    }

3.2 容错降级

![e5e15a151e49459aa274ac9f9a7f527d.jpeg][]

[44fa828676574058a214f82b6f9d059a.jpeg]: https://img-blog.csdnimg.cn/44fa828676574058a214f82b6f9d059a.jpeg
[0c6301504f7a41038ad2b530737714fa.jpeg]: https://img-blog.csdnimg.cn/0c6301504f7a41038ad2b530737714fa.jpeg
[29d339aba9214d6db2b7aa9a07054252.jpeg]: https://img-blog.csdnimg.cn/29d339aba9214d6db2b7aa9a07054252.jpeg
[e5e15a151e49459aa274ac9f9a7f527d.jpeg]: https://img-blog.csdnimg.cn/e5e15a151e49459aa274ac9f9a7f527d.jpeg