一、簡介
Bloom Filter（BF）是一種空間效率很高的隨機數據結構，它利用位數組很簡潔地表示一個集合，並能判斷一個元素是否屬於這個集合。它是一個判斷元素是否存在集合的快速的概率算法。Bloom Filter有可能會出現錯誤判斷，但不會漏掉判斷。因此，Bloom Filter不適合那些“零錯誤”的應用場合。而在能容忍低錯誤率的應用場合下，Bloom Filter比其他常見的算法（如hash，折半查找）極大節省了空間。它的優點是空間效率和查詢時間都遠遠超過一般的算法，缺點是有一定的誤識別率和刪除困難。
二、算法思想
Bloom-Filter算法的核心思想就是利用多個不同的Hash函數來解決“沖突”。
計算某元素x是否在一個集合中，首先能想到的方法就是將所有的已知元素保存起來構成一個集合R，然后用元素x跟這些R中的元素一一比較來判斷是否存在於集合R中；我們可以采用鏈表等數據結構來實現。但是，隨着集合R中元素的增加，其占用的內存將越來越大。試想，如果有幾千萬個不同網頁需要下載，所需的內存將足以占用掉整個進程的內存地址空間。即使用MD5，UUID這些方法將URL轉成固定的短小的字符串，內存占用也是相當巨大的。
於是，我們會想到用Hash table的數據結構，運用一個足夠好的Hash函數將一個URL映射到二進制位數組（位圖數組）中的某一位。如果該位已經被置為1，那么表示該URL已經存在。
但是Hash存在一個沖突（碰撞）的問題，用同一個Hash得到的兩個URL的值有可能相同。為了減少沖突，我們可以多引入幾個Hash，如果通過其中的一個Hash值我們得出某元素不在集合中，那么該元素肯定不在集合中。只有在所有的Hash函數告訴我們該元素在集合中時，才能確定該元素存在於集合中。這便是Bloom-Filter的基本思想。
三、過程
工具：一個位數組、K個獨立hash函數
1）位數組：
假設Bloom Filter使用一個m比特的數組來保存信息，初始狀態時，Bloom Filter是一個包含m位的位數組，每一位都置為0，即BF整個數組的元素都設置為0。
| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
2）添加元素，k個獨立hash函數
為了表達S={x1, x2,…,xn}這樣一個n個元素的集合，Bloom Filter使用k個相互獨立的哈希函數（Hash Function），它們分別將集合中的每個元素映射到{1,…,m}的范圍中。
當我們往Bloom Filter中增加任意一個元素x時候，我們使用k個哈希函數得到k個哈希值（可以對應數組下標），然后將數組中對應的比特位設置為1。即第i個哈希函數映射的位置hashi(x)就會被置為1（1≤i≤k）。
注意，如果一個位置多次被置為1，那么只有第一次會起作用，后面幾次將沒有任何效果。在下圖中，k=3，且有兩個哈希函數選中同一個位置（從左邊數第五位，即第二個“1“處）。
3）判斷元素是否存在集合
在判斷y是否屬於這個集合時，我們只需要對y使用k個哈希函數得到k個哈希值，如果所有hashi(y)的位置都是1（1≤i≤k），即k個位置都被設置為1了，那么我們就認為y是集合中的元素，否則就認為y不是集合中的元素。下圖中y1就不是集合中的元素（因為y1有一處指向了“0”位）。y2或者屬於這個集合，或者剛好是一個false positive。
很顯然這個判斷並不能保證查找的結果是100%正確的。
四、數學理論
參數：
m:bit數組的寬度（bit數）
n:加入其中的key的數量
k：使用的hash函數的個數
f:false positive的比率
則BF滿足下面的數學公式：
在給定m和n時，能夠使f最小化的k值為：
此時給出的f為：
根據上述的理論可以推出：
a、對於給定的f，則有：n = m ln(0.6185) / ln(f)
b、同時需要用k個hash函數來實現目標：k = - ln(f) / ln(2)
c、k必須取整，那么需要f = (1 – e-kn/m)k 求實際值
五、缺陷
1）Bloom Filter無法從Bloom Filter集合中刪除一個元素。因為該元素對應的位會牽動到其他的元素。所以一個簡單的改進就是 counting Bloom filter，用一個counter數組代替位數組，就可以支持刪除了。 此外，Bloom Filter的hash函數選擇會影響算法的效果。
2）還有一個比較重要的問題，如何根據輸入元素個數n，確定位數組m的大小及hash函數個數，即hash函數選擇會影響算法的效果。當hash函數個數k=(ln2)*(m/n)時錯誤率最小。在錯誤率不大於E的情況 下，m至少要等於n*lg(1/E) 才能表示任意n個元素的集合。但m還應該更大些，因為還要保證bit數組里至少一半為0，則m應 該>=nlg(1/E)*lge ，大概就是nlg(1/E)1.44倍(lg表示以2為底的對數)。
舉個例子我們假設錯誤率為0.01，則此時m應大概是n的13倍。這樣k大概是8個。（PS：這里m與n的單位不同，m是bit為單位，而n則是以元素個數為單位(准確的說是不同元素的個數)。通常單個元素的長度都是有很多bit的。所以使用bloom filter內存上通常都是節省的。 ）
一般BF可以與一些key-value的數據庫（如redis）一起使用，來加快查詢。由於BF所用的空間非常小，所有BF可以常駐內存。這樣子的話，對於大部分不存在的元素，我們只需要訪問內存中的BF就可以判斷出來了，只有一小部分，我們需要訪問在硬盤上的key-value數據庫。從而大大地提高了效率。
六、應用
1、垃圾郵件過濾
像網易、騰訊等公眾電子郵件（email）提供商，總是需要過濾來自發送垃圾郵件的人（spamer）的垃圾郵件。一個辦法就是記錄下那些發垃圾郵件的 email地址。由於那些發送者不停地在注冊新的地址，全世界少說也有幾十億個發送垃圾郵件的地址，將他們都存起來則需要大量的網絡服務器。如果用哈希表，每存儲一億個 email地址，就需要 1.6GB的內存（用哈希表實現的具體辦法是將每一個 email地址對應成一個八字節的信息指紋，然后將這些信息指紋存入哈希表，由於哈希表的存儲效率一般只有 50%，因此一個 email地址需要占用十六個字節。一億個地址大約要 1.6GB，即十六億字節的內存）。因此存貯幾十億個郵件地址可能需要上百GB的內存。而Bloom Filter只需要哈希表 1/8到 1/4 的大小就能解決同樣的問題。BloomFilter決不會漏掉任何一個在黑名單中的可疑地址。而至於誤判問題，常見的補救辦法是在建立一個小的白名單，存儲那些可能別誤判的郵件地址
2、網絡應用
1）P2P網絡中查找資源操作，可以對每條網絡通路保存Bloom Filter，當命中時，則選擇該通路訪問。
2）廣播消息時，可以檢測某個IP是否已發包。
3）檢測廣播消息包的環路，將Bloom Filter保存在包里，每個節點將自己添加入Bloom Filter。
4）信息隊列管理，使用Counter Bloom Filter管理信息流量。
3、Hbase底層
Hbase也使用了Bloom Filter，以減少不存在的行或列在磁盤上的查詢，大大提高了數據庫的查詢操作的性能。
七、java實現
package fuyunnet.com;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.List;
public class Bloomfilter {
private BitSet bitSet;
private int bitSetSize;
private int addedElements;
private int hashFunctionNumber;
/**
* 構造一個布隆過濾器，過濾器的容量為c * n 個bit.
* @param c 當前過濾器預先開辟的最大包含記錄,通常要比預計存入的記錄多一倍.
* @param n 當前過濾器預計所要包含的記錄.
* @param k 哈希函數的個數，等同每條記錄要占用的bit數.
*/
public Bloomfilter(int c, int n, int k) {
this.hashFunctionNumber = k;
this.bitSetSize = (int) Math.ceil(c * k);
this.addedElements = n;
this.bitSet = new BitSet(this.bitSetSize);
}
/**
* 通過文件初始化過濾器.
* @param file
*/
public void init(String file) {
BufferedReader reader = null;
try {
reader = new BufferedReader(new FileReader(file));
String line = reader.readLine();
while (line != null && line.length() > 0) {
this.put(line);
line = reader.readLine();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (reader != null) reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public void put(String str) {
int[] positions = createHashes(str.getBytes(), hashFunctionNumber);
for (int i = 0; i < positions.length; i++) {
int position = Math.abs(positions[i] % bitSetSize);
bitSet.set(position, true);
}
}
public boolean contains(String str) {
byte[] bytes = str.getBytes();
int[] positions = createHashes(bytes, hashFunctionNumber);
for (int i : positions) {
int position = Math.abs(i % bitSetSize);
if (!bitSet.get(position)) {
return false;
}
}
return true;
}
/**
* 得到當前過濾器的錯誤率.
* @return
*/
public double getFalsePositiveProbability() {
// (1 - e^(-k * n / m)) ^ k
return Math.pow((1 - Math.exp(-hashFunctionNumber * (double) addedElements / bitSetSize)),
hashFunctionNumber);
}
/**
* 將字符串的字節表示進行多哈希編碼.
* @param bytes 待添加進過濾器的字符串字節表示.
* @param hashNumber 要經過的哈希個數.
* @return 各個哈希的結果數組.
*/
public static int[] createHashes(byte[] bytes, int hashNumber) {
int[] result = new int[hashNumber];
int k = 0;
while (k < hashNumber) {
result[k] = HashFunctions.hash(bytes, k);
k++;
}
return result;
}
public static void main(String[] args) throws Exception {
Bloomfilter bloomfilter = new Bloomfilter(30000000, 10000000, 8);
System.out.println("Bloom Filter Initialize ... ");
bloomfilter.init("data/base.txt");
System.out.println("Bloom Filter Ready");
System.out.println("False Positive Probability : "
+ bloomfilter.getFalsePositiveProbability());
// 查找新數據
List<String> result = new ArrayList<String>();
long t1 = System.currentTimeMillis();
BufferedReader reader = new BufferedReader(new FileReader("data/input.txt"));
String line = reader.readLine();
while (line != null && line.length() > 0) {
if (!bloomfilter.contains(line)) {
result.add(line);
}
line = reader.readLine();
}
reader.close();
long t2 = System.currentTimeMillis();
System.out.println("Parse 9900000 items, Time : " + (t2 - t1) + "ms , find "
+ result.size() + " new items.");
System.out.println("Average : " + 9900000 / ((t2 - t1) / 1000) + " items/second");
}
}
class HashFunctions {
public static int hash(byte[] bytes, int k) {
switch (k) {
case 0:
return RSHash(bytes);
case 1:
return JSHash(bytes);
case 2:
return ELFHash(bytes);
case 3:
return BKDRHash(bytes);
case 4:
return APHash(bytes);
case 5:
return DJBHash(bytes);
case 6:
return SDBMHash(bytes);
case 7:
return PJWHash(bytes);
}
return 0;
}
public static int RSHash(byte[] bytes) {
int hash = 0;
int magic = 63689;
int len = bytes.length;
for (int i = 0; i < len; i++) {
hash = hash * magic + bytes[i];
magic = magic * 378551;
}
return hash;
}
public static int JSHash(byte[] bytes) {
int hash = 1315423911;
for (int i = 0; i < bytes.length; i++) {
hash ^= ((hash << 5) + bytes[i] + (hash >> 2));
}
return hash;
}
public static int ELFHash(byte[] bytes) {
int hash = 0;
int x = 0;
int len = bytes.length;
for (int i = 0; i < len; i++) {
hash = (hash << 4) + bytes[i];
if ((x = hash & 0xF0000000) != 0) {
hash ^= (x >> 24);
hash &= ~x;
}
}
return hash;
}
public static int BKDRHash(byte[] bytes) {
int seed = 131;
int hash = 0;
int len = bytes.length;
for (int i = 0; i < len; i++) {
hash = (hash * seed) + bytes[i];
}
return hash;
}
public static int APHash(byte[] bytes) {
int hash = 0;
int len = bytes.length;
for (int i = 0; i < len; i++) {
if ((i & 1) == 0) {
hash ^= ((hash << 7) ^ bytes[i] ^ (hash >> 3));
} else {
hash ^= (~((hash << 11) ^ bytes[i] ^ (hash >> 5)));
}
}
return hash;
}
public static int DJBHash(byte[] bytes) {
int hash = 5381;
int len = bytes.length;
for (int i = 0; i < len; i++) {
hash = ((hash << 5) + hash) + bytes[i];
}
return hash;
}
public static int SDBMHash(byte[] bytes) {
int hash = 0;
int len = bytes.length;
for (int i = 0; i < len; i++) {
hash = bytes[i] + (hash << 6) + (hash << 16) - hash;
}
return hash;
}
public static int PJWHash(byte[] bytes) {
long BitsInUnsignedInt = (4 * 8);
long ThreeQuarters = ((BitsInUnsignedInt * 3) / 4);
long OneEighth = (BitsInUnsignedInt / 8);
long HighBits = (long) (0xFFFFFFFF) << (BitsInUnsignedInt - OneEighth);
int hash = 0;
long test = 0;
for (int i = 0; i < bytes.length; i++) {
hash = (hash << OneEighth) + bytes[i];
if ((test = hash & HighBits) != 0) {
hash = (int) ((hash ^ (test >> ThreeQuarters)) & (~HighBits));
}
}
return hash;
}
}
八、問題拋出
最后拋出搜索引擎領域的一個問題：
給你A,B兩個文件，各存放50億條URL，每條URL占用64字節，內存限制是4G，讓你找出A,B文件共同的URL。如果是三個乃至n個文件呢？