Redis_保证缓存与数据库数据一致性/分布式锁/预防缓存击穿/Spring Cache能否保证数据一致性

﹏ヽ暗。殇╰゛Y 2023-02-19 01:25 20阅读 0赞

# 缓存与数据库读写模式 #

*  读数据时先读缓存，如果缓存中有数据直接响应，如果没有数据，查询数据库，写入缓存，同时响应
 *  写数据时，先写入数据库，并删除缓存

## 为什么写数据时删除缓存而不是更新缓存？ ##

如果这个数据写多读少，频繁的更新缓存反而会造成资源浪费，删除缓存则采用了懒加载的思想。

# 缓存失效模式存在的问题 #

如果多个线程同时在缓存过期时访问数据库请求数据，由于种种状况的可能（比如一个线程先访问到数据库，但是在取数据时卡住了，另一个线程访问到数据库，取到数据放入缓存，这时前一个线程刚取到数据，又把更新的缓存给覆盖掉了），可能导致缓存和数据库数据不一致的问题。

# 如何保证缓存与数据库数据一致性 #

核心是在缓存过期时，所有微服务只能有一个请求访问数据库。

另外，如果数据的一致性要求不是非常严格，即使在短时间内存在数据不一致的情况，只要设置了缓存过期时间，每隔一段时间会自动更新到最新数据，不影响实际业务也可。

## Redisson分布式锁 ##

public Map<String, List<Vo>> getJsonFromDBWithRedissonLock() {
        
        // 1、占分布式锁，去reids占坑
        RLock lock = redisson.getLock("Json-lock");
        lock.lock(); // 阻塞等待
        // 加锁成功...执行业务
        Map<String, List<Vo>> dataFromDB;
        try {
        
            // 访问数据库
            dataFromDB = getJSONDataFromDB();
        } finally {
        
            lock.unlock(); // 解锁
        }
        return dataFromDB;
    }

Redisson的加锁方式和JUC中Lock很像。

*  锁自动续期，30s，每10s续期，不必担心业务时间过长，锁过期自动删除
 *  构造器自行指定解锁时间，将不会自动续期
 *  建议使用手动指定过期时间，手动释放锁

## Redis分布式锁 ##

Redisson其实就是封装了Redis的分布式锁，Redis指令实现分布式锁主要是运用`Set NX EX`命令

public Map<String, List<Vo>> getJsonFromDBWithRedisLock() {
        
        // 抢占分布式锁 setIfAbsent --> NX 不存在才占坑 EX 自动过期时间
        // 设置redis锁的自动过期时间 - 防止出现异常、服务崩塌等各种情况，没有执行删除锁操作导致的死锁问题
        // 设置过期时间和加锁必须是同步的、原子的
        String uuid = UUID.randomUUID().toString();
        Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", uuid, 300, TimeUnit.SECONDS);
        if (lock) {
        
            System.out.println("获取分布式锁成功...");
            // 加锁成功...执行业务
            Map<String, List<Vo>> dataFromDB;
            try {
        
                // 访问数据库
                dataFromDB = getJSONDataFromDB();
            } finally {
        
                // 获取对比值和对比成功删除锁也是要同步的、原子的执行  
                // 参照官方使用lua脚本解锁
                String script = "if redis.call('get',KEYS[1]) == ARGV[1] then return redis.call('del',KEYS[1]) else return 0 end";
    
                Long lock1 = stringRedisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class),
                        Arrays.asList("lock"), uuid);
            }
            return dataFromDB;
        } else {
        
            // 加锁失败休眠一段时间...重试获取锁
            System.out.println("获取分布式锁失败...等待重试");
            // 重试的频率太快会导致内存溢出
            try {
        
                Thread.sleep(200);
            } catch (Exception e) {
        
                e.printStackTrace();
            }
            // 自旋的方式
            return getJsonFromDBWithRedisLock();
        }
    }

# 缓存击穿是什么？ #

缓存中的热点key过期，刚好高并发情况下，大量请求访问该key，由于缓存中没有，所以请求直接打到数据库，造成数据库压力激增。

## 如何解决？ ##

*  分布式锁，保证只有一个请求访问数据库，其他请求阻塞等待
 *  将热点key过期时间延长，或暂时设置为永久key

# Spring Cache提供的缓存框架能否保证缓存与数据库数据一致性？ #

一定程度上保证。

@Cacheable(value = {
        "value"}, key = "#root.methodName", sync = true)

通过将`sync`设置为`true`，在访问数据库放入缓存的方法是用`synchronized`修饰的，

public synchronized <T> T get(Object key, Callable<T> valueLoader) {
        
    	//首先从缓存中尝试获取值
        ValueWrapper result = this.get(key);
        //如果有结果直接返回
        if (result != null) {
        
            return result.get();
        } else {
        
        	//如果没有查询数据库
            T value = valueFromLoader(key, valueLoader);
            //放入缓存
            this.put(key, value);
            //返回结果
            return value;
        }
    }

这在单个微服务中是可以保证的，但是在微服务集群中是保证不了的，因为`synchronized`只能锁`this`，也就是说加入有10个相同业务的微服务，在某个缓存失效后，最不理想的情况下每个微服务会有1个请求访问到数据库，也就是有10个请求访问到数据库。一般来说，这样设置并不会造成数据库的压力激增，所以一般使用Spring Cache框架已经足够了，同时注解可以大大简化开发。