缓存问题急救？

最新推荐文章于 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是一个诊断模块，用于检测网络连接的状态，包括硬件接口、网络适配器、网络协议栈等方面的问题。它会执行一...
缓存穿透优化：缓存空对象
05-16 1926
缓存穿透优化：缓存空对象 所谓的"缓存穿透"是指查询一个根本不存在的数据，缓存层和存储层都不会命中。 缓存穿透将导致不存在的数据每次请求都要到存储层去查询，失去了缓存保护后端的意义。 造成缓存穿透的基本原因有两个：自身业务代码或者数据出现问题；一些恶意攻击、爬虫等造成大量空命中。 缓存空对象会有2个问题： 1、空值做了缓存，意味着缓存层中存了更多的键，需要更多内存空间。 比较有效的方法是针对这类数...
redis缓存三大问题及内存满了该怎么办
haogeoyes的博客
08-08 2191
日常的开发中，无不都是使用数据库来进行数据的存储，由于一般的系统任务中通常不会存在高并发的情况，所以这样看起来并没有什么问题。一旦涉及大数据量的需求，如一些商品抢购的情景，或者主页访问量瞬间较大的时候，单一使用数据库来保存数据的系统会因为面向磁盘，磁盘读/写速度问题有严重的性能弊端，详细的磁盘读写原理请参考这一片[]。在这一瞬间成千上万的请求到来，需要系统在极短的时间内完成成千上万次的读/写操作，这个时候往往不是数据库能够承受的，极其容易造成数据库系统瘫痪，最终导致服务宕机的严重生产问题。...
情景再现，Java面试老大难问题：缓存雪崩，穿透，击穿，一文道明
m0_69305074的博客
05-14 247
正文 提到Redis我相信各位在面试，或者实际开发过程中对缓存雪崩，穿透，击穿也不陌生吧，就算没遇到过但是你肯定听过，那三者到底有什么区别，我们又应该怎么去防止这样的情况发生呢，我们有请下一位受害者。 面试开始 一个大腹便便，穿着格子衬衣的中年男子，拿着一个满是划痕的mac向你走来，看着快秃顶的头发，心想着肯定是尼玛顶级架构师吧！但是我们腹有诗书气自华，说虚都不虚。 小伙子我看你的简历上写到了Redis，那么我们直接开门见山，直接怼常见的几个大问题，Redis雪崩了解么？ 帅气迷人的面试官您好
阿里面试Redis最常问的三个问题：缓存雪崩、击穿、穿透（带答案）(2)
2401_84301315的博客
05-04 770
我们玩归玩，闹归闹，别拿面试开玩笑。本文简单的介绍了，Redis的雪崩击穿穿透，三者其实都差不多，但是又有一些区别，在面试中其实这是问到缓存必问的，大家不要把三者搞混了，因为缓存雪崩、穿透和击穿，是缓存最大的问题，要么不出现，一旦出现就是致命性的问题，所以面试官一定会问你。大家一定要理解是怎么发生的，以及是怎么去避免的，发生之后又怎么去抢救，你可以不是知道很深入，但是你不能一点都不去想，面试有时候不一定是对知识面的拷问，或许是对你的态度的拷问，如果你思路清晰，然后知其然还知其所以然。
断网急救箱
03-07
2. **修复工具**：该工具集成了多种修复策略，例如重置网络设置、更新或回滚网络驱动、清除DNS缓存等，针对不同的网络问题提供相应的修复措施。 3. **安全扫描**：考虑到网络安全可能对网络连接造成影响，断网急救...
基于JAVA开发的文章资讯类（急救应急处理知识）小程序
03-29
性能优化也是关键，比如通过缓存技术减少数据加载时间，提升用户体验。 总之，基于Java开发的文章资讯类（急救应急处理知识）小程序是一项有益于社会的项目。它将Java的强大功能与急救知识相结合，为用户提供了一个...
高性能内存对象缓存Memcached原理与部署
weixin_73188318的博客
07-20 1111
Memcached是一个高性能、分布式的内存对象缓存系统，主要用于加速动态Web应用程序，通过减少数据库负载来提升响应速度。它是一个开源软件，以键值对的形式存储数据，数据存储在内存中，访问速度极快，但数据不具备持久性，重启或断电后数据会丢失。Memcached支持多服务器分布式部署，能够水平扩展以处理大量数据和高并发请求。
mybatis中的缓存（一级缓存、二级缓存）
最新发布
m0_62943934的博客
07-23 366
在计算机的世界中，缓存无处不在，重要性不言而喻。作为一款优秀的ORM框架，MyBatis中又岂能少得了缓存，本博客基于mybatis 3.5.11版本，全面介绍mybatis一级缓存、二级缓存以及自定义缓存的使用方法、实现原理、应用场景、优缺点等，并进行验证，带你彻底掌握MyBatis缓存。
Nginx 如何实现请求的缓存过期策略？
技术笔记
07-22 1036
其中，Nginx 的请求缓存过期策略就是一项关键的性能优化手段，它能够有效地减少服务器的负载，提高响应速度，为用户带来更流畅的体验。缓存，简单来说，就像是一个临时的“仓库”，把经常用到的数据或者结果存起来，下次需要的时候直接拿，不用再重新计算或者从远处获取。比如说，我们有一个电商网站，对于热门商品的页面，我们希望缓存时间长一点，而对于冷门商品的页面，缓存时间短一些。希望通过本文的介绍，您对 Nginx 的缓存过期策略有了更深入的了解，能够在实际应用中发挥它的最大作用，为您的网站和应用带来更出色的性能表现。
Python面试题：Python中的记忆化与缓存技术
码农超哥的博客
07-21 345
记忆化和缓存技术是Python中优化计算性能的有效方法。记忆化主要用于递归函数，常通过手动实现或使用装饰器来实现。缓存则更广泛地应用于需要重用计算结果的场景，可以使用cachetools和等库来实现。通过合理地使用这些技术，可以显著提高程序的执行效率。
C++实现LRU缓存（新手入门详解）
ZY52678的博客
07-18 577
LRU（Least Recently Used，最近最少使用）是一种常用的缓存淘汰策略，主要目的是在缓存空间有限的情况下，优先淘汰那些最长时间没有被访问的数据项。并添加了一些整数元素。然后，我们遍历并打印链表中的元素，删除头部和尾部的元素，并再次打印链表中的元素。方法用于插入或更新缓存中的键值对，如果缓存已满，则淘汰最不常用的键（链表尾部的键）。：随着数据访问模式的变化，LRU策略可以动态调整缓存中的数据项，以适应访问模式的变化。：每次数据项被访问时，都会更新其访问记录，使得最近访问的数据项保留在缓存中。
springboot中如果我想每个接口对应redis应该怎么做？ 更改的时候只删除对应的缓存？
qq_35915504的博客
07-20 552
需要注意的是,在实现缓存的过程中,要合理设计缓存的粒度和过期时间,避免缓存的数据过多或过期时间过长,导致内存占用过高或数据不一致的问题。通过以上步骤,你可以为每个接口设置对应的Redis缓存,并在更改数据时只删除对应的缓存。为了区分不同接口的缓存,你需要为每个接口设计一个唯一的缓存键。方法时,如果缓存中存在对应的数据,就直接返回缓存的结果;当你更改了某个接口对应的数据时,需要删除该接口对应的缓存,以保证数据的一致性。方法时,会删除对应的缓存,确保缓存与数据库的一致性。方法时,会删除对应的缓存。
arcgis紧凑型切片缓存(解决大范围切片，文件数量大的问题)
GIS工具
07-19 896
ArcGIS 切片缓存的紧凑型存储格式是一种优化的存储方式，用于提高切片缓存的存储效率和访问速度。紧凑型存储格式将多个切片文件合并为一个单一的 .bundle 文件，从而减少文件系统的开销和切片的加载时间。这类格式已经应用很久了，我记得2013我项目中就采用过此类格式!最重要的是这是一种公开开放的格式有很多代码和库可以读写此类格式。而我们在日常使用软件中应尽量使用公开和开放的格式，以保证系统数据的可兼容性和可迁移性!
redis缓存击穿和缓存穿透的封装、缓存更新的CacheAside方案、数据预热
f552126506的博客
07-18 1590
redis缓存击穿和缓存穿透的封装、缓存更新的CacheAside方案、数据预热
Kafka Producer发送消息流程之Sender发送线程和在途请求缓存区
m0_51390969的博客
07-17 912
线程将消息批次发送到broker后，这些请求会存储在在途请求缓存区中，直到收到broker的确认响应。线程会将这些批次按目标broker进行组织，因为一个broker通常负责多个分区的消息处理。：如果某个请求在指定时间内没有收到响应，生产者会根据配置的重试机制重新发送这些请求。线程工作流程中，如果一次任务中包含了来自多个分区的批次，并且这些批次涉及到多个broker，那么。通过这些配置，Kafka生产者可以在不同的网络条件和负载下优化消息发送的效率和可靠性。响应中包含了每个分区的消息是否成功写入的信息。
day06：缓存商品、购物车
m0_69266818的博客
07-21 683
写了缓存商品和购物车相关代码
Redis如何解决缓存穿透和缓存击穿问题？
06-09
Redis可以通过以下两种方式解决缓存穿透和缓存击穿问题： 1. 使用布隆过滤器 布隆过滤器是一种空间效率很高的数据结构，它可以告诉你一个元素是否一定不存在于一个集合中。在Redis中，可以使用布隆过滤器来过滤那些不存在于数据库中的请求，从而避免缓存穿透问题。 2. 使用互斥锁 在Redis中，可以使用互斥锁来解决缓存击穿问题。当某个请求发现缓存中不存在需要的数据时，可以使用互斥锁来锁住对缓存的访问，然后重新从数据库中获取数据，并将获取到的数据更新到缓存中。其他的请求需要等待这个请求完成后才能继续访问缓存，从而避免了缓存击穿问题。 需要注意的是，使用互斥锁需要注意锁的粒度，不能将整个缓存锁住，否则会影响系统的并发性能。可以根据具体的业务场景将缓存划分为不同的区域，对每个区域使用不同的锁来控制并发访问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值