浅谈布隆过滤器Bloom Filter

先从一道面试题开始：

给A,B两个文件，各存放50亿条URL，每条URL占用64字节，内存限制是4G，让你找出A,B文件共同的URL。

这个问题的本质在于判断一个元素是否在一个集合中。哈希表以O(1)的时间复杂度来查询元素，但付出了空间的代价。在这个大数据问题中，就算哈希表有100%的空间利用率，也至少需要50亿*64Byte的空间，4G肯定是远远不够的。

当然我们可能想到使用位图，每个URL取整数哈希值，置于位图相应的位置上。4G大概有320亿个bit，看上去是可行的。但位图适合对海量的、取值分布很均匀的集合去重。位图的空间复杂度是随集合内最大元素增大而线性增大的。要设计冲突率很低的哈希函数，势必要增加哈希值的取值范围，假如哈希值最大取到了2⁶⁴，位图大概需要23亿G的空间。4G的位图最大值是320亿左右，为50亿条URL设计冲突率很低、最大值为320亿的哈希函数比较困难。

题目的一个解决思路是将文件切割成可以放入4G空间的小文件，重点在于A与B两个文件切割后的小文件要一一对应。

分别切割A与B文件，根据hash(URL) % k值将URL划分到k个不同的文件中，如A1，A2，...，Ak和B1，B2，...，Bk，同时可以保存hash值避免重复运算。这样Bn小文件与A文件共同的URL肯定会分到对应的An小文件中。读取An到一个哈希表中，再遍历Bn，判断是否有重复的URL。

另一个解决思路就是使用Bloom Filter布隆过滤器了。

Bloom Filter简介

布隆过滤器(Bloom-Filter)是1970年由Bloom提出的。它可以用于检索一个元素是否在一个集合中。

布隆过滤器其实是位图的一种扩展，不同的是要使用多个哈希函数。它包括一个很长的二进制向量(位图)和一系列随机映射函数。

首先建立一个m位的位图，然后对于每一个加入的元素，使用k个哈希函数求k个哈希值映射到位图的k个位置，然后将这k个位置的bit全设置为1。下图是k=3的布隆过滤器：

检索时，我们只要检索这些k个位是不是都是1就可以了：如果这些位有任何一个0，则被检元素一定不在；如果都是1，则被检元素很可能在。

可以看出布隆过滤器在时间和空间上的效率比较高，但也有缺点：

存在误判。布隆过滤器可以100%确定一个元素不在集合之中，但不能100%确定一个元素在集合之中。当k个位都为1时，也有可能是其它的元素将这些bit置为1的。
删除困难。一个放入容器的元素映射到位图的k个位置上是1，删除的时候不能简单的直接全部置为0，可能会影响其他元素的判断。

Bloom Filter实现

要实现一个布隆过滤器，我们需要预估要存储的数据量为n，期望的误判率为P，然后计算位图的大小m，哈希函数的个数k，并选择哈希函数。

求位图大小m公式：

哈希函数数目k公式：

Python中已经有实现布隆过滤器的包：pybloom

安装

pip install pybloom

简单的看一下实现：

class BloomFilter(object):
    FILE_FMT = b'<dQQQQ'

    def __init__(self, capacity, error_rate=0.001):
        """Implements a space-efficient probabilistic data structure
        capacity
            this BloomFilter must be able to store at least *capacity* elements
            while maintaining no more than *error_rate* chance of false
            positives
        error_rate
            the error_rate of the filter returning false positives. This
            determines the filters capacity. Inserting more than capacity
            elements greatly increases the chance of false positives.
        >>> b = BloomFilter(capacity=100000, error_rate=0.001)
        >>> b.add("test")
        False
        >>> "test" in b
        True
        """
        if not (0 < error_rate < 1):
            raise ValueError("Error_Rate must be between 0 and 1.")
        if not capacity > 0:
            raise ValueError("Capacity must be > 0")
        # given M = num_bits, k = num_slices, P = error_rate, n = capacity
        #       k = log2(1/P)
        # solving for m = bits_per_slice
        # n ~= M * ((ln(2) ** 2) / abs(ln(P)))
        # n ~= (k * m) * ((ln(2) ** 2) / abs(ln(P)))
        # m ~= n * abs(ln(P)) / (k * (ln(2) ** 2))
        num_slices = int(math.ceil(math.log(1.0 / error_rate, 2)))
        bits_per_slice = int(math.ceil(
            (capacity * abs(math.log(error_rate))) /
            (num_slices * (math.log(2) ** 2))))
        self._setup(error_rate, num_slices, bits_per_slice, capacity, 0)
        self.bitarray = bitarray.bitarray(self.num_bits, endian='little')
        self.bitarray.setall(False)

    def _setup(self, error_rate, num_slices, bits_per_slice, capacity, count):
        self.error_rate = error_rate
        self.num_slices = num_slices
        self.bits_per_slice = bits_per_slice
        self.capacity = capacity
        self.num_bits = num_slices * bits_per_slice
        self.count = count
        self.make_hashes = make_hashfuncs(self.num_slices, self.bits_per_slice)

    def __contains__(self, key):
        """Tests a key's membership in this bloom filter.
        >>> b = BloomFilter(capacity=100)
        >>> b.add("hello")
        False
        >>> "hello" in b
        True
        """
        bits_per_slice = self.bits_per_slice
        bitarray = self.bitarray
        hashes = self.make_hashes(key)
        offset = 0
        for k in hashes:
            if not bitarray[offset + k]:
                return False
            offset += bits_per_slice
        return True

计算公式基本一致。

算法将位图分成了k段(代码中的num_slices，也就是哈希函数的数量k)，每段长度为代码中的bits_per_slice，每个哈希函数只负责将对应的段中的bit置为1：

        for k in hashes:
            if not skip_check and found_all_bits and not bitarray[offset + k]:
                found_all_bits = False
            self.bitarray[offset + k] = True
            offset += bits_per_slice

当期望误判率为0.001时，m与n的比率大概是14：

>>> import math
>>> abs(math.log(0.001))/(math.log(2)**2)
14.37758756605116

当期望误判率为0.05时，m与n的比率大概是6：

>>> import math
>>> abs(math.log(0.05))/(math.log(2)**2)
6.235224229572683

上述题目中，m最大为320亿，n为50亿，误判率大概为0.04，在可以接受的范围：

>>> math.e**-((320/50.0)*(math.log(2)**2))
0.04619428041606246

应用

布隆过滤器一般用于在大数据量的集合中判定某元素是否存在：

1. 缓存穿透：

缓存穿透，是指查询一个数据库中不一定存在的数据。正常情况下，查询先进行缓存查询，如果key不存在或者key已经过期，再对数据库进行查询，并将查询到的对象放进缓存。如果每次都查询一个数据库中不存在的key，由于缓存中没有数据，每次都会去查询数据库，很可能会对数据库造成影响。

缓存穿透的一种解决办法是为不存在的key缓存一个空值，直接在缓存层返回。这样做的弊端就是缓存太多空值占用了太多额外的空间，这点可以通过给缓存层空值设立一个较短的过期时间来解决。

另一种解决办法就是使用布隆过滤器，查询一个key时，先使用布隆过滤器进行过滤，如果判断请求查询key值存在，则继续查询数据库；如果判断请求查询不存在，直接丢弃。

2. 爬虫：

在网络爬虫中，用于URL去重策略。

3. 垃圾邮件地址过滤

由于垃圾邮件发送者可以不停地注册新地址，垃圾邮件的Email地址是一个巨量的集合。使用哈希表存贮几十亿个邮件地址可能需要上百GB的内存，而布隆过滤器只需要哈希表1/8到1/4的大小就能解决问题。布隆过滤器决不会漏掉任何一个在黑名单中的可疑地址。至于误判问题，常见的补救办法是在建立一个小的白名单，存储那些可能被误判的清白邮件地址。

4. Google的BigTable

Google的BigTable也使用了布隆过滤器，以减少不存在的行或列在磁盘上的I/O。

5. Summary Cache

Summary Cache是一种用于代理服务器Proxy之间共享Cache的协议。可以使用布隆过滤器构建Summary Cache，每一个Cache的网页由URL唯一标识，因此Proxy的Cache内容可以表示为一个URL列表。进而我们可以将URL列表这个集合用布隆过滤器表示。