簡介

布隆過濾器（BloomFilter）是一種用于判斷元素是否存在的方式，它的空間成本非常小，速度也很快。

但是由于它是基于概率的，因此它存在一定的誤判率，它的Contains()操作如果返回true只是表示元素可能存在集合內，返回false則表示元素一定不存在集合內。因此適合用于能夠容忍一定誤判元素存在集合內的場景，比如緩存。

它一秒能夠進行上百萬次操作（主要取決于哈希函數(shù)的速度），并且1億數(shù)據(jù)在誤判率1%的情況下，只需要114MB內存。

原理

數(shù)據(jù)結構

布隆過濾器的數(shù)據(jù)結構是一個位向量，也就是一個由0、1所組成的向量（下面是一個初始向量）：

添加

每個元素添加進布隆過濾器前，都會經(jīng)過多個不同的哈希函數(shù)，計算出不同的哈希值，然后映射到位向量上，也就是對應的位上面置1：

判斷存在

判斷元素是否存在也是如上圖流程，根據(jù)哈希函數(shù)映射的位置，判斷所有映射位置是否都為1，如果是則元素可能存在，否則元素一定不存在。

由于不同的值通過哈希函數(shù)之后可能會映射到相同的位置，因此如果一個不存在的元素對應的位位置都被其他元素所設置位1，則查詢時就會誤判：

假設上圖元素3334并沒有加入集合，但是由于它映射的位置已經(jīng)被其他元素所映射，則查詢時會誤判。

哈希函數(shù)

布隆過濾器里面的哈希函數(shù)需要是彼此獨立且均勻分布（類似于哈希表的哈希函數(shù)），而且需要盡可能的快，比如murmur3就是一個很好的選擇。

布隆過濾器的性能嚴重依賴于哈希函數(shù)的性能，而一般哈希函數(shù)的性能則依賴于輸入串（一般為字節(jié)數(shù)組）的長度，因此為了提高布隆過濾器的性能建議減少輸入串的長度。

下面是一個簡單的性能測試，單位是字節(jié)，可以看到時間的消耗隨著元素的增大基本是線性增長的：

cpu: Intel(R) Core(TM) i5-10210U CPU @ 1.60GHz
BenchmarkAddAndContains/1-8              1805840               659.6 ns/op         1.52 MB/s           0 B/op          0 allocs/op
BenchmarkAddAndContains/2-8              1824064               696.4 ns/op         2.87 MB/s           0 B/op          0 allocs/op
BenchmarkAddAndContains/4-8              1819742               649.5 ns/op         6.16 MB/s           0 B/op          0 allocs/op
BenchmarkAddAndContains/8-8              1828371               653.2 ns/op        12.25 MB/s           0 B/op          0 allocs/op
BenchmarkAddAndContains/16-8             1828426               642.0 ns/op        24.92 MB/s           0 B/op          0 allocs/op
BenchmarkAddAndContains/32-8             2106834               565.7 ns/op        56.57 MB/s           0 B/op          0 allocs/op
BenchmarkAddAndContains/64-8             2063895               579.3 ns/op       110.48 MB/s           0 B/op          0 allocs/op
BenchmarkAddAndContains/128-8            1767673               666.1 ns/op       192.17 MB/s           0 B/op          0 allocs/op
BenchmarkAddAndContains/256-8            1292918               916.9 ns/op       279.21 MB/s           0 B/op          0 allocs/op
BenchmarkAddAndContains/512-8             749666              1590 ns/op         322.11 MB/s           0 B/op          0 allocs/op
BenchmarkAddAndContains/1024-8            388015              2933 ns/op         349.12 MB/s           0 B/op          0 allocs/op
BenchmarkAddAndContains/2048-8            203404              5603 ns/op         365.51 MB/s           0 B/op          0 allocs/op
BenchmarkAddAndContains/4096-8            105134             11303 ns/op         362.38 MB/s           0 B/op          0 allocs/op
BenchmarkAddAndContains/8192-8             52305             22067 ns/op         371.23 MB/s           0 B/op          0 allocs/op

布隆過濾器大小、哈希函數(shù)數(shù)量、誤判率

布隆過濾器的大小、哈希函數(shù)數(shù)量和誤判率之間是互相影響的，如果我們想減少誤判率，則需要更大的布隆過濾器和更多的哈希函數(shù)。但是我們很難直觀的計算出這些參數(shù)，還好有兩個公式可以幫助我們計算出準確的數(shù)值：

在我們可以確定我們的元素數(shù)量和能夠容忍的錯誤率的情況下，我們可以根據(jù)下面公式計算布隆過濾器大小和哈希函數(shù)數(shù)量：

n = 元素數(shù)量
m = 布隆過濾器大小（位數(shù)）
k = 哈希函數(shù)數(shù)量
fpr = 錯誤率（falsePositiveRate，假陽性率）

m = n*(-ln(fpr)/(ln2*ln2))
k = ln2 * m / n

應用場景

數(shù)據(jù)庫

布隆過濾器可以提前過濾所查詢數(shù)據(jù)并不存在的請求，避免對磁盤訪問的耗時。比如LevelDB就使用了布隆過濾器過濾請求github.com/google/leve… 。

黑名單

假設有10億個黑名單URL，每個URL大小為64字節(jié)。使用Bloom Filter，如果錯誤率為0.1%，只需要1.4GB內存，如果錯誤率為0.0001%，也只需要2.9GB內存。

實現(xiàn)

這里簡單的介紹一下Golang的實現(xiàn)方式。

代碼：github.com/jiaxwu/gomm…

數(shù)據(jù)結構

由于我們沒辦法直接申請一個bit組成的數(shù)組，因此我們使用uint64表示64個bit。

type Filter struct {
	bits    []uint64     // bit數(shù)組
	bitsCnt uint64       // bit位數(shù)
	hashs   []*hash.Hash // 不同哈希函數(shù)
}

初始化

在初始化的時候，我們需要根據(jù)上面提到的兩個公式，計算布隆過濾器的大小和哈希函數(shù)的數(shù)量。

// capacity：容量
// falsePositiveRate：誤判率
func New(capacity uint64, falsePositiveRate float64) *Filter {
	// bit數(shù)量
	ln2 := math.Log(2.0)
	factor := -math.Log(falsePositiveRate) / (ln2 * ln2)
	bitsCnt := mmath.Max(1, uint64(float64(capacity)*factor))
	// 哈希函數(shù)數(shù)量
	hashsCnt := mmath.Max(1, int(ln2*float64(bitsCnt)/float64(capacity)))
	hashs := make([]*hash.Hash, hashsCnt)
	for i := 0; i < hashsCnt; i++ {
		hashs[i] = hash.New()
	}
	return &Filter{
		bits:    make([]uint64, (bitsCnt+63)/64),
		bitsCnt: bitsCnt,
		hashs:   hashs,
	}
}

添加元素

添加元素的時候，把每個哈希函數(shù)映射的位置都設置為1。這里需要注意，因為是用的uint64的數(shù)組，因此需要把按照bit計算的偏移，轉換為按照64位計算的數(shù)組下標和對應下標元素里面的偏移。

// 添加元素
func (f *Filter) Add(b []byte) {
	for _, h := range f.hashs {
		index, offset := f.pos(h, b)
		f.bits[index] |= 1 << offset
	}
}
// 獲取對應元素下標和偏移
func (f *Filter) pos(h *hash.Hash, b []byte) (uint64, uint64) {
	hashValue := h.Sum64(b)
	// 按照位計算的偏移
	bitsIndex := hashValue % f.bitsCnt
	// 因為一個元素64位，因此需要轉換
	index := bitsIndex / uint64Bits
	// 在一個元素里面的偏移
	offset := bitsIndex % uint64Bits
	return index, offset
}

判斷元素是否存在

同理，只是這里我們如果發(fā)現(xiàn)某一位不為1則可以直接返回false。

// 元素是否存在
// true表示可能存在
func (f *Filter) Contains(b []byte) bool {
	for _, h := range f.hashs {
		index, offset := f.pos(h, b)
		mask := uint64(1) << offset
		// 判斷這一位是否位1
		if (f.bits[index] & mask) != mask {
			return false
		}
	}
	return true
}

參考

Bloom Filters by Example

以上就是go語言中布隆過濾器低空間成本判斷元素是否存在方式的詳細內容，更多關于go 布隆過濾器判斷元素的資料請關注腳本之家其它相關文章！

最新評論