Redis雪崩、穿透、击穿补充学习与布隆过滤器


一、缓存雪崩

1、介绍

同一时间大面积失效,那一瞬间Redis跟没有一样

2、处理雪崩数据

在批量往Redis存数据的时候,把每个Key的失效时间都加个随机值就好了,这样可以保证数据不会在同一时间大面积失效。

setRedis(Key,value,time + Math.random() * 10000);

设置热点数据永远不过期,有更新操作就更新缓存就好了(比如运维更新了首页商品,那你刷下缓存就完事了,不要设置过期时间),电商首页的数据也可以用这个操作,保险。

二、缓存穿透

1、介绍

缓存穿透是指缓存和数据库中都没有的数据,而用户不断发起请求,我们数据库的 id 都是1开始自增上去的,如发起为id值为 -1 的数据或 id 为特别大不存在的数据。这时的用户很可能是攻击者,攻击会导致数据库压力过大,严重会击垮数据库。
如果不对参数做校验,数据库id都是大于0的,我一直用小于0的参数去请求你,每次都能绕开Redis直接打到数据库,数据库也查不到,每次都这样,并发高点就容易崩掉了。

2、处理穿透数据

缓存穿透我会在接口层增加校验,比如用户鉴权校验,参数做校验,不合法的参数直接代码Return,比如:id 做基础校验,id <=0的直接拦截等。
下面我有使用布隆过滤器解决穿透的案例

三、缓存击穿

缓存雪崩是因为大面积的缓存失效,打崩了DB,而缓存击穿不同的是缓存击穿是指一个Key非常热点,在不停的扛着大并发,大并发集中对这一个点进行访问,当这个Key在失效的瞬间,持续的大并发就穿破缓存。

2、处理击穿数据

缓存击穿的话,设置热点数据永远不过期。或者加上互斥锁就能搞定

public static String getData(String key) throws InterruptedException {
        //从Redis查询数据
        String result = getDataByKV(key);
        //参数校验
        if (StringUtils.isBlank(result)) {
            try {
                //获得锁
                if (reenLock.tryLock()) {
                    //去数据库查询
                    result = getDataByDB(key);
                    //校验
                    if (StringUtils.isNotBlank(result)) {
                        //插进缓存
                        setDataToKV(key, result);
                    }
                } else {
                    //睡一会再拿
                    Thread.sleep(100L);
                    result = getData(key);
                }
            } finally {
                //释放锁
                reenLock.unlock();
            }
        }
        return result;
    }

四、Redis其他知识

1、Redis为何这么快

  1. Redis完全是基于内存的操作,CPU不是Redis的瓶颈,Redis的瓶颈最有可能是机器内存的大小或者网络带宽。
  2. 采用单线程,避免了不必要的上下文切换和竞争条件,不存在多线程导致的CPU切换,不用去考虑各种锁的问题,不存在加锁释放锁操作,没有死锁问题导致的性能消耗。

2、Redis的持久化策略

Redis的持久化策略有两种:1、RDB:快照形式是直接把内存中的数据保存到一个dump的文件中,定时保存,保存策略。2、AOF:把所有的对Redis的服务器进行修改的命令都存到一个文件里,命令的集合。Redis默认是快照RDB的持久化方式。当Redis重启的时候,它会优先使用AOF文件来还原数据集,因为AOF文件保存的数据集通常比RDB文件所保存的数据集更完整。你甚至可以关闭持久化功能,让数据只在服务器运行时存。

五、布隆过滤器

1、安装

要redis4.0以上才支持

wget http://download.redis.io/releases/redis-4.0.14.tar.gz
tar xzf redis-4.0.14.tar.gz
mv redis-4.0.14 redis
cd redis
make
cd src 
make install 
#修改redis.conf配置
注释掉bind 127.0.0.1
daemonize yes 
#设置密码password为密码
requirepass password
#指定配置文件启动服务
redis-server /home/installed/redis/redis.conf

其他

#修改redis启动端口
vim redis.conf
#修改内容
port 6378
pidfile /var/run/redis_6378.pid
#远程测试连接
redis-cli -h 112.17.192.219 -p 6378 auth 123321

安装布隆过滤器

#下载插件压缩包
wget https://github.com/RedisLabsModules/rebloom/archive/v1.1.1.tar.gz
#解压
tar -zxvf v1.1.1.tar.gz
#编译插件
cd RedisBloom-1.1.1/
make
#编译成功后看到redisbloom.so文件即可
#在redis.conf配置文件中加入如RedisBloom的redisbloom.so文件的地址
loadmodule /home/installed/RedisBloom-1.1.1/rebloom.so
#添加完成后需要重启redis
redis-server /home/installed/redis/redis.conf

测试

127.0.0.1:6379> bf.add users user2
 
(integer) 1
 
127.0.0.1:6379> bf.exists users user2
 
(integer) 1
 
127.0.0.1:6379> bf.exists users user3
 
(integer) 0

2、介绍布隆过滤器

布隆过滤器的特点是判断不存在的,则一定不存在;判断存在的,大概率存在,但也有小概率不存在。并且这个概率是可控的,我们可以让这个概率变小或者变高,取决于用户本身的需求。

使用布隆过滤器时,我们只要对布隆过滤器进行初始化,将数据库的数据全都先载入到布隆过滤器中。这样操作后,当一个不存在的id再次进行请求时,在经过过滤器时,过滤器比较id转换成的hash值对应的byte数组位置,立刻就能发现该id不存在,直接返回空即可,速度几乎快到忽略不计。这样即可完美解决缓存穿透的问题。

布隆过滤器由一个 bitSet 和 一组 Hash 函数(算法)组成,是一种空间效率极高的概率型算法和数据结构,主要用来判断一个元素是否在集合中存在。

在初始化时,bitSet 的每一位被初始化为0,同时会定义 Hash 函数,例如有3组 Hash 函数:hash1、hash2、hash3。
将 bitSet 的这3个下标标记为1。
在查找的时候也是根据得到的三个Hash所指向的位置是否为1.
在这里插入图片描述

3、使用布隆过滤器BloomFilter解决Redis的缓存穿透问题(方法一)

当一个查询请求过来时,先经过布隆过滤器进行查,如果判断请求查询值存在,则继续查;如果判断请求查询不存在,直接丢弃。

依赖

        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>21.0</version>
        </dependency>
        <!--redis设置-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--redis连接池-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

配置文件

server:
  port: 8000

spring:
  redis:
    database:
      cache: 15 # cache索引
      token: 15 # Token索引
      mr: 15 # 病历索引
    host: 111.111.112.111  #Redis服务器地址
    port: 6379 # Redis服务器连接端口(本地环境端口6378,其他环境端口是6379)
    password: 123321 # Redis服务器连接密码(默认为空)
    lettuce:
      pool:
        max-active: 8 # 连接池最大连接数(使用负值表示没有限制)
        max-idle: 5 # 连接池中的最大空闲连接
        max-wait: -1 # 连接池最大阻塞等待时间(使用负值表示没有限制)
        min-idle: 0 # 连接池中的最小空闲连接
    timeout: 20000 # 连接超时时间(毫秒)

配置类

@Configuration
@EnableCaching
public class RedisConfig {
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {

        RedisCacheManager rcm = RedisCacheManager.create(connectionFactory);

        return rcm;
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
        redisTemplate.setConnectionFactory(factory);

        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new
                Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        //序列化设置 ,这样计算是正常显示的数据,也能正常存储和获取
        redisTemplate.setKeySerializer(jackson2JsonRedisSerializer);
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashKeySerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);

        return redisTemplate;
    }

    @Bean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
        stringRedisTemplate.setConnectionFactory(factory);
        return stringRedisTemplate;
    }


    //初始化布隆过滤器,放入到spring容器里面
    @Bean
    public BloomFilterHelper<String> initBloomFilterHelper() {
        return new BloomFilterHelper<>((Funnel<String>) (from, into) -> into.putString(from, Charsets.UTF_8).putString(from, Charsets.UTF_8), 1000000, 0.01);
    }

}

工具类

public class BloomFilterHelper<T> {

    private int numHashFunctions;

    private int bitSize;

    private Funnel<T> funnel;

    /**
     * @param funnel
     * @param expectedInsertions
     * @param fpp
     */
    public BloomFilterHelper(Funnel<T> funnel, int expectedInsertions, double fpp) {
        Preconditions.checkArgument(funnel != null, "funnel不能为空");
        this.funnel = funnel;
        // 计算bit数组长度
        bitSize = optimalNumOfBits(expectedInsertions, fpp);
        // 计算hash方法执行次数
        numHashFunctions = optimalNumOfHashFunctions(expectedInsertions, bitSize);
    }

    /**
     * @param value
     * @return
     */
    public int[] murmurHashOffset(T value) {
        int[] offset = new int[numHashFunctions];

        long hash64 = Hashing.murmur3_128().hashObject(value, funnel).asLong();
        int hash1 = (int) hash64;
        int hash2 = (int) (hash64 >>> 32);
        for (int i = 1; i <= numHashFunctions; i++) {
            int nextHash = hash1 + i * hash2;
            if (nextHash < 0) {
                nextHash = ~nextHash;
            }
            offset[i - 1] = nextHash % bitSize;
        }

        return offset;
    }

    /**
     * 计算bit数组长度
     *
     * @param n
     * @param p
     * @return
     */
    private int optimalNumOfBits(long n, double p) {
        if (p == 0) {
            // 设定最小期望长度
            p = Double.MIN_VALUE;
        }
        int sizeOfBitArray = (int) (-n * Math.log(p) / (Math.log(2) * Math.log(2)));
        return sizeOfBitArray;
    }

    /**
     * 计算hash方法执行次数
     *
     * @param n
     * @param m
     * @return
     */
    private int optimalNumOfHashFunctions(long n, long m) {
        int countOfHash = Math.max(1, (int) Math.round((double) m / n * Math.log(2)));
        return countOfHash;
    }
}
@Service
public class RedisBloomFilter {
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 根据给定的布隆过滤器添加值
     */
    public <T> void addByBloomFilter(BloomFilterHelper<T> bloomFilterHelper, String key, T value) {
        Preconditions.checkArgument(bloomFilterHelper != null, "bloomFilterHelper不能为空");
        //就是把我们需要存入的value,通过算法计算出相关需要绑定 1的 bit位  的数组。
        int[] offset = bloomFilterHelper.murmurHashOffset(value);
        for (int i : offset) {
            System.out.println("key : " + key + " " + "value : " + i);
            //就是将计算完得到的bit位数组,存入redis里面的bit结构里面,i就是数组内的bit位位置,每个都设置为true。
            redisTemplate.opsForValue().setBit(key, i, true);
        }
    }

    /**
     * 根据给定的布隆过滤器判断值是否存在
     */
    public <T> boolean includeByBloomFilter(BloomFilterHelper<T> bloomFilterHelper, String key, T value) {
        Preconditions.checkArgument(bloomFilterHelper != null, "bloomFilterHelper不能为空");
        int[] offset = bloomFilterHelper.murmurHashOffset(value);
        //循环遍历得到的所有值,判断是否都被标记
        for (int i : offset) {
            System.out.println("key : " + key + " " + "value : " + i);
            if (!redisTemplate.opsForValue().getBit(key, i)) {
                return false;
            }
        }

        return true;
    }

}

测试类

@RestController
public class BloomFilterController {
    @Autowired
    RedisBloomFilter redisBloomFilter;

    @Autowired
    private BloomFilterHelper bloomFilterHelper;


    @RequestMapping("/add")
    public String addBloomFilter(@RequestParam("orderNum") String orderNum) {
        try {
            redisBloomFilter.addByBloomFilter(bloomFilterHelper, "bloom", orderNum);
        } catch (Exception e) {
            e.printStackTrace();
            return "添加失败";
        }
        return "添加成功";
    }


    @RequestMapping("/check")
    public boolean checkBloomFilter(@RequestParam("orderNum") String orderNum) {

        boolean result = redisBloomFilter.includeByBloomFilter(bloomFilterHelper, "bloom", orderNum);

        return result;
    }
}

打印出来的这些就是“sb”产生的Hash,我们逻辑用其标记redis相应的位置。
在这里插入图片描述

效果图
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

4、使用布隆过滤器BloomFilter解决Redis的缓存穿透问题(方法二集合Lua脚本)

这个我个人比较喜欢,前提是redis4.0以上版本

代码块

@RestController
public class RedisController {
    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    @RequestMapping("/lua/{id}")
    public String sendLua(@PathVariable String id) {
        //添加key值
        String script = "return redis.call('bf.add',KEYS[1],ARGV[1])";
        DefaultRedisScript<Boolean> redisScript = new DefaultRedisScript<>(script, Boolean.class);
        Boolean result1 = redisTemplate.execute(redisScript, Collections.singletonList("my_bloom_one"), String.valueOf("user" + id));
        System.out.println(result1);

        //判断是否存在
        String scriptEx = "return redis.call('bf.exists',KEYS[1],ARGV[1])";
        DefaultRedisScript<Boolean> redisScript1 = new DefaultRedisScript<>(scriptEx, Boolean.class);
        Boolean result2 = redisTemplate.execute(redisScript1, Collections.singletonList("my_bloom_one"), String.valueOf("user" + id));
        System.out.println(result2);

        return "添加是否成功"+result1+"====================="+"查询是否存在"+result2;
    }

}

在这里插入图片描述
再次创建时
在这里插入图片描述
redis程序中已成功创建
在这里插入图片描述

七、其他知识

设置过期时间(第三个参数表示单位为秒)

stringRedisTemplate.expire("baike",10 , TimeUnit.SECONDS);

添加单个元素(redis命令)

BF.ADD newFilter foo

添加 并检查多个元素

//添加已存在的元素返回0
BF.MADD myFilter foo bar baz

检查 过滤器中是否存在该元素

BF.EXISTS newFilter foo

批量检查 过滤器中是否存在该元素

BF.MEXISTS newFilter foo bar bbb

设置过滤器的错误率和储存量

//key  :需要设置的键,必须是不存在的键
//error_rate:允许的错误率 0.0001等  默认值:0.01
//size:保存的数组大小,尽可能设大一些,防止不够用。默认值:100
BF.RESERVE  <key> <error_rate> <size>
  • 1
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

打赏作者

和烨

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

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

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

打赏作者

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

抵扣说明:

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

余额充值