项目中解决redis缓存击穿和缓存穿透两大常见问题

最新推荐文章于 2024-09-27 17:04:20 发布
最新推荐文章于 2024-09-27 17:04:20 发布
阅读量581 收藏 4
点赞数 1
分类专栏： java 文章标签： redis java spring 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45150104/article/details/113634709
版权

      真快，今天都是农历2020年腊月二十三啦，也就是我们北方人所称呼的“小年”，家里的父老乡亲们都以背起行囊回到了家乡，然而我还在一线进行奋斗着辛苦搬砖，公司马上也要快放假了，我这上周给大家承诺的分享项目中解决redis缓存击穿和缓存穿透问题还没兑现呢，最近出来新项目一直在赶赶、、、现在闲下来一会，赶紧写这篇文章给大家分享下，废话少说，开始干，干就完了，接下来开始。
      redis的详细描述我在之前已经写过了两篇，分别是：说会redis的帅哥都拿到了月入过万 和 咳咳，会用redis的帅哥拿到了上万，我这会用redis,还会配置redis的小鲜肉最低也待18k吧 这两篇，分别讲的是redis和springBoot的整合和用法，以及redis的各种配置等等，这里我就不过多聊这方面内容了哈，这里主要讲在项目中使用redis带来的几大问题。
      一：缓存击穿、缓存穿透和缓存雪崩概念以及解决思路描述
            1、缓存穿透（查询结果缓存中和数据库中都不存在）：在使用缓存的情况下，我们查询数据时会先查询缓存，假如缓存中不存在，那么就会在数据库中查询，数据库中查询到的话会将查询的数据返回而且会将数据暂存在缓存中一份。缓存穿透可以理解为查询数据，这个时候缓存中不存在，然后进行去数据库中查询，数据库中也不存在。当持续查询某一数据时，查询数据压力全部扔给了数据库，这个时候数据库不堪压力，给崩掉了，这个时候就是缓存穿透。例如：id为-1的值肯定不存在，黑客持续访问这个id为-1的值，缓存中不存在，数据库中也不存在，数据库在持续的扛着高并发，当数据库承受不住的时候，数据库就给挂掉了，这就是缓存穿透。
            可以采用布隆过滤器（这里不再详述，后期深入研究后进行补充），或者去数据库中查询，数据库中不存在，返回不存在同时在缓存中暂存为null值，这样等下次再来查询时就不需要再走刚刚的那重复步骤去数据库中查询，可以减轻数据库压力。
            2、缓存击穿（量太大，缓存过期）：缓存穿透和缓存击穿的区别是，缓存穿透是缓存中没有这个key，然后进数据库进行查询，但是数据库中也查询不到，在持续抗高并发，持续大量的去访问不存在的数据库，那么数据库不堪压力，最终挂掉；缓存击穿可以把缓存当作一堵墙，所有火力打在这堵墙上的某一个点上，把这个墙上的这一点给打穿，然后大量的火力穿透这堵墙上这一点直接打在数据库上，这时候数据库不堪压力，最后给崩掉。用官方话可以说：当缓存中的一个key值是非常热点，不停的抗高并发，高并发数据集中对这个key进行访问，当key值失效的瞬间，会访问数据库来访问数据，导致数据库压力过大，数据库瞬间崩掉。例如微博中爆料当某某明星出轨时，是一个非常热的热点，当这个key失效时，数据库受不了压力就会挂掉。这个时候就是我们常称为微博因某某明星出轨给挂掉了。
            解决方案：1、设置key值永不过期；2、加互斥锁，只保证只有一个线程能够进去访问数据库，其余都进行等待。
            3、缓存雪崩：在一段时间段内，缓存集中过期失效，Redis宕机。例如：双十一期间，凌晨十二点开始抢购，key值的有效期是一个小时，那么在凌晨一点的时候，会失效，那么压力全部打在了存储层，这个时候服务器就会造成周期性压力。
             解决方案：1、利用redis的高可用性，多准备几台服务器，也就是异地多活，当其中一台服务器挂了，那么其他redis服务器可以进行工作，也就是搭建集群。
                   2、限流降级，在缓存失效之后，通过加锁或者队列来控制数据库写缓存的数量，比如某一个key只能允许一个线程查询和写缓存，其他线程等待。
      二：简单讲下项目中引入redis
            1、引入pom依赖：

 <dependency>
     <groupId>redis.clients</groupId>
     <artifactId>jedis</artifactId>
     <version>2.9.0</version>
 </dependency>

            2、创建工具类RedisUtil类，代码如下：

package com.ygl.gmall.util;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class RedisUtil {

    private JedisPool jedisPool;

    public void initPool(String host,int port ,int database){
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(200);
        poolConfig.setMaxIdle(30);
        poolConfig.setBlockWhenExhausted(true);
        poolConfig.setMaxWaitMillis(10*1000);
        poolConfig.setTestOnBorrow(true);
        jedisPool=new JedisPool(poolConfig,host,port,20*1000);
    }

    public Jedis getJedis(){
        Jedis jedis = jedisPool.getResource();
        return jedis;
    }

}

            3、创建RedisConfig配置类

package com.ygl.gmall.conf;

import com.ygl.gmall.util.RedisUtil;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
 public class RedisConfig {

	 //读取配置文件中的redis的ip地址
	 @Value("${spring.redis.host:disabled}")
	 private String host;
	
	 @Value("${spring.redis.port:0}")
	 private int port;
	
	 @Value("${spring.redis.database:0}")
	 private int database;
	
	 @Bean
	 public RedisUtil getRedisUtil(){
	     if(host.equals("disabled")){
	         return null;
	     }
	     RedisUtil redisUtil=new RedisUtil();
	     redisUtil.initPool(host,port,database);
	     return redisUtil;
	 }
}

目录如下图所示，我这里把redis配置类和工具类统一放在了service的工具类模块中。
在这里插入图片描述
            4、接下来在yml中配置redis的连接地址和端口号等，注意：一定一定是在哪里使用就在那里的yml中去编写，千万不要在引入的工具类和配置类的模块中编写redis配置。我们这里在service模块中使用，那么我们在service的yml文件去编写配置文件。配置如下：

spring:
  #redis配置
  redis:
    #redis地址
    host: 192.168.80.133
    #端口号
    port: 6379
    database: 0

好了，这里就用好了，接下来就可以在项目中使用redis了。
使用方法如下图所示：
在这里插入图片描述

            4、解决redis的缓存穿透问题
                  首先我先用一张图给大家解释下解决缓存穿透的思路：
在这里插入图片描述        上图给大家非常清晰的描述出解决缓存穿透的问题，我在给大家解释下上面图描述的含义：当请求查询数据结果时，首先进入redis缓存中进行查询结果是否存在，如果存在结果，那么直接将该结果进行返回给前端；如果不存在，那么则需要去数据库中查询数据，如果在数据库中查询到该结果，那么将该结果返回给请求端，同时将该结果存放在redis缓存中，方便下次查找时直接在redis缓存中就可以查询到，进而不需要再进数据库中查询，因而下次查询时直接进redis查询，提高了非常高的查询效率。如果数据库中也查询不到结果，那么我们就要采用方法防止因缓存穿透造成数据库服务器压力过大，进而服务器宕机；我们可以采用布隆过滤器解决，这里我们将采用另外一种方法解决，就是将该结果设置成null值，存放在缓存中，而且要设置过期时间，减小缓存压力。
       上面思路有了，那么我们开始上代码来解决其带来的缓存穿透问题：

package com.ygl.gmall.manage.service.impl;

import com.alibaba.dubbo.common.utils.StringUtils;
import com.alibaba.dubbo.config.annotation.Service;
import com.alibaba.fastjson.JSON;
import com.ygl.gmall.bean.PmsSkuAttrValue;
import com.ygl.gmall.bean.PmsSkuImage;
import com.ygl.gmall.bean.PmsSkuInfo;
import com.ygl.gmall.bean.PmsSkuSaleAttrValue;
import com.ygl.gmall.manage.mapper.PmsSkuAttrValueMapper;
import com.ygl.gmall.manage.mapper.PmsSkuImageMapper;
import com.ygl.gmall.manage.mapper.PmsSkuSaleAttrValueMapper;
import com.ygl.gmall.manage.mapper.SkuInfoMapper;
import com.ygl.gmall.service.SkuService;
import com.ygl.gmall.util.RedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import redis.clients.jedis.Jedis;

import java.util.Date;
import java.util.List;
import java.util.UUID;

@Service
public class SkuServiceImpl implements SkuService {
    @Autowired
    RedisUtil redisUtil;
    @Override
    public PmsSkuInfo getSkuById(String skuId) {
    	PmsSkuInfo pmsSkuInfo = new PmsSkuInfo();
	 	//连接缓存
        Jedis jedis = redisUtil.getJedis();
        //查询缓存
        //设置redis的key值
        String skuKey = "sku:" + skuId + ":info";
        String skuJson = jedis.get(skuKey);
        //判断查询的结果是否存在
        if (!StringUtils.isBlank(skuJson)) {//if (skuJson!= null&&skuJson.equals(""))
        	//将查询的String类型转换为实体类
            pmsSkuInfo = JSON.parseObject(skuJson, PmsSkuInfo.class);
        } else {
            //如果缓存中没有，去mysql中查询
            //调用进数据库中查询结果方法
            pmsSkuInfo = getSkuByIdFromDb(skuId);
            //mysql查询结果存放在redis缓存中
            if (pmsSkuInfo != null) {
            		//将实体转换为String
                    String s = JSON.toJSONString(pmsSkuInfo);
                    //将查询的结果设置到redis中
                    jedis.set("sku:" + skuId + ":info", s);
                } else {
                    //如果该sku不存在
                    //为了防止缓存穿透，设置一个短暂的key的skuId过期,值为空。一定要设置过期时间，否则会造成占用内存
                    jedis.setex("sku:" + skuId + ":info", 60, "");
                }
            }
       //关闭缓存
       jedis.close();
       return pmsSkuInfo;
	}
	/**
	*进数据库中进行查询结果
	*/
	public PmsSkuInfo getSkuByIdFromDb(String skuId) {
        PmsSkuInfo pmsSkuInfo = new PmsSkuInfo();
        pmsSkuInfo.setId(skuId);
        PmsSkuInfo pmsSkuInfo1 = skuInfoMapper.selectOne(pmsSkuInfo);
        return pmsSkuInfo1;
    }

}

      好了，上面成功解决缓存穿透问题，下面分享解决缓存击穿问题。
   5、解决缓存击穿问题
      老规矩，先上图让大家理解：
在这里插入图片描述
      缓存击穿的定义在文章的刚开始就给大家解释了，刚刚在上图中又表述了下什么是缓存击穿和如何解决缓存击穿问题。这里我就不过多絮叨，直接在刚才解决缓存穿透的代码上进行更改，添加缓存击穿问题。代码如下：

package com.ygl.gmall.manage.service.impl;

import com.alibaba.dubbo.common.utils.StringUtils;
import com.alibaba.dubbo.config.annotation.Service;
import com.alibaba.fastjson.JSON;
import com.ygl.gmall.bean.PmsSkuAttrValue;
import com.ygl.gmall.bean.PmsSkuImage;
import com.ygl.gmall.bean.PmsSkuInfo;
import com.ygl.gmall.bean.PmsSkuSaleAttrValue;
import com.ygl.gmall.manage.mapper.PmsSkuAttrValueMapper;
import com.ygl.gmall.manage.mapper.PmsSkuImageMapper;
import com.ygl.gmall.manage.mapper.PmsSkuSaleAttrValueMapper;
import com.ygl.gmall.manage.mapper.SkuInfoMapper;
import com.ygl.gmall.service.SkuService;
import com.ygl.gmall.util.RedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import redis.clients.jedis.Jedis;

import java.util.Date;
import java.util.List;
import java.util.UUID;

@Service
public class SkuServiceImpl implements SkuService {
    @Autowired
    RedisUtil redisUtil;
    @Override
    public PmsSkuInfo getSkuById(String skuId) {
    	PmsSkuInfo pmsSkuInfo = new PmsSkuInfo();
	 	//连接缓存
        Jedis jedis = redisUtil.getJedis();
        //查询缓存
        //设置redis的key值
        String skuKey = "sku:" + skuId + ":info";
        String skuJson = jedis.get(skuKey);
        //判断查询的结果是否存在
        if (!StringUtils.isBlank(skuJson)) {//if (skuJson!= null&&skuJson.equals(""))
        	//将查询的String类型转换为实体类
            pmsSkuInfo = JSON.parseObject(skuJson, PmsSkuInfo.class);
        } else {
            //如果缓存中没有，去mysql中查询
             //设置分布式锁   token是设置分布式锁的value随机值
            String token = UUID.randomUUID().toString();
            //设置分布式锁，并且这种设置是只有当该key值不存在的情况下才能设置成功，否则设置失败，设置成功将返回OK,且过期时间是10s
            String OK = jedis.set("sku:" + skuId + ":lock", token, "nx", "px", 10000);
            if ((!StringUtils.isBlank(OK)) && OK.equals("OK")) {
	            //调用进数据库中查询结果方法
	            pmsSkuInfo = getSkuByIdFromDb(skuId);
	            //mysql查询结果存放在redis缓存中
	            if (pmsSkuInfo != null) {
	            		//将实体转换为String
	                    String s = JSON.toJSONString(pmsSkuInfo);
	                    //将查询的结果设置到redis中
	                    jedis.set("sku:" + skuId + ":info", s);
               } else {
                    //如果该sku不存在
                    //为了防止缓存穿透，设置一个短暂的key的skuId过期,值为空。一定要设置过期时间，否则会造成占用内存
                    jedis.setex("sku:" + skuId + ":info", 60, "");
                }
                //在访问mysql后，要将mysql的分布式锁进行释放掉
                String lockToken = jedis.get("sku:" + skuId + ":lock");
                //判断lockToken不为空值且值与刚才生成的token相等，才表明就是自己的锁，否则可能会删除别人的锁，这样的话可以肯定删除的是自己的锁
                //这里解决的问题就是：   如果redis锁已经过期了，然后锁过期的那个请求又执行完毕，回来删锁，删除了其他线程的锁怎么办？——可以采用判断key和value两个都相等来判断是否是自己的锁
                if (!(StringUtils.isBlank(lockToken))&&lockToken.equals(token)){
               		jedis.del("sku:" + skuId + ":lock");//用token（也就是value和key两个一起判断）删除是否是自己的锁
                }
	      }else{
	      //未成功获得分布式锁
	      //设置失败，开启自旋（线程睡眠几秒之后，重新尝试访问该方法）
	      return getSkuById(skuId);
	      }
        }
       //关闭缓存
       jedis.close();
       return pmsSkuInfo;
	}
	/**
	*进数据库中进行查询结果
	*/
	public PmsSkuInfo getSkuByIdFromDb(String skuId) {
        PmsSkuInfo pmsSkuInfo = new PmsSkuInfo();
        pmsSkuInfo.setId(skuId);
        PmsSkuInfo pmsSkuInfo1 = skuInfoMapper.selectOne(pmsSkuInfo);
        return pmsSkuInfo1;
    }

}

代码思维逻辑如下图所示：主要逻辑也就是请求获取分布式锁，请求获得分布式锁可以访问数据库，请求获得数据或者分布式锁因超时而自动释放，其他请求才可以再次获得锁。
在这里插入图片描述     这里看似已经非常完美的解决了问题，其实还有问题存在，这个问题我用如图表示，我怕我用语言叙述的不清楚，图示如下：
在这里插入图片描述      第一种方法：可以用lua脚本，在查询到key的同时删除该key，防止高并发时意外发生。
      第二种方法：采用ression框架，将整个的操作片段给锁起来，防止其他请求过来，它的使用就类似与多线程的lock锁，我在这里就不详细描述，在图中我把代码分析下：
在这里插入图片描述它这的用法和多线程的lock锁一样吧，我就不多谈了。
      好了，这篇文章就分享到这了，大家有不懂的地方或者我讲的不对的地方，希望大家给我指出，谢谢大家。大家要记得三连哦，转发，点赞、收藏走一波 ，双击66666

岭岭颖颖
关注
专栏目录
SpringBoot入门教程：Redis四大缓存问题(击穿、穿透、雪崩、数据一致性)
人不风流枉少年
11-09 550
一：穿透 假如我们的id都是数据库自增，大于0的值，如果使用 http://localhost:8080/users/-1 访问以下接口就会出现在缓存中查不到，在数据库中也查不到的现象，这种现象就叫做缓存穿透。 @Slf4j @RestController @RequestMapping("/users") public class UserController { @Autowired private RedissonClient redissonClient; @Autowi
牛逼，三句话搞懂 Redis 缓存穿透、击穿、雪崩！
weixin_47531845的博客
10-07 3664
前言 如何有效的理解并且区分 Reids 穿透、击穿和雪崩之间的区别，一直以来都挺困扰我的。特别是穿透和击穿，过一段时间就稀里糊涂的分不清了。 为了有效的帮助笔者自己，以及拥有同样烦恼的朋友们区分这三种场景。笔者总结了一些关键词，希望大家可以和我一样通过联想的方式来区分并理解这三种场景的区别！ 缓存穿透 关键词：穿过 Redis 和数据库 当 Redis 和数据库中都没有我们想要的数据时，就需要考虑缓存穿透的问题了。下面这段逻辑大家用的会比较多：先去 Redis 中查找某资源，Redis 中查不到
【Redis】缓存击穿问题及解决思路
qq_39921135的博客
08-06 899
如果缓存雪崩是无数key同时过期而引发的问题，那么缓存击穿就是部分key过期而导致的严重后果。那为什么部分key过期也会导致严重的后果？这是因为这部分key不是普通的key。缓存击穿问题也叫热点Key问题，就是一个被高并发访问并且缓存重建业务较复杂的key突然失效了，无数的请求访问会在瞬间给数据库带来巨大的冲击。高并发访问：这个Key访问的非常多，可能是在做活动的某一件商品的缓存，同一时刻可能会有无数的请求来访问这一个key。
Redis-应用问题解决
啦啦啦=_=的博客
04-26 475
缓存穿透 缓存穿透现象: 应用服务器压力变大 redis命中率降低 一直查询数据库 原因: redis查询不到数据库 出现很多非正常url访问 解决方案 （1） 对空值缓存：如果一个查询返回的数据为空（不管是数据是否不存在），我们仍然把这个空结果（null）进行缓存，设置空结果的过期时间会很短，最长不超过五分钟 （2） 设置可访问的名单（白名单）： 使用bitmaps类型定义一个可以访问的名单，名单id作为bitmaps的偏移量，每次访问和bitmap里面的id进行比较，如果访问id
“缓存穿透 缓存击穿 缓存雪崩”项目实战
飞奔的小土豆@1024
01-15 127
缓存穿 缓存击穿 缓存雪崩
redis缓存击穿和缓存穿透解决办法
weixin_46553523的博客
06-17 435
redis存在的三个问题 一：缓存穿透（缓存和数据库中都没有数据，请求过来查询结果为null，这样就造成数据库短时间线程数被打满，导致其他服务被阻塞，从而导致线上服务不可用） 二：缓存雪崩（同一时间，大量的缓存失效了，所有请求都打到数据库中，造成数据库奔溃） 三：缓存击穿（缓存中没有数据，数据库中存在数据，一般都是大量热点数据过期，这时由于大量请求过来查询，同时去读缓存中没有数据，然后就去数据库查，大量请求导致数据库压力剧增，线上服务就卡主了） ？？？？？缓存击穿的解决办法 为什么会出现缓存击穿，上面都给出
Redis缓存穿透，缓存击穿和缓存雪崩
12-14
在IT行业中，Redis作为一种高...以上是针对Redis缓存系统中可能出现的缓存穿透、缓存击穿和缓存雪崩问题的解决方案。在设计缓存系统时，应当充分考虑这些潜在风险，采取适当的预防措施，以确保系统的稳定性和高可用性。
Redis的缓存穿透、缓存击穿、缓存雪崩
qq_48595067的博客
07-13 6422
缓存击穿和缓存雪崩都是与缓存相关的常见问题，它们有一些共同点，并可以采用类似的解决方法。
什么是redis缓存穿透 雪崩 ,如何应对解决 redis缓存穿透 雪崩 的解决办法
01-07
然而，如果使用不当，可能会遇到两种常见问题：缓存穿透和缓存雪崩。这两者都会对系统的稳定性和性能产生严重影响。 **缓存穿透** 缓存穿透是指用户请求的数据既不在Redis缓存中，也不在数据库中，导致每次请求都...
redis缓存击穿，缓存穿透和缓存雪崩解决方案
THanHan的博客
08-27 1909
一、缓存击穿 1.什么是缓存击穿 缓存击穿也就是说当redis缓存中有一个key是大量请求同时访问的热点数据，如果突然这个key时间到了，那么大量的请求在缓存中获取不到该key，穿过缓存直接来到数据库导致数据库崩溃，这样因为单个key失效而穿过缓存到数据库称为缓存击穿。 2.怎么办，怎么解决 最简单粗暴的解决方案就是让热点key不设置过期时间，即key一直存在于缓存中，更新时直接覆盖即可。 设置定时任务检测要过期的key，然后在将要过期的时候重新从数据库把数据刷新到缓存中，这样的方式增加系统复杂度，并且
SpringBoot中如何解决Redis的缓存穿透、缓存击穿、缓存雪崩？
m0_71777195的博客
03-16 167
缓存穿透指的是一个缓存系统无法缓存某个查询的数据，从而导致这个查询每一次都要访问数据库。查询一个不存在的数据：攻击者可能会发送一些无效的查询来触发缓存穿透。查询一些非常热门的数据：如果一个数据被访问的非常频繁，那么可能会导致缓存系统无法处理这些请求，从而造成缓存穿透。查询一些异常数据：这种情况通常发生在数据服务出现故障或异常时，从而造成缓存系统无法访问相关数据，从而导致缓存穿透。
redis击穿、雪崩、穿透解决方案
m0_48811221的博客
03-05 5474
Redis击穿 redis缓存击穿是指某一个非常热点的key(即在客户端搜索的比较多的关键字)突然失效了,这时从客户端发送的大量的请求在redis里找不到这个key，就会去数据里找，最终导致数据库压力过大崩掉。 解决方案： 1.将value的时效设置成永不过期 这种方式非常简单粗暴但是安全可靠。但是非常占用空间对内存消耗也是极大。个人并不建议使用该方法，应该根据具体业务逻辑来操作。 2.使用Timetask做一个定时任务 使用Timetask做定时，每隔一段时间对一些热点key进行数据库查询，将查询出的结
redis缓存穿透击穿及解决方案
m0_56197127的博客
01-30 1519
redis的缓存穿透击穿及解决办法
Redis进阶篇 - 缓存穿透、缓存击穿、缓存雪崩问题及其解决方案
最新发布
ChineHe的博客
09-27 1279
在使用 Redis 作为缓存时，缓存穿透、缓存击穿和缓存雪崩是常见的问题，可能会影响系统性能和稳定性。本文将深入探讨这些问题的概念、产生原因、以及可能带来的影响，并针对这些问题提供的解决方案，以帮助读者更好地理解并解决这些挑战。
redis
toutieqiuchui的博客
07-31 214
redis简介 简单来说 Redis 就是一个使用 C 语言开发的数据库，不过与传统数据库不同的是 Redis 的数据是存在内存中的 ，也就是它是内存数据库，所以读写速度非常快，因此 Redis 被广泛应用于缓存方向。 另外，Redis 除了做缓存之外，Redis 也经常用来做分布式锁，甚至是消息队列。 Redis 提供了多种数据类型来支持不同的业务场景。Redis 还支持事务 、持久化、Lua 脚本、多种集群方案。 Redis 单线程模型详解 Redis 基于 Reactor 模式来设计开发了自己的一套高
黑马点评-Redis常见问题击穿穿透及其解决方法
abc123mma的博客
10-25 926
Redis缓存与常见的穿透，雪崩和击穿讲解和代码实现
如何解决Redis作为缓存的雪崩、击穿、穿透难题
ggh0314的博客
05-31 633
缓存雪崩 缓存雪崩是指大量的应用请求无法在 Redis 缓存中进行处理，紧接着，应用将大量请求发送到数据库层，导致数据库层的压力激增。 缓存雪崩一般是由两个原因导致的： 第一个原因是：缓存中有大量数据同时过期，导致大量请求无法得到处理。 解决方案： 首先，我们可以避免给大量的数据设置相同的过期时间。如果业务层的确要求有些数据同时失效，你可以在用 EXPIRE 命令给每个数据设置过期时间时，给这些数据的过期时间增加一个较小的随机数。这样既避免了大量数据同时过期，同时也保证了这些数据基本在相近的时间失效，
redis - 击穿、穿透、雪崩及其解决方案（一）
ApatheCrazyFan的博客
04-11 314
本文转载自Redis 击穿、穿透、雪崩产生原因以及解决思路 - 击穿- 大家都知道，计算机的瓶颈之一就是IO，为了解决内存与磁盘速度不匹配的问题，产生了缓存，将一些热点数据放在内存中，随用随取，降低连接到数据库的请求链接,避免数据库挂掉。需要注意的是，无论是击穿还是后面谈到的穿透与雪崩,都是在高并发前提下，比如当缓存中某一个热点key失效。 -问题起因- 有两个主要原因: 1、Key过期；2、Key被页面置换淘汰。 对于第一个原因是因为在Redis中，Key有过期时间，如...
秒杀项目缓存问题（缓存穿透，缓存击穿，缓存雪崩）
qq_44855338的博客
08-18 384
缓存穿透，缓存击穿，缓存雪崩
redis 缓存击穿 缓存雪崩 缓存穿透
04-09
Redis缓存击穿、缓存雪崩和缓存穿透都是常见的缓存问题。缓存击穿指的是大量请求同时访问一个不存在于缓存中的数据，导致请求直接打到数据库，增加了数据库的负载。缓存雪崩指的是缓存数据同时失效，导致大量请求访问数据库，也会增加数据库的负载。缓存穿透指的是恶意攻击者通过构造不存在于缓存和数据库中的数据进行请求，也会增加数据库的负载。针对这些问题，我们可以采取一些措施，比如增加缓存过期时间的随机性，使用互斥锁等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

岭岭颖颖

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值