java实现布隆过滤器(手写和Guava库提供的)

目录

前言

布隆过滤器的原理

 插入​编辑

查询

删除

 布隆过滤器优缺点

优点:

缺点:

代码实现

方式一: Google Guava 提供的 BloomFilter 类来实现布隆过滤器

到底经过几次哈希计算

解决缓存穿透 

方式二:手写


前言

        在学习Reids时,关于缓存的三大问题:缓存雪崩、缓存穿透、缓存击穿,其中缓存穿透最好的解决办法就是依靠布隆过滤器,什么是布隆过滤器呢?
布隆过滤器(Bloom Filter)是1970年由布隆提出的。它实际上是一个很长的二进制向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都比一般的算法要好的多,缺点是有一定的误识别率和删除困难。——百度百科


布隆过滤器的原理


java实现布隆过滤器(手写和Guava库提供的)_第1张图片
     布隆过滤器本质上是一个很长的二进制数组,主要用来判断一个数据存不存在数组里,如果存在就用1表示,不存在用0表示,如何表示呢?看下面这张图

 插入java实现布隆过滤器(手写和Guava库提供的)_第2张图片

          比如我们把java这行字符存入到布隆过滤器中,首先进过3次哈希函数,分别得到3个哈希值,然后将哈希值根据下标映射到数组中,将对应的0改成1,那么1、3、5这三个位置就存储了java字符。这就是布隆过滤器的插入原理

问题来了:为什么要经历三次哈希计算呢?

其实不一定就是三次哈希计算,这里我只是举例子而已,到底要进行多少次哈希计算。莫急,待会结合实际情况和代码讲解

查询

 讲完插入,再看查询,其实查询和插入原理差不多,当我们查询(java)字符存不存在布隆过滤器中,首先依然进行哈希函数,计算出来的哈希值对应的数组下标,如果对应的1、3、5数组中都是1,那么表示java存在,要是有任意一个位置不为1,那么(java)字符就不存在。

这就是布隆过滤器的主要优势,那么他的缺点之一的就是删除困难,请看详细讲解

删除

java实现布隆过滤器(手写和Guava库提供的)_第3张图片

             插入java字符时,经过一系列的哈希计算,将下标为1的位置用来储存它,此时jvm字符也经过一系列哈希计算,也得到下标为1的位置来存储它,那么这个1即表示java字符存在又表示jvm字符存在,若要进行删除操作,很难确认你删除的是java还是jvm或许两者同时被删除,所以布隆过滤器不做删除处理

 布隆过滤器优缺点

优点:

1.它是由二进制数组组成,所占空间小

2.基于数组的特性,它的查询和插入是非常快的,它只需要根据哈希计算出来的值找相应的角标就行,时间复杂度是O(m);m=哈希计算的个数,比如存入java字符,进行一个哈希计算就是O(1),进行三个哈希计算就是O(3)。

缺点:

1.不能进行删除操作;

2.存在误判,因为不同的数据计算出来的哈希值可能相同,比如上方的java字符存在于布隆过滤器中,jvm字符不存在,但是他俩的哈希值相同,所以查询jvm时会发生误判。

这个误判是一定存在的,不能避免,但是能减少误判的概率。上代码:

代码实现

方式一: Google Guava 提供的 BloomFilter 类来实现布隆过滤器

导入依赖:


    com.google.guava
    guava
    30.1-jre

 创建 BloomFilter 对象并添加元素

public class BloomFilterCase {

  /**
   * 预计要插入多少数据
   */
  private static int size = 1000000;

  /**
   * 期望的误判率
   */
  private static double fpp = 0.01;

  /**
   * 布隆过滤器
   */
  private static BloomFilter bloomFilter = BloomFilter.create(Funnels.integerFunnel(), size, fpp);


  public static void main(String[] args) {
    // 插入10万样本数据
    for (int i = 0; i < size; i++) {
      bloomFilter.put(i);
    }

    // 用另外十万测试数据,测试误判率
    int count = 0;
    for (int i = size; i < size + 100000; i++) {
      if (bloomFilter.mightContain(i)) {
        count++;
        System.out.println(i + "误判了");
      }
    }
    System.out.println("总共的误判数:" + count);
  }
}

 private static BloomFilter bloomFilter = BloomFilter.create(Funnels.integerFunnel(), size, fpp);

三个参数:第一个是默认的;存入数据的大小;误判率

 测试一下设置的误判率是否准确

 /**
     * 期望的误判率
     */
    private static double fpp = 0.01;

java实现布隆过滤器(手写和Guava库提供的)_第4张图片

 这里误判了947个约等于1000除以10万=1%,所以说这个设置的误判率是正确的,可以多设几个值验证一下java实现布隆过滤器(手写和Guava库提供的)_第5张图片

 java实现布隆过滤器(手写和Guava库提供的)_第6张图片

可以看到误判率设定的越小,出现误判的概率越小,那是不是把误判率设置的非常非常小就更好呢?这里没办法展示,大家可以自行实践一下,当误判率设定的太小,结果输出延迟会很大,不能实时展示结果,误判率太小,计算量时间长,性能就非常差!

到底经过几次哈希计算

fpp=0.03

java实现布隆过滤器(手写和Guava库提供的)_第7张图片

 fpp=0.01java实现布隆过滤器(手写和Guava库提供的)_第8张图片

 这两张图中

fpp是我们设置的误判率;

numBits是指表示存一百万个int类型数字,需要的位数为7298440,700多万位。理论上存一百万个数,一个int是4字节32位,需要481000000=3200万位。如果使用HashMap去存,按HashMap50%的存储效率,需要6400万位。可以看出BloomFilter的存储空间很小,只有HashMap的1/10左右

numHashFunctions表示需要几个哈希函数去计算数据的哈希值

所以,当fpp越小,所需要的存储空间越大,需要的哈希函数个数越多

解决缓存穿透 

public static void main(String[] args) {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://120.48.17.2");
        config.useSingleServer().setPassword("123456");
        //构造Redisson
        RedissonClient redisson = Redisson.create(config);

        RBloomFilter bloomFilter = redisson.getBloomFilter("随便起个名");
        //初始化布隆过滤器:预计元素为100000000L,误差率为3%
        bloomFilter.tryInit(100000000L,0.03);
        //将号码10086插入到布隆过滤器中
        bloomFilter.add("10086");

        //判断下面号码是否在布隆过滤器中
        //输出false
        System.out.println(bloomFilter.contains("123456"));
        //输出true
        System.out.println(bloomFilter.contains("10086"));
    }

方式二:手写

package Bloomfilter;

import java.io.*;
import java.util.BitSet;
import java.util.Random;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Created by Intellij IDEA.
 * User:   LYX
 * Date:  2023/6/24
 */
public class BloomFilter {
        /**
         * 位数组,用于存储布隆过滤器的状态
         */
        private BitSet bitSet;
        /**
         * 位数组的长度
         */
        private int bitSetSize;
        /**
         * 预期元素数量
         */
        private int expectedNumberOfElements;
        /**
         * 哈希函数数量
         */
        private int numberOfHashFunctions;
        /**
         *  用于生成哈希种子的伪随机数生成器
         */
        private Random random = new Random();

        public BloomFilter(int bitSetSize, int expectedNumberOfElements) {
                this.bitSetSize = bitSetSize;
                this.expectedNumberOfElements = expectedNumberOfElements;

                // 根据公式计算哈希函数数量
                this.numberOfHashFunctions = (int) Math.round((bitSetSize / expectedNumberOfElements) * Math.log(2.0));

                // 创建位数组并初始化所有位为0
                this.bitSet = new BitSet(bitSetSize);
                }

        public void add(Object element) {
                // 对元素进行多次哈希,并将对应的位设置为1
                for (int i = 0; i < numberOfHashFunctions; i++) {
                long hash = computeHash(element.toString(), i);
                int index = getIndex(hash);
                bitSet.set(index, true);
                }
                }

        public boolean contains(Object element) {
                // 对元素进行多次哈希,并检查所有哈希值所对应的位是否都被设置为1
                for (int i = 0; i < numberOfHashFunctions; i++) {
                long hash = computeHash(element.toString(), i);
                int index = getIndex(hash);

                if (!bitSet.get(index)) {
                return false;
                }
                }

                return true;
                }

        private int getIndex(long hash) {
                // 将哈希值映射到位数组的下标(需要确保下标非负)
                return Math.abs((int) (hash % bitSetSize));
                }

        private long computeHash(String element, int seed) {
                // 使用伪随机数生成器生成不同的哈希种子
                random.setSeed(seed);

                // 将元素转换为字节数组,并计算其哈希值
                byte[] data = element.getBytes();
                long hash = 0x7f52bed27117b5efL;

                for (byte b : data) {
                hash ^= random.nextInt();
                hash *= 0xcbf29ce484222325L;
                hash ^= b;
                }

                return hash;
                }
}

测试


/**
 * Created by Intellij IDEA.
 * User:   LYX
 * Date:  2023/6/25
 */
public class BloomfilterTest {
    public static void main(String[] args) {


        List strings = Arrays.asList("JAVA", "JVM", "Redis", "MySQL", "GG");
        BloomFilter filter = new BloomFilter(1000, 5);

        // 将所有字符串添加到布隆过滤器中
        for (String s : strings) {
            filter.add(s);
        }

        String[] queries = {"GG", "MySQL", "JVM", "java"};
        for (String query : queries) {
            System.out.println("是否包含:" + query + "-" + filter.contains(query));
        }
    }
}

运行结果java实现布隆过滤器(手写和Guava库提供的)_第9张图片

 


你可能感兴趣的:(Redis,java,开发语言,redis)