BloomFilter

最新推荐文章于 2024-09-27 12:50:24 发布

Leopard锋

最新推荐文章于 2024-09-27 12:50:24 发布

阅读量327

点赞数 1

分类专栏： java 文章标签： BloomFilter

java 专栏收录该内容

15 篇文章

订阅专栏

本文深入解析布隆过滤器的原理与应用，探讨其在海量数据检索中的优势及误判风险，涵盖网页黑名单、垃圾邮件过滤等典型场景，附带Guava库实现示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、布隆过滤器

布隆过滤器（Bloom Filter）是1970年由布隆提出的。它实际上是一个很长的二进制向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。

算法优势：

仅仅保留数据的指纹信息，空间效率极高（指纹信息：根据随意映射函数找到对应的二进制向量位置，并标记该位置）
查询效率极高，时间复杂度为：O（n）
信息安全性较高

算法不足：

存在一定的误判
数据删除困难

如果想判断一个元素是不是在一个集合里，一般想到的是将集合中所有元素保存起来，然后通过比较确定。链表、树、散列表（又叫哈希表，Hash table）等等数据结构都是这种思路。但是随着集合中元素的增加，我们需要的存储空间越来越大。同时检索速度也越来越慢，上述三种结构的检索时间复杂度分别为：O(n), O(log n), O(n/k)。

布隆过滤器的原理是，当一个元素被加入集合时，通过K个Hash函数将这个元素映射成一个位数组中的K个点，把它们置为1。检索时，我们只要看看这些点是不是都是1就（大约）知道集合中有没有它了：如果这些点有任何一个0，则被检元素一定不在；如果都是1，则被检元素很可能在。这就是布隆过滤器的基本思想。

二、为什么要用布隆过滤器？

通过介绍已经知晓布隆过滤器的作用是检索一个元素是否在集合中。可能有人认为这个功能非常简单，直接放在redis中或者数据库中查询就好了。又或者当数据量较小，内存又足够大时，使用hashMap或者hashSet等结构就好了。但是如果当这些数据量很大，数十亿甚至更多，内存装不下且数据库检索又极慢的情况，我们应该如何去处理？这个时候我们不妨考虑下布隆过滤器，因为它是一个空间效率占用极少和查询时间极快的算法，但是需要业务可以忍受一个判断失误率。

三、布隆过滤器应用场景

网页黑名单系统
垃圾邮件过滤系统
爬虫的网址判重系统
解决缓存穿透

对布隆过滤器算法比较感兴趣的朋友，可以自行搜索下，这里暂时不展示

四、布隆过滤器的简单实现

google已经将布隆过滤器封装进jar包，可直接引入依赖调用实现

		<dependency>
			<groupId>com.google.guava</groupId>
			<artifactId>guava</artifactId>
			<version>19.0</version>
		</dependency>

PS：guava包在19.0版本以上才封装有布隆过滤器的实现

testDemo code

	public void testDemo(){
		//初始化个数
		int initNumber = 200000;
		
		//初始化3个存储String类型的容器
		BloomFilter<String> bf = BloomFilter.create(Funnels.stringFunnel(Charsets.UTF_8), initNumber,0.01);
		Set<String> sets = new HashSet<String>(initNumber);
		List<String> lists = new ArrayList<String>(initNumber);
		
		//向三个容器存入随机字符串数据
		for (int i = 0; i < initNumber; i++) {
			String uuid = UUID.randomUUID().toString();
			bf.put(uuid);
			sets.add(uuid);
			lists.add(uuid);
		}
		
		int wrong = 0;//正确个数
		int right = 0;//错误个数
		
		int testNumber = 10000;
		for (int i = 0; i < testNumber; i++) {
			//按照一定比例的选择bf内肯定存在的值
			String test = i%100 == 0 ? lists.get(i/100) : UUID.randomUUID().toString();
			if(bf.mightContain(test)){
				if(sets.contains(test)){
					right++;
				}else{
					wrong++;
				}
			}
		}
		System.out.println("正确个数："+ right);
		System.out.println("错误个数："+ wrong);
		System.out.println("错误率    ："+ ((wrong*1.0)/(testNumber*1.0)));
		
	}

这是简单的调用实现，BloomFilter.create 有三个参数

Funnel：描述了如何把一个具体的对象类型分解为原生字段值，从而写入
expectedInsertions：插入一个确定的初始化数值
fpp：期望的错误率，默认0.03

进入源码查看创建过程

static <T> BloomFilter<T> create(
      Funnel<? super T> funnel, long expectedInsertions, double fpp, Strategy strategy) {
    checkNotNull(funnel);
    checkArgument(
        expectedInsertions >= 0, "Expected insertions (%s) must be >= 0", expectedInsertions);
    checkArgument(fpp > 0.0, "False positive probability (%s) must be > 0.0", fpp);
    checkArgument(fpp < 1.0, "False positive probability (%s) must be < 1.0", fpp);
    checkNotNull(strategy);

    if (expectedInsertions == 0) {
      expectedInsertions = 1;
    }
    /*
     * TODO(user): Put a warning in the javadoc about tiny fpp values,
     * since the resulting size is proportional to -log(p), but there is not
     * much of a point after all, e.g. optimalM(1000, 0.0000000000000001) = 76680
     * which is less than 10kb. Who cares!
     */
    //根据初始化数据大小和错误率，计算出可用数组长度
    long numBits = optimalNumOfBits(expectedInsertions, fpp);
    //根据初始化数据大小和数组长度，计算需要使用到的hash容器个数
    int numHashFunctions = optimalNumOfHashFunctions(expectedInsertions, numBits);
    try {
      return new BloomFilter<T>(new BitArray(numBits), numHashFunctions, funnel, strategy);
    } catch (IllegalArgumentException e) {
      throw new IllegalArgumentException("Could not create BloomFilter of " + numBits + " bits", e);
    }
  }

PS：计算数组长度和容器个数的所需数量，是开发者们测试得出来的较为可靠的值，数据展示在对应方法注释内有提供参考链接，这里就不展示。

如果失误率越低，所需的数组空间也就越大，采用空间作为代价，实际场景根据业务自行调整。

插入过程

    public <T> boolean put(
        T object, Funnel<? super T> funnel, int numHashFunctions, BitArray bits) {
      long bitSize = bits.bitSize();
      //这里使用hash算法进行hash运算
      byte[] bytes = Hashing.murmur3_128().hashObject(object, funnel).getBytesInternal();
      //获取字节数组的低8位进行运算
      long hash1 = lowerEight(bytes);
      //获取字节数组的高8位进行运算
      long hash2 = upperEight(bytes);

      boolean bitsChanged = false;
      long combinedHash = hash1;
      //遍历容器个数，更改对应的位置标识
      for (int i = 0; i < numHashFunctions; i++) {
        // Make the combined hash positive and indexable
        bitsChanged |= bits.set((combinedHash & Long.MAX_VALUE) % bitSize);
        combinedHash += hash2;
      }
      return bitsChanged;
    }

判断元素是否存在，原理同插入相似

    public <T> boolean mightContain(
        T object, Funnel<? super T> funnel, int numHashFunctions, BitArray bits) {
      long bitSize = bits.bitSize();
      byte[] bytes = Hashing.murmur3_128().hashObject(object, funnel).getBytesInternal();
      long hash1 = lowerEight(bytes);
      long hash2 = upperEight(bytes);

      long combinedHash = hash1;
      for (int i = 0; i < numHashFunctions; i++) {
        // Make the combined hash positive and indexable
        if (!bits.get((combinedHash & Long.MAX_VALUE) % bitSize)) {
          return false;
        }
        combinedHash += hash2;
      }
      return true;
    }

在实际业务中，可在实现类初始化时，将所需判断的所有数据查询导入布隆过滤器，在海量数据中，查询操作也要做对应的优化。