bloom filter

布隆过滤器（Bloom Filter）是1970年由布隆提出的。它实际上是一个很长的二进制向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都远远超过一般的算法，缺点是有一定的误识别率和删除困难。本文着重于在实现Bloom Filter的时候会使用到的一些技巧。

    布隆过滤器的原理不难理解。相对于一个精简的HashMap的数据结构，存入数据的时候，不存入数据本身，只保存其Hash的值。可以用于判断该数据是否存在。其本质是用Hash对数据进行"有损压缩"的位图索引。
     如果想判断一个元素是不是在一个集合里，一般想到的是将所有元素保存起来，然后通过比较确定。链表，树等等数据结构都是这种思路. 但是随着集合中元素的增加，我们需要的存储空间越来越大，检索速度也越来越慢(O(n),O(logn))。

    这时候就可以利用哈希表这个数据结构（它可以通过一个Hash函数将一个元素映射成一个位阵列（Bit array）中的一个点）。这样一来，我们只要看看这个点是不是1就知道可以集合中有没有它了。这就是Bloom Filter的基本思想。

    但这时，哈希冲突会是一个问题：假设Hash函数是良好的，如果我们的位阵列长度为m个点，那么如果我们想将冲突率降低到例如 1%, 这个散列表就只能容纳m/100个元素。显然这就不叫空间效率了（Space-efficient）了。解决方法也简单，就是使用多个Hash，如果它们有一个说元素不在集合中，那肯定就不在。如果它们都说在，虽然也有一定可能性它们都在说谎，不过直觉上判断这种事情的概率是比较低的。这种多个Hash组成的数据结构就叫Bloom Filter。

    一个Bloom Filter是基于一个m位的位向量（b1,…bm），这些位向量的初始值为0。另外，还有一系列的hash函数（h1,…hk），这些hash函数的值域属于1~m。下图是一个bloom filter插入x,y,z并判断某个值w是否在该数据集的示意图：

    上图中，m=18，k=3；插入x是，三个hash函数分别得到蓝线对应的三个值，并将对应的位向量改为1，插入y，z时，类似的，分别将红线，紫线对应的位向量改为1。查找时，当查找x时，三个hash值对应的位向量都为1，因此判断x在此数据集中。y，z也是如此。但是查找w时，w有个hash值对应的位向量为0，因此可以判断不在此集合中。但是，假如w的最后那个hash值比上图中的大1，这是就会认为w在此集合中，而事实上，w可能不在此集合中，因此可能出现误报。显然的，插入数据越多，1的位数越多，误报的概率越大。

错误率

如果用来存放Hash值的槽位足够多，那么碰撞的概率就会比较小。但是所占用的空间就会比较大。所以当分配空间的时候，需要通过你能容忍的错误率和需要存放的Key的数量来指定。如果所需存储的Key数量是n,错误率是p，所需要的槽位是m。有计算槽位的公式 m = − n ln ⁡ p ( ln ⁡ 2 ) 2 .。也有计算概率的公式， p = 1 − e − ( m / n ln ⁡ 2 ) n / m ( m / n ln ⁡ 2 ) 这些公式当然不是我推导出来的，想来也不太难，就不赘述推导过程了。下面这张图可以很好的表示n和m取不同的值的时候，p的值。

根据这张图。我们可以计算出所需要的内存使用量。如果把错误率控制在1%以下的话。

保存key数占用空间1万64KB10万1MB100万16MB1000万256MB1亿<4GB

 

可见占用的空间在key的数量在百万级别还是很划算的，但到了上亿的级别就不那么划算了。

Bloom Filter的插入和查询都是常数级别的，所以最大的问题就是占用内存过大。而初次分配内存的时候，如果没有能够确认槽位的个数。如果分配过多会导致内存浪费，太少就会倒是错误率过高。下面提到的两个改进方案可以分别解决这两个问题。

折叠

折叠是指当你初始化一个Bloom Filter的时候，可以分配足够大的槽位，等到Key导入完毕后，可以对使用的槽位进行合并操作。具体方法是将槽位切成两半，一边完全叠加到另一边上。减少内存的使用量。检查key的代码要做稍许改变。例：

通过这个操作，可以使实际使用的内存量减半。多执行几次，能减少更多。

动态扩展

通过折叠操作，可以解决分配过大的问题，但是如果一开始分配过小，就需要扩展槽位才行。如何扩展呢？只要按原尺寸再建立一个Bloom Filter数组。原来的那个保存起来，不再写入。有新的写请求的时候，就将数据写入到新的那个Bloom Filter数组里面去。等到新的也写满了，就再建立一个，以此类推。查询的时候，就需要遍历每一个Bloom Filter数组才行。但因为查询一个Bloom Filter数组的速度很快，查询一组Bloom Filter数组也不会太影响性能。使用这种手段可以是Bloom Filter的大小可以轻易的扩展。但这样做有个的缺陷，就是错误率会随着数组的增加而上升，因为实际的数组长度并没有增加。

通过上面的两个方法，就可以解决BloomFilter的分配内存的问题。但无论哪种方法都有自己局限性，折叠每次只能减半，不是很精确。动态增加的方法会造成错误率增加。最好还是能预先估计到这个BloomFilter的容量。

附：这里有一个布隆过滤器的PHP扩展，http://bbs.phpchina.com/thread-254492-1-3.html。
另外，此算法也是各大互联网公司热衷的面试题之一。我没记错的话，这个应该是百度的某个笔试题。

假设有A,B两个文件，文件里面都是url地址，各有10亿条，如何找出AB两个文件里面都存在的Url。(内存装不下任何一个文件的十分之一）

吴军的《数学之美》也有讲解。

下面贴Java源码，已注释。

import java.util.BitSet;//传统的Bloom filter 不支持从集合中删除成员。//Counting Bloom filter由于采用了计数，因此支持remove操作。//基于BitSet来实现，性能上可能存在问题public class SimpleBloomFilter {    //DEFAULT_SIZE为2的25次方    private static final int DEFAULT_SIZE = 2 << 24;    /* 不同哈希函数的种子，一般应取质数,seeds数据共有7个值，则代表采用7种不同的HASH算法 */    private static final int[] seeds = new int[] { 5, 7, 11, 13, 31, 37, 61 };    //BitSet实际是由“二进制位”构成的一个Vector。假如希望高效率地保存大量“开－关”信息，就应使用BitSet.    //BitSet的最小长度是一个长整数（Long）的长度：64位    private BitSet bits = new BitSet(DEFAULT_SIZE);    /* 哈希函数对象 */    private SimpleHash[] func = new SimpleHash[seeds.length];    public static void main(String[] args) {       String value = "[e-mail]";       //定义一个filter，定义的时候会调用构造函数，即初始化七个hash函数对象所需要的信息。       SimpleBloomFilter filter = new SimpleBloomFilter();       //判断是否包含在里面。因为没有调用add方法，所以肯定是返回false       System.out.println(filter.contains(value));       filter.add(value);       System.out.println(filter.contains(value));    }    //构造函数    public SimpleBloomFilter() {       for (int i = 0; i < seeds.length; i++) {           //给出所有的hash值，共计seeds.length个hash值。共7位。           //通过调用SimpleHash.hash(),可以得到根据7种hash函数计算得出的hash值。           //传入DEFAULT_SIZE(最终字符串的长度），seeds[i](一个指定的质数)即可得到需要的那个hash值的位置。           func[i] = new SimpleHash(DEFAULT_SIZE, seeds[i]);       }    }    // 将字符串标记到bits中，即设置字符串的7个hash值函数为1    public void add(String value) {       for (SimpleHash f : func) {           bits.set(f.hash(value), true);       }    }    //判断字符串是否已经被bits标记    public boolean contains(String value) {       //确保传入的不是空值       if (value == null) {           return false;       }       boolean ret = true;       //计算7种hash算法下各自对应的hash值，并判断       for (SimpleHash f : func) {           //&&是boolen运算符，只要有一个为0，则为0。即需要所有的位都为1，才代表包含在里面。           //f.hash(value)返回hash对应的位数值           //bits.get函数返回bitset中对应position的值。即返回hash值是否为0或1。           ret = ret && bits.get(f.hash(value));       }       return ret;    }    /* 哈希函数类 */    public static class SimpleHash {       //cap为DEFAULT_SIZE的值，即用于结果的最大的字符串长度。       //seed为计算hash值的一个给定key，具体对应上面定义的seeds数组       private int cap;       private int seed;       public SimpleHash(int cap, int seed) {           this.cap = cap;           this.seed = seed;       }       //计算hash值的具体算法,hash函数，采用简单的加权和hash       public int hash(String value) {           //int的范围最大是2的31次方减1，或超过值则用负数来表示           int result = 0;           int len = value.length();           for (int i = 0; i < len; i++) {              //数字和字符串相加，字符串转换成为ASCII码              result = seed * result + value.charAt(i);              //System.out.println(result+"--"+seed+"*"+result+"+"+value.charAt(i));           }       //  System.out.println("result="+result+";"+((cap - 1) & result));       //  System.out.println(414356308*61+'h');  执行此运算结果为负数，为什么？           //&是java中的位逻辑运算，用于过滤负数（负数与进算转换成反码进行）。           return (cap - 1) & result;       }    }} 

结论:

测试m/nK（括号内为最优解）数据基数误判数误判率理论值用时（单位：秒）一次判定时间(单位：微秒)一次Hash时间(单位：微秒.估参考)1206(14)1000W30350.03035%0.0303%252.50.4172206(14)2000W58390.029%0.0303%512.550.42532014(14)1000W6050.00605%0.014%373.70.26542014(14)2000W12240.00612%0.014%844.20.352020(14)1000W9140.00914%不计算484.80.2462020(14)2000W18810.00941%不计算994.950.24757107（7）1000w5178540.786%0.819%414.10.59853（3）1000w9014119.014%9.2%313.11.033921(1)1000w391072639.107%39.3%292.92.91022(1)1000w396106539.61%40%303.03.01125(1)1000w643669664.37%不计算767.61.52

 

一次判断时间计算方式为：总时间/总次数

一次HASH所需时间计算方式为：一次判定时间/每次判断需要的hash数。

一次HASH所需时间，当执行hash次数越少，基数越小，误差越大。当一次判断所需的hash次数越大时，一次hash时间越精确。

结论：

m/n的比值越大越好，比较越大，误判率会越代，但同时会使用更多的空间成本。

         Hash次数增加带来的收益并不大。需要在条件允许的情况下，尽量的扩大m/n的值。