布隆過濾器(Bloom Filter)原理分析及代碼實現

布隆過濾器(Bloom Filter)原理分析及代碼實現

直觀的說，bloom算法類似一個hash set，用來判斷某個元素（key）是否在某個集合中。
和一般的hash set不同的是，這個算法無需存儲key的值，對於每個key，只需要k個比特位，每個存儲一個標誌，用來判斷key是否在集合中。

算法：
1. 首先需要k個hash函數，每個函數可以把key散列成爲1個整數
2. 初始化時，需要一個長度爲n比特的數組，每個比特位初始化爲0
3. 某個key加入集合時，用k個hash函數計算出k個散列值，並把數組中對應的比特位置爲1
4. 判斷某個key是否在集合時，用k個hash函數計算出k個散列值，並查詢數組中對應的比特位，如果所有的比特位都是1，認爲在集合中。

優點：不需要存儲key，節省空間

缺點：
1. 算法判斷key在集合中時，有一定的概率key其實不在集合中
2. 無法刪除

典型的應用場景：
某些存儲系統的設計中，會存在空查詢缺陷：當查詢一個不存在的key時，需要訪問慢設備，導致效率低下。
比如一個前端頁面的緩存系統，可能這樣設計：先查詢某個頁面在本地是否存在，如果存在就直接返回，如果不存在，就從後端獲取。但是當頻繁從緩存系統查詢一個頁面時，緩存系統將會頻繁請求後端，把壓力導入後端。

這是隻要增加一個bloom算法的服務，後端插入一個key時，在這個服務中設置一次
需要查詢後端時，先判斷key在後端是否存在，這樣就能避免後端的壓力。

 

 

 

 

 

布隆過濾器［1］（Bloom Filter）是由布隆（Burton Howard Bloom）在1970年提出的。它實際上是由一個很長的二進制向量和一系列隨機映射函數組成，布隆過濾器可以用於檢索一個元素是否在一個集合中。它的優點是空間效率和查詢時間都遠遠超過一般的算法，缺點是有一定的誤識別率（假正例False positives，即Bloom Filter報告某一元素存在於某集合中，但是實際上該元素並不在集合中）和刪除困難，但是沒有識別錯誤的情形（即假反例False negatives，如果某個元素確實沒有在該集合中，那麼Bloom Filter 是不會報告該元素存在於集合中的，所以不會漏報）。

在日常生活中，包括在設計計算機軟件時，我們經常要判斷一個元素是否在一個集合中。比如在字處理軟件中，需要檢查一個英語單詞是否拼寫正確（也就是要判斷 它是否在已知的字典中）；在 FBI，一個嫌疑人的名字是否已經在嫌疑名單上；在網絡爬蟲裏，一個網址是否被訪問過等等。最直接的方法就是將集合中全部的元素存在計算機中，遇到一個新 元素時，將它和集合中的元素直接比較即可。一般來講，計算機中的集合是用哈希表（hash table）來存儲的。它的好處是快速準確，缺點是費存儲空間。當集合比較小時，這個問題不顯著，但是當集合巨大時，哈希表存儲效率低的問題就顯現出來 了。比如說，一個象 Yahoo,Hotmail 和 Gmai 那樣的公衆電子郵件（email）提供商，總是需要過濾來自發送垃圾郵件的人（spamer）的垃圾郵件。一個辦法就是記錄下那些發垃圾郵件的 email 地址。由於那些發送者不停地在註冊新的地址，全世界少說也有幾十億個發垃圾郵件的地址，將他們都存起來則需要大量的網絡服務器。如果用哈希表，每存儲一億 個 email 地址， 就需要 1.6GB 的內存（用哈希表實現的具體辦法是將每一個 email 地址對應成一個八字節的信息指紋（詳見：googlechinablog.com/2006/08/blog-post.html）， 然後將這些信息指紋存入哈希表，由於哈希表的存儲效率一般只有 50%，因此一個 email 地址需要佔用十六個字節。一億個地址大約要 1.6GB， 即十六億字節的內存）。因此存貯幾十億個郵件地址可能需要上百 GB 的內存。除非是超級計算機，一般服務器是無法存儲的［2］。（該段引用谷歌數學之美：http://www.google.com.hk/ggblog/googlechinablog/2007/07/bloom-filter_7469.html）

基本概念

如果想判斷一個元素是不是在一個集合裏，一般想到的是將所有元素保存起來，然後通過比較確定。鏈表，樹等等數據結構都是這種思路. 但是隨着集合中元素的增加，我們需要的存儲空間越來越大，檢索速度也越來越慢。不過世界上還有一種叫作散列表（又叫哈希表，Hash table）的數據結構。它可以通過一個Hash函數將一個元素映射成一個位陣列（Bit Array）中的一個點。這樣一來，我們只要看看這個點是不是 1 就知道可以集合中有沒有它了。這就是布隆過濾器的基本思想。

Hash面臨的問題就是衝突。假設 Hash 函數是良好的，如果我們的位陣列長度爲 m 個點，那麼如果我們想將衝突率降低到例如 1%, 這個散列表就只能容納 m/100 個元素。顯然這就不叫空間有效了（Space-efficient）。解決方法也簡單，就是使用多個 Hash，如果它們有一個說元素不在集合中，那肯定就不在。如果它們都說在，雖然也有一定可能性它們在說謊，不過直覺上判斷這種事情的概率是比較低的。

優點

相比於其它的數據結構，布隆過濾器在空間和時間方面都有巨大的優勢。布隆過濾器存儲空間和插入/查詢時間都是常數。另外, Hash 函數相互之間沒有關係，方便由硬件並行實現。布隆過濾器不需要存儲元素本身，在某些對保密要求非常嚴格的場合有優勢。

布隆過濾器可以表示全集，其它任何數據結構都不能；

k 和 m 相同，使用同一組 Hash 函數的兩個布隆過濾器的交併差運算可以使用位操作進行。

缺點

但是布隆過濾器的缺點和優點一樣明顯。誤算率（False Positive）是其中之一。隨着存入的元素數量增加，誤算率隨之增加。但是如果元素數量太少，則使用散列表足矣。

另外，一般情況下不能從布隆過濾器中刪除元素. 我們很容易想到把位列陣變成整數數組，每插入一個元素相應的計數器加1, 這樣刪除元素時將計數器減掉就可以了。然而要保證安全的刪除元素並非如此簡單。首先我們必須保證刪除的元素的確在布隆過濾器裏面. 這一點單憑這個過濾器是無法保證的。另外計數器迴繞也會造成問題。

False positives 概率推導

假設 Hash 函數以等概率條件選擇並設置 Bit Array 中的某一位，m 是該位數組的大小，k 是 Hash 函數的個數，那麼位數組中某一特定的位在進行元素插入時的 Hash 操作中沒有被置位的概率是：

那麼在所有 k 次 Hash 操作後該位都沒有被置 "1" 的概率是：

如果我們插入了 n 個元素，那麼某一位仍然爲 "0" 的概率是：

因而該位爲 "1"的概率是：

現在檢測某一元素是否在該集合中。標明某個元素是否在集合中所需的 k 個位置都按照如上的方法設置爲 "1"，但是該方法可能會使算法錯誤的認爲某一原本不在集合中的元素卻被檢測爲在該集合中（False Positives），該概率由以下公式確定：

其實上述結果是在假定由每個 Hash 計算出需要設置的位（bit） 的位置是相互獨立爲前提計算出來的，不難看出，隨着 m （位數組大小）的增加，假正例（False Positives）的概率會下降，同時隨着插入元素個數 n 的增加，False Positives的概率又會上升，對於給定的m，n，如何選擇Hash函數個數 k 由以下公式確定：

此時False Positives的概率爲：

而對於給定的False Positives概率 p，如何選擇最優的位數組大小 m 呢，

上式表明，位數組的大小最好與插入元素的個數成線性關係，對於給定的 m，n，k，假正例概率最大爲：

 

下圖是布隆過濾器假正例概率 p 與位數組大小 m 和集合中插入元素個數 n 的關係圖，假定 Hash 函數個數選取最優數目：

 

Bloom Filter 用例

Google 著名的分佈式數據庫 Bigtable 使用了布隆過濾器來查找不存在的行或列，以減少磁盤查找的IO次數［3］。

Squid 網頁代理緩存服務器在 cache digests 中使用了也布隆過濾器［4］。

Venti 文檔存儲系統也採用布隆過濾器來檢測先前存儲的數據［5］。

SPIN 模型檢測器也使用布隆過濾器在大規模驗證問題時跟蹤可達狀態空間［6］。

Google Chrome瀏覽器使用了布隆過濾器加速安全瀏覽服務［7］。

在很多Key-Value系統中也使用了布隆過濾器來加快查詢過程，如 Hbase，Accumulo，Leveldb，一般而言，Value 保存在磁盤中，訪問磁盤需要花費大量時間，然而使用布隆過濾器可以快速判斷某個Key對應的Value是否存在，因此可以避免很多不必要的磁盤IO操作，只是引入布隆過濾器會帶來一定的內存消耗，下圖是在Key-Value系統中布隆過濾器的典型使用：

 

布隆過濾器相關擴展

 Counting filters

基本的布隆過濾器不支持刪除（Deletion）操作，但是 Counting filters 提供了一種可以不用重新構建布隆過濾器但卻支持元素刪除操作的方法。在Counting filters中原來的位數組中的每一位由 bit 擴展爲 n-bit 計數器，實際上，基本的布隆過濾器可以看作是隻有一位的計數器的Counting filters。原來的插入操作也被擴展爲把 n-bit 的位計數器加1，查找操作即檢查位數組非零即可，而刪除操作定義爲把位數組的相應位減1，但是該方法也有位的算術溢出問題，即某一位在多次刪除操作後可能變成負值，所以位數組大小 m 需要充分大。另外一個問題是Counting filters不具備伸縮性，由於Counting filters不能擴展，所以需要保存的最大的元素個數需要提前知道。否則一旦插入的元素個數超過了位數組的容量，false positive的發生概率將會急劇增加。當然也有人提出了一種基於 D-left Hash 方法實現支持刪除操作的布隆過濾器，同時空間效率也比Counting filters高。

Data synchronization

Byers等人提出了使用布隆過濾器近似數據同步［9］。

Bloomier filters

Chazelle 等人提出了一個通用的布隆過濾器，該布隆過濾器可以將某一值與每個已經插入的元素關聯起來，並實現了一個關聯數組Map［10］。與普通的布隆過濾器一樣，Chazelle實現的布隆過濾器也可以達到較低的空間消耗，但同時也會產生false positive，不過，在Bloomier filter中，某 key 如果不在 map 中，false positive在會返回時會被定義出的。該Map 結構不會返回與 key 相關的在 map 中的錯誤的值。

 

 

附上代碼：

bloomfilter.h

#ifndef __MICRO_BLOOMFILTER_H__
#define __MICRO_BLOOMFILTER_H__

/**
 *
 *  仿照Cassandra中的BloomFilter實現，Hash選用MurmurHash2，通過雙重散列公式生成散列函數，參考：http://hur.st/bloomfilter
 *    Hash(key, i) = (H1(key) + i * H2(key)) % m
 *
**/

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <math.h>

#define __BLOOMFILTER_VERSION__ "1.1"
#define __MGAIC_CODE__          (0x01464C42)

/**
 *  BloomFilter使用例子：
 *  static BaseBloomFilter stBloomFilter = {0};
 *
 *  初始化BloomFilter(最大100000元素，不超過0.00001的錯誤率)：
 *      InitBloomFilter(&stBloomFilter, 0, 100000, 0.00001);
 *  重置BloomFilter：
 *      ResetBloomFilter(&stBloomFilter);
 *  釋放BloomFilter:
 *      FreeBloomFilter(&stBloomFilter);
 *
 *  向BloomFilter中新增一個數值（0-正常，1-加入數值過多）：
 *      uint32_t dwValue;
 *      iRet = BloomFilter_Add(&stBloomFilter, &dwValue, sizeof(uint32_t));
 *  檢查數值是否在BloomFilter內（0-存在，1-不存在）：
 *      iRet = BloomFilter_Check(&stBloomFilter, &dwValue, sizeof(uint32_t));
 *
 *  (1.1新增) 將生成好的BloomFilter寫入文件:
 *      iRet = SaveBloomFilterToFile(&stBloomFilter, "dump.bin")
 *  (1.1新增) 從文件讀取生成好的BloomFilter:
 *      iRet = LoadBloomFilterFromFile(&stBloomFilter, "dump.bin")
**/

// 注意，要讓Add/Check函數內聯，必須使用 -O2 或以上的優化等級
#define FORCE_INLINE __attribute__((always_inline))

#define BYTE_BITS           (8)
#define MIX_UINT64(v)       ((uint32_t)((v>>32)^(v)))

#define SETBIT(filter, n)   (filter->pstFilter[n/BYTE_BITS] |= (1 << (n%BYTE_BITS)))
#define GETBIT(filter, n)   (filter->pstFilter[n/BYTE_BITS] & (1 << (n%BYTE_BITS)))

#pragma pack(1)

// BloomFilter結構定義
typedef struct
{
    uint8_t cInitFlag;                              // 初始化標誌，爲0時的第一次Add()會對stFilter[]做初始化
    uint8_t cResv[3];

    uint32_t dwMaxItems;                            // n - BloomFilter中最大元素個數 (輸入量)
    double dProbFalse;                              // p - 假陽概率 (輸入量，比如萬分之一：0.00001)
    uint32_t dwFilterBits;                          // m = ceil((n * log(p)) / log(1.0 / (pow(2.0, log(2.0))))); - BloomFilter的比特數
    uint32_t dwHashFuncs;                           // k = round(log(2.0) * m / n); - 哈希函數個數

    uint32_t dwSeed;                                // MurmurHash的種子偏移量
    uint32_t dwCount;                               // Add()的計數，超過MAX_BLOOMFILTER_N則返回失敗

    uint32_t dwFilterSize;                          // dwFilterBits / BYTE_BITS
    unsigned char *pstFilter;                       // BloomFilter存儲指針，使用malloc分配
    uint32_t *pdwHashPos;                           // 存儲上次hash得到的K個bit位置數組(由bloom_hash填充)
} BaseBloomFilter;

// BloomFilter文件頭部定義
typedef struct
{
    uint32_t dwMagicCode;                           // 文件頭部標識，填充 __MGAIC_CODE__
    uint32_t dwSeed;
    uint32_t dwCount;

    uint32_t dwMaxItems;                            // n - BloomFilter中最大元素個數 (輸入量)
    double dProbFalse;                              // p - 假陽概率 (輸入量，比如萬分之一：0.00001)
    uint32_t dwFilterBits;                          // m = ceil((n * log(p)) / log(1.0 / (pow(2.0, log(2.0))))); - BloomFilter的比特數
    uint32_t dwHashFuncs;                           // k = round(log(2.0) * m / n); - 哈希函數個數

    uint32_t dwResv[6];
    uint32_t dwFileCrc;                             // (未使用)整個文件的校驗和
    uint32_t dwFilterSize;                          // 後面Filter的Buffer長度
} BloomFileHead;

#pragma pack()


// 計算BloomFilter的參數m,k
static inline void _CalcBloomFilterParam(uint32_t n, double p, uint32_t *pm, uint32_t *pk)
{
    /**
     *  n - Number of items in the filter
     *  p - Probability of false positives, float between 0 and 1 or a number indicating 1-in-p
     *  m - Number of bits in the filter
     *  k - Number of hash functions
     *
     *  f = ln(2) × ln(1/2) × m / n = (0.6185) ^ (m/n)
     *  m = -1 * ln(p) × n / 0.6185 , 這裏有錯誤
     *  k = ln(2) × m / n = 0.6931 * m / n
     * darren修正：
     * m = -1*n*ln(p)/((ln(2))^2) = -1*n*ln(p)/(ln(2)*ln(2)) = -1*n*ln(p)/(0.69314718055995*0.69314718055995))
     *   = -1*n*ln(p)/0.4804530139182079271955440025
     * k = ln(2)*m/n
    **/

    uint32_t m, k, m2;

    //    printf("ln(2):%lf, ln(p):%lf\n", log(2), log(p)); // 用來驗證函數正確性

    // 計算指定假陽(誤差)概率下需要的比特數
    m =(uint32_t) ceil(-1.0 * n * log(p) / 0.480453); //darren 修正，注意使用-1.0而不是使用-1 涉及float計算
    m = (m - m % 64) + 64;                              // 8字節對齊

    // 計算哈希函數個數
    double double_k = (0.69314 * m / n); // ln(2)*m/n // 這裏只是爲了debug出來看看具體的浮點數值
    k = round(double_k);    // 返回x的四捨五入整數值。
    printf("orig_k:%lf, k:%u\n", double_k, k);

    *pm = m;
    *pk = k;
    return;
}


// 根據目標精度和數據個數，初始化BloomFilter結構
/**
 * @brief 初始化布隆過濾器
 * @param pstBloomfilter 布隆過濾器實例
 * @param dwSeed    hash種子
 * @param dwMaxItems 存儲容量
 * @param dProbFalse 允許的誤判率
 * @return 返回值
 *      -1 傳入的布隆過濾器爲空
 *      -2 hash種子錯誤或誤差>=1
 */
inline int InitBloomFilter(BaseBloomFilter *pstBloomfilter, uint32_t dwSeed, uint32_t dwMaxItems,
                           double dProbFalse)
{
    if (pstBloomfilter == NULL)
        return -1;
    if ((dProbFalse <= 0) || (dProbFalse >= 1))
        return -2;

    // 先檢查是否重複Init，釋放內存
    if (pstBloomfilter->pstFilter != NULL)
        free(pstBloomfilter->pstFilter);
    if (pstBloomfilter->pdwHashPos != NULL)
        free(pstBloomfilter->pdwHashPos);

    memset(pstBloomfilter, 0, sizeof(BaseBloomFilter));

    // 初始化內存結構，並計算BloomFilter需要的空間
    pstBloomfilter->dwMaxItems = dwMaxItems;    // 最大存儲
    pstBloomfilter->dProbFalse = dProbFalse;    // 誤差
    pstBloomfilter->dwSeed = dwSeed;            // hash種子

    // 計算 m, k
    _CalcBloomFilterParam(pstBloomfilter->dwMaxItems, pstBloomfilter->dProbFalse,
                          &pstBloomfilter->dwFilterBits, &pstBloomfilter->dwHashFuncs);

    // 分配BloomFilter的存儲空間
    pstBloomfilter->dwFilterSize = pstBloomfilter->dwFilterBits / BYTE_BITS;
    pstBloomfilter->pstFilter = (unsigned char *) malloc(pstBloomfilter->dwFilterSize);
    if (NULL == pstBloomfilter->pstFilter)
        return -100;

    // 哈希結果數組，每個哈希函數一個
    pstBloomfilter->pdwHashPos = (uint32_t*) malloc(pstBloomfilter->dwHashFuncs * sizeof(uint32_t));
    if (NULL == pstBloomfilter->pdwHashPos)
        return -200;

    printf(">>> Init BloomFilter(n=%u, p=%e, m=%u, k=%d), malloc() size=%.2fMB, items:bits=1:%0.1lf\n",
           pstBloomfilter->dwMaxItems, pstBloomfilter->dProbFalse, pstBloomfilter->dwFilterBits,
           pstBloomfilter->dwHashFuncs, (double)pstBloomfilter->dwFilterSize/1024/1024,
           pstBloomfilter->dwFilterBits*1.0/pstBloomfilter->dwMaxItems);

    // 初始化BloomFilter的內存
    memset(pstBloomfilter->pstFilter, 0, pstBloomfilter->dwFilterSize);
    pstBloomfilter->cInitFlag = 1;
    return 0;
}

// 釋放BloomFilter
inline int FreeBloomFilter(BaseBloomFilter *pstBloomfilter)
{
    if (pstBloomfilter == NULL)
        return -1;

    pstBloomfilter->cInitFlag = 0;
    pstBloomfilter->dwCount = 0;

    free(pstBloomfilter->pstFilter);
    pstBloomfilter->pstFilter = NULL;
    free(pstBloomfilter->pdwHashPos);
    pstBloomfilter->pdwHashPos = NULL;
    return 0;
}

// 重置BloomFilter
// 注意: Reset()函數不會立即初始化stFilter，而是當一次Add()時去memset
inline int ResetBloomFilter(BaseBloomFilter *pstBloomfilter)
{
    if (pstBloomfilter == NULL)
        return -1;

    pstBloomfilter->cInitFlag = 0;
    pstBloomfilter->dwCount = 0;
    return 0;
}

// 和ResetBloomFilter不同，調用後立即memset內存
inline int RealResetBloomFilter(BaseBloomFilter *pstBloomfilter)
{
    if (pstBloomfilter == NULL)
        return -1;

    memset(pstBloomfilter->pstFilter, 0, pstBloomfilter->dwFilterSize);
    pstBloomfilter->cInitFlag = 1;
    pstBloomfilter->dwCount = 0;
    return 0;
}

///
///  函數FORCE_INLINE，加速執行
///
// MurmurHash2, 64-bit versions, by Austin Appleby
// https://sites.google.com/site/murmurhash/
FORCE_INLINE uint64_t MurmurHash2_x64 ( const void * key, int len, uint32_t seed )
{
    const uint64_t m = 0xc6a4a7935bd1e995;
    const int r = 47;

    uint64_t h = seed ^ (len * m);

    const uint64_t * data = (const uint64_t *)key;
    const uint64_t * end = data + (len/8);

    while(data != end)
    {
        uint64_t k = *data++;

        k *= m;
        k ^= k >> r;
        k *= m;

        h ^= k;
        h *= m;
    }

    const uint8_t * data2 = (const uint8_t*)data;

    switch(len & 7)
    {
        case 7: h ^= ((uint64_t)data2[6]) << 48;
        case 6: h ^= ((uint64_t)data2[5]) << 40;
        case 5: h ^= ((uint64_t)data2[4]) << 32;
        case 4: h ^= ((uint64_t)data2[3]) << 24;
        case 3: h ^= ((uint64_t)data2[2]) << 16;
        case 2: h ^= ((uint64_t)data2[1]) << 8;
        case 1: h ^= ((uint64_t)data2[0]);
            h *= m;
    };

    h ^= h >> r;
    h *= m;
    h ^= h >> r;

    return h;
}

// 雙重散列封裝
FORCE_INLINE void bloom_hash(BaseBloomFilter *pstBloomfilter, const void * key, int len)
{
    //if (pstBloomfilter == NULL) return;
    int i;
    uint32_t dwFilterBits = pstBloomfilter->dwFilterBits;
    uint64_t hash1 = MurmurHash2_x64(key, len, pstBloomfilter->dwSeed);
    uint64_t hash2 = MurmurHash2_x64(key, len, MIX_UINT64(hash1));

    for (i = 0; i < (int)pstBloomfilter->dwHashFuncs; i++)
    {
        //
        pstBloomfilter->pdwHashPos[i] = (hash1 + i*hash2) % dwFilterBits;
    }

    return;
}

// 向BloomFilter中新增一個元素
// 成功返回0，當添加數據超過限制值時返回1提示用戶
FORCE_INLINE int BloomFilter_Add(BaseBloomFilter *pstBloomfilter, const void * key, int len)
{
    if ((pstBloomfilter == NULL) || (key == NULL) || (len <= 0))
        return -1;

    int i;

    if (pstBloomfilter->cInitFlag != 1)
    {
        // Reset後沒有初始化，使用前需要memset
        memset(pstBloomfilter->pstFilter, 0, pstBloomfilter->dwFilterSize);
        pstBloomfilter->cInitFlag = 1;
    }

    // hash key到bloomfilter中
    bloom_hash(pstBloomfilter, key, len);
    for (i = 0; i < (int)pstBloomfilter->dwHashFuncs; i++)
    {
        SETBIT(pstBloomfilter, pstBloomfilter->pdwHashPos[i]);
    }

    // 增加count數
    pstBloomfilter->dwCount++;
    if (pstBloomfilter->dwCount <= pstBloomfilter->dwMaxItems)
        return 0;
    else
        return 1;       // 超過N最大值，可能出現準確率下降等情況
}

// 檢查一個元素是否在bloomfilter中
// 返回：0-存在，1-不存在，負數表示失敗
FORCE_INLINE int BloomFilter_Check(BaseBloomFilter *pstBloomfilter, const void * key, int len)
{
    if ((pstBloomfilter == NULL) || (key == NULL) || (len <= 0))
        return -1;

    int i;

    bloom_hash(pstBloomfilter, key, len);
    for (i = 0; i < (int)pstBloomfilter->dwHashFuncs; i++)
    {
        // 如果有任意bit不爲1，說明key不在bloomfilter中
        // 注意: GETBIT()返回不是0|1，高位可能出現128之類的情況
        if (GETBIT(pstBloomfilter, pstBloomfilter->pdwHashPos[i]) == 0)
            return 1;
    }

    return 0;
}


/* 文件相關封裝 */
// 將生成好的BloomFilter寫入文件
inline int SaveBloomFilterToFile(BaseBloomFilter *pstBloomfilter, char *szFileName)
{
    if ((pstBloomfilter == NULL) || (szFileName == NULL))
        return -1;

    int iRet;
    FILE *pFile;
    static BloomFileHead stFileHeader = {0};

    pFile = fopen(szFileName, "wb");
    if (pFile == NULL)
    {
        perror("fopen");
        return -11;
    }

    // 先寫入文件頭
    stFileHeader.dwMagicCode = __MGAIC_CODE__;
    stFileHeader.dwSeed = pstBloomfilter->dwSeed;
    stFileHeader.dwCount = pstBloomfilter->dwCount;
    stFileHeader.dwMaxItems = pstBloomfilter->dwMaxItems;
    stFileHeader.dProbFalse = pstBloomfilter->dProbFalse;
    stFileHeader.dwFilterBits = pstBloomfilter->dwFilterBits;
    stFileHeader.dwHashFuncs = pstBloomfilter->dwHashFuncs;
    stFileHeader.dwFilterSize = pstBloomfilter->dwFilterSize;

    iRet = fwrite((const void*)&stFileHeader, sizeof(stFileHeader), 1, pFile);
    if (iRet != 1)
    {
        perror("fwrite(head)");
        return -21;
    }

    // 接着寫入BloomFilter的內容
    iRet = fwrite(pstBloomfilter->pstFilter, 1, pstBloomfilter->dwFilterSize, pFile);
    if ((uint32_t)iRet != pstBloomfilter->dwFilterSize)
    {
        perror("fwrite(data)");
        return -31;
    }

    fclose(pFile);
    return 0;
}

// 從文件讀取生成好的BloomFilter
inline int LoadBloomFilterFromFile(BaseBloomFilter *pstBloomfilter, char *szFileName)
{
    if ((pstBloomfilter == NULL) || (szFileName == NULL))
        return -1;

    int iRet;
    FILE *pFile;
    static BloomFileHead stFileHeader = {0};

    if (pstBloomfilter->pstFilter != NULL)
        free(pstBloomfilter->pstFilter);
    if (pstBloomfilter->pdwHashPos != NULL)
        free(pstBloomfilter->pdwHashPos);

    //
    pFile = fopen(szFileName, "rb");
    if (pFile == NULL)
    {
        perror("fopen");
        return -11;
    }

    // 讀取並檢查文件頭
    iRet = fread((void*)&stFileHeader, sizeof(stFileHeader), 1, pFile);
    if (iRet != 1)
    {
        perror("fread(head)");
        return -21;
    }

    if ((stFileHeader.dwMagicCode != __MGAIC_CODE__)
        || (stFileHeader.dwFilterBits != stFileHeader.dwFilterSize*BYTE_BITS))
        return -50;

    // 初始化傳入的 BaseBloomFilter 結構
    pstBloomfilter->dwMaxItems = stFileHeader.dwMaxItems;
    pstBloomfilter->dProbFalse = stFileHeader.dProbFalse;
    pstBloomfilter->dwFilterBits = stFileHeader.dwFilterBits;
    pstBloomfilter->dwHashFuncs = stFileHeader.dwHashFuncs;
    pstBloomfilter->dwSeed = stFileHeader.dwSeed;
    pstBloomfilter->dwCount = stFileHeader.dwCount;
    pstBloomfilter->dwFilterSize = stFileHeader.dwFilterSize;

    pstBloomfilter->pstFilter = (unsigned char *) malloc(pstBloomfilter->dwFilterSize);
    if (NULL == pstBloomfilter->pstFilter)
        return -100;
    pstBloomfilter->pdwHashPos = (uint32_t*) malloc(pstBloomfilter->dwHashFuncs * sizeof(uint32_t));
    if (NULL == pstBloomfilter->pdwHashPos)
        return -200;


    // 將後面的Data部分讀入 pstFilter
    iRet = fread((void*)(pstBloomfilter->pstFilter), 1, pstBloomfilter->dwFilterSize, pFile);
    if ((uint32_t)iRet != pstBloomfilter->dwFilterSize)
    {
        perror("fread(data)");
        return -31;
    }
    pstBloomfilter->cInitFlag = 1;

    printf(">>> Load BloomFilter(n=%u, p=%f, m=%u, k=%d), malloc() size=%.2fMB\n",
           pstBloomfilter->dwMaxItems, pstBloomfilter->dProbFalse, pstBloomfilter->dwFilterBits,
           pstBloomfilter->dwHashFuncs, (double)pstBloomfilter->dwFilterSize/1024/1024);

    fclose(pFile);
    return 0;
}

#endif

調用方法

#include "bloomfilter.h"
#include <stdio.h>

#define MAX_ITEMS 4000      // 設置最大元素
#define ADD_ITEMS 1000      // 添加測試元素
#define P_ERROR 0.0000001   // 設置誤差



int main(int argc, char** argv)
{

    printf(" test bloomfilter\n");

    // 1. 定義BaseBloomFilter
    static BaseBloomFilter stBloomFilter = {0};

    // 2. 初始化stBloomFilter，調用時傳入hash種子，存儲容量，以及允許的誤判率
    InitBloomFilter(&stBloomFilter, 0, MAX_ITEMS, P_ERROR);

    // 3. 向BloomFilter中新增數值
    char url[128] = {0};
    for(int i = 0; i < ADD_ITEMS; i++){
        sprintf(url, "https://0voice.com/%d.html", i);
        if(0 == BloomFilter_Add(&stBloomFilter, (const void*)url, strlen(url))){
            // printf("add %s success", url);
        }else{
            printf("add %s failed", url);
        }
        memset(url, 0, sizeof(url));
    }

    // 4. check url exist or not
    char* str = "https://0voice.com/0.html";
    if (0 == BloomFilter_Check(&stBloomFilter, (const void*)str, strlen(str)) ){
        printf("https://0voice.com/0.html exist\n");
    }

    char* str2 = "https://0voice.com/10001.html";
    if (0 != BloomFilter_Check(&stBloomFilter, (const void*)str2, strlen(str2)) ){
        printf("https://0voice.com/10001.html not exist\n");
    }

    // 5. free bloomfilter
    FreeBloomFilter(&stBloomFilter);
    getchar();
    return 0;
}

對着原理和代碼，理容易理解。只寫原理不寫實現，或是隻寫實現不寫原理，類似只說不做，只做不說，都不行。要實踐和原理一致才更加容易掌握。