【Redis】Redis经典问题：缓存穿透、缓存击穿、缓存雪崩

目录

  • 缓存的处理流程
  • 缓存穿透
    • 解释
    • 产生原因
    • 解决方案
      • 1.针对不存在的数据也进行缓存
      • 2.设置合适的缓存过期时间
      • 3. 对缓存访问进行限流和降级
      • 4. 接口层增加校验
      • 5. 布隆过滤器
        • 原理
        • 优点
        • 缺点
        • 关于扩容
        • 其他使用场景
        • SpringBoot 整合 布隆过滤器
  • 缓存击穿
    • 产生原因
    • 解决方案
      • 1.设置热点数据永不过期
        • 优点
        • 缺点
        • 示例
      • 2.使用互斥锁
        • 优点
        • 缺点
        • 示例
      • 3. 使用分布式缓存
      • 4. 设置随机过期时间
  • 缓存雪崩
    • 产生原因
    • 解决方案
      • 对于大量的缓存key同时失效
      • 对于redis服务宕机

缓存的处理流程

  • 客户端发起请求，服务端先尝试从缓存中取数据，若取到直接返回结果
  • 若取不到，则从数据库中取，然后将取出的数据更新到缓存，并返回结果
  • 若数据库也没取到，那直接返回空结果。

在这里插入图片描述

缓存穿透

解释

  • Redis缓存穿透指的是针对一个不存在于缓存中的数据进行查询操作，由于缓存中不存在该数据，所以会直接访问数据库获取数据。
  • 这种情况下，如果有大量并发查询这个不存在于缓存中的数据，就会导致大量的查询请求直接访问数据库，增加了数据库的负载，并且没有起到缓存的作用。

产生原因

  • 缓存穿透的主要原因是恶意攻击或者查询频率极高的缓存击穿。
  • 恶意攻击指的是有人故意请求不存在于缓存中的数据，以此来进行攻击。
  • 查询频率极高的缓存击穿是指某个热点数据在缓存中过期后，大量并发访问该数据，导致缓存失效并且直接访问数据库。

解决方案

1.针对不存在的数据也进行缓存

针对不存在的数据也进行缓存：即使查询的数据不存在于数据库中，也可以将查询的结果缓存起来，标记为不存在。这样下次查询同样的数据时，就可以直接从缓存中获取结果，而不需要再查询数据库。

2.设置合适的缓存过期时间

设置合适的缓存过期时间：对于热点数据，可以设置较长的缓存过期时间，让它在过期之前不会被失效。这样可以减少缓存击穿的风险。

3. 对缓存访问进行限流和降级

对缓存访问进行限流和降级：限制并发访问缓存的请求数量，避免由于高并发访问导致缓存失效。当缓存失效时，可以选择使用备用方案，如返回默认值或者降级处理。

4. 接口层增加校验

接口层增加校验：如用户鉴权校验；查询数据的id做基础校验，id<=0的直接拦截；

5. 布隆过滤器

  • 使用布隆过滤器（Bloom Filter）来过滤掉不存在的数据：布隆过滤器是一种高效的数据结构，可以用来判断一个元素是否存在于一个集合中，如果布隆过滤器判断一个元素不存在，则可以避免进行数据库查询操作。
  • 它由位数组（Bit Array）和一系列哈希函数组成。
原理
  • 初始化时，位数组的所有位都被设置为0。
  • 当要插入一个元素时，使用预先设定好的多个独立、均匀分布的哈希函数对元素进行哈希运算，每个哈希函数都会计算出一个位数组的索引位置。
  • 将通过哈希运算得到的每个索引位置的位设置为1。
  • 查询一个元素是否存在时，同样用相同的哈希函数对该元素进行运算，并检查对应位数组的位置是否都是1。
    • 如果所有位都为1，则认为该元素可能存在于集合中；
    • 如果有任何一个位为0，则可以确定该元素肯定不在集合中。
  • 由于哈希碰撞的存在，当多位同时为1时，可能出现误报（False Positive），即报告元素可能在集合中，但实际上并未被插入过。但布隆过滤器不会出现漏报（False Negative），即如果布隆过滤器说元素不在集合中，则这个结论是绝对正确的。

在这里插入图片描述- 由于哈希碰撞的存在，在实际应用中，随着更多元素被插入，相同哈希值对应的位会被多次置1，这就导致原本未出现过的元素经过哈希运算后也可能指向已经置1的位置，从而产生误报。不过，通过调整位数组大小、哈希函数的数量以及负载因子等参数，可以在误报率和存储空间之间取得平衡。

在这里插入图片描述

总之，布隆过滤器提供了一种空间效率极高但牺牲了精确性的解决方案，特别适合用于那些能够容忍一定误报率的大规模数据处理场景。

优点
  • 布隆过滤器的主要优点是占用空间较小，查询速度快。
  • 由于只需要位数组和哈希函数，不需要存储实际的元素，因此占用的空间相对较小。
  • 同时，布隆过滤器查询一个元素的时间复杂度为O(k)，与集合的大小无关，查询速度非常快。
    在这里插入图片描述
缺点
  • 由于哈希函数的关系，布隆过滤器一旦出现误判元素存在于集合中的情况，就无法修正，也无法直接删除其中的元素。
  • 此外，布隆过滤器存在一定的误判率，即有一定的概率将不存在的元素误判为存在，这取决于位数组的大小和哈希函数的个数。
关于扩容
  • 布隆过滤器步进无法直接删除，而且在布隆过滤器设计时，其容量是固定的，因此不支持直接扩容。
  • 传统的布隆过滤器一旦创建，它的位数组大小就无法改变，这意味着如果需要处理的数据量超过了初始化时预设的容量，将导致误报率增加，且无法通过简单地增大位数组来解决这个问题
  • 在实际应用中，为了应对数据增长的需求，可以采用以下策略来进行扩容
    • 并行布隆过滤器：
      • 可以维护多个独立的布隆过滤器，随着数据增长，当一个过滤器填满后，新加入的数据放入新的布隆过滤器中。
      • 查询时，需要对所有布隆过滤器进行查询，只有当所有的过滤器都表明元素可能不存在时，才能确定元素肯定不在集合中。
    • 可扩展布隆过滤器：
      • 一些变种如 Scalable Bloom Filter 或 Dynamic Bloom Filter 允许添加额外的空间，并重新哈希已有数据到更大的位数组中，从而维持较低的误报率。
      • 扩容过程通常涉及构造一个新的更大容量的布隆过滤器，然后迁移旧数据到新过滤器，并从这一刻起在新过滤器中插入新数据。
    • 层次结构布隆过滤器： 创建一个多层的布隆过滤器结构，新数据首先被插入到最顶层（最小容量）的过滤器中，当某个层级的过滤器接近饱和时，再启用下一个容量更大的过滤器。
其他使用场景
  • 数据库索引优化：对于大型数据库，可以利用布隆过滤器作为辅助索引结构，提前过滤掉大部分肯定不在结果集中的查询条件，减轻主索引的压力。
  • 推荐系统：在个性化推荐系统中，用于快速排除用户已经浏览过或者不感兴趣的内容。
  • 垃圾邮件过滤：用于电子邮件系统的垃圾邮件地址库，快速判断收到的邮件是否可能来自已知的垃圾邮件发送者。
  • 数据分析与挖掘：在大规模数据清洗阶段，用来剔除重复样本或无效数据。
  • 实时监控与报警系统：当大量事件流经系统时，可以用于快速识别并过滤出已知异常事件，降低报警系统误报率。
  • 重复数据检测：
    • 在爬虫抓取网页或者日志分析中，用于URL去重，确保不会重复抓取相同的页面或记录。
    • 在大数据处理中，比如在Hadoop等框架中，用来过滤掉重复的数据块或者记录，减少计算和存储负担。
  • 网络安全： 网络防火墙和入侵检测系统中，用于过滤已知恶意IP或攻击特征。
  • 社交网络和互联网服务：在社交网络中，用于快速检测用户上传的内容是否存在违规信息，或是检查用户ID、账号是否存在黑名单中。
SpringBoot 整合 布隆过滤器

在这里插入图片描述

  • 依赖

            <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!-- 引入Redisson的Spring Boot启动器 -->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>3.16.2</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

  • 配置

    spring:
  datasource:
    username: xx
    password: xxxxxx
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/smbms?useUnicode=true&characterEncoding=utf-8&serverTimezone=CTT
  cache:
    type: redis
  redis:
    database: 0
    port: 6379               # Redis服务器连接端口
    host: localhost
    password: 123456
    timeout: 5000            # 超时时间
mybatis:
  mapper-locations: classpath:mapper/*.xml
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

  • 工具类

    package com.kgc.utils;
import org.redisson.api.RBloomFilter;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
/**
 * @author: zjl
 * @datetime: 2024/6/7
 * @desc: 复兴Java，我辈义不容辞
 */
@Component
public class BloomFilterUtil {

    @Resource
    private RedissonClient redissonClient;

    /**
     * 创建布隆过滤器
     *
     * @param filterName         过滤器名称
     * @param expectedInsertions 预测插入数量
     * @param falsePositiveRate  误判率
     */
    public <T> RBloomFilter<T> create(String filterName, long expectedInsertions, double falsePositiveRate) {
        RBloomFilter<T> bloomFilter = redissonClient.getBloomFilter(filterName);
        bloomFilter.tryInit(expectedInsertions, falsePositiveRate);
        return bloomFilter;
    }
}

  • 业务示例

    package com.kgc.service;

import com.kgc.mapper.UserMapper;
import com.kgc.pojo.User;
import com.kgc.utils.BloomFilterUtil;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RBloomFilter;
import org.redisson.api.RedissonClient;
import org.redisson.client.codec.StringCodec;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.List;
import java.util.Random;
import java.util.concurrent.TimeUnit;

/**
 * @author: zjl
 * @datetime: 2024/6/7
 * @desc: 复兴Java，我辈义不容辞
 */
@Service
@Slf4j
public class UserService {
    // 预期插入数量
    static long expectedInsertions = 200L;
    // 误判率
    static double falseProbability = 0.01;

    // 非法请求所返回的JSON
    static String illegalJson = "[{\"id\":0,\"userName\":\"null\",\"userCode\":null,\"userRole\":0}]";

    private RBloomFilter<Long> bloomFilter = null;

    @Resource
    private BloomFilterUtil bloomFilterUtil;

    @Resource
    private RedissonClient redissonClient;
    @Resource
    private UserMapper userMapper;
    @PostConstruct // 项目启动的时候执行该方法，也可以理解为在spring容器初始化的时候执行该方法
    public void init() {
        // 启动项目时初始化bloomFilter
        List<User> userList = userMapper.selectUserList(null,0L);
        bloomFilter = bloomFilterUtil.create("idWhiteList", expectedInsertions, falseProbability);
        for (User user : userList) {
            bloomFilter.add(user.getId());
        }
    }

    @Cacheable(cacheNames = "user", key = "#id", unless = "#result==null")
    public User findById(Long id) {
        // bloomFilter中不存在该key,为非法访问
        if (!bloomFilter.contains(id)) {
            log.info("所要查询的数据既不在缓存中，也不在数据库中，为非法key");
            /**
             * 设置unless = "#result==null"并在非法访问的时候返回null的目的是不将该次查询返回的null使用
             * RedissonConfig-->RedisCacheManager-->RedisCacheConfiguration-->entryTtl设置的过期时间存入缓存。
             *
             * 因为那段时间太长了，在那段时间内可能该非法key又添加到bloomFilter，比如之前不存在id为1234567的用户，
             * 在那段时间可能刚好id为1234567的用户完成注册，使该key成为合法key。
             *
             * 所以我们需要在缓存中添加一个可容忍的短期过期的null或者是其它自定义的值,使得短时间内直接读取缓存中的该值。
             *
             * 因为Spring Cache本身无法缓存null，因此选择设置为一个其中所有值均为null的JSON，
             */
            redissonClient.getBucket("user::" + id, new StringCodec()).set(illegalJson, new Random().nextInt(200) + 300, TimeUnit.SECONDS);
            return null;
        }
        // 不是非法访问，可以访问数据库
        log.info("数据库中得到数据.......");
        return userMapper.selectById(id);
    }

    // 先执行方法体中的代码，成功执行之后删除缓存
    @CacheEvict(cacheNames = "user", key = "#id")
    public boolean delete(Long id) {
        // 删除数据库中具有的数据,就算此key从此之后不再出现，也不能从布隆过滤器删除
        return userMapper.deleteById(id) == 1;
    }

    // 如果缓存中先前存在，则更新缓存;如果不存在，则将方法的返回值存入缓存
    @CachePut(cacheNames = "user", key = "#user.id")
    public User update(User user) {
        userMapper.updateById(user);
        // 新生成key的加入布隆过滤器，此key从此合法,因为该更新方法并不更新id,所以也不会产生新的合法的key
        bloomFilter.add(user.getId());
        return user;
    }

    @CachePut(cacheNames = "user", key = "#user.id")
    public User insert(User user) {
        userMapper.insert(user);
        // 新生成key的加入布隆过滤器，此key从此合法
        bloomFilter.add(user.getId());
        return user;
    }
}

  • 省略实体类、mapper、测试

缓存击穿

  • Redis缓存击穿是指在使用Redis作为缓存服务时，当一个缓存键失效时，大量的请求同时涌入，导致数据库负载激增，造成性能下降甚至崩溃的情况。
    在这里插入图片描述

产生原因

  1. 热点数据失效：当一个热点数据的缓存键失效时，大量的请求会同时请求该数据，导致数据库负载过高。

  2. 频繁的缓存失效：如果某个应用频繁地对某个缓存键进行更新或者删除操作，那么每次失效后都会触发大量的请求同时请求该数据。

  3. 缓存击穿攻击：恶意用户故意请求不存在的缓存键，造成大量的请求同时涌入。

解决方案

1.设置热点数据永不过期

  • 设置热点数据永不过期：对于一些热点数据，可以设置其缓存键永不过期，转为逻辑过期，以避免缓存失效时大量请求涌入。
    在这里插入图片描述
优点
  • 逻辑过期的优点是可以减少缓存的更新次数，避免在没有必要的情况下过多地读取后端数据源，并且在数据本身有频繁更新的情况下可以避免缓存数据过时；
缺点
  • 逻辑过期的缺点是在某些极端情况下会出现缓存为空的情况，如果此时恰巧有大量请求同时访问缓存，则可能导致缓存击穿，
  • 并且无法避免大量的并发请求直接落到后端，并且实现起来也是比较复杂和数据无法保证一致性（因为可能返回旧数据）。
示例

在这里插入图片描述

@Data
public class RedisData {
    private LocalDateTime expireTime;
    private Object data;
}

/**
 * 给热点key缓存预热
 * @param id
 * @param expireSeconds
 */
private 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(CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(redisData));
}

/**
 * 缓存击穿（逻辑过期）功能封装
 * @param id
 * @return
 */
public Shop queryWithLogicalExpire(Long id) {
    String key = CACHE_SHOP_KEY + id;
    //1. 从Redis中查询商铺缓存
    String shopJson = stringRedisTemplate.opsForValue().get(key);
    //2. 判断是否存在
    if(StrUtil.isBlank(shopJson)){
        //3. 不存在，直接返回（这里做的事热点key预热，所以已经假定热点key已经在缓存中）
        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. 缓存重建
    //6.1 获取互斥锁
    String lockKey = LOCK_SHOP_KEY + id;
    //6.2 判断是否获取锁成功
    boolean isLock = tryLock(lockKey);
    if(isLock) {
        // 二次验证是否过期，防止多线程下出现缓存重建多次
        String shopJson2 = stringRedisTemplate.opsForValue().get(key);
        // 这里假定key存在，所以不做存在校验
        // 存在，需要判断过期时间，需要先把json反序列化为对象
        RedisData redisData2 = JSONUtil.toBean(shopJson2, RedisData.class);
        Shop shop2 = JSONUtil.toBean((JSONObject) redisData2.getData(), Shop.class);
        LocalDateTime expireTime2 = redisData2.getExpireTime();
        if(expireTime2.isAfter(LocalDateTime.now())) {
            // 未过期，直接返回店铺信息
            return shop2;
        }
            //6.3 成功，开启独立线程，实现缓存重建
            CACHE_REBUILD_EXECUTOR.submit(() -> {
                try {
                    // 重建缓存，这里设置的值小一点，方便观察程序执行效果，实际开发应该设为30min
                    this.saveShop2Redis(id, 20L);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    // 释放锁
                    unLock(lockKey);
                }
            });
    }
    //7. 返回
    return shop;
}

测试

@SpringBootTest
class HmDianPingApplicationTests {

    @Resource
    private ShopServiceImpl shopService;

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

2.使用互斥锁

  • 使用互斥锁：在缓存失效时，可以通过加锁的方式只允许一个请求去更新缓存，其他请求等待直到缓存更新完成。
    在这里插入图片描述
优点
  • 互斥锁的优点是它可以确保只有一个线程在访问缓存内容，并且在缓存中没有命中时，只会读取一次后端数据库（或其他数据源），
  • 其余线程会等待读取完毕后再次读取缓存，这避免了大量的并发请求直接落到后端，从而减少了并发压力，保证系统的稳定性，并且可以保证数据的一致性；
缺点
  • 互斥锁的缺点是会增加单个请求的响应时间，因为只有一个线程能够读取缓存值，其他线程则需要等待，这可能会在高并发场景下导致线程池饱和。
示例

在这里插入图片描述

/**
  * 获取锁
  * @param key
  * @return
*/
private boolean tryLock(String key) {
    // setnx 就是 setIfAbsent 如果存在
    Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.MINUTES);
    // 装箱是将值类型装换成引用类型的过程；拆箱就是将引用类型转换成值类型的过程
    // 不要直接返回flag，可能为null
    return BooleanUtil.isTrue(flag);
}
 
/**
 * 释放锁
 * @param key
 */
private void unLock(String key) {
    stringRedisTemplate.delete(key);
}

/**
 * 互斥锁解决缓存击穿 queryWithMutex()
 * @param id
 * @return
 */
public Shop queryWithMutex(Long id) {
    // 1.从redis查询商铺缓存
    String key = CACHE_SHOP_KEY + id;
    String shopJson = stringRedisTemplate.opsForValue().get(key);
 
    // 2.判断是否存在
    if (StrUtil.isNotBlank(shopJson)) {
        return JSONUtil.toBean(shopJson, Shop.class);
    }
 
    // 判断空值
    if (shopJson != null) {
        // 返回一个错误信息
        return null;
    }
 
    String lockKey = "lock:shop:" + id;
    Shop shop = null;
    try {
        // 4.实现缓存重建
        // 4.1获取互斥锁
        boolean isLock = tryLock(lockKey);
 
        // 4.2判断是否成功
        if (!isLock) {
            // 4.3失败，则休眠并重试
            Thread.sleep(50);
            // 递归
            return queryWithMutex(id);
        }
        // 4.4成功，根据id查询数据库
        shop = getById(id);
 
        // 模拟延迟
        Thread.sleep(200);
 
        // 5.不存在，返回错误
        if (shop == null) {
            stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
            return null;
        }
 
        // 6.存在，写入redis
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL,TimeUnit.MINUTES);
 
    } catch (InterruptedException ex) {
        throw new RuntimeException(ex);
    } finally {
        // 7.释放锁
        unLock(lockKey);
    }
 
    // 8.返回
    return shop;
}

合并

/**
 * 缓存击穿和缓存穿透功能合并封装
 * @param id
 * @return
 */
public Shop queryWithMutex(Long id) {
    String key = CACHE_SHOP_KEY + id;
    //1. 从Redis中查询商铺缓存
    String shopJson = stringRedisTemplate.opsForValue().get(key);
    //2. 判断是否存在
    if(StrUtil.isNotBlank(shopJson)){
        //3. 存在，直接返回
        return JSONUtil.toBean(shopJson, Shop.class);
    }
    // 这里要先判断命中的是否是null，因为是null的话也是被上面逻辑判断为不存在
    // 这里要做缓存穿透处理，所以要对null多做一次判断，如果命中的是null则shopJson为""
    if("".equals(shopJson)){
        return null;
    }
    //4. 实现缓存重建
    //4.1 获取互斥锁
    String lockKey = LOCK_SHOP_KEY + id;
    Shop shop = null;
    try {
        boolean isLock = tryLock(lockKey);
        //4.2 判断获取是否成功
        if(!isLock) {
            //4.3 失败，则休眠并重试
            Thread.sleep(50);
            // 递归重试
            return queryWithMutex(id);
        }
        //4.4 成功，根据id查询数据库
        shop = getById(id);
        if(shop == null) {
            //5. 不存在，将null写入redis，以便下次继续查询缓存时，如果还是查询空值可以直接返回false信息
            stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
            return null;
        }
        //6. 存在，写入Redis
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    } finally {
        //7. 释放互斥锁
        unLock(lockKey);
    }
    //8. 返回
    return shop;
}

3. 使用分布式缓存

  • 使用分布式缓存：将缓存分散到多个Redis实例中，以减轻单个Redis实例的负载压力。

4. 设置随机过期时间

  • 设置随机过期时间：在设置缓存键的过期时间时，可以增加一个随机的过期时间，以避免大量的缓存同时失效。

缓存雪崩

  • Redis缓存雪崩是指在使用Redis作为缓存服务时，当缓存的大量键同时失效或者Redis服务发生故障时，导致大量请求直接访问数据库，造成数据库负载过高，甚至导致数据库崩溃的情况。

产生原因

  1. 缓存键过期时间一致：如果大量的缓存键设置了相同的过期时间，同时失效，那么所有请求都会直接访问数据库，导致数据库压力过大。

  2. Redis服务宕机：当Redis服务发生故障无法提供缓存服务时，所有的请求都会直接访问数据库，造成数据库负载过高。

  3. 大规模数据更新：在进行大规模数据更新时，如果更新操作直接修改数据库，而不是通过更新缓存，那么所有请求都会直接访问数据库，导致数据库负载过高。

解决方案

对于大量的缓存key同时失效

在这里插入图片描述- 给不同的Key的TTL添加随机值，比如将缓存失效时间分散开，可以在原有的失效时间基础上增加一个随机值
比如1-5分钟随机，这样每一个缓存的过期时间的重复率就会降低，就很难引发集体失效的事件。

对于redis服务宕机

在这里插入图片描述

  • 利用Redis集群提高服务的可用性，比如哨兵模式、集群模式；
  • 给缓存业务添加降级限流策略，比如可以在ngxin或spring cloud gateway中处理；
    • 降级也可以做为系统的保底策略，适用于穿透、击穿、雪崩
  • 给业务添加多级缓存，比如使用Guava或Caffeine作为一级缓存，redis作为二级缓存等；

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/690805.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Swift 序列（Sequence）排序面面俱到 - 从过去到现在（二）

Swift 序列（Sequence）排序面面俱到 - 从过去到现在（二）

概览 在上篇 Swift 序列（Sequence）排序面面俱到 - 从过去到现在（一）博文中，我们讨论了 Swift 语言中序列和集合元素排序的一些基本知识，我们还给出了以自定义类型中任意属性排序的“康庄大道”。 不过在实际的撸码场景中，我们往往需要的是“多属性”同时参与到排序的考…
阅读更多...
STM32F103C8T6基于HAL库移植uC/OS-III

STM32F103C8T6基于HAL库移植uC/OS-III

文章目录 一、建立STM32CubeMX工程二、移植1、 uC/OS-III源码2、移植过程 三、配置相关代码1、bsp.c和bsp.h2、main.c3、修改启动代码4、修改app_cfg.h文件5、修改includes.h文件6、修改lib_cfg.h文件 四、编译与烧录总结参考资料 学习嵌入式实时操作系统&#xff08;RTOS&…
阅读更多...
Swift 序列（Sequence）排序面面俱到 - 从过去到现在（一）

Swift 序列（Sequence）排序面面俱到 - 从过去到现在（一）

概览 在任何语言中对序列（或集合）元素的排序无疑是一种司空见惯的常规操作，在 Swift 语言里自然也不例外。序列排序看似简单，实则“暗藏玄机”。 要想真正掌握 Swift 语言中对排序的“各种姿势”，我们还得从长计议。不如就先从最简单的排序基本功开始聊起吧。 在本篇博…
阅读更多...
9行超强代码用Python工具快速获取放假日期

9行超强代码用Python工具快速获取放假日期

9行超强代码用Python工具快速获取放假日期 在很多场景下,我们需要获知国内具体的节假日安排情况,而国内每一年具体的放假安排以及调休情况,都依赖于国务院发布的具体公告,如果不想自己手动整理相关数据的话,我们可以用Python来快速获取最新的放假日期. 可以通过调用公开的 API…
阅读更多...
spark-3.5.1+Hadoop 3.4.0+Hive4.0 分布式集群 安装配置

spark-3.5.1+Hadoop 3.4.0+Hive4.0 分布式集群 安装配置

Hadoop安装参考: Hadoop 3.4.0HBase2.5.8ZooKeeper3.8.4Hive4.0Sqoop 分布式高可用集群部署安装 大数据系列二-CSDN博客 一 下载:Downloads | Apache Spark 1 下载Maven – Welcome to Apache Maven # maven安装及配置教程 wget https://dlcdn.apache.org/maven/maven-3/3.8…
阅读更多...
App UI 风格创新无限

App UI 风格创新无限

App UI 风格创新无限
阅读更多...
如何理解与学习数学分析——第二部分——数学分析中的基本概念——第8章——可微性

如何理解与学习数学分析——第二部分——数学分析中的基本概念——第8章——可微性

第2 部分&#xff1a;数学分析中的基本概念 (Concepts in Analysis) 8. 可微性(Differentiability) 本章讨论梯度(gradients)/斜率(slopes)和切线(tangent)&#xff0c;指出常见的误解并解释如何避免这些误解。将可微性的定义与图形表示联系起来&#xff0c;展示如何将其应用…
阅读更多...
什么是2+1退休模式？什么是链动2+1模式？

什么是2+1退休模式？什么是链动2+1模式？

21退休模式又称链动21模式&#xff0c;主要是建立团队模式&#xff0c;同时快速提升销量。是目前成熟模式中裂变速度最快的模式。21退休模式合理合规&#xff0c;同时激励用户公司的利润分享机制&#xff0c;让您在享受购物折扣的同时&#xff0c;也能促进并获得客观收益。 模…
阅读更多...
大模型多轮问答的两种方式

大模型多轮问答的两种方式

前言 大模型的多轮问答难点就是在于如何精确识别用户最新的提问的真实意图&#xff0c;而在常见的使用大模型进行多轮对话方式中&#xff0c;我接触到的只有两种方式&#xff1a; 一种是简单地直接使用 user 和 assistant 两个角色将一问一答的会话内容喂给大模型&#xff0c…
阅读更多...
Large-Scale LiDAR Consistent Mapping usingHierarchical LiDAR Bundle Adjustment

Large-Scale LiDAR Consistent Mapping usingHierarchical LiDAR Bundle Adjustment

1. 代码地址 GitHub - hku-mars/HBA: [RAL 2023] A globally consistent LiDAR map optimization module 2. 摘要 重建精确一致的大规模激光雷达点云地图对于机器人应用至关重要。现有的基于位姿图优化的解决方案&#xff0c;尽管它在时间方面是有效的&#xff0c;但不能直接…
阅读更多...
【python】python电影评论数据抓取分析可视化（源码+数据+课程论文）【独一无二】

【python】python电影评论数据抓取分析可视化（源码+数据+课程论文）【独一无二】

&#x1f449;博__主&#x1f448;&#xff1a;米码收割机 &#x1f449;技__能&#x1f448;&#xff1a;C/Python语言 &#x1f449;公众号&#x1f448;&#xff1a;测试开发自动化【获取源码商业合作】 &#x1f449;荣__誉&#x1f448;&#xff1a;阿里云博客专家博主、5…
阅读更多...
Windows系统问题

Windows系统问题

Windows系统问题 一、补丁更新提示&#xff1a;0x80070643问题&#xff1a;解决方法&#xff1a;1.以管理员权限运行【cmd】。2.禁用 【Windows RE】&#xff0c;请运行reagentc /disable。3.回收【Windows RE】恢复分区空间。4.准备新的【Windows RE】恢复分区空间。5.配置并启…
阅读更多...
如何检测UV胶的均匀性？

如何检测UV胶的均匀性？

如何检测UV胶的均匀性&#xff1f; 检测UV胶的均匀性可以通过以下几种方法来实现&#xff1a; 肉眼目视检查&#xff1a; 这是最简单直接的方法。将UV胶涂在表面上&#xff0c;使用裸眼观察胶层的表面。特别注意是否存在气泡、颜色不均匀、裂纹或其他明显的不均匀性。如凹凸不…
阅读更多...
从零开始实现自己的串口调试助手(9)-重置多文本框,保存/载入指令集

从零开始实现自己的串口调试助手(9)-重置多文本框,保存/载入指令集

重置多文本框 添加多文本控件列表 在构造函数中把我们需要操作的控件归类到对应列表之中 //创建多文本存放数组 - 存放那三列内容 checkBox lineEdi btnfor(int i1;i<9;i){// 添加到按钮数组QString btnName QString("pushButton_t%1").arg(i); //构建对应控件名…
阅读更多...
独享IP VS 原生IP，二者的区别与定义详解

独享IP VS 原生IP，二者的区别与定义详解

原生IP&#xff1a;原生IP是指由Internet服务提供商&#xff08;ISP&#xff09;直接分配给用户的IP地址&#xff0c;这些IP地址通常反映了用户的实际地理位置和网络连接。原生IP是用户在其所在地区或国家使用的真实IP地址&#xff0c;与用户的物理位置直接相关。在跨境电商中&…
阅读更多...
汉中门禁系统设备多少钱，门禁系统报价单

汉中门禁系统设备多少钱，门禁系统报价单

汉中门禁系统设备多少钱&#xff0c;门禁系统报价单 门禁系统设备存在普通与智能之分&#xff0c;其价格差异颇大。以下是一些国内品牌的门禁系统价格&#xff1b; 以上只是部分国内品牌门禁机设备的报价&#xff0c;仅供参考&#xff0c;能看出目前市面上&#xff0c;海…
阅读更多...
Freetype 介绍和使用

Freetype 介绍和使用

目录 一、矢量字体引入 二、Freetype 介绍 1.给定一个字符&#xff0c;怎么在字体文件中找到它的关键点&#xff1f; 2.文字显示过程 3.如何使用 freetype 库 三、在 LCD 上显示一个矢量字体 1.使用 wchar_t 获得字符的 UNICODE 值 2.使用 freetype 得到位图 3.在屏幕上…
阅读更多...
Java——数组排序

Java——数组排序

一、排序介绍 1、排序的概念 排序是将多个数据按照指定的顺序进行排列的过程。 2、排序的种类 排序可以分为两大类&#xff1a;内部排序和外部排序。 3、内部排序和外部排序 1&#xff09;内部排序 内部排序是指数据在内存中进行排序&#xff0c;适用于数据量较小的情况…
阅读更多...
一个 buffer 使用的负反馈实例

一个 buffer 使用的负反馈实例

端到端拥塞控制其实就是负反馈的实施。典型的做法是识别到一系列标志性事件&#xff0c;比如丢包&#xff0c;时延增加等&#xff0c;然后对这些事件做反应&#xff0c;进而形成负反馈&#xff0c;但 inflight 守恒是一种完全不同的做法&#xff0c;它将负反馈平铺到了整个传输…
阅读更多...
pytorch 笔记：pytorch 优化内容（更新中）

pytorch 笔记：pytorch 优化内容（更新中）

1 Tensor创建类 1.1 直接创建Tensor&#xff0c;而不是从Python或Numpy中转换 不要使用原生Python或NumPy创建数据&#xff0c;然后将其转换为torch.Tensor直接用torch.Tensor创建或者直接&#xff1a;torch.empty(), torch.zeros(), torch.full(), torch.ones(), torch.…
阅读更多...
最新文章

Copyright @ 2022~2023