Redis极致性能存储 - BloomFilter

一、布隆过滤器BloomFilter

1.是什么

布隆过滤器（英语：Bloom Filter）是 1970 年由布隆提出的。

它实际上是一个很长的二进制数组+一系列随机hash算法映射函数，主要用于判断一个元素是否在集合中。

通常我们会遇到很多要判断一个元素是否在某个集合中的业务场景，一般想到的是将集合中所有元素保存起来，然后通过比较确定。

链表、树、散列表（又叫哈希表，Hash table）等等数据结构都是这种思路。

但是随着集合中元素的增加，需要的存储空间也会呈现线性增长，最终达到瓶颈。同时检索速度也越来越慢，上述三种结构的检索时间复杂度分别为O(n),O(logn),O(1)。这个时候，就有了布隆过滤器（Bloom Filter）

由一个初值都为零的bit数组和多个哈希函数构成,用来快速判断某个数据是否存在

本质就是判断具体数据存不存在一个超大的集合中,布隆过滤器是一种类似set的数据结构，只是统计结果不太准确

2.特点

高效地插入和查询，占用空间少，返回的结果是不确定性的.

一个元素如果判断结果为存在的时候元素不一定存在；但是判断结果为不存在的时候则一定不存在
布隆过滤器可以添加元素，但是不能删除元素；因为删掉元素会导致误判率增加。
误判只会发生在过滤器没有添加过的元素；对于添加过的元素不会发生误判。已经加进来的不会误判。(注意)
- 由于外面某各元素算出的hash值，刚好跟里面已有的hash值一样（hash冲突）

一个超大的集合中，判断某个元素是否存在
- 有，是极大可能有
- 无，是一定无

可以保证的是，如果布隆过滤器判断一个元素不在一个集合中，那这个元素一定不会在集合中

3.布隆过滤器的使用场景

1) 布隆过滤器的使用场景

解决缓存穿透的问题
- 一般情况下，先查询缓存redis是否有该条数据，缓存中没有时，再查询数据库。
  
  当数据库也不存在该条数据时，每次查询都要访问数据库，这就是缓存穿透。
  
  缓存透带来的问题是，当有大量请求查询数据库不存在的数据时，就会给数据库带来压力，甚至会拖垮数据库。
使用布隆过滤器解决缓存穿透的问题
- 把已存在数据的key存在布隆过滤器中，相当于redis前面挡着一个布隆过滤器。
当有新的请求时，先到布隆过滤器中查询是否存在：

如果布隆过滤器中不存在该条数据则直接返回；

如果布隆过滤器中已存在，才去查询缓存redis，如果redis里没查询到则穿透到Mysql数据库

2) 布隆过滤器原理

Java中的hash

哈希函数的概念是：将任意大小的输入数据转换成特定大小的输出数据的函数，转换后的数据称为哈希值或哈希编码，散列值
- 如果两个散列值是不相同的（根据同一函数）那么这两个散列值的原始输入也是不相同的。
- 这个特性是散列函数具有确定性的结果，具有这种性质的散列函数称为单向散列函数。
- 散列函数的输入和输出不是唯一对应关系的，如果两个散列值相同，两个输入值很可能是相同的，但也可能不同，
  
  这种情况称为“散列碰撞（collision）”。
- 用 hash表存储大数据量时，空间效率还是很低，当只有一个 hash 函数时，还很容易发生哈希碰撞。
由一个初值都为零的bit数组和多个哈希函数构成,用来快速判断某个数据是否存在；
- 吸取java的经验一个hash函数容易产生碰撞，那么把规则多弄几个，尽量的减少它发生hash碰撞的概率，这样判断的精准度就可以提高；

hash冲突100%会存在，无法规避，所以会有误判率
多个hash尽量的减少hash碰撞的概率，那么就增加了统计的准确度

3) 布隆过滤器实现原理和数据结构

布隆过滤器(Bloom Filter) 是一种专门用来解决去重问题的高级数据结构。
实质就是一个大型位数组和几个不同的无偏hash函数(无偏表示分布均匀)。由一个初值都为零的bit数组和多个个哈希函数构成，用来快速判断某个数据是否存在。但是跟 HyperLogLog 一样，它也一样有那么一点点不精确，也存在一定的误判概率
添加key时
- 使用多个hash函数对key进行hash运算得到一个整数索引值，对位数组长度进行取模运算得到一个位置，
  
  每个hash函数都会得到一个不同的位置，将这几个位置都置1就完成了add操作。
- 当有变量被加入集合时，通过N个映射函数将这个变量映射成位图中的N个点，
  
  把它们置为 1（假定有两个变量都通过 3 个映射函数）。
查询key时
- 只要有其中一位是零就表示这个key不存在，但如果都是1，则不一定存在对应的key。(hash冲突)
- 查询某个变量的时候我们只要看看这些点是不是都是 1，就可以大概率知道集合中有没有它了
- 如果这些点，有任何一个为零则被查询变量一定不在，
  
  如果都是 1，则被查询变量很可能存在。
为什么说是可能存在，而不是一定存在呢？那是因为映射函数本身就是散列函数，散列函数是会有碰撞。(hash冲突)
- 正是基于布隆过滤器的快速检测特性，我们可以在把数据写入数据库时，使用布隆过滤器做个标记。当缓存缺失后，应用查询数据库时，可以通过查询布隆过滤器快速判断数据是否存在。如果不存在，就不用再去数据库中查询了。这样一来，即使发生缓存穿透了，大量请求只会查询Redis和布降过滤器，而不会积压到数据库，也就不会影响数据库的正常运行。布隆过滤器可以使用Redis实现，本身就能承担较大的并发访问压力。

初始化/添加/查询过程
- 初始化
  - 布隆过滤器本质上是由长度为 m 的位向量或位列表（仅包含 0 或 1 位值的列表）组成，最初所有的值均设置为 0
- 添加
  - 当我们向布隆过滤器中添加数据时，为了尽量地址不冲突，会使用多个 hash 函数对 key 进行运算，算得一个下标索引值，然后对位数组长度进行取模运算得到一个位置，每个 hash 函数都会算得一个不同的位置。再把位数组的这几个位置都置为 1 就完成了 add 操作。
  例如，添加一个字符串wmyskxz
- 判断是否存在
  - 向布隆过滤器查询某个key是否存在时，先把这个 key 通过相同的多个 hash 函数进行运算，查看对应的位置是否都为 1，
    
    只要有一个位为 0，那么说明布隆过滤器中这个 key 不存在；
    
    如果这几个位置全都是 1，那么说明极有可能存在；
    
    因为这些位置的 1 可能是因为其他的 key 存在导致的，也就是前面说过的hash冲突。。。。。
  就比如在 add 了字符串wmyskxz数据之后，很明显下面1/3/5 这几个位置的 1 是因为第一次添加的 wmyskxz 而导致的；
  
  此时再查询一个没添加过的不存在的字符串inexistent-key，它有可能计算后坑位也是1/3/5 ，这就是误判了......
布隆过滤器误判率，为什么不要删除
- 布隆过滤器的误判是指多个输入经过哈希之后在相同的bit位置1了，这样就无法判断究竟是哪个输入产生的，
  - 因此误判的根源在于相同的 bit 位被多次映射且置 1。
  - 这种情况也造成了布隆过滤器的删除问题，因为布隆过滤器的每一个 bit 并不是独占的，很有可能多个元素共享了某一位。
  - 如果我们直接删除这一位的话，会影响其他的元素
  - 特性
    - 一个元素判断结果为没有时则一定没有，
    - 如果判断结果为存在的时候元素不一定存在。
    - 布隆过滤器可以添加元素，但是不能删除元素。因为删掉元素会导致误判率增加。
总结
- 判断是否存在
  
  有，是很可能有 / 无，是肯定无
  
  可以保证的是，如果布隆过滤器判断一个元素不在一个集合中，那这个元素一定不会在集合中
  
  使用时最好不要让实际元素数量远大于初始化数量
- 当实际元素数量超过初始化数量时，应该对布隆过滤器进行重建，重新分配一个 size 更大的过滤器，再将所有的历史元素批量 add 进行
- 布隆过滤器优缺点
  - 优点
    - 高效地插入和查询，占用空间少
  - 缺点

4 ) 布隆过滤器代码分析

Guava 误判率演示+源码分析

public class GuavaBloomfilterDemo
{
    public static final int _1W = 10000;
    //布隆过滤器里预计要插入多少数据
    public static int size = 100 * _1W;
    //误判率,它越小误判的个数也就越少(是不是可以设置的无限小，没有误判岂不更好)
    public static double fpp = 0.03;
 
    /**
     * demo
     */
    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));
 
    }
 
    /**
     * 误判率演示+源码分析
     */
    public void bloomFilter2()
    {
        // 构建布隆过滤器
        BloomFilter<Integer> bloomFilter = BloomFilter.create(Funnels.integerFunnel(),size);
 
        //1 先往布隆过滤器里面插入100万的样本数据
        for (int i = 0; i < size; i++) {
            bloomFilter.put(i);
        }
        List<Integer> listSample = new ArrayList<>(size);
        //2 这100万的样本数据，是否都在布隆过滤器里面存在？
        for (int i = 0; i < size; i++)
        {
            if (bloomFilter.mightContain(i)) {
                listSample.add(i);
                continue;
            }
        }
        //误判只会发生在过滤器没有添加过的元素，对于添加过的元素不会发生误判
        System.out.println("存在的数量：" + listSample.size());
 
        //3 故意取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());
    }
 
    public static void main(String[] args)
    {
        new GuavaBloomfilterDemo().bloomFilter2();
    }
}

1.取样本100W数据，查不在100W范围内的其它10W数据是否存在

现在总共有10万数据是不存在的，误判了3303次，

原始样本：100W

不存在的数据：101W --- 110W

计算误判率：

google guava自带的Google版的布隆过滤器，

它是100W的数据，给的是7298440个bit，且有5个hash函数，来达到0.03的误判率，保证布隆过滤器对于大数据元素的存在判断的靠谱性

100W中多出来的10W是否存在，这100W中；误判为 0.03

0.03 --> 7298440 --> 5个hash函数

0.01 --> 9585058 --> 7个hash函数

误判率越小，要求占用的内存bits，也就越高；误判率越好，程序性能效率下降；精度提高了，时间耗费就要变大。

不是设置的越小越好，需要兼顾误判率和程序执行的效率

RedissonBloom

public class RedissonBloomFilterDemo
{
    public static final int _1W = 10000;
 
    //布隆过滤器里预计要插入多少数据
    public static int size = 100 * _1W;
    //误判率,它越小误判的个数也就越少
    public static double fpp = 0.03;
 
    static RedissonClient redissonClient = null;//jedis
    static RBloomFilter rBloomFilter = null;//redis版内置的布隆过滤器
 
    @Resource
    RedisTemplate redisTemplate;
 
 
    static
    {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1: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");
 
        //redisTemplate.opsForValue().set("10086",chinamobile10086);
 
        // 2测试  布隆过滤器有+redis无
        //rBloomFilter.add("10087");
 
        //3 测试 ，布隆过滤器无+redis无
 
    }
 
    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 "come from redis: "+result;
            }else{
                result = getPhoneListByMySQL(IDNumber);
                if (result == null) {
                    return null;
                }
                // 重新将数据更新回redis
                redissonClient.getBucket(IDNumber, new StringCodec()).set(result);
            }
            return "come from mysql: "+result;
        }
        return result;
    }
 
    private static String getPhoneListByMySQL(String IDNumber)
    {
        return "chinamobile"+IDNumber;
    }
 
 
 
    public static void main(String[] args)
    {
        String phoneListById = getPhoneListById("10086");
        //String phoneListById = getPhoneListById("10087"); //请测试执行2次
        //String phoneListById = getPhoneListById("10088");
        System.out.println("------查询出来的结果： "+phoneListById);
 
        //暂停几秒钟线程
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
        redissonClient.shutdown();
    }

redis中对应BlomFilter

posted @ 2022-06-18 16:25 逃亡中_ 阅读(1091) 评论(0) 收藏举报

刷新页面返回顶部

逃亡中_