Redis缓存更新策略以及常见缓存问题_缓存更新策略 缓存失效

---

一、什么是缓存？

缓存就是数据交换的缓冲区(Cache)，是存储数据的临时地方，一般读写性能较好，常见缓存：

Web应用中缓存有什么作用呢？

• 降低后端负载
• 提高读写效率，降低响应时间

缓存的成本：

• 数据的一致性成本
• 代码维护成本
• 运维成本

二、添加Redis缓存

缓存作用模型：

给一段Redis作为缓存的具体案例代码：

public Shop queryWithPassThrough(Long id) {
        // 1. 从Redis 查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get("cache:shop:" + id);
        // 2. 判断是否存在
        if (StrUtil.isNotBlank(shopJson)) {
            // 存在返回
            Shop shop = JSONUtil.toBean(shopJson,Shop.class);
            return shop;
        }
        // 不存在,根据id查询数据库
        Shop shop = getById(id);
        // 数据库中不存在 直接返回
        if(shop == null) {
            return null;
        }
        // 存在 写入redis
        stringRedisTemplate.opsForValue().set("cache:shop:" + id,JSONUtil.toJsonStr(shop));
        return shop;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

三、缓存更新策略

我们在使用Redis作为缓存，可以大大降低数据库的负载压力，但是也会带来缓存一致性问题(Redis数据与数据库数据不一样)，以下为三种常见的缓存更新策略：

业务场景：

• 低一致性需求：使用内存淘汰机制
• 高一致性需求：主动更新，并以超时剔除作为兜底方案

主动更新策略：

1. Cache Aside Pattern：由缓存的调用者，在更新数据库时同时更新缓存
2. Read/Write Through Pattern：缓存与数据库整合为一个服务，由服务来维护一致性。调用者调用该服务，无需关心缓存一致性问题
3. Write Behind Caching Pattern：调用者只操作缓存，用其他线程异步将缓存持久化到数据库，保证最终一致

综合比较一般使用的还是一种Cache Aside Pattern策略，但是在操作缓存和数据库时有三个问题需要考虑：
1.删除缓存还是更新缓存？
更新缓存：每次更新数据库都更新缓存，无效写操作较多
删除缓存：更新数据库时让缓存失效，查询时再更新缓存(选择的方案)

2.如何保证缓存与数据库的操作的同时成功或失败？
单体系统，将缓存与数据库操作放在一个事务
分布式系统，利用TTC等分布式事务方案

3.先操作缓存还是先操作数据库？
其实两种方案都可以，哪一个更优呢？我们来对比一下：
1.先删除缓存在操作数据库：

这种情况，缓存和数据库都是20，一致性没有问题

但是上述情况就产生了数据不一致情况，上述场景的情况发生的概率还是比较高的，因为更新数据库是相对较慢的，而查询缓存，写缓存速度是相对较快的就会出现上述情况

2.先操作数据库，再删除缓存

上述这种情况是不存在一致性问题的

上述这种情况是存在一致性问题，但需要几个条件，线程一恰好缓存失效，并且在查询完数据库与写入缓存之间完成更慢的更新数据库与删除缓存操作，这种可能性是更低的

缓存更新策略的最佳实践方案：
低一致性需求：使用Redis自带的内存淘汰机制

高一致性需求：主动更新，并以超时剔除作为兜底方案
读操作：

• 缓存命中之间返回
• 缓存未命中则查询数据库，并写入缓存，并设定超时时间

写操作：

• 先写数据库，然后再删除缓存
• 要确保数据库与缓存操作的原子性

写操作：

	@Override
    @Transactional
    public Result update(Shop shop) {
        Long id = shop.getId();
        if(id == null) {
            return Result.fail("店铺id不能为空");
        }
        // 1. 更新数据库
        updateById(shop);
        // 2. 删除缓存
        stringRedisTemplate.delete("cache:shop:"+id);
        return Result.ok();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

我们需要加上@Transactional事务注解来保证数据库与缓存操作的原子性

四、缓存穿透

缓存穿透：指客户端请求的数据在缓存和数据库中都不存在，这样缓存永远都不生效，这样大量的请求都会打到数据库，给数据库造成巨大压力

常见的两种解决方案：
缓存空对象
这是一种简单暴力的方法，当请求缓存与数据库中都不存在的数据时往缓存中写一份空数据，防止给数据库造成巨大压力
优点：实现简单，维护方便
缺点：额外的内存消耗，可能造成短期的不一致(可以设置一个TTL)

布隆过滤
布隆过滤器通过为位数据和多个哈希函数来实现判断，当请求查询缓存前会先对请求关键字进行布隆过滤器的判断，如果不存在直接返回，不再查询缓存或数据库
优点：内存占用较少，没有多余key
缺点：实现复杂，存在误判可能

缓存穿透解决方案：

public Shop queryWithPassThrough(Long id) {
        // 1. 从Redis 查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get("cache:shop:" + id);
        // 2. 判断是否存在
        if (StrUtil.isNotBlank(shopJson)) {
            // 存在返回
            Shop shop = JSONUtil.toBean(shopJson,Shop.class);
            return shop;
        }
        // 判断命中的是否为空值
        if(shopJson != null) {
            return null;
        }
        // 不存在,根据id查询数据库
        Shop shop = getById(id);
        // 数据库中不存在 存放空值
        if(shop == null) {
            // 将空值写入Redis
            stringRedisTemplate.opsForValue().set("cache:shop:" + id,"",2,TimeUnit.MINUTES);
            return null;
        }
        // 存在 写入redis
        stringRedisTemplate.opsForValue().set("cache:shop:" + id,JSONUtil.toJsonStr(shop),30, TimeUnit.MINUTES);
        return shop;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

当访问缓存和数据库都不存在的数据时，往缓存中写入一个空数据，并设置TTL。

缓存穿透解决方案有哪些？

• 缓存null值
• 布隆过滤
• 增强id复杂度，避免被猜测id规律
• 做好数据的基础格式校验
• 加强用户权限校验
• 做好热点参数的限流

五、缓存雪崩

缓存雪崩：指在同一时刻大量的缓存key同时失效或者Redis服务宕机，导致大量请求到达数据库，带来巨大压力

面对这种同一时刻大量缓存失效或者Redis服务宕机的情况，我们有以下几种解决方案：

• 给不同的Key的TTL添加随机值
• 利用Redis集群提高服务的可用性
• 给缓存业务添加降级限流策略
• 给业务添加多级

六、缓存击穿

缓存击穿：也叫热点Key问题，就是一个被高并发访问并且缓存重建业务比较复杂的Key突然失效了，无数的请求访问会在瞬间给数据库带来巨大的冲击

常见的解决方案：

1. 互斥锁，该方案最大的问题是线程都在相互等待

2. 逻辑过期，设置一个expire字段，比较这个字段与当前时间判断是否过期
   

利用互斥锁解决缓存击穿问题
这里我们使用什么互斥锁呢？其实Redis中的setnx命令就是一个不错的选择

// 加锁解锁
	private boolean tryLock(String key) {
        Boolean flg = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(flg);
    }

    private void unLock(String key) {
        stringRedisTemplate.delete(key);
    }
1
2
3
4
5
6
7
8
9

// 缓存击穿
    public Shop queryWithMutex(Long id){
        // 1. 从Redis 查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get("cache:shop:" + id);
        // 2. 判断是否存在
        if (StrUtil.isNotBlank(shopJson)) {
            // 存在返回
            Shop shop = JSONUtil.toBean(shopJson,Shop.class);
            return shop;
        }
        // 判断命中的是否为空值
        if(shopJson != null) {
            return null;
        }
        // 4.实现缓存重建
        // 4.1获取互斥锁
        String lockKey = "lock:shop:" + id;
        Shop shop = null;
        try {
            boolean isLock = tryLock(lockKey);
            // 4.2失败,休眠重试
            if (!isLock) {
               Thread.sleep(50);
               return queryWithMutex(id);
            }
            // 4.3 成功,根据id查询数据库
            shop = getById(id);
            if(shop == null) {
                // 将空值写入Redis
                stringRedisTemplate.opsForValue().set("cache:shop:" + id,"",2,TimeUnit.MINUTES);
                return null;
            }
            // 存在 写入redis
            stringRedisTemplate.opsForValue().set("cache:shop:" + id,JSONUtil.toJsonStr(shop),30, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            unLock(lockKey);
        }
        return shop;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

基于逻辑过期方式解决缓存击穿问题：

那既然我们要加一个逻辑字段，我们是怎么加，直接在实体类中增加吗？让实体类继承带有expire属性的类？这两种都不太好，因为都会都实体类进行修改。我们选择的是组合方式

@Data
public class RedisData {
    private LocalDateTime expireTime;
    private Object data;
}
1
2
3
4
5

// 写入数据时 + 一个逻辑过期字段
public void saveShop2Redis(Long id, Long expireSeconds) {
        // 1. 查询店铺数据
        Shop shop = getById(id);
        // 2. 封装逻辑过期时间
        RedisData redisData = new RedisData();
        redisData.setData(shop);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
        // 3. 写入Redis
        stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id,JSONUtil.toJsonStr(redisData));
    }
1
2
3
4
5
6
7
8
9
10
11

private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
    public Shop queryWithLogicalExpire(Long id) {
        // 1. 从Redis 查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get("cache:shop:" + id);
        // 2. 判断是否存在
        if (StrUtil.isBlank(shopJson)) {
            // 不存在返回
            return null;
        }
        // 4. 命中,先把json反序列化为对象
        RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
        Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(),Shop.class);
        LocalDateTime expireTime = redisData.getExpireTime();
        // 5. 判断是否过期
        if(expireTime.isAfter(LocalDateTime.now())) {
            // 5.1 未过期 返回店铺信息
            return shop;
        }
        // 5.2 已过期, 缓存重建
        // 6 缓存重建
        String lockKey = "lock:shop:" + id;
        boolean isLock = tryLock(lockKey);
        // 6.1 获取互斥锁
        // 6.2 判断是否获取成功
        if (isLock) {
            // 6.3 成功,开启独立线程 实现缓存重建
            CACHE_REBUILD_EXECUTOR.submit(() -> {
                // 重建缓存
                try {
                    saveShop2Redis(id,30L);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    // 释放锁
                    unLock(lockKey);
                }
            });
        }
        // 6.4 返回过期商铺信息
        return shop;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

七、缓存工具封装

基于StringRedisTemplate封装一个缓存工具类，满足下列要求：

@Slf4j
@Component
public class CacheClient {

    private final StringRedisTemplate stringRedisTemplate;

    public CacheClient(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }
}
1
2
3
4
5
6
7
8
9
10

1.将任意的Java对象序列化为json并存储在String类型的key中，并且可以设置TTL超时时间

	public void set(String key, Object value, Long time, TimeUnit unit) {
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value),time,unit);
    }
1
2
3

2.将任意的Java对象序列化为json并存储在String类型的key中，并且可以设置逻辑过期时间，用于处理缓存击穿问题

public void setWithLogicalExpire(String key,Object value,Long time,TimeUnit unit) {
        // 设置逻辑过期时间
        RedisData redisData = new RedisData();
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
        redisData.setData(value);
        // 写入Redis
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(redisData));
    }
1
2
3
4
5
6
7
8

3.根据指定的key进行查询缓存，并反序列化为指定类型，利用缓存的空值方式解决缓存穿透问题

public <R,ID> R queryWithPassThrough(String keyPrefix, ID id, Class<R> type, Function<ID,R> dbFallback,Long time,TimeUnit unit) {
        String key = keyPrefix + id;
        // 从redis查询商铺缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        // 判断是否存在
        if (StrUtil.isNotBlank(json)) {
            // 存在 直接返回
            return JSONUtil.toBean(json,type);
        }
        // 判断命中的是否为空值
        if (json != null) {
            return null;
        }
        // 不存在,根据id查询数据库
        R r = dbFallback.apply(id);
        // 不存在 将空值写入Redis
        if(r == null) {
            stringRedisTemplate.opsForValue().set(key,"",time,unit);
        }
        // 存在 写入redis
        set(key,r,time,unit);
        return r;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

4.根据指定的key查询缓存，并反序列化为指定类型，利用逻辑过期时间解决缓存击穿问题

private boolean tryLock(String key) {
        Boolean flg = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(flg);
    }

    private void unLock(String key) {
        stringRedisTemplate.delete(key);
    }

    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
    public <R,ID> R queryWithLogicalExpire(String keyPrefix,String lockPrefix,ID id,Class<R> type, Function<ID,R> dbFallback,
    Long time,TimeUnit unit) {
        String key = keyPrefix + id;
        // 1. 从Redis 查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        // 2. 判断是否存在
        if (StrUtil.isBlank(shopJson)) {
            // 不存在返回
            return null;
        }
        // 4. 命中,先把json反序列化为对象
        RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
        R r = JSONUtil.toBean((JSONObject) redisData.getData(),type);
        LocalDateTime expireTime = redisData.getExpireTime();
        // 5. 判断是否过期
        if(expireTime.isAfter(LocalDateTime.now())) {
            // 5.1 未过期 返回店铺信息
            return r;
        }
        // 5.2 已过期, 缓存重建
        // 6 缓存重建
        String lockKey = lockPrefix + id;
        boolean isLock = tryLock(lockKey);
        // 6.1 获取互斥锁
        // 6.2 判断是否获取成功
        if (isLock) {
            // 6.3 成功,开启独立线程 实现缓存重建
            CACHE_REBUILD_EXECUTOR.submit(() -> {
                // 重建缓存
                try {
                    // 查数据库
                    R r1 = dbFallback.apply(id);
                    // 写 Redis
                    setWithLogicalExpire(key,r1,time,unit);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    // 释放锁
                    unLock(lockKey);
                }
            });
        }
        // 6.4 返回过期商铺信息
        return r;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55