Redis实战常用二、缓存的使用-EW帮帮网

一、什么是缓存

在实际开发中,系统需要"避震器"，防止过高的数据访问勐冲系统,导致其操作线程无法及时处理信息而瘫痪.
- 这在实际开发中对企业讲,对产品口碑,用户评价都是致命的。所以企业非常重视缓存技术;
缓存(Cache)：就是数据交换的缓冲区，俗称的缓存就是缓冲区内的数据，一般从数据库中获取，存储于本地代码中。
- 缓冲区：是存储数据的临时地方，一般读写性能较高。

例子：

// 例1:
static final ConcurrentHashMap<K,V> map = new ConcurrentHashMap<>(); //本地用于高并发缓存

// 例2:
static final Cache<K,V> USER_CACHE = CacheBuilder.newBuilder().build(); // 用于redis等缓存

// 例3:
Static final Map<K,V> map =  new HashMap(); // 本地缓存

由于其被Static修饰,所以随着类的加载而被加载到内存之中，作为本地缓存，由于其又被final修饰，所以其引用(例3:map)和对象(例3:new HashMap())之间的关系是固定的，不能改变，因此不用担心赋值(=)导致缓存失效。

二、为什么使用缓存

优点：访问速度快，好用

缓存数据存储于代码中，而代码运行在内存中，内存的读写性能远高于磁盘，缓存可以大大降低用户访问并发量带来的服务器读写压力。
- 实际开发过程中,企业的数据量,少则几十万,多则几千万,这么大数据量,如果没有缓存来作为"避震器",系统是几乎撑不住的,所以企业会大量运用到缓存技术。

缓存也会增加代码复杂度和运营的成本。

三、使用缓存的缺点与优点

在这里插入图片描述

四、如何使用缓存

实际开发中,会构建多级缓存来使系统运行速度进一步提升，例如：本地缓存与redis中的缓存并发使用等等。
- 浏览器缓存：主要是存在于浏览器端的缓存
- 应用层缓存：可以分为tomcat本地缓存，比如之前提到的map，或者是使用redis作为缓存
- 数据库缓存：在数据库中有一片空间是 buffer pool，增改查数据都会先加载到mysql的缓存中
- CPU缓存：当代计算机最大的问题是 cpu性能提升了，但内存读写速度没有跟上，所以为了适应当下的情况，增加了cpu的L1，L2，L3级的缓存

四、1、添加缓存的思路

标准的操作方式就是查询数据库之前先查询缓存：
- 如果缓存数据存在，则直接从缓存中返回。
- 如果缓存数据不存在，再查询数据库，然后将查询到的数据存入redis，再把数据库的数据返回。
不使用缓存
使用缓存
举例：根据id查询商铺的信息

四、2、缓存的更新策略

缓存更新是redis为了节约内存而设计出来的一个东西，主要是因为内存数据宝贵，当我们向redis插入太多数据，此时就可能会导致缓存中的数据过多，所以redis会对部分数据进行更新，或者把它叫为淘汰更合适。主要有一下三种策略：
- 内存淘汰：redis自动进行，当redis内存达到咱们设定的max-memery的时候，会自动触发淘汰机制，淘汰掉一些不重要的数据(可以自己设置策略方式)
- 超时剔除：当我们给redis设置了过期时间ttl之后，redis会将超时的数据进行删除，方便后面继续使用缓存
- 主动更新：我们可以手动调用方法把缓存删掉，通常用于解决缓存和数据库不一致问题

在这里插入图片描述

四、2.1、数据库和缓存不一致的问题解决：

由于我们的缓存的数据源来自于数据库,而数据库的数据是会发生变化的,因此,如果当数据库中数据发生变化,而缓存却没有同步,此时就会有一致性问题存在,其后果是:
- 用户使用缓存中的过时数据,就会产生类似多线程数据安全问题，从而影响业务，产品口碑等。怎么解决呢？有如下几种方案：
  - 1、Cache Aside Pattern 人工编码方式：缓存调用者在更新完数据库后再去更新缓存，也称之为双写方案
  - 2、Read/Write Through Pattern : 由系统本身完成，数据库与缓存的问题交由系统本身去处理
  - 3、Write Behind Caching Pattern ：调用者只操作缓存，其他线程去异步处理数据库，实现最终一致

数据库和缓存不一致采用Cache Aside Pattern 人工编码方式

数据库和缓存不一致采用方法为：Cache Aside Pattern 人工编码方式：缓存调用者在更新完数据库后再去更新缓存，也称之为双写方案

操作缓存和数据库时有三个问题需要考虑：

假设我们每次操作数据库后，都操作缓存，但是中间如果没有人查询，那么这个更新动作实际上只有最后一次生效，中间的更新动作意义并不大，我们可以把缓存删除，等待再次查询时，将缓存中的数据加载出来.
问题一：选择删除缓存还是更新缓存？ （删除缓存）
- 更新缓存：每次更新数据库都更新缓存，无效写操作较多
- 删除缓存：更新数据库时让缓存失效，查询时再更新缓存
为什么不更新缓存儿选择直接删除缓存呢？
- 因为缓存的更新成本比删除成本更高。（因为你写入数据库的值在很多情况下并不是直接写入缓存的，而是要经过一系列复杂的计算再写入缓存。那么每次写入数据库后都再次计算写入缓存的值，无疑是浪费性能的，所以删除缓存更为适合。

问题二：如何保证缓存与数据库的操作的同时成功或失败？
- 单体系统，将缓存与数据库操作放在一个事务
- 分布式系统，利用TCC等分布式事务方案
问题三：选择先操作缓存还是先操作数据库？（先操作数据库，再删除缓存 ）
- 先删除缓存，再操作数据库
- 先操作数据库，再删除缓存

具体操作缓存还是操作数据库，我们应当是先操作数据库，再删除缓存
- 原因：如果你选择第一种方案（Cache Aside Pattern 人工编码方式），在两个线程并发来访问时，假设线程1先来，他先把缓存删了，此时线程2过来查询缓存数据并不存在，此时线程2查询数据库并把查询出来的数据写入缓存，当线程2把数据写入缓存后，线程1再执行更新动作时，实际上写入的就是旧的数据，新的数据被旧数据覆盖了。

先删除缓存还是先执行数据库操作的选择分析

写缓存的时间是很快的（几毫秒），而操作数据库的时间是很长的。（操作缓存和操作数据库效率差别大）

1、先删除缓存，再操作数据

先删除缓存，再操作数据的正常情况：
先删除缓存，再操作数据的异常情况（出现数据库和缓存数据不一致的问题）：
- 解决办法一：延迟双删：最终一致性的方法，即使用双删的办法。（就是每次修改完数据之后再把缓存删除了（使用延迟删除，避免删除缓存操作在旧数据的写入缓存操作之前）），这样就保证了数据的一致性了，但还是会出现一次数据不一致的问题，如果想避免一次数据一致性都不出现就得使用强一致性的方法了）（推荐使用这个方法）
  - 这方法感觉就相当于先操作数据库再删除缓存一样了，由此看来还是选择先操作再删除缓存
- 解决办法二：使用强一致性的办法（就是保证redis的操作和数据库的操作的原子性），可以使用加锁的方法（使用这种方法会影响性能，我们使用redis的意义就是为了提高性能，所以加锁就得不偿失了，所以不太推荐了）

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

先操作数据，再删除缓存的正常情况：
先操作数据，再删除缓存的异常情况1（出现数据库和缓存数据不一致的问题）：因为缓存操作是很快的，所以这种异常情况几乎不可能发生。
先操作数据，再删除缓存的异常情况2：删除缓存失败的情况，就是线程2执行删除缓存操作时出现删除失败的问题，导致最终的缓存数据还是旧数据。
- 解决方案一：使用异步删除重试的办法（结合mq）
- 解决方案二：cannal解耦（使用cannal提供的java客户端）

最终选择：先操作数据库再删除缓存

在这里插入图片描述

缓存穿透

缓存雪崩

缓存击穿（热点key）

最后可以把缓存击穿和缓存穿透的解决方法封装成一个工具类

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

方法1：将任意Java对象序列化为json并存储在string类型的key中，并且可以设置TTL过期时间
方法2：将任意Java对象序列化为json并存储在string类型的key中，并且可以设置逻辑过期时间，用于处理缓

存击穿问题

方法3：根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题
方法4：根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题

@Component
public class CacheClient {

    private final StringRedisTemplate stringRedisTemplate;

    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

//使用构造器注入第三方beanStringRedisTemplate
    public CacheClient(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

// 添加缓存，设置key的过期时间
    public void set(String key, Object value, Long time, TimeUnit unit) {
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), time, unit);
    }

// 添加缓存，设置逻辑过期时间
    public void setWithLogicalExpire(String key, Object value, Long time, TimeUnit unit) {
        // 设置逻辑过期
        RedisData redisData = new RedisData();
        redisData.setData(value);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
        // 写入Redis
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
    }

// 获取缓存，解决缓存穿透
    public <R,ID> R queryWithPassThrough(
            String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit){
        String key = keyPrefix + id;
        // 1.从redis查询商铺缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        // 2.判断是否存在
        if (StrUtil.isNotBlank(json)) {
            // 3.存在，直接返回
            return JSONUtil.toBean(json, type);
        }
        // 判断命中的是否是空值
        if (json != null) {
            // 返回一个错误信息
            return null;
        }

        // 4.不存在，根据id查询数据库
        R r = dbFallback.apply(id);
        // 5.不存在，返回错误
        if (r == null) {
            // 将空值写入redis
            stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
            // 返回错误信息
            return null;
        }
        // 6.存在，写入redis
        this.set(key, r, time, unit);
        return r;
    }
    
// 使用逻辑过期时间，解决缓存击穿
    public <R, ID> R queryWithLogicalExpire(
            String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit) {
        String key = keyPrefix + id;
        // 1.从redis查询商铺缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        // 2.判断是否存在
        if (StrUtil.isBlank(json)) {
            // 3.存在，直接返回
            return null;
        }
        // 4.命中，需要先把json反序列化为对象
        RedisData redisData = JSONUtil.toBean(json, 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.缓存重建
        // 6.1.获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        boolean isLock = tryLock(lockKey);
        // 6.2.判断是否获取锁成功
        if (isLock){
            // 6.3.成功，开启独立线程，实现缓存重建
            CACHE_REBUILD_EXECUTOR.submit(() -> {
                try {
                    // 查询数据库
                    R newR = dbFallback.apply(id);
                    // 重建缓存
                    this.setWithLogicalExpire(key, newR, time, unit);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }finally {
                    // 释放锁
                    unlock(lockKey);
                }
            });
        }
        // 6.4.返回过期的商铺信息
        return r;
    }

// 使用互斥锁解决缓存穿透
    public <R, ID> R queryWithMutex(
            String keyPrefix, 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.isNotBlank(shopJson)) {
            // 3.存在，直接返回
            return JSONUtil.toBean(shopJson, type);
        }
        // 判断命中的是否是空值
        if (shopJson != null) {
            // 返回一个错误信息
            return null;
        }

        // 4.实现缓存重建
        // 4.1.获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        R r = null;
        try {
            boolean isLock = tryLock(lockKey);
            // 4.2.判断是否获取成功
            if (!isLock) {
                // 4.3.获取锁失败，休眠并重试
                Thread.sleep(50);
                return queryWithMutex(keyPrefix, id, type, dbFallback, time, unit);
            }
            // 4.4.获取锁成功，根据id查询数据库
            r = dbFallback.apply(id);
            // 5.不存在，返回错误
            if (r == null) {
                // 将空值写入redis
                stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
                // 返回错误信息
                return null;
            }
            // 6.存在，写入redis
            this.set(key, r, time, unit);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }finally {
            // 7.释放锁
            unlock(lockKey);
        }
        // 8.返回
        return r;
    }

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

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

Redis实战常用二、缓存的使用

一、什么是缓存

二、为什么使用缓存

三、使用缓存的缺点与优点

四、如何使用缓存

四、1、添加缓存的思路

四、2、缓存的更新策略

四、2.1、数据库和缓存不一致的问题解决：

数据库和缓存不一致采用Cache Aside Pattern 人工编码方式

操作缓存和数据库时有三个问题需要考虑：

先删除缓存还是先执行数据库操作的选择分析

1、先删除缓存，再操作数据

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

最终选择：先操作数据库再删除缓存

缓存穿透

缓存雪崩

缓存击穿（热点key）

最后可以把缓存击穿和缓存穿透的解决方法封装成一个工具类

网站公告

今日签到

热门文章

最新发布

Redis实战常用二、缓存的使用

一、什么是缓存

二、为什么使用缓存

三、使用缓存的缺点与优点

四、如何使用缓存

四、1、添加缓存的思路

四、2、缓存的更新策略

四、2.1、数据库和缓存不一致的问题解决：

数据库和缓存不一致采用Cache Aside Pattern 人工编码方式

操作缓存和数据库时有三个问题需要考虑：

先删除缓存还是先执行数据库操作的选择分析

1、先删除缓存，再操作数据

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

最终选择：先操作数据库再删除缓存

缓存穿透

缓存雪崩

缓存击穿（热点key）

最后可以把缓存击穿和缓存穿透的解决方法封装成一个工具类

网站公告

今日签到

热门文章

最新发布

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