4.Redis实战—缓存中的更新策略，缓存穿透，缓存雪崩，缓存击穿

已于 2022-04-22 20:34:04 修改
阅读量449 收藏 1
点赞数
分类专栏： Redis 文章标签： redis
于 2022-04-22 20:27:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sichenss/article/details/124354315
版权

缓存更新策略:

image-20220414151513530

image-20220414153441713

03方案 :

先是将数据缓存 , 在一个异步操作中 , 将这些数据保存到数据库 , 这么做的好处是 , 在两次异步操作之间 , 进行的数据增删改 , 不用频繁的对数据库进行操作 , 只用在下一次异步操作时 , 将最终的数据进行保存即可

但是 , 如果在两次异步操作之间 , 出现宕机 , 可能会造成数据的丢失 , 一致性和可靠性都会存在一定的问题 ,

02方案 : 开发和维护成本较高

01方案 : 在开发中经常使用

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

  1. 删除缓存还是更新缓存
    • 更新缓存 : 每次更新数据库都要更新缓存 , 无效写操作较多
    • 删除缓存 : 更新数据库时让缓存失效 , 查询时在更新缓存 (推荐)
  2. 如何保证缓存与数据库的操作同时成功或失败?
    • 单体系统 : 将缓存与数据库操作放在一个事务
    • 分布式系统 : 利用TCC等分布式事务方案
  3. 先操作缓存还是操作数据库 (两种方案都有可能造成线程安全问题 )
    • 先删除缓存 , 再操作数据库 (出现的可能性较高)
    • 先操作数据库 , 再删除缓存 (出现的可能性极低)

总结 :

综上所述 : 选择缓存更新策略的最佳实践方案是 :

  1. 低一致性需求 : 使用Redis自带的内存淘汰机制

  2. 高一致性需求 : 主动更新 , 并以超时剔除作为兜底方案

    • 读操作 :

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

    • 写操作 :

      • 先写数据库 , 然后在删除缓存

      • 要确保数据库与缓存操作的原子性

        • 在更新操作上加一个注解

          @Transactional 
//TODO 添加事务处理 , 整个方法是一个事务

// TODO 数据的更新操作
@Override
@Transactional //TODO 添加事务处理 , 整个方法是一个事务
public Result update(Shop shop) {
    Long id = shop.getId();
    if (id == null) {
        return Result.fail("店铺id不能为空!");
    }
    // 1.更新数据库
    updateById(shop);
    // 2.删除缓存
    stringRedisTemplate.delete(CACHE_SHOP_KEY + id);
    return Result.ok();
}

缓存穿透 :

  • 缓存穿透 :
    • 是指客户端请求的数据在缓存中和数据库中都不存在 , 这样的缓存永远都不会生效 , 这些请求都会打到数据库

常见的解决方案 有两种 :

  1. 缓存空对象
    • 实现 :
      • 在查询时 , 缓存中没有 , 去查询数据库 , 数据库中也没有 , 返回一个 " " , 将这个" “缓存到缓存中 , 下次再请求的时候 , 直接从redis中返回这个” "
    • 优点 :
      • 实现简单 , 维护方便
    • 缺点 :
      • 额外的内存消耗
      • 可能造成短期的不一致
  2. 布隆过滤
    • image-20220414163414798
    • 优点 :
      • 内存占用较少 , 没有多于key
    • 缺点 :
      • 实现复杂
      • 存在误判可能 , 并不是百分百的准确
  3. 增强id的复杂度 , 避免被猜测id规律
  4. 做好数据的基础格式校验
  5. 加强用户权限校验
  6. 做好热点参数的限流

实现逻辑 :

  1. 从redis中查询商铺缓存
    1. 判断是否存在
      1. 存在 , 直接输出
      2. 不存在 , 判断是否是空字符串 " " ,
        1. 是 , 返回一个错误信息
        2. 不是 , 根据id查询数据库
          1. 数据库中不存在该店铺
            1. 以id加前缀 作为key , 以 " " 作为key值保存在缓存中 , 设置过期时间
            2. 返回错误信息
          2. 数据库中存在该店铺
            1. 将查询出来的数据转换 , 存储在Redis中
            2. 返回商铺信息

代码实现 :

// TODO 解决缓存穿透问题
public Shop queryWithPassThrough(Long id) {
    // TODO 1.从redis中查询商铺缓存 , 以商铺id作为唯一标识
    String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
    // 2.判断是否存在
    if (StrUtil.isNotBlank(shopJson)) {
        // TODO isNotBlank只有是有数据的情况加才为true , "" , null都为false
        // TODO 3.判断不为空 , 直接返回 , 将字符串转为bean
        return JSONUtil.toBean(shopJson, Shop.class);
    }
    //TODO 判断命中是否是空值 ,
    if (shopJson != null) { //结果是空字符串
        // 返回一个错误信息
        return null;
    }

    // 4.不存在 , 根据id查询数据库
    Shop shop = getById(id);
    // 5.不存在返回错误
    if (shop == null) {
        // TODO 将空值写入redis
        stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
        return null;
    }
    //  TODO 6.存在 , 写入redis , 使用huTool中的工具类 , 将对象转为json数据
    stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
    // 7.返回
    return shop;
}

缓存雪崩 :

  • 缓存雪崩 :
    • 是指在同一时间段大量的缓存key同时失效或者Redis服务宕机 , 导致大量请求到达数据库 , 带来巨大压力
  • 解决方案 :
    • 给不同的key的TTL添加随机值
    • 利用Redis集群提高服务的可用性
    • 给缓存业务添加降级限流策略
      • 添加机制 , 检测到redis服务出现宕机等严重事故时 , 牺牲一部分的业务来减少数据库的压力
    • 给业务添加多级缓存

缓存击穿:

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

image-20220414172640349

常用的解决方案 :

image-20220414173603697

基于互斥锁方式解决缓存击穿问题 :

互斥锁

  • image-20220414172846392
  • 问题 : 线程中只有一个线程 能够获取互斥锁 , 其他线程就只能进行等待 , 效率不高

需求 : 修改根据id查询商铺的业务 , 基于互斥锁方式来解决缓存击穿问题

获取锁 :

  • 使用的是Redis中的setnx , 这个操作在执行的时候 , 只有当它不存在的时候 , 才能执行成功 , 一旦创建成功之后 , 后边的所有setnx操作都会失败 ,

  • // TODO 设置获取锁的方法 , 这个key值就是锁的名称 , 谁调用 , 谁来赋予
private boolean tryLock(String key) {
    // TODO setIfAbsent : 就是setnx的操作 , 可以设置过期时间 , 一般设置为业务完成时间的十倍左右 , 可以自定义
    Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", LOCK_SHOP_TTL, TimeUnit.SECONDS);
    // TODO 不要直接返回这个Boolean ,
    //  因为直接返回的话是要进行拆箱的 , 这时可能会造成空指针异常 , 我们使用的是huTool中的工具类
    //  他可以帮你进行判断 , isTrue , isFalse(判断是否为false) , isBoolean(拆箱) ,
    return BooleanUtil.isTrue(flag);
}
删除锁 :
  • // TODO 删除锁
private void unLock(String key) {
    stringRedisTemplate.delete(key);
}

  • 缺陷 :

    • 如果设置锁之后 , 程序出现错误 , 导致没有人删除这个锁 , 那么后续所有的操作都会出错 ,

  • 解决 : 给锁设置一个有效期 , 来进行兜底

实现逻辑 :

image-20220415105035791

代码实现 :
// TODO 互斥锁解决缓存击穿 + 解决缓存穿透问题
public Shop queryWithMutex(Long id) {
    // TODO 1.从redis中查询商铺缓存 , 以商铺id作为唯一标识
    String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
    // 2.判断是否存在
    if (StrUtil.isNotBlank(shopJson)) {
        // TODO isNoyBlank只有是有数据的情况加才为true , "" , null都为false
        // TODO 3.判断不为空 , 直接返回 , 将字符串转为bean
        return JSONUtil.toBean(shopJson, Shop.class);
    }
    //TODO 判断命中是否是空值 ,
    if (shopJson != null) { //结果是空字符串
        // 返回一个错误信息
        return null;
    }
    // TODO 开始缓存重建 , 获取互斥锁
    // TODO 给每一个店铺设置互斥锁
    String lockKey = LOCK_SHOP_KEY + id;
    Shop shop;
    try {
        if (!tryLock(lockKey)) {
            // 获取互斥锁 失败 , 则休眠并重试
            Thread.sleep(50);
            // TODO 重试就是递归调用这个方法
            return queryWithMutex(id);
        }

        // 4. 获取互斥锁成功 , 根据id查询数据库
        shop = getById(id);
        // TODO 模拟重建的延时
        Thread.sleep(200);
        // 5.不存在返回错误
        if (shop == null) {
            // TODO 将空值写入redis
            stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
            return null;
        }
        //  TODO 6.存在 , 写入redis , 使用huTool中的工具类 , 将对象转为json数据
        stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }finally { // 确保一定会释放锁
        // TODO 释放互斥锁
        unLock(lockKey);
    }
    // 7.返回
    return shop;
}

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

逻辑过期

  • image-20220414173301267

image-20220414195355039

原有的实体类中并没有设置逻辑过期的时间 , 但是也不能直接在原有的实体类中加这个属性 , 不然会对其他的代码有影响 , 可以新建一个类 , 来单独存放这个逻辑过期时间

@Data
public class RedisData {
    // TODO 设置的逻辑过期时间
    private LocalDateTime expireTime;
    // TODO 用来封装想存入redis的实体类数据 ,
    private Object data;
}
封装逻辑过期时间 :缓存重建
public void saveShop2Redis(Long id , Long expireSeconds){
    // TODO 1.查询店铺数据
    Shop shop = getById(id);
    try {
        Thread.sleep(200);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
    // TODO 2.封装逻辑过期时间
    RedisData redisData = new RedisData();
    redisData.setData(shop);
    // TODO  LocalDateTime.now() : 表示当前时间 ,
    //  plusSeconds : 表示添加多少时间
    redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
    // TODO 3.写入Redis , 不用设置过期时间 , 在redisData中已经封装了逻辑过期时间了
    stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY+id,JSONUtil.toJsonStr(redisData));
}
逻辑实现 :
  1. 从Redis中查询商铺数据 , 用商铺id加前缀作为唯一标识
    1. 判断是否命中 ,
      1. 未命中 , 直接返回错误信息
      2. 命中 , 将json格式反序列化为对象
        1. 判断逻辑时间是否过期
          1. 未过期 , 直接返回数据
          2. 过期 , 进行缓存重建
            1. 获取互斥锁 ,
              1. 成功 ,
                1. 开启一个新的线程 , 进行缓存重建
                2. 返回旧数据
              2. 未成功 , 返回旧数据
代码实现 :
// TODO 创建一个线程池 , 里边有十个线程
private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

// TODO 逻辑过期解决缓存击穿问题
public Shop queryWithLogicalExpire(Long id) {
    // TODO 1.从redis中查询商铺缓存 , 以商铺id作为唯一标识
    String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
    // 2.判断是否命中
    if (StrUtil.isBlank(shopJson)) {
        // TODO isNoyBlank只有是有数据的情况加才为true , "" , null都为false
        // TODO 3.判断为空 , 直接返回null
        return null;
    }

    // TODO 4.命中 , 需要先把json反序列化为对象 ,
    RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
    // TODO 因为实体类中设置的是Object , 所以这里在转换的时候 , 转换的是一个JSONObject类型的数据
    JSONObject data = (JSONObject) redisData.getData();
    Shop shop = JSONUtil.toBean(data, Shop.class);
    LocalDateTime expireTime = redisData.getExpireTime();
    // TODO 5.判断是否过期 , 是否在当前时间之后 , isBefore是判断是否在当前时间之前
    if (expireTime.isAfter(LocalDateTime.now())){
        // TODO 5.1未过期 , 直接返回信息
        return shop;
    }
    // TODO 5.2 过期 , 缓存重建
    // TODO 6.缓存重建 ,
    // TODO 6.1 获取互斥锁
    String lockKey = LOCK_SHOP_KEY + id;
    boolean isLock = tryLock(lockKey);
    // TODO 6.2 判断是否获取互斥锁
    if (isLock){
        // TODO 6.3 成功 , 开启独立线程实现缓存重建 , 线程池在上边创建
        CACHE_REBUILD_EXECUTOR.submit(() -> {
            try {
                this.saveShop2Redis(id,20L);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }finally{
                // TODO 释放锁
                unLock(lockKey);
            }
        });
    }
    return shop;
}

缓存工具的封装 :

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

  1. 方法1 : 将任意java对象序列化为JSON并存储在string类型的key中 , 并且可以设置TTL过期时间
  2. 方法2 : 将任意java对象序列化为JSON并存储在string类型的key中 , 并且可以设置逻辑过期时间 , 用于处理缓存击穿问题
  3. 方法3 : 根据指定的key查询缓存 , 并反序列换为指定类型 , 利用缓存空值的方式解决缓存穿透问题
  4. 方法3 : 根据指定的key查询缓存 , 并反序列化为指定类型 , 需要利用逻辑过期解决缓存击穿问题

代码实现 :

@Component
@Slf4j
public class CacheClient {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Resource
    private RedisData redisData;

    /**
     * 普通类型的缓存
     *
     * @param key   key
     * @param value value
     * @param time  TTL
     * @param unit  时间单位
     */
    public void set(String key, Object value, Long time, TimeUnit unit) {
        // TODO 这里需要将value转为json类型的字符串
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), time, unit);
    }

    /**
     * 解决缓存穿透问题
     *
     * @param keyPrefix 前缀
     * @param id        id
     * @param type      数据类型
     * @param function  查询数据库函数
     * @param time      缓存时间
     * @param unit      时间单位
     * @param <R>       泛型 , 返回值
     * @param <ID>      泛型 , 主键
     * @return 返回的数据
     * TODO 解决缓存穿透问题 , 定义泛型 ,使用泛型 , 对于不确定的类型 , 统统使用泛型定义类型
     */
    public <R, ID> R queryWithPassThrough(String keyPrefix, ID id, Class<R> type, Function<ID, R> function, Long time, TimeUnit unit) {
        String key = keyPrefix + id;
        // 1.从redis中查询缓存 , 以id加key作为唯一标识
        String json = stringRedisTemplate.opsForValue().get(key);
        // 2.判断是否存在
        if (StrUtil.isNotBlank(json)) {
            //  3.判断不为空 , 直接返回 , 将字符串转为bean
            return JSONUtil.toBean(json, type); // TODO 这里直接使用泛型的数据类型 ,
        }
        // 判断命中是否是空值 ,
        if (json != null) { //结果是空字符串
            // 返回一个错误信息
            return null;
        }

        //TODO 4.不存在 , 根据id查询数据库 ,
        // 这里不能直接调用数据库进行查询了 , 因为对应的类型不一致 , 查询的数据库也不一致 ,
        // 这里可以使用参数传递逻辑  , java中传递逻辑 , 使用的是Function<T,R> function , 可以传递一个函数到方法中
        // 调用函数形参中的方法 , apply , 将参数传递进去即可
        R r = function.apply(id);
        // 5.不存在返回错误
        if (r == null) {
            // TODO 将空值写入redis
            stringRedisTemplate.opsForValue().set(key, "", time, unit);
            return null;
        }
        //  TODO 6.存在 , 写入redis , 使用huTool中的工具类 , 将对象转为json数据
        this.set(key, r, time, unit);
        // 7.返回
        return r;
    }


    // TODO 创建一个线程池 , 里边有十个线程
    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);


    /**
     * 封装逻辑过期时间
     *
     * @param key key
     * @param value value
     * @param time 过期时间
     * @param unit 时间单位
     */
    public void setWithLogicalExpire(String key, Object value, Long time, TimeUnit unit) {
        redisData = new RedisData();
        redisData.setData(value);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
        // TODO 这里需要将value转为json类型的字符串
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
    }

    // TODO 逻辑过期解决缓存击穿问题
    public <R , ID> R queryWithLogicalExpire(String keyPrefix, String lockPrefix ,ID id , Class<R> type , Function<ID ,R> function , Long time, TimeUnit unit) {
        redisData = new RedisData();
        String key = keyPrefix + id ;
        // TODO 1.从redis中查询缓存 , 以id作为唯一标识
        String json = stringRedisTemplate.opsForValue().get(key);
        // 2.判断是否命中
        if (StrUtil.isBlank(json)) {
            // TODO isNoyBlank只有是有数据的情况加才为true , "" , null都为false
            // TODO 3.判断为空 , 直接返回null
            return null;
        }

        // TODO 4.命中 , 需要先把json反序列化为对象 ,
        RedisData redisData = JSONUtil.toBean(json, RedisData.class);
        // TODO 因为实体类中设置的是Object , 所以这里在转换的时候 , 转换的是一个JSONObject类型的数据
        JSONObject data = (JSONObject) redisData.getData();
        R r = JSONUtil.toBean(data, type);
        // TODO 5.判断是否过期 , 是否在当前时间之后 , isBefore是判断是否在当前时间之前
        if (redisData.getExpireTime().isAfter(LocalDateTime.now())) {
            // TODO 5.1未过期 , 直接返回旧信息
            return r;
        }
        // TODO 5.2 过期 , 缓存重建
        // TODO 6.缓存重建 ,
        // TODO 6.1 获取互斥锁
        String lockKey = lockPrefix + id;
        boolean isLock = tryLock(lockKey);
        // TODO 6.2 判断是否获取互斥锁
        if (isLock) {
            // TODO 6.3 成功 , 开启独立线程实现缓存重建
            CACHE_REBUILD_EXECUTOR.submit(() -> {
                try {
                    R r1 = function.apply(id);
                    this.setWithLogicalExpire(key , r1 ,time , unit);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    // TODO 释放锁
                    unLock(lockKey);
                }
            });
        }
        return r;
    }

    // TODO 设置获取锁的方法 , 这个key值就是锁的名称 , 谁调用 , 谁来赋予
    private boolean tryLock(String key) {
        // TODO setIfAbsent : 就是setnx的操作 , 可以设置过期时间 , 一般设置为业务完成时间的十倍左右 , 可以自定义
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", LOCK_SHOP_TTL, TimeUnit.SECONDS);
        // TODO 不要直接返回这个Boolean ,
        //  因为直接返回的话是要进行拆箱的 , 这时可能会造成空指针异常 , 我们使用的是huTool中的工具类
        //  他可以帮你进行判断 , isTrue , isFalse(判断是否为false) , isBoolean(拆箱) ,
        return BooleanUtil.isTrue(flag);
    }

    // TODO 删除锁
    private void unLock(String key) {
        stringRedisTemplate.delete(key);
    }
}
思尘S
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Redis缓存穿透，缓存击穿和缓存雪崩
12-14
二、缓存穿透，缓存击穿和缓存雪崩 缓存穿透 描述：缓存穿透是指缓存和数据库中都没有的数据，而用户不断发起请求，如发起为id为“-1024”的数据或id为特别大不存在的数据。这时的用户很可能是攻击者，攻击会导致...
第7章 缓存雪崩+缓存击穿+缓存穿透
m0_50829683的博客
01-05 709
分布式存储极致性能Redis6
缓存穿透、缓存击穿、缓存雪崩的理解和解决方案
热门推荐
a898712940的博客
04-28 3万+
目录 一、缓存穿透 二、缓存击穿 三：缓存雪崩 在生产环境中，会因为很多的原因造成访问请求绕过了缓存，都需要访问数据库持久层，虽然对Redsi缓存服务器不会造成影响，但是数据库的负载就会增大，使缓存的作用降低 一、缓存穿透 1、缓存穿透理解 缓存穿透是指查询一个根本不存在的数据，缓存层和持久层都不会命中。在日常工作中出于容错的考虑，如果从持久层查不到数据则不写入缓存层，缓存穿透将导致不存在的数据每次请求都要到持久层去查询，失去了缓存保护后端持久的意义。 缓存穿透示意图： 缓存穿透问...
SpringBoot整合Redis：缓存击穿--互斥锁解决
最新发布
终于等到你啦~欢迎来到我的知识空间 这里是苏泽的成神之路
03-27 3万+
Redis缓存击穿是指在高并发的情况下，当某个热点数据的缓存过期或不存在时，大量的请求同时涌入数据库或后端服务，导致数据库或后端服务负载过高，甚至崩溃的情况。
什么是缓存穿透、缓存击穿、缓存雪崩及其解决方案
shy_1762538422的博客
07-13 2648
什么是缓存穿透、缓存击穿、缓存雪崩及其相应的解决方案
详解缓存穿透、缓存雪崩、缓存击穿
怪咖@的博客
06-29 5912
在实际的业务场景中，Redis 一般和其他数据库搭配使用，用来减轻后端数据库的压力，比如和关系型数据库 MySQL 配合使用。Redis 会把 MySQL 中经常被查询的数据缓存起来，比如热点数据，这样当用户来访问的时候，就不需要到 MySQL 中去查询了，而是直接获取 Redis 中的缓存数据，从而降低了后端数据库的读取压力。
Redis缓存及缓存更新，缓存穿透，缓存雪崩，缓存击穿具体解决方案
leyasuzhou的博客
11-17 358
缓存就是数据交换的缓冲区，是临时储存数据的地方，读写性能高。
Redis 缓存穿透、缓存击穿工具类资源
09-07
Redis 缓存穿透的处理（缓存空值） Redis缓存击穿处理（互斥锁与逻辑删除方案） 封装为工具类，并适用于所有需要进行缓存穿透、击穿的方案，采用了泛型以及Lambda 函数式编程来完成编码
什么是redis缓存穿透 雪崩 ,如何应对解决 redis缓存穿透 雪崩 的解决办法
01-07
什么是redis缓存穿透 雪崩 ,如何应对解决 redis缓存穿透 雪崩 的解决办法 redis缓存穿透的解决办法 redis雪崩的解决办法
Redis缓存常用4种策略原理详解
09-08
主要介绍了Redis缓存常用4种策略原理详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
如何解决Redis缓存雪崩、缓存穿透、缓存并发等5大难题.pdf
06-29
提供了解redis实践开过程中，所面对缓存雪崩 缓存穿透 缓存并发的处理方案，同时这些个问题也是面试的经典问题，有助提升开发者的知识视野
Redis+Springboot实现缓存功能、缓存更新策略、缓存穿透、缓存雪崩、缓存击穿、缓存工具封装
weixin_51351637的博客
11-02 2656
数据交换的缓冲区（称为Cache），是存储数据的临时地方，一般读写性能较高/*** 根据id查询商铺信息* @param id 商铺id* @return 商铺详情数据*/}用户查询的数据在Redis与数据库中都没有。
【Redis】缓存穿透、缓存击穿、缓存雪崩的原因及解决方案
小扣的学习Blog
07-06 1万+
本质都是Redis的命中率降低，导致大量请求直接访问数据库。缓存穿透的解决方法包括设置带TTL的空值 & 使用布隆过滤器。
缓存问题之缓存穿透
yangyanping20108的博客
09-11 594
缓存穿透是指缓存和数据库中都没有的数据，而用户不断发起请求，如用户伪造特别大的Id 值(数据库中不存在此Id)，并且自增循环频繁请求接口，导致数据库压力过大，从而导致服务器反应缓慢，影响用户体验。
Redis学习笔记
qq_30228707的博客
05-16 123
Redis 1 常见的五种数据结构以及使用场景 2 Redis为什么会很快? 3 Redis 持久化 持久化方案有两种 RDB 将当前进程中的数据生成快照保存到硬盘(因此也称作快照持久化) 手动触发 触发指令bgsave:创建一个子进程，由子进程来负责创建RDB文件 使用场景:主从复制 全量同步 自动触发 save m n 指定当m秒内发生n次变化时，会触发bgsa...
5种缓存更新策略
琦彦
01-18 8753
5种缓存更新策略 缓存一般是为了应对高并发场景、缓解数据库读写压力，而将数据存储在读写更快的某种存储介质中（如内存），以加快读取数据的速度。缓存一般分为本地缓存（如java堆内存缓存）、分布式缓存（如redis)等。 既然是缓存，就意味着缓存中暂存的数据只是个副本，也就意味着需要保证副本和主数据之间的数据一致性，这就是接下来要分析的缓存的更新。 常见的缓存更新策略有： 先删缓存，再更新数据库 旁路缓存(Cache Aside) 先更新数据库，再删缓存 先更新数据库，再更新缓存 读/写直通(Read/Wri
【Redis】缓存更新策略
liuwanqing233333的博客
11-30 1608
Redis 的缓存更新策略
缓存更新策略
一个真ikun
02-05 680
redis实战缓存更新策略
redis的缓存穿透缓存击穿缓存雪崩
01-04
缓存穿透、缓存击穿和缓存雪崩是常见的缓存问题，下面是关于Redis的缓存穿透、缓存击穿和缓存雪崩的介绍： 1. 缓存穿透： 缓存穿透是指当一个请求查询一个不存在于缓存中的数据时，由于缓存无法命中，请求会直接...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值