缓存问题急救？

最新推荐文章于 2024-07-23 15:38:42 发布
最新推荐文章于 2024-07-23 15:38:42 发布
阅读量117 收藏
点赞数
分类专栏： redis高阶 文章标签： 缓存 redis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qwe780310/article/details/125074791
版权

第5节-缓存预热+缓存雪崩+缓存击穿+缓存穿透

1、缓存雪崩

发生情况：

​ redis主机挂了，redis全盘崩溃，比如缓存中有大量数据同时过期。

解决方案：

image-20220531011427557

redis缓存集群实现高可用，主从+哨兵|| redis cluster

ehcache本地缓存 + hystrix 或者 阿里sentinel限流&降级

开启Redis持久化机制/aof+rdb，尽快恢复缓存集群

2、缓存穿透

什么是缓存穿透

请求去查询一条记录，先redis后mysql发现，都查不到该条记录，但是每次请求都会打到数据库上面去，导致后台数据库压力暴增，这种现象我们称为缓存穿透，redis成为了一个摆设。

简单说就是，本来无一物，即不再redis中，也不在mysql中。

危害

数据库可能会被打崩。导致服务不可用。

第一次来查询后，一般我们会有回写redis机制，

第二次来查询的时候redis就有了，偶尔出现穿透现象一般情况无关紧要。

解决方案

image-20220531012535511

1、返回空对象缓存或者缺省值

一般OK

image-20220531012754061

但是存在黑客和恶意攻击情况

黑客会对你的系统进行攻击，拿到一个不存在的id，去查询数据，会产生大量的请求到数据库去查询。可能会导致你的数据库由于压力过大而宕机掉

id相同打你的系统：第一次打到mysql，空对象缓存后第二次就返回null了，避免mysql被攻击，不用再缓存到数据库中去走一圈了。

id不同打你的系统：由于存在空对象缓存和缓存回写，redis中的无关紧要的key也会越来越多，（记得设置key过期时间）

2、google布隆过滤器Guava解决缓存穿透（单机版）

guava中布隆过滤器的实现算是比较权威的，所以实际项目中我们不需要手动实现一个布隆过滤器

guava布隆过滤器实战

?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.10.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.atguigu.redis.bloomfilter</groupId>
    <artifactId>bloomfilter_demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>


    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <junit.version>4.12</junit.version>
        <log4j.version>1.2.17</log4j.version>
        <lombok.version>1.16.18</lombok.version>
        <mysql.version>5.1.47</mysql.version>
        <druid.version>1.1.16</druid.version>
        <mybatis.spring.boot.version>1.3.0</mybatis.spring.boot.version>
    </properties>

    <dependencies>
        <!--guava Google 开源的 Guava 中自带的布隆过滤器-->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>23.0</version>
        </dependency>
        <!-- redisson -->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.13.4</version>
        </dependency>
        <!--web+actuator-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--SpringBoot与Redis整合依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <!-- jedis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.1.0</version>
        </dependency>
        <!-- springboot-aop 技术-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <!--Mysql数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!--集成druid连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>${druid.version}</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>${druid.version}</version>
        </dependency>
        <!--mybatis和springboot整合-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>${mybatis.spring.boot.version}</version>
        </dependency>
        <!-- 添加springboot对amqp的支持 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <!--通用基础配置-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

server.port=6666


# ========================alibaba.druid相关配置=====================
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/db2021?useUnicode=true&characterEncoding=utf-8&useSSL=false
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.druid.test-while-idle=false

# ========================redis相关配置=====================
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=192.168.111.147
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制） 默认 8
spring.redis.lettuce.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
spring.redis.lettuce.pool.max-wait=-1
# 连接池中的最大空闲连接 默认 8
spring.redis.lettuce.pool.max-idle=8
# 连接池中的最小空闲连接 默认 0
spring.redis.lettuce.pool.min-idle=0

helloworld案例入门

@Test
public void bloomFilter(){
    // 创建布隆过滤器对象
    BloomFilter<Integer> filter = BloomFilter.create(Funnels.integerFunnel(), 100);
    // 判断指定元素是否存在
    System.out.println(filter.mightContain(1));
    System.out.println(filter.mightContain(2));
    // 将元素添加进布隆过滤器
    filter.put(1);
    filter.put(2);
    System.out.println(filter.mightContain(1));
    System.out.println(filter.mightContain(2));
}

去样本数据100w，查查不在100w范围内的其他10w数据 是否存在

public class BloomfilterDemo
{
    public static final int _1W = 10000;

    //布隆过滤器里预计要插入多少数据
    public static int size = 100 * _1W;
    //误判率,它越小误判的个数也就越少(思考，是不是可以设置的无限小，没有误判岂不更好)
    public static double fpp = 0.03;

    // 构建布隆过滤器
    private static BloomFilter<Integer> bloomFilter = BloomFilter.create(Funnels.integerFunnel(), size,fpp);

    public static void main(String[] args)
    {
        //1 先往布隆过滤器里面插入100万的样本数据
        for (int i = 0; i < size; i++) {
            bloomFilter.put(i);
        }
        //故意取10万个不在过滤器里的值，看看有多少个会被认为在过滤器里
        List<Integer> list = new ArrayList<>(10 * _1W);

        for (int i = size+1; i < size + 100000; i++) {
            if (bloomFilter.mightContain(i)) {
                System.out.println(i+"\t"+"被误判了.");
                list.add(i);
            }
        }
        System.out.println("误判的数量：" + list.size());
    }
}

上步骤结论：

​ 现在总共有10万数据是不存在的，误判了3033次，原始样本：100W，不存在数据:101W—110W

image-20220531014555404

布隆过滤器说明：

image-20220531014639341

3、Redis布隆过滤器解决缓存穿透

guava的缺点：

Guava 提供的布隆过滤器的实现还是很不错的 （想要详细了解的可以看一下它的源码实现），但是它有一个重大的缺陷就是只能单机使用 ，而现在互联网一般都是分布式的场景。

为了解决这个问题，我们就需要用到 Redis 中的布隆过滤器了

案例：白名单过滤器

image-20220531014826668

误判问题，但是概率小可以接受，不能从布隆过滤器删除

全部合法的key都需要放入过滤器+redis里面，不然数据就是返回null

public class RedissonBloomFilterDemo2
{
    public static final int _1W = 10000;

    //布隆过滤器里预计要插入多少数据
    public static int size = 100 * _1W;
    //误判率,它越小误判的个数也就越少
    public static double fpp = 0.03;

    static RedissonClient redissonClient = null;
    static RBloomFilter rBloomFilter = null;

    static
    {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://192.168.111.147:6379").setDatabase(0);
        //构造redisson
        redissonClient = Redisson.create(config);
        //通过redisson构造rBloomFilter
        rBloomFilter = redissonClient.getBloomFilter("phoneListBloomFilter",new StringCodec());

        rBloomFilter.tryInit(size,fpp);

        // 1测试  布隆过滤器有+redis有
        rBloomFilter.add("10086");
        redissonClient.getBucket("10086",new StringCodec()).set("chinamobile10086");

        // 2测试  布隆过滤器有+redis无
        //rBloomFilter.add("10087");

        //3 测试 ，都没有

    }

    public static void main(String[] args)
    {
        String phoneListById = getPhoneListById("10087");
        System.out.println("------查询出来的结果： "+phoneListById);

        //暂停几秒钟线程
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
        redissonClient.shutdown();
    }

    private static String getPhoneListById(String IDNumber)
    {
        String result = null;

        if (IDNumber == null) {
            return null;
        }
        //1 先去布隆过滤器里面查询
        if (rBloomFilter.contains(IDNumber)) {
            //2 布隆过滤器里有，再去redis里面查询
            RBucket<String> rBucket = redissonClient.getBucket(IDNumber, new StringCodec());
            result = rBucket.get();
            if(result != null)
            {
                return "i come from redis: "+result;
            }else{
                result = getPhoneListByMySQL(IDNumber);
                if (result == null) {
                    return null;
                }
                // 重新将数据更新回redis
                redissonClient.getBucket(IDNumber,new StringCodec()).set(result);
            }
            return "i come from mysql: "+result;
        }
        return result;
    }

    private static String getPhoneListByMySQL(String IDNumber)
    {
        return "chinamobile"+IDNumber;
    }

}

重要总结：

image-20220531015039161

黑名单实现思路：

image-20220531015157553

在Centos7下布隆过滤器2种安装方式

采用docker安装RedisBloom，推荐

Redis在4.0以后有了插件功能，可以使用外部的扩展功能，可以使用RedisBloom作为Redis布隆过滤器插件。

docker run -p 6379 --name=redis6379bloom -d redislabs/rebloom

image-20220531015440910

docker exec -it redis6379bloom /bin/bash 

redis-cli 连入redis客户端

布隆过滤器常用操作命令

image-20220531015536178

bf.reserve key error_rate 的值initial_size的值  默认error_rate=0.01  默认initial_size是100

bf.add key value 

bf.exists key value 

bf.madd 一次添加多个value

bf.mexists 一次查询多个元素是否存在

编译安装

# 解压 
tar -zxvf v2.2.2.tar.gz
cd RedisBloom-2.2.2
# 若是第一次使用 需要安装gcc++环境
make
# redis服启动添加对应参数 这样写还是挺麻烦的
# rebloom_module="/usr/local/rebloom/rebloom.so"
# daemon --user ${REDIS_USER-redis} "$exec $REDIS_CONFIG --loadmodule # $rebloom_module --daemonize yes --pidfile $pidfile"
# 记录当前位置
pwd
# 进入reids目录 配置在redis.conf中 更加方便
vim redis.conf
# :/loadmodule redisbloom.so是刚才具体的pwd位置 cv一下
loadmodule /xxx/redis/redis-5.0.8/RedisBloom-2.2.2/redisbloom.so
# 保存退出
wq
# 重新启动redis-server 我是在redis中 操作的 若不在请写出具体位置 不然会报错
redis-server redis.conf
# 连接容器中的 redis 服务 若是无密码 redis-cli即可
redis-cli -a 密码
# 进入可以使用BF.ADD命令算成功

3、缓存击穿

是什么？

大量的请求同时查询一个key时，此时正好这个key失效了，就会导致大量的请求都打到数据库上面去，

简单来说就是热点key突然失效了，请求暴打mysql

危害

造成某一时刻数据库请求量过大，压力剧增

解决方案

image-20220531015948300

1、对于频繁访问的热点key，干脆就不设置过期时间

2、互斥独占锁防止击穿

多个线程同时去查询数据库的这条数据，那么我们可以在第一个查询数据的请求上使用一个 互斥锁来锁住它。

其他的线程走到这一步拿不到锁就等着，等第一个线程查询到了数据，然后做缓存。后面的线程进来发现已经有缓存了，就直接走缓存。

image-20220531020055163

案例：淘宝聚划算功能实现+防止缓存击穿

技术方案实现：

分析过程image-20220531020208930

redis数据类型选型：list

image-20220531020256469

springboot+redis实现高并发的淘宝聚划算业务

配置redisConfig

@Configuration
public class RedisConfig
{
    /**
     * @param lettuceConnectionFactory
     * @return
     *
     * redis序列化的工具配置类，下面这个请一定开启配置
     * 127.0.0.1:6379> keys *
     * 1) "ord:102"  序列化过
     * 2) "\xac\xed\x00\x05t\x00\aord:102"   野生，没有序列化过
     */
    @Bean
    public RedisTemplate<String,Serializable> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory)
    {
        RedisTemplate<String,Serializable> redisTemplate = new RedisTemplate<>();

        redisTemplate.setConnectionFactory(lettuceConnectionFactory);
        //设置key序列化方式string
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        //设置value的序列化方式json
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());

        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());

        redisTemplate.afterPropertiesSet();

        return redisTemplate;
    }
}

entity实体类

@Data
@ApiModel(value = "聚划算活动producet信息")
public class Product {

    private Long id;
    /**
     * 产品名称
     */
    private String name;
    /**
     * 产品价格
     */
    private Integer price;
    /**
     * 产品详情
     */
    private String detail;

    public Product() {
    }

    public Product(Long id, String name, Integer price, String detail) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.detail = detail;
    }
}

常量

public class Constants {

    public  static final String JHS_KEY="jhs";

    public  static final String JHS_KEY_A="jhs:a";

    public  static final String JHS_KEY_B="jhs:b";

}

采用定时器将参与聚划算活动的特价商品新增进入redis中

@Service
@Slf4j
public class JHSTaskService
{
    @Autowired
    private RedisTemplate redisTemplate;

    @PostConstruct
    public void initJHS(){
        log.info("启动定时器淘宝聚划算功能模拟.........."+DateUtil.now());
        new Thread(() -> {
            //模拟定时器，定时把数据库的特价商品，刷新到redis中
            while (true){
                //模拟从数据库读取100件特价商品，用于加载到聚划算的页面中
                List<Product> list=this.products();
                //采用redis list数据结构的lpush来实现存储
                this.redisTemplate.delete(Constants.JHS_KEY);
                //lpush命令
                this.redisTemplate.opsForList().leftPushAll(Constants.JHS_KEY,list);
                //间隔一分钟 执行一遍
                try { TimeUnit.MINUTES.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

                log.info("runJhs定时刷新..............");
            }
        },"t1").start();
    }

    /**
     * 模拟从数据库读取100件特价商品，用于加载到聚划算的页面中
     */
    public List<Product> products() {
        List<Product> list=new ArrayList<>();
        for (int i = 1; i <=20; i++) {
            Random rand = new Random();
            int id= rand.nextInt(10000);
            Product obj=new Product((long) id,"product"+i,i,"detail");
            list.add(obj);
        }
        return list;
    }
}

控制层

@RestController
@Slf4j
@Api(description = "聚划算商品列表接口")
public class JHSProductController
{
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 分页查询：在高并发的情况下，只能走redis查询，走db的话必定会把db打垮
     * http://localhost:5555/swagger-ui.html#/jhs-product-controller/findUsingGET
     */
    @RequestMapping(value = "/pruduct/find",method = RequestMethod.GET)
    @ApiOperation("按照分页和每页显示容量，点击查看")
    public List<Product> find(int page, int size) {
        List<Product> list=null;
        long start = (page - 1) * size;
        long end = start + size - 1;
        try {
            //采用redis list数据结构的lrange命令实现分页查询
            list = this.redisTemplate.opsForList().range(Constants.JHS_KEY, start, end);
            if (CollectionUtils.isEmpty(list)) {
                //TODO 走DB查询
            }
            log.info("查询结果：{}", list);
        } catch (Exception ex) {
            //这里的异常，一般是redis瘫痪 ，或 redis网络timeout
            log.error("exception:", ex);
            //TODO 走DB查询
        }
        return list;
    }
}

上述功能算是完成，但是思考在高并发下，会有什么经典的生产问题？

bug和隐患说明

QPS上1000后导致可怕的缓存击穿

image-20220531020702311

image-20220531020713030

image-20220531020724801

进一步升级加固案例

准则或者说方向 ： 定时轮询、互斥更新、差异失效时间

image-20220531020816330

采用多级缓存 + 一级本地缓存也可以实现防止缓存击穿（不同的过期时间即可）

service

@Service
@Slf4j
public class JHSABTaskService
{
    @Autowired
    private RedisTemplate redisTemplate;

    @PostConstruct
    public void initJHSAB(){
        log.info("启动AB定时器计划任务淘宝聚划算功能模拟.........."+DateUtil.now());
        new Thread(() -> {
            //模拟定时器，定时把数据库的特价商品，刷新到redis中
            while (true){
                //模拟从数据库读取100件特价商品，用于加载到聚划算的页面中
                List<Product> list=this.products();
                //先更新B缓存
                this.redisTemplate.delete(Constants.JHS_KEY_B);
                this.redisTemplate.opsForList().leftPushAll(Constants.JHS_KEY_B,list);
                this.redisTemplate.expire(Constants.JHS_KEY_B,20L,TimeUnit.DAYS);
                //再更新A缓存
                this.redisTemplate.delete(Constants.JHS_KEY_A);
                this.redisTemplate.opsForList().leftPushAll(Constants.JHS_KEY_A,list);
                this.redisTemplate.expire(Constants.JHS_KEY_A,15L,TimeUnit.DAYS);
                //间隔一分钟 执行一遍
                try { TimeUnit.MINUTES.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

                log.info("runJhs定时刷新..............");
            }
        },"t1").start();
    }

    /**
     * 模拟从数据库读取100件特价商品，用于加载到聚划算的页面中
     */
    public List<Product> products() {
        List<Product> list=new ArrayList<>();
        for (int i = 1; i <=20; i++) {
            Random rand = new Random();
            int id= rand.nextInt(10000);
            Product obj=new Product((long) id,"product"+i,i,"detail");
            list.add(obj);
        }
        return list;
    }
}

controller

@RestController
@Slf4j
@Api(description = "聚划算商品列表接口AB")
public class JHSABProductController
{
    @Autowired
    private RedisTemplate redisTemplate;

    @RequestMapping(value = "/pruduct/findab",method = RequestMethod.GET)
    @ApiOperation("按照分页和每页显示容量，点击查看AB")
    public List<Product> findAB(int page, int size) {
        List<Product> list=null;
        long start = (page - 1) * size;
        long end = start + size - 1;
        try {
            //采用redis list数据结构的lrange命令实现分页查询
            list = this.redisTemplate.opsForList().range(Constants.JHS_KEY_A, start, end);
            if (CollectionUtils.isEmpty(list)) {
                log.info("=========A缓存已经失效了，记得人工修补，B缓存自动延续5天");
                //用户先查询缓存A(上面的代码)，如果缓存A查询不到（例如，更新缓存的时候删除了），再查询缓存B
                this.redisTemplate.opsForList().range(Constants.JHS_KEY_B, start, end);
            }
            log.info("查询结果：{}", list);
        } catch (Exception ex) {
            //这里的异常，一般是redis瘫痪 ，或 redis网络timeout
            log.error("exception:", ex);
            //TODO 走DB查询
        }
        return list;
    }
}

总结：

image-20220531020724801

白给的阿威
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
360断网急救箱.zip
08-21
3. **清除网络垃圾**：急救箱还可以清理网络缓存、临时文件，释放网络资源，提高网络速度。 4. **防止恶意干扰**：部分病毒或恶意软件可能会篡改网络设置，360断网急救箱能够检测并阻止这类行为，保护网络环境的...
360断网急救箱
10-18
它们允许急救箱识别和处理各种网络问题，如IP冲突、DNS解析错误、网络驱动程序问题等。 360netdiag.dll是一个诊断模块，用于检测网络连接的状态，包括硬件接口、网络适配器、网络协议栈等方面的问题。它会执行一...
redis缓存三大问题及内存满了该怎么办
haogeoyes的博客
08-08 2191
日常的开发中，无不都是使用数据库来进行数据的存储，由于一般的系统任务中通常不会存在高并发的情况，所以这样看起来并没有什么问题。一旦涉及大数据量的需求，如一些商品抢购的情景，或者主页访问量瞬间较大的时候，单一使用数据库来保存数据的系统会因为面向磁盘，磁盘读/写速度问题有严重的性能弊端，详细的磁盘读写原理请参考这一片[]。在这一瞬间成千上万的请求到来，需要系统在极短的时间内完成成千上万次的读/写操作，这个时候往往不是数据库能够承受的，极其容易造成数据库系统瘫痪，最终导致服务宕机的严重生产问题。...
缓存穿透优化：缓存空对象
05-16 1926
缓存穿透优化：缓存空对象 所谓的"缓存穿透"是指查询一个根本不存在的数据，缓存层和存储层都不会命中。 缓存穿透将导致不存在的数据每次请求都要到存储层去查询，失去了缓存保护后端的意义。 造成缓存穿透的基本原因有两个：自身业务代码或者数据出现问题；一些恶意攻击、爬虫等造成大量空命中。 缓存空对象会有2个问题： 1、空值做了缓存，意味着缓存层中存了更多的键，需要更多内存空间。 比较有效的方法是针对这类数...
情景再现，Java面试老大难问题：缓存雪崩，穿透，击穿，一文道明
m0_69305074的博客
05-14 247
正文 提到Redis我相信各位在面试，或者实际开发过程中对缓存雪崩，穿透，击穿也不陌生吧，就算没遇到过但是你肯定听过，那三者到底有什么区别，我们又应该怎么去防止这样的情况发生呢，我们有请下一位受害者。 面试开始 一个大腹便便，穿着格子衬衣的中年男子，拿着一个满是划痕的mac向你走来，看着快秃顶的头发，心想着肯定是尼玛顶级架构师吧！但是我们腹有诗书气自华，说虚都不虚。 小伙子我看你的简历上写到了Redis，那么我们直接开门见山，直接怼常见的几个大问题，Redis雪崩了解么？ 帅气迷人的面试官您好
阿里面试Redis最常问的三个问题：缓存雪崩、击穿、穿透（带答案）(2)
2401_84301315的博客
05-04 770
我们玩归玩，闹归闹，别拿面试开玩笑。本文简单的介绍了，Redis的雪崩击穿穿透，三者其实都差不多，但是又有一些区别，在面试中其实这是问到缓存必问的，大家不要把三者搞混了，因为缓存雪崩、穿透和击穿，是缓存最大的问题，要么不出现，一旦出现就是致命性的问题，所以面试官一定会问你。大家一定要理解是怎么发生的，以及是怎么去避免的，发生之后又怎么去抢救，你可以不是知道很深入，但是你不能一点都不去想，面试有时候不一定是对知识面的拷问，或许是对你的态度的拷问，如果你思路清晰，然后知其然还知其所以然。
浅谈缓存系统的三个问题
good575654643的博客
12-06 305
一.无处不在的缓存缓存在计算机系统是无处不在，在CPU层面有L1-L3的Cache，在Linux中有TLB加速虚拟地址和物理地址的转换，在应用层有Redis等内存数据库缓存、在浏览器有本地缓存、手机有本地文件缓存等等。可见，缓存在计算机系统中有非常重要的地位，主要作用就是提高响应速度、减少磁盘读取等，本文主要讨论在高并发系统中的缓存系统。一句话概括缓存系统在高并发系统中的地位的话，就...
情景再现，Java 面试老大难问题：缓存雪崩，穿透，击穿，一文道明
2401_85379639的博客
07-17 552
给大家送一个小福利附高清脑图，高清知识点讲解教程，以及一些面试真题及答案解析。送给需要的提升技术、准备面试跳槽、自身职业规划迷茫的朋友们。后给大家送一个小福利[外链图片转存中…(img-g6ogQs5E-1721188301473)]附高清脑图，高清知识点讲解教程，以及一些面试真题及答案解析。送给需要的提升技术、准备面试跳槽、自身职业规划迷茫的朋友们。[外链图片转存中…(img-AJCi66zO-1721188301474)]
缓存雪崩、击穿、穿透，该如何避免？
lxw1844912514的博客
01-13 1220
一个大腹便便，穿着格子衬衣的中年男子，拿着一个满是划痕的mac向你走来，看着快秃顶的头发，心想着肯定是尼玛顶级架构师吧！但是我们腹有诗书气自华，虚都不虚。小伙子我看你的简历上写到了Red...
Redis之缓存雪崩、击穿、穿透
冬日追梦少年的博客
01-18 127
正文 那提到Redis我相信各位在面试，或者实际开发过程中对缓存雪崩，穿透，击穿也不陌生吧，就算没遇到过但是你肯定听过，那三者到底有什么区别，我们又应该怎么去防止这样的情况发生呢，我们有请下一位受害者。 面试开始 一个大腹便便，穿着格子衬衣的中年男子，拿着一个满是划痕的mac向你走来，看着快秃顶的头发，心想着肯定是尼玛顶级架构师吧！但是我们腹有诗书气自华，虚都不虚。 小伙子我看你的简历上写到了Redis，那么我们直接开门见山，直接怼常见的几个大问题，Redis雪崩了解么？ 帅气迷人的面试官
keep-alive不能缓存多层级路由菜单问题
热门推荐
一路从容
08-30 1万+
这出现的原因是多级路由导致的，就是router-view嵌套 在层级不同的router-view中切换tag会出现缓存数据失效的问题。目前keep-alive可以有效缓存一级，二级的路由菜单，3级以上菜单并不能做到缓存，这里提供一个解决方案： 在cachedViews中手动加上一级菜单和三级菜单之间，缺失的二级菜单的名字，这样二级菜单下的组件就会缓存了 实列代码如下： const _import...
断网急救箱
03-07
2. **修复工具**：该工具集成了多种修复策略，例如重置网络设置、更新或回滚网络驱动、清除DNS缓存等，针对不同的网络问题提供相应的修复措施。 3. **安全扫描**：考虑到网络安全可能对网络连接造成影响，断网急救...
基于JAVA开发的文章资讯类（急救应急处理知识）小程序
03-29
性能优化也是关键，比如通过缓存技术减少数据加载时间，提升用户体验。 总之，基于Java开发的文章资讯类（急救应急处理知识）小程序是一项有益于社会的项目。它将Java的强大功能与急救知识相结合，为用户提供了一个...
高性能内存对象缓存Memcached原理与部署
weixin_73188318的博客
07-20 1111
Memcached是一个高性能、分布式的内存对象缓存系统，主要用于加速动态Web应用程序，通过减少数据库负载来提升响应速度。它是一个开源软件，以键值对的形式存储数据，数据存储在内存中，访问速度极快，但数据不具备持久性，重启或断电后数据会丢失。Memcached支持多服务器分布式部署，能够水平扩展以处理大量数据和高并发请求。
mybatis中的缓存（一级缓存、二级缓存）
最新发布
m0_62943934的博客
07-23 357
在计算机的世界中，缓存无处不在，重要性不言而喻。作为一款优秀的ORM框架，MyBatis中又岂能少得了缓存，本博客基于mybatis 3.5.11版本，全面介绍mybatis一级缓存、二级缓存以及自定义缓存的使用方法、实现原理、应用场景、优缺点等，并进行验证，带你彻底掌握MyBatis缓存。
Nginx 如何实现请求的缓存过期策略？
技术笔记
07-22 1035
其中，Nginx 的请求缓存过期策略就是一项关键的性能优化手段，它能够有效地减少服务器的负载，提高响应速度，为用户带来更流畅的体验。缓存，简单来说，就像是一个临时的“仓库”，把经常用到的数据或者结果存起来，下次需要的时候直接拿，不用再重新计算或者从远处获取。比如说，我们有一个电商网站，对于热门商品的页面，我们希望缓存时间长一点，而对于冷门商品的页面，缓存时间短一些。希望通过本文的介绍，您对 Nginx 的缓存过期策略有了更深入的了解，能够在实际应用中发挥它的最大作用，为您的网站和应用带来更出色的性能表现。
Python面试题：Python中的记忆化与缓存技术
码农超哥的博客
07-21 344
记忆化和缓存技术是Python中优化计算性能的有效方法。记忆化主要用于递归函数，常通过手动实现或使用装饰器来实现。缓存则更广泛地应用于需要重用计算结果的场景，可以使用cachetools和等库来实现。通过合理地使用这些技术，可以显著提高程序的执行效率。
C++实现LRU缓存（新手入门详解）
ZY52678的博客
07-18 576
LRU（Least Recently Used，最近最少使用）是一种常用的缓存淘汰策略，主要目的是在缓存空间有限的情况下，优先淘汰那些最长时间没有被访问的数据项。并添加了一些整数元素。然后，我们遍历并打印链表中的元素，删除头部和尾部的元素，并再次打印链表中的元素。方法用于插入或更新缓存中的键值对，如果缓存已满，则淘汰最不常用的键（链表尾部的键）。：随着数据访问模式的变化，LRU策略可以动态调整缓存中的数据项，以适应访问模式的变化。：每次数据项被访问时，都会更新其访问记录，使得最近访问的数据项保留在缓存中。
Redis如何解决缓存穿透和缓存击穿问题？
06-09
Redis可以通过以下两种方式解决缓存穿透和缓存击穿问题： 1. 使用布隆过滤器 布隆过滤器是一种空间效率很高的数据结构，它可以告诉你一个元素是否一定不存在于一个集合中。在Redis中，可以使用布隆过滤器来过滤...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值