Redis02——缓存（缓存更新策略、缓存穿透、缓存雪崩、缓存击穿、缓存工具封装）

浏览器缓存：常见的是缓存静态资源到本地，如CSS、JS、图片等，这样就不用每次访问都去加载数据，大大降低了网络的延时，提高了页面的显示速度，提升用户体验
Tomcat 中应用层缓存：将数据库中的数据缓存到redis中，当有请求访问数据时，就会首先去redis中获取，如果redis中有需要的数据就可以直接返回，不需要再去访问数据库，只有redis查询不到数据时才去访问数据库。redis的读写速度很快，所以可以提高数据的响应速度
数据库缓存：比如可以对索引进行缓存，如id，当根据id查询数据时，可以在内存中进行快速检索，而不需要去读取磁盘中，只有当缓存中找不到时才去读磁盘进行查询，效率也会提高
CPU缓存
磁盘缓存

缓存的作用：

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

缓存的成本：

数据一致性成本：当更新数据库而还没来得及更新缓存时，此时缓存中的数据就是旧数据，就会产生和数据库中的数据不一致的问题
代码维护成本：为了解决数据一致性问题，就会通过较为复杂的代码来维护，而且在数据一致性问题的处理过程中，也可能产生缓存穿透、击穿等问题，解决这些问题也会让代码复杂度提高，也就提高了代码维护的成本
运维成本：为了解决缓存雪崩问题以及保证缓存的高可用性，缓存一般需要搭建集群，而集群的部署、维护等都会产生相应的成本

添加Redis缓存

业务场景

比如有一个后端接口是根据商家id查看商家详情信息，在不使用缓存时，这个后端接口的实现是直接根据传递过来的商家id去数据库查询商家详情信息，然后返回给前端，这里对这个接口用Redis做缓存

缓存作用模型

java代码

只包含service实现类的代码，因为主要业务逻辑都在这个类里

java 复制代码

package com.hmdp.service.impl;

import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.hmdp.dto.Result;
import com.hmdp.entity.Shop;
import com.hmdp.mapper.ShopMapper;
import com.hmdp.service.IShopService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

import static com.hmdp.utils.RedisConstants.CACHE_SHOP_KEY;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author 虎哥
 * @since 2021-12-22
 */
@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public Result queryById(Long id) {
        // 1、从Redis中查询商家信息
        String key = CACHE_SHOP_KEY + id;
        // 可以使用Redis中的Hash结构
//        stringRedisTemplate.opsForHash().entries("" + id);
        // 这里用String来演示
        String jsonStr = stringRedisTemplate.opsForValue().get(key);
        // 2、判断缓存是否命中，即Redis中是否有要查询的商家信息
        if (StrUtil.isNotBlank(jsonStr)) {
            // 2.1 命中，直接返回给前端
            // 先把JSON字符串转出java对象
            Shop shop = JSONUtil.toBean(jsonStr, Shop.class);
            return Result.ok(shop);
        }

        // 2.2 未命中，根据id去数据库里查询
        Shop shop = getById(id);
        // 2.1.1 判断数据库中该商家是否存在
        if (shop == null){
            // 2.1.1.1 数据库中不存在，返回404
            return Result.fail("店铺不存在");
        }

        // 2.1.1.2 数据库中存在，写入Redis，并返回给前端
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop));
        return Result.ok(shop);
    }
}

缓存更新策略

当更新数据库而没有更新缓存数据时，就会产生数据一致性问题，为了解决这个问题，就需要对缓存中的数据进行更新

有以下三种缓存更新策略：

内存淘汰：当内存不足时，redis自带的内存淘汰机制就会淘汰掉一部分数据，当需要查询这部分数据时，就会去数据库查询，进而重新写入到缓存，也就实现了缓存的更新，在一定程度上保证了数据的一致性。但是这种方式是不可控的，我们不知道什么时候会进行淘汰，不知道淘汰的是哪些数据，有可能内存一直充足，那么就不会进行内存淘汰，获取到的数据就一直是旧数据。但维护成本很低，这是redis自带的功能，默认是开启的，不需要我们维护
超时剔除：在向缓存写入数据的同时设置数据的超时时间，当时间到了就会自动删除数据，然后查询时缓存中没有就会去查询数据库并重新写入缓存，也就实现了缓存的更新。数据的一致性可靠程度可以通过设置超时时间的长短来控制，但是在超时时间没到之前，还是可能产生数据不一致的情况，但总的来说还是比内存淘汰可靠些，而且维护成本也很低，因为只需要在存入时设置一个超时时间即可
主动更新：在数据库更新之后，通过编写代码主动更新缓存中的数据，这种方式的一致性比较好，但维护成本也相对较高，因为需要手动编写代码来进行维护，在业务逻辑复杂时，代码也会较为复杂，代码的维护成本也就会提高

主动更新的三种策略

Cache Aside Pattern：由缓存的调用者，在更新数据库的同时更新缓存，也就是自己写代码实现
Read/Write Through Pattern：缓存和数据库整合为一个服务，由服务来维护一致性，调用者使用该服务，无需关心缓存的一致性问题。即有一个现成的服务可以直接调用，调用者不需要关心它底层到底是怎么工作的。但是要维护这样的服务也是比较难的，而且一般市面上不容易找到这样的服务，自己开发维护成本会很高
Write Behind Caching Pattern：调用者只操作缓存，不关心数据库，由其他线程异步的将缓存数据持久化到数据库，也就是对数据的增删改查操作都是在缓存里进行，而操作结果的持久化由其他线程异步进行，保证一致性。好处是当对缓存中的数据更新N次时，只有第N次是有效的，刚好其他线程就在此时来进行数据持久化，就会把最后一次的缓存更新保持到数据库，即多次缓存更新结果只需一次持久化。坏处一是这个异步任务会比较复杂，需要实时监控缓存数据的变化；二是数据一致性不能保证，当缓存进行多次更新时，此时还未触发线程进行数据持久化，就会造成缓存和数据库数据不一致，如果此时缓存再出现问题，如宕机，数据就会丢失，且也没有进行数据的持久化

综上，第一种方式比较好，下面对第一种方式进行介绍

主动更新------Cache Aside Pattern

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

1、删除缓存还是更新缓存

更新缓存：每次更新数据库都更新缓存，无效写操作比较多。也就是说每次更新数据库，都会去更新一次缓存中对应的数据，但如果是写操作比较多，读操作比较少，比如更新了一百次数据库后，才会进行一次数据查询，那么就会更新一百次缓存，如果在前面的更新中都没有数据查询请求，只在第一百次更新完缓存之后，才有一次数据查询请求，那么就会将缓存中的结果返回（此时返回的是第一百更新后的最新数据），那么就会造成前面九十九次的缓存更新都白费，所以一般不用这种方法
删除缓存，更新数据库时让缓存失效，查询时再更新缓存。每次更新完数据库，就把缓存中对应的数据设置为失效（可以通过设置超时时间来完成），并且没有对缓存中的数据马上进行更新，而是当有数据查询请求时，查询缓存时未命中，就会去查询数据库，然后把查询到数据写入缓存（此时才进行缓存更新）并返回

2、如何保证缓存与数据库的操作同时完成或同时失败

对于单体系统：将缓存和数据库操作放在一个事务内即可
对于分布式系统：利用TCC等分布式事务方案

3、先操作缓存还是先操作数据库（线程安全问题）

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

这种情况下，在多线程并发时出现异常的概率还是比较大的，因为删除缓存，读缓存和查数据库（直接获取数据库数据）以及写入缓存的操作也很快，但是写入数据库（这里要组织数据，然后再进行插入操作，比直接从数据库获取数据要慢）的速度相对上述操作来说就很慢，所以很容易出现下图中的异常情况：

在线程1删除缓存（速度很快）之后，还没把更新数据库的操作完成（因为该操作比较耗时）的这段时间内，有另一个线程2来查找数据，此时因为已经删除了缓存，所以未命中就会去查找数据库然后写入缓存（读缓存->查数据库->写入缓存这三个操作加起来都比更新数据库操作块），此时缓存中再次被写入了旧数据10，而线程2更新完数据库后，数据库中的数据就变成了20，造成了数据不一致的情况

并且，可以从图中看出，出现异常情况之后，缓存中的数据就一直是旧数据，后续如果线程2或其他线程来获取数据，得到的就一直是缓存中的旧数据

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

异常情况1：在线程1更新完数据库之后，删除缓存之前的这段时间里，有另一个线程2来查询数据，此时缓存还未删除，命中并返回旧数据10，然后线程1执行删除缓存操作，缓存变为空，此时也造成了数据不一致

但是，由于线程1在已经更新完数据库到删除缓存的这段时间非常短（因为耗时的写入数据库已经完成，而删除缓存速度非常块），所以在这段很短的时间里出现线程2的概率比较小。其次，就算真的发生这种异常情况，线程2第一次查询得到的是旧数据10，第二次来查询时缓存已经为空了，即未命中，那么就会去查找数据库然后写入缓存，此时得到的又会是最新的数据20，缓存中的数据也被更新为20，所以这种异常情况的代价是比较小的（线程2第一次查询返回的是旧数据）

异常情况2：刚好缓存中的数据因为某些原因失效（如过期时间到了），可以理解成被删除，假设线程2查询数据未命中（数据已失效），去查询数据库得到10，并准备将10写入缓存，在这期间线程1进行更新数据库和删除缓存操作，然后线程2才执行写入缓存操作，如图所示

这种情况的概率也很低，要同时满足两个条件：1、有两个进程并行执行；2、线程2查询时恰好缓存失效；同时有另一个线程1要在线程2写入缓存之前来执行更新数据库和删除缓存操作

从上面的《先删除缓存，再操作数据库》分析中知道，在第二个条件中，在线程2已经查询到数据库之后写入缓存之前的这段时间很短，而线程1的更新数据库以及删除缓存操作相比之下耗时更长（其实光更新数据库这一操作就已经很耗时了），所以要同时满足上面的两个条件概率就很低

假如这种概率很小的情况真的发生了，也可以通过设置超时时间，当超时时间到了就会删除旧数据

综上所述，虽然上面两种方式都有可能产生线程安全问题，但是先操作数据库再删除缓存发生的概率更小，所以选择先操作数据库再删除缓存

综上，缓存更新的最佳实践方案为：

实际应用

java代码

java 复制代码

package com.hmdp.service.impl;

import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.hmdp.dto.Result;
import com.hmdp.entity.Shop;
import com.hmdp.mapper.ShopMapper;
import com.hmdp.service.IShopService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;

import java.util.concurrent.TimeUnit;

import static com.hmdp.utils.RedisConstants.CACHE_SHOP_KEY;
import static com.hmdp.utils.RedisConstants.CACHE_SHOP_TTL;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author 虎哥
 * @since 2021-12-22
 */
@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public Result queryById(Long id) {
        // 1、从Redis中查询商家信息
        String key = CACHE_SHOP_KEY + id;
        // 可以使用Redis中的Hash结构
//        stringRedisTemplate.opsForHash().entries("" + id);
        // 这里用String来演示
        String jsonStr = stringRedisTemplate.opsForValue().get(key);
        // 2、判断缓存是否命中，即Redis中是否有要查询的商家信息
        if (StrUtil.isNotBlank(jsonStr)) {
            // 2.1 命中，直接返回给前端
            // 先把JSON字符串转出java对象
            Shop shop = JSONUtil.toBean(jsonStr, Shop.class);
            return Result.ok(shop);
        }

        // 2.2 未命中，根据id去数据库里查询
        Shop shop = getById(id);
        // 2.1.1 判断数据库中该商家是否存在
        if (shop == null){
            // 2.1.1.1 数据库中不存在，返回404
            return Result.fail("店铺不存在");
        }

        // 2.1.1.2 数据库中存在，写入Redis，并返回给前端
        // CACHE_SHOP_TTL, TimeUnit.MINUTES：设置Redis过期时间为30分钟
        stringRedisTemplate.opsForValue()
                .set(key, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
        return Result.ok(shop);
    }

    @Override
    @Transactional  // 事务注解
    public Result update(Shop shop) {
        // 该方法使用了事务注解，所以可以保证更新数据库操作好删除Redis缓存操作同时成功或同时失败
        Long id = shop.getId();
        if (id == null){
            return Result.fail("店铺id不存在");
        }
        // 更新数据库
        updateById(shop);
        // 删除缓存
        stringRedisTemplate.delete(CACHE_SHOP_KEY + id);
        return Result.ok();
    }
}

缓存穿透

概念

缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在，那么查询请求在缓存中找不到数据时就会直接去数据库查询，而数据库中也没有要查询的数据，所以就返回给客户端找不到的提示信息

这种情况下，如果有人恶意使用多线程来请求根本不存在的数据，那么这些请求就会让程序直接去数据库查询（因为redis，也就是缓存中没有），就会给数据库造成巨大压力

解决方法

缓存空对象
- 优点：实现简单，维护方便
- 缺点：1、有额外的内存消耗（因为要对不存在的数据值存储为空，当有很多不存在的数据被请求时，这些数据都会被缓存为空，此时缓存中就会有很多没用的key缓存着空值，可以通过给key设置超时时间来解决）；2、可能造成短期的数据不一致（比如第一次访问的某个数据确实不存在，将其存为空值，后来真的在数据库中插入该数据，而此时缓存中还是空值，就会产生数据不一致的情况，可以设置超时时间来解决或者当数据库更新时主动更新缓存）
布隆过滤（具体是啥百度吧）
- 优点：内存占用较少，没有多余的key（因为不用将不存在的数据缓存为空值）
- 缺点：1、实现复杂（但Redis自带了一个布隆过滤，可以帮助简化开发）；2、存在误判的可能（当告诉数据不存在时，是真的不存在，但当告诉存在时，不一定真的存在，此时还是有缓存穿透的风险）
增强id的复杂度，避免被攻击者猜测到id的组成规律
做好数据的基础格式校验（比如校验id是否符合格式，这也是上一条说的增强id复杂度的作用），只有数据符合要求才能访问
加强用户的权限校验（是否已经登录，是否有权限访问）
做好热点参数的限流，对于一些比较热门的请求接口，做限流处理，比如一些秒杀活动，限制用户的访问次数

实际应用

基于上面的代码和业务需求（根据id查询店铺详情信息）

流程图

java代码

java 复制代码

package com.hmdp.service.impl;

import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.hmdp.dto.Result;
import com.hmdp.entity.Shop;
import com.hmdp.mapper.ShopMapper;
import com.hmdp.service.IShopService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;

import java.util.concurrent.TimeUnit;

import static com.hmdp.utils.RedisConstants.*;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author 虎哥
 * @since 2021-12-22
 */
@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public Result queryById(Long id) {
        // 1、从Redis中查询商家信息
        String key = CACHE_SHOP_KEY + id;
        // 这里用String来演示
        String jsonStr = stringRedisTemplate.opsForValue().get(key);
        // 2、判断缓存是否命中，即Redis中是否有要查询的商家信息
        if (StrUtil.isNotBlank(jsonStr)) {
            // 2.1 命中，直接返回给前端
            // 先把JSON字符串转出java对象
            Shop shop = JSONUtil.toBean(jsonStr, Shop.class);
            return Result.ok(shop);
        }

        // 判断命中的是否是空值（缓存雪崩问题解决方案：缓存空值）
        if (jsonStr != null){  // 命中的是空值
            return Result.fail("店铺不存在");
        }

        // 2.2 未命中，根据id去数据库里查询
        Shop shop = getById(id);
        // 2.1.1 判断数据库中该商家是否存在
        if (shop == null){
            // 缓存空值（缓存雪崩问题解决方案），并设置较短的过期时间
            stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
            // 2.1.1.1 数据库中不存在，返回404
            return Result.fail("店铺不存在");
        }

        // 2.1.1.2 数据库中存在，写入Redis，并返回给前端
        // CACHE_SHOP_TTL, TimeUnit.MINUTES：设置Redis过期时间为30分钟
        stringRedisTemplate.opsForValue()
                .set(key, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
        return Result.ok(shop);
    }
}

缓存雪崩

概念

缓存雪崩是指在同一时段大量的缓存key同时失效或者Redis服务宕机，而此时有大量的请求来访问这些丢失的数据，那么在Redis中没有，这些请求就会直接到达数据库，给数据库带来巨大压力

解决方法

给不同的key设置不同的过期时间，比如过期时间原本要设置为30分钟，可以在这30分钟的基础上随机加上一个时间值，如随机值为3到5分钟（也可以是其他值），这样就不会让多个key同时过期失效（针对同一时段大量的缓存key同时失效的情况）
利用Redis集群提高服务的可用性（避免Redis服务宕机的情况）
给缓存业务添加降级限流策略，如当Redis宕机时，有客户端来请求数据时，一律返回类似于"服务暂时不可用"等提示信息，拒绝服务（Redis真的宕机且无法恢复的情况）
给业务添加多级缓存，如添加浏览器缓存、反向代理Nginx缓存、Redis缓存、JVM缓存、数据库缓存

缓存击穿

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

常见的解决方法有两种：互斥锁和逻辑过期

互斥锁

介绍

当有一个线程1开始重建key时，就用锁锁住，这样当其他线程也想重建key时，就要等待线程1释放锁，这样就不会出现多个线程都重建key的情况

下图的过程是：线程1最先要获取数据，去查询缓存，未命中，开始获取锁，获取锁成功之后开始查询数据库重建缓存数据，将数据写入缓存中，最后释放锁。而在线程1获取锁成功之后，线程2也来查询数据（和线程1要查询的数据相同），去查询缓存，未命中，开始获取锁，获取失败（因为已经被线程1先获取到了），休眠一会，然后重新去缓存中获取数据，如果缓存中已经有了（线程1已经写入）直接返回，如果缓存还是未命中，就去获取锁，还是失败，继续休眠....一直重复，直到缓存中有数据或者锁被释放

互斥锁存在的问题：多个没有拿到锁的线程会一直处于等待状态，如果key构建的时间比较久，那这些线程的等待时间也就会变长，响应速度也就会比较慢，性能就会比较差。而且有可能存在死锁的情况，比如构建一个key需要获取多个锁，而这些锁被不同的线程获取到，它们就会相互等待没有获取到的锁，就会造成死锁现象

实际应用

业务需求及流程图描述

java代码

代码放在下面逻辑过期中，因为分别把互斥锁和逻辑过期两种实现方式封装成了一个方法

逻辑过期

介绍

不直接给缓存中的key设置过期时间TTL，而是在要缓存的数据中增加一个字段，用这个字段标明过期时间，这个字段一般是用当前时间（也就是向缓存中存入数据时的时间）加上真正要设置的过期时间（如30分钟）得到的，这个字段就是逻辑过期时间

因为没有给key设置实际的过期时间TTL，再配合一些合适的内存淘汰策略，那么理论上key一旦存入Redis就会永不过期，也就是一直能从缓存中获取到，如果想删除掉这个key，再手动进行删除

实际应用

业务需求及流程图如下

java实现代码

测试类代码，提前向缓存中存入数据

java 复制代码

package com.hmdp;

import com.hmdp.service.impl.ShopServiceImpl;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;

@SpringBootTest
class HmDianPingApplicationTests {
    @Resource
    private ShopServiceImpl shopService;

    @Test
    void testSaveShop() throws InterruptedException {
        shopService.saveShop2Redis(1l, 10l);
    }
}

RedisData类

java 复制代码

package com.hmdp.utils;

import lombok.Data;

import java.time.LocalDateTime;

/**
 * 为了不改动原有的Shop类的代码，在此重新定义一个数据类
 * 该类的expireTime字段就表示逻辑过期时间
 * data字段表示原有的数据，在这里指的是Shop类对象，即店铺信息
 * 也就是通过该类在原有数据的基础上添加一个逻辑过期时间
 * 根据不同的业务需要，data可以表示任意的数据，因为器类型是Object
 */
@Data
public class RedisData {
    private LocalDateTime expireTime;
    private Object data;
}

ShopServiceImpl类中的代码

java 复制代码

package com.hmdp.service.impl;

import cn.hutool.core.util.BooleanUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.hmdp.dto.Result;
import com.hmdp.entity.Shop;
import com.hmdp.mapper.ShopMapper;
import com.hmdp.service.IShopService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmdp.utils.RedisData;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;

import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import static com.hmdp.utils.RedisConstants.*;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author 虎哥
 * @since 2021-12-22
 */
@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
    @Resource
    private StringRedisTemplate stringRedisTemplate;


    /**
     * 根据id查询店铺详情信息
     *
     * @param id 要查询的店铺id
     * @return 返回店铺信息
     */
    @Override
    public Result queryById(Long id) {
        // 缓存空值解决缓存穿透
//        Shop shop = queryWithPassThrough(id);

        // 互斥锁解决缓存击穿
//        Shop shop = queryWithPassMutex(id);
//        if (shop == null) {
//            return Result.fail("店铺不存在");
//        }

        // 逻辑过期解决缓存击穿
        Shop shop = queryWithLogicalExpire(id);
        if (shop == null) {
            return Result.fail("店铺不存在");
        }
        return Result.ok(shop);
    }

    /**
     * 互斥锁解决缓存击穿
     *
     * @param id 要查询的店铺id
     * @return 店铺信息
     */
    public Shop queryWithPassMutex(Long id) {
        // 从Redis中查询商家信息
        Map<String, Object> stringObjectMap = queryShopFromCache(id);
        Boolean isExist = (Boolean) stringObjectMap.get("isExist");
        if (BooleanUtil.isTrue(isExist)) {
            // 缓存中存在数据，直接返回
            return (Shop) stringObjectMap.get("shop");
        }

        // 缓存未命中数据
        String lockKey = LOCK_SHOP_KEY + id;
        Shop shop = null;
        try {
            // 尝试获取锁
            boolean isGetLock = tryGetLock(lockKey);
            if (!isGetLock) {
                // 获取锁失败
                // 休眠等待
                Thread.sleep(80);
                // 休眠结束之后重新查询，即递归调用queryWithPassMutex方法
                return queryWithPassMutex(id);
            }
            // 获取锁成功
            // 再次判断缓存中是否已经有数据
            Map<String, Object> stringObjectMap2 = queryShopFromCache(id);
            Boolean isExist2 = (Boolean) stringObjectMap2.get("isExist");
            if (BooleanUtil.isTrue(isExist2)) {
                // 缓存中存在数据，直接返回
                return (Shop) stringObjectMap2.get("shop");
            }

            // 开始缓存重建
            // 缓存未命中数据
            String key = CACHE_SHOP_KEY + id;
            // 根据id去数据库里查询
            shop = getById(id);
            // 模拟缓存重建的延时
            Thread.sleep(200);
            // 判断数据库中该商家是否存在
            if (shop == null) {
                // 缓存空值（缓存雪崩问题解决方案），并设置较短的过期时间
                stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
                // 数据库中不存在，返回404
                return null;
            }

            // 数据库中存在，写入Redis，并返回给前端
            // CACHE_SHOP_TTL, TimeUnit.MINUTES：设置Redis过期时间为30分钟
            stringRedisTemplate.opsForValue()
                    .set(key, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            // 释放锁
            releaseLock(lockKey);
        }
        return shop;
    }

    /**
     * 判断缓存中是否命中数据
     *
     * @param id 要查询的数据id
     * @return 返回一个map集合，表示是否命中数据和命中的数据内容
     */
    private Map<String, Object> queryShopFromCache(Long id) {
        HashMap<String, Object> map = new HashMap<>();
        // 从Redis中查询商家信息
        String key = CACHE_SHOP_KEY + id;
        String jsonStr = stringRedisTemplate.opsForValue().get(key);
        // 判断缓存是否命中，即Redis中是否有要查询的商家信息
        if (StrUtil.isNotBlank(jsonStr)) {
            // 命中，直接返回给前端
            // 先把JSON字符串转出java对象
            Shop shop = JSONUtil.toBean(jsonStr, Shop.class);
            map.put("isExist", true);
            map.put("shop", shop);
            return map;
        }

        // 判断命中的是否是空值（缓存雪崩问题解决方案：缓存空值）
        if (jsonStr != null) {  // 命中的是空值
            map.put("isExist", true);
            map.put("shop", null);
            return map;
        }

        // 未命中，返回false和null
        map.put("isExist", false);
        map.put("shop", null);
        return map;
    }

    /**
     * 在实际业务中，热点key一般都是通过后台系统提前添加进Redis里
     * 这里用单元测试模拟一下后台管理，提前向Redis中存入热点key
     *
     * @param id            店铺的id
     * @param expireSeconds 逻辑过期时间，单位秒
     */
    public void saveShop2Redis(Long id, Long expireSeconds) throws InterruptedException {
        // 查询数据库获取店铺信息
        Shop shop = getById(id);
        // 模拟重建缓存的延时
        Thread.sleep(200);
        RedisData redisData = new RedisData();
        // 设置Shop数据
        redisData.setData(shop);
        // 设置过期时间
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
        // 存入Redis，注意Redis没有设置TTL
        stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(redisData));
    }

    // 定义一个线程池
    private final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

    /**
     * 逻辑过期解决缓存击穿
     *
     * @param id 要查询的店铺id
     * @return 店铺信息
     */
    public Shop queryWithLogicalExpire(Long id) {
        // 从Redis中查询商家信息
        String key = CACHE_SHOP_KEY + id;
        String jsonStr = stringRedisTemplate.opsForValue().get(key);
        if (StrUtil.isBlank(jsonStr)) {
            // 未命中数据，直接返回空
            return null;
        }

        // 命中数据，判断数据是否过期
        // 把json反序列化成java对象
        RedisData redisData = JSONUtil.toBean(jsonStr, RedisData.class);
        // redisData.getData()由于是Object类型，在反序列化的时候会反序列化为JSONObject
        // 所以需要再次将JSONObject反序列化为Shop
        // Shop shop = (Shop) redisData.getData();
        // 我觉得redisData.getData()得到的是一个Object对象，可以把Object强转成Shop
        // 但是实际上不可以，会报错：cn.hutool.json.JSONObject cannot be cast to com.hmdp.entity.Shop
        // 具体为啥不能直接强转成Shop我还没弄明白
        JSONObject jsonObj = (JSONObject) redisData.getData();
        Shop shop = JSONUtil.toBean(jsonObj, Shop.class);

        // 逻辑时间没有过期
        if (LocalDateTime.now().isBefore(redisData.getExpireTime())) {
            // 当前时间在逻辑过期时间之前 => 逻辑时间没有过期，直接返回数据
            return shop;
        }

        /* 逻辑时间过期 */
        String lockKey = LOCK_SHOP_KEY + id;
        // 获取锁
        if (tryGetLock(lockKey)) {
            // 获取锁成功，需要再次判断缓存中的数据是否过期
            /*
            因为在多线程的情况下，很有可能出现这一种情况：
                线程1判断数据逻辑过期，并且获得锁成功，它会新建一个线程2来重建key，然后线程1返回旧数据
                在线程2重构完成释放锁之前，有另一个线程3判断缓存中的数据过期开始往下尝试获得锁
                切好此时线程2构建完成（此时缓存中已经是新数据了）释放锁，释放掉的锁被线程3拿到
                如果不进行二次判断缓存中的数据是否过期，那么线程3又会再次去重建key，但是此时缓存中的
                数据并没有过期（因为刚刚线程2已经重建好了）
                所以为了避免重复重建缓存，就需要再次进行判断
            */
            String jsonStr2 = stringRedisTemplate.opsForValue().get(key);
            RedisData redisData2 = JSONUtil.toBean(jsonStr2, RedisData.class);
            if (LocalDateTime.now().isBefore(redisData2.getExpireTime())) {
                // 缓存中的数据未过期，直接返回
                return JSONUtil.toBean((JSONObject) redisData2.getData(), Shop.class);
            }
            // 获取锁成功，开启新线程重建缓存数据
            CACHE_REBUILD_EXECUTOR.submit(() -> {
                try {
                    // 重建缓存
                    this.saveShop2Redis(id, 10l);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    // 释放锁
                    releaseLock(lockKey);
                }
            });
        }


        // 无论获取锁成功还是失败，都要返回旧数据
        // 返回旧数据
        return shop;
    }


    /**
     * 尝试获取锁
     *
     * @param key 代表锁的键
     * @return 返回布尔值，是否获取锁成功
     */
    private boolean tryGetLock(String key) {
        // 设置锁并设置超时时间为10秒
        // setnx命令就对应着java中的setIfAbsent方法
        // 返回一个Boolean类型的变量
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", LOCK_SHOP_TTL, TimeUnit.SECONDS);
        // return flag  // 不建议直接返回flag，因为flag会被自动拆箱成boolean，在拆箱的过程中可能出现空指针异常
        // 使用工具类BooleanUtil进行返回
        return BooleanUtil.isTrue(flag);
    }

    /**
     * 释放锁，即删除key为lock的数据
     *
     * @param key 表示锁的键
     */
    private void releaseLock(String key) {
        stringRedisTemplate.delete(key);
    }

    /**
     * 用缓存空值的方式解决缓存穿透
     *
     * @param id 要查询的店铺id
     * @return 店铺的信息
     */
    public Shop queryWithPassThrough(Long id) {
        // 从Redis中查询商家信息
        String key = CACHE_SHOP_KEY + id;
        // 这里用String来演示
        String jsonStr = stringRedisTemplate.opsForValue().get(key);
        // 判断缓存是否命中，即Redis中是否有要查询的商家信息
        if (StrUtil.isNotBlank(jsonStr)) {
            // 命中，直接返回给前端
            // 先把JSON字符串转出java对象
            return JSONUtil.toBean(jsonStr, Shop.class);
        }

        // 判断命中的是否是空值（缓存雪崩问题解决方案：缓存空值）
        if (jsonStr != null) {  // 命中的是空值
            return null;
        }

        // 根据id去数据库里查询
        Shop shop = getById(id);
        // 判断数据库中该商家是否存在
        if (shop == null) {
            // 缓存空值（缓存雪崩问题解决方案），并设置较短的过期时间
            stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
            // 数据库中不存在，返回404
            return null;
        }

        // 数据库中存在，写入Redis，并返回给前端
        // CACHE_SHOP_TTL, TimeUnit.MINUTES：设置Redis过期时间为30分钟
        stringRedisTemplate.opsForValue()
                .set(key, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);

        return shop;
    }
}

互斥锁 VS 逻辑过期

这两种方式都是解决缓存重建key这段时间内产生的并发问题，优缺点如下

缓存工具封装

根据上述所说的，简单的封装一个缓存工具类，工具类要求如下

注意，如果是要调用逻辑过期的方法，要提前向缓存中存入数据，这里封装工具类和上面逻辑过期中的代码差不多，就是修改成了通用的写法

调用工具类

java 复制代码

package com.hmdp.service.impl;
import com.hmdp.dto.Result;
import com.hmdp.entity.Shop;
import com.hmdp.mapper.ShopMapper;
import com.hmdp.service.IShopService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmdp.utils.CacheClient;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

import java.util.concurrent.TimeUnit;

import static com.hmdp.utils.RedisConstants.*;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author 虎哥
 * @since 2021-12-22
 */
@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
    @Resource
    private CacheClient cacheClient;

    /**
     * 根据id查询店铺详情信息
     *
     * @param id 要查询的店铺id
     * @return 返回店铺信息
     */
    @Override
    public Result queryById(Long id) {
        // 缓存空值解决缓存穿透
        // lambda表达式：id2 -> getById(id2) 可以简化为：this::getById
//        Shop shop = cacheClient.queryWithPassThrough(
//                CACHE_SHOP_KEY, id, Shop.class, this::getById, CACHE_SHOP_TTL, TimeUnit.MINUTES);
//        if (shop == null) {
//            return Result.fail("店铺不存在");
//        }
//        return Result.ok(shop);

        // 逻辑过期时间解决缓存击穿
        // 注意提前使用单元测试向缓存写入数据，还有为了测试方便，把逻辑过期时间设置为30秒
        Shop shop = cacheClient.queryWithLogicalExpire(
                CACHE_SHOP_KEY, LOCK_SHOP_KEY, id, Shop.class, this::getById, 30l, TimeUnit.SECONDS);
        if (shop == null) {
            return Result.fail("店铺不存在");
        }
        return Result.ok(shop);
    }
}

工具类具体代码

java 复制代码

package com.hmdp.utils;

import cn.hutool.core.util.BooleanUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;

import static com.hmdp.utils.RedisConstants.LOCK_SHOP_TTL;

@Slf4j
@Component
public class CacheClient {
    private final StringRedisTemplate stringRedisTemplate;

    public CacheClient(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    /**
     * 将任意类型对象缓存到Redis中，并设置缓存过期时间，key的类型为String
     *
     * @param key   Redis的键
     * @param value 要缓存的对象，因为可以保存任意类型，所以这里定义value的类型为Object
     * @param time  缓存过期时间
     * @param unit  时间单位
     */
    public void set(String key, Object value, Long time, TimeUnit unit) {
        // 将java对象序列化为JSON
        String jsonStr = JSONUtil.toJsonStr(value);
        // 存入Redis
        stringRedisTemplate.opsForValue().set(key, jsonStr, time, unit);
    }

    /**
     * 将任意类型对象缓存到Redis中，并设置逻辑过期时间，key的类型为String
     *
     * @param key   Redis的键
     * @param value 要缓存的对象，因为可以保存任意类型，所以这里定义value的类型为Object
     * @param time  逻辑过期时间
     * @param unit  时间单位
     */
    public void setWithLogicalExpire(String key, Object value, Long time, TimeUnit unit) {
        // 实例化一个RedisData对象，其中对象的data存储具体的数据，expireTime存储逻辑过期时间
        RedisData redisData = new RedisData();
        // 保存逻辑过期时间
        // unit.toSeconds(time) 因为不确定时间单位是多少，但是这里统一转换成秒
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
        redisData.setData(value);
        // 存入Redis
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
    }

    /**
     * 根据id查询数据（用缓存空值解决缓存穿透问题）
     *
     * @param keyPrefix key的前缀
     * @param id        查询对象的id
     * @param type      查询对象的类型
     * @param func      查询对象的数据库方法
     * @param time      缓存过期时间
     * @param unit      时间单位
     * @param <R>       对象类型，因为不知道调用者要查询什么对象，所以这里用泛型
     * @param <ID>      对象id的类型，同理，不知道id的类型，这里用泛型
     * @return 返回查询到的对象数据
     */
    public <R, ID> R queryWithPassThrough(
            String keyPrefix, ID id, Class<R> type,
            Function<ID, R> func, Long time, TimeUnit unit) {
        // 拼接缓存的key
        String key = keyPrefix + id;
        // 查询缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        if (StrUtil.isNotBlank(json)) {
            // 缓存命中，直接返回值
            return JSONUtil.toBean(json, type);
        }

        if (json != null) {
            // 缓存命中，只是命中的是缓存的空值（缓存空值解决缓存穿透）
            return null;
        }

        // 缓存未命中，查询数据库
        /*
        这里由于是工具类，使用该工具类的可以是任意对象，所以在查找数据库时不能明确知道是查询哪张表
        也就不知道该调用哪个数据库方法来查询，所以需要调用者将查询数据库的方法通过参数传递过来
        即函数式编程（我个人觉得也可以理解为回调）
        */
        R r = func.apply(id);
        if (r == null) {
            // 如果数据库查不到，就缓存空值并设置过期时间，防止缓存穿透
            stringRedisTemplate.opsForValue().set(key, "", time, unit);
            return null;
        }
        // 将数据库查询结果缓存到Redis
//        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(r), time, unit);
        // 也可以调用上述定义好的方法
        this.set(key, r, time, unit);
        return r;
    }

    // 定义一个线程池
    private final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

    /**
     * 根据id查询数据（用逻辑过期解决缓存击穿问题）
     *
     * @param keyPrefix     店铺key的前缀
     * @param keyLockPrefix 店铺锁key的前缀
     * @param id            店铺id
     * @param type      查询对象的类型
     * @param func      查询对象的数据库方法
     * @param time      逻辑过期时间
     * @param unit      时间单位
     * @param <R>       对象类型，因为不知道调用者要查询什么对象，所以这里用泛型
     * @param <ID>      对象id的类型，同理，不知道id的类型，这里用泛型
     * @return 返回查询到的对象数据
     */
    public <R, ID> R queryWithLogicalExpire(
            String keyPrefix, String keyLockPrefix, ID id, Class<R> type,
            Function<ID, R> func, Long time, TimeUnit unit) {
        String key = keyPrefix + id;
        String json = stringRedisTemplate.opsForValue().get(key);
        if (StrUtil.isBlank(json)) {
            // 缓存未命中，直接返回空
            // 因为针对热点key且采用逻辑过期时间，那么就不可能取不到数据，真的取不到那就是真的没有，直接返回空
            return null;
        }
        RedisData redisData = JSONUtil.toBean(json, RedisData.class);
        LocalDateTime expireDate = redisData.getExpireTime();
        JSONObject jsonObject = (JSONObject) redisData.getData();
        R r = JSONUtil.toBean(jsonObject, type);
        if (LocalDateTime.now().isBefore(expireDate)) {
            // 当前时间在逻辑过期时间之前 => 数据未过期，直接返回
            return r;
        }

        // 逻辑时间过期，尝试获取锁
        String lockKey = keyLockPrefix + id;
        if (getLock(lockKey)) {
            // 获取锁成功，再次判断缓存中数据的逻辑时间是否过期，原因已经在之前说明
            String json2 = stringRedisTemplate.opsForValue().get(key);
            if (StrUtil.isBlank(json2)) {
                return null;
            }
            RedisData redisData2 = JSONUtil.toBean(json2, RedisData.class);
            if (LocalDateTime.now().isBefore(redisData2.getExpireTime())) {
                // 缓存中的数据未过期，直接返回
                return JSONUtil.toBean((JSONObject) redisData2.getData(), type);
            }
            // 新开一个线程，重建缓存
            CACHE_REBUILD_EXECUTOR.submit(() -> {
                try {
                    // 查询数据库
                    R r1 = func.apply(id);
                    // 模拟重建延时
                    Thread.sleep(200);
                    // 写入缓存
//                    RedisData redisData1 = new RedisData();
//                    redisData1.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
//                    redisData1.setData(r1);
//                    stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData1));
                    // 调用本工具类提供的方法写入缓存
                    this.setWithLogicalExpire(key, r1, time, unit);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    // 释放锁
                    unLock(lockKey);
                }
            });
        }
        // 无论获取锁成功还是失败，都要返回旧数据
        return r;
    }

    /**
     * 尝试获取锁
     *
     * @param key 代表锁的键
     * @return 返回布尔值，是否获取锁成功
     */
    private boolean getLock(String key) {
        // 设置锁并设置超时时间为LOCK_SHOP_TTL秒
        // setnx命令就对应着java中的setIfAbsent方法
        // 返回一个Boolean类型的变量
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", LOCK_SHOP_TTL, TimeUnit.SECONDS);
        // return flag  // 不建议直接返回flag，因为flag会被自动拆箱成boolean，在拆箱的过程中可能出现空指针异常
        // 使用工具类BooleanUtil进行返回
        return BooleanUtil.isTrue(flag);
    }

    /**
     * 释放锁，即删除key为lock的数据
     *
     * @param key 表示锁的键
     */
    private void unLock(String key) {
        stringRedisTemplate.delete(key);
    }
}