布隆过滤器概念
布隆过滤器（英语：Bloom Filter）是1970年由一个叫布隆的小伙子提出的。它实际上是一个很长的二进制向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都远远超过一般的算法，缺点是有一定的误识别率和删除困难。一句话概括：Bloom Filter 是一个基于概率的数据结构，它只能告诉我们一个元素绝对不在集合内或可能在集合内。
布隆过滤器优缺点
优点
相比于其它的数据结构，布隆过滤器在空间和时间方面都有巨大的优势。
- 布隆过滤器存储空间和插入/查询时间都是常数（即hash函数的个数）；
- Hash 函数相互之间没有关系，方便由硬件并行实现；
- 布隆过滤器不需要存储元素本身，在某些对保密要求非常严格的场合有优势；
- 布隆过滤器可以表示全集，其它任何数据结构都不能；
缺点
布隆过滤器的缺点和优点一样明显：
- 误算率（False Positive）是其中之一。随着存入的元素数量增加，误算率随之增加（误判补救方法是：再建立一个小的白名单，存储那些可能被误判的信息）。但是如果元素数量太少，则使用散列表足矣。
- 一般情况下不能从布隆过滤器中删除元素。我们很容易想到把位列阵变成整数数组，每插入一个元素相应的计数器加 1, 这样删除元素时将计数器减掉就可以了。然而要保证安全的删除元素并非如此简单。首先我们必须保证删除的元素的确在布隆过滤器里面. 这一点单凭这个过滤器是无法保证的。另外计数器回绕也会造成问题。
布隆过滤器使用场景
利用布隆过滤器减少磁盘 IO 或者网络请求，因为一旦一个值必定不存在的话，就可以直接结束查询，比如以下场景：
- 大数据去重，比如判断一个数字是否存在于包含大量数字的数字集中（数字集很大，5 亿以上！）；
- 网页爬虫对 URL 的去重，避免爬取相同的 URL 地址；
- 反垃圾邮件，从数十亿个垃圾邮件列表中判断某邮箱是否垃圾邮箱；
- 缓存击穿，将已存在的缓存放到布隆过滤器中，当黑客频繁访问不存在的缓存时迅速返回避免缓存及数据库挂掉；
布隆过滤器原理
布隆过滤器的原理是，当一个元素被加入集合时，通过K个散列函数将这个元素映射成一个位数组中的K个点，把它们置为1。检索时，我们只要看看这些点是不是都是1就（大约）知道集合中有没有它了：如果这些点有任何一个0，则被检元素一定不在；如果都是1，则被检元素很可能在。这就是布隆过滤器的基本思想。
Bloom Filter跟单哈希函数Bit-Map不同之处在于：Bloom Filter使用了k个哈希函数，每个字符串跟k个bit对应。从而降低了冲突的概率。
布隆过滤器实现
布隆过滤器有许多实现与优化，Guava中就提供了一种Bloom Filter的实现。
在使用bloom filter时，绕不过的两点是预估数据量n以及期望的误判率fpp，
在实现bloom filter时，绕不过的两点就是hash函数的选取以及bit数组的大小。
对于一个确定的场景，我们预估要存的数据量为n，期望的误判率为fpp，然后需要计算我们需要的Bit数组的大小m，以及hash函数的个数k，并选择hash函数
-
Bit数组大小选择
根据预估数据量n以及误判率fpp，bit数组大小的m的计算方式：
-
哈希函数选择
由预估数据量n以及bit数组长度m，可以得到一个hash函数的个数k：
哈希函数的选择对性能的影响应该是很大的，一个好的哈希函数要能近似等概率的将字符串映射到各个Bit。选择k个不同的哈希函数比较麻烦，一种简单的方法是选择一个哈希函数，然后送入k个不同的参数。
哈希函数个数k、位数组大小m、加入的字符串数量n的关系可以参考:
https://blog.csdn.net/jiaomeng/article/details/1495500
简单示例
Add 过程
布隆过滤器的核心就是一个二进制数据的集合和hash计算函数。当一个元素加入布隆过滤器中的时会进行如下操作：
-
使用布隆过滤器中的哈希函数对元素值进行计算，返回对应的哈希值（一般有几个哈希函数得到几个哈希值）；
-
根据返回的hash值映射到对应的二进制集合的下标；
-
将下标对应的二进制数据改成1；
如上图所示，三个Hash函数计算key值“test”的hash值分别为2、5、9；那么就会把集合中2、5、9下标对应的数据改成1。
match 过程
当我们需要判断一个元素是否存在于布隆过滤器的时候，会进行如下操作：
-
对给定元素再次进行相同的哈希计算；
-
根据返回的hash值判断位数组中对应的元素是否都为 1，如果值都为 1，那么说明这个值在布隆过滤器中，如果存在一个值不为 1，则说明该元素不在布隆过滤器中。
从上图可以看到，元素“test”通过哈希函数计算，得到下标为 2、5、9 这 3个数据。虽然前两个点都为 1，但是很明显第 3 个点得到的数据为0，说明元素不在集合中。
代码示例
- 构建集合
根据之前介绍的布隆过滤器的实现原理，布隆过滤器的实现主要包括可以存放二进制元素的 BitSet 以及多样性的哈希计算函数。下面通过实例演示布隆过滤器的实现。
public class MyBloomFilter {
/**
* 位数组的大小
*/
private static final int DEFAULT_SIZE = 2 << 24;
/**
* 位数组。数组中的元素只能是 0 或者 1
*/
private BitSet bits = new BitSet(DEFAULT_SIZE);
/**
* 通过这个数组可以创建 3 个不同的哈希函数
*/
private static final int[] SEEDS = new int[]{3, 13, 46};
/**
* 存放包含 hash 函数的类的数组
*/
private SimpleHash[] func = new SimpleHash[SEEDS.length];
/**
* 初始化多个包含 hash 函数的类的数组，每个类中的 hash 函数都不一样
*/
public MyBloomFilter() {
// 初始化多个不同的 Hash 函数
for (int i = 0; i < SEEDS.length; i++) {
func[i] = new SimpleHash(DEFAULT_SIZE, SEEDS[i]);
}
}
}
所有的元素存放都经过多样的哈希计算存放到 BitSet 中，这样可以尽可能地分散元素，减少误判。
- hash函数
这里只是提供了一种哈希计算的方式，实际可以实现多种不同的hash计算方式，每一个哈希计算都是一次扰动处理。一个元素的存放可以经过多次哈希，尽量让元素值做到散列，从而避免hash碰撞。
/**
* 静态内部类。用于 hash 操作！
*/
public static class SimpleHash {
private int cap;
private int seed;
public SimpleHash(int cap, int seed) {
this.cap = cap;
this.seed = seed;
}
/**
* 计算 hash 值
*/
public int hash(Object value) {
int h;
return (value == null) ? 0 : Math.abs(seed * (cap - 1) & ((h = value.hashCode()) ^ (h >>> 16)));
}
}
- 添加函数
添加元素就是当某个元素不在集合中时，我们使用布隆过滤器中的哈希函数对元素值进行计算得到哈希值，然后根据返回的哈希值，将集合数组中把对应下标的值置为 1。具体代码如下：
/**
* 添加元素到位数组
*/
public void add(Object value) {
for (SimpleHash f : func) {
bits.set(f.hash(value), true);
}
}
- 匹配函数
比对元素就是判断某个元素是否存在。我们对该元素进行哈希计算，然后通过哈希值获取集合中的数据，最后把这些哈希值 进行&& 计算，从而确定该元素是否存在。具体代码如下：
/**
* 判断指定元素是否存在于位数组
*/
public boolean contains(Object value) {
boolean ret = true;
for (SimpleHash f : func) {
ret = ret && bits.get(f.hash(value));
}
return ret;
}
- 验证测试
public class MyBloomFilterTest {
public static void main(String[] args) {
String value1 = "com:weiz:user:logininfo";
String value2 = "https://www.cnblogs.com/zhangweizhong";
String value3 = "200110221";
MyBloomFilter filter = new MyBloomFilter();
filter.add(value1);
filter.add(value2);
System.out.println("key:" + value1 +"是否存在:"+ filter.contains(value1));
System.out.println("key:" + value2 +"是否存在:"+ filter.contains(value2));
System.out.println("key:" + value3 +"是否存在:"+ filter.contains(value3));
}
}
leveldb示例
参数选择
options.filter_policy = NewBloomFilterPolicy(10);
这里10 为m/n 的值；
该策略使用一个Bloom过滤器，每个密钥大约有指定的每个密钥的比特数。键的比特数是10。
最终测试最佳值是10，这将产生一个误报率为1%的过滤器。
因此k 为：
// We intentionally round down to reduce probing cost a little bit
// bits_per_key = 10
k_ = static_cast<size_t>(bits_per_key * 0.69); // 0.69 =~ ln(2)
因此m 为：
// We intentionally round down to reduce probing cost a little bit
// bits_per_key = 10 默认
// 我们有意四舍五入，以减少一点探测成本
k_ = static_cast<size_t>(bits_per_key * 0.69); // 0.69 =~ ln(2)
if (k_ < 1) k_ = 1;
if (k_ > 30) k_ = 30;
hash 函数
LevelDB的布隆过滤器精髓在哈希函数上，它通过一个哈希达到多个哈希的性能，同时保证误判率在一定的限制。
哈希函数采用的是MurMurHash的一种变体；这种哈希是一种高效低碰撞的非加密型哈希函数，相对于MD5/SHA1，其开销低，
MurmurHash 算法相比于 hashCode 算法有以下优点：
-
更好的哈希性能：MurmurHash 算法在哈希性能方面比 hashCode 算法更优秀，因为它能够快速地计算出任意数据的哈希值。MurmurHash 算法的哈希性能取决于数据的分布情况，但是在大多数情况下，它都能够提供比较好的哈希性能。
-
更低的哈希冲突率：MurmurHash 算法在哈希冲突率方面比 hashCode 算法更优秀，因为它能够更好地处理哈希冲突。MurmurHash 算法使用了一些技巧来减少哈希冲突，例如使用了两个不同的哈希函数、对哈希值进行了混淆等。
-
更好的分布性：MurmurHash 算法的哈希值在分布性方面比 hashCode 算法更优秀，因为它能够更好地处理数据的分布情况。MurmurHash 算法使用了一些技巧来保证哈希值的均匀分布，例如使用了随机数种子、对哈希值进行了混淆等。
-
更少的哈希碰撞：MurmurHash 算法在哈希碰撞方面比 hashCode 算法更优秀，因为它能够更好地处理哈希碰撞。MurmurHash 算法使用了一些技巧来减少哈希碰撞，例如使用了两个不同的哈希函数、对哈希值进行了混淆等。
/*
data：bit 位数
n：n 个 key
seed：种子，实际固定为 0xbc9f1d34
*/
uint32_t Hash(const char* data, size_t n, uint32_t seed) {
// Similar to murmur hash
// 类似杂音哈希
const uint32_t m = 0xc6a4a793;
const uint32_t r = 24;
// limit指向了char*数组的最后一个位置的下一个位置，类似于迭代器end()
const char* limit = data + n;
uint32_t h = seed ^ (n * m);
// Pick up four bytes at a time
// 以4个字节作为一次解析
while (data + 4 <= limit) {
// 每次解码前4个字节，直到最后剩下小于4个字节
// DecodeFixed32 低级别的Get...版本，直接从字符缓冲区读取 而不进行任何边界检查，最近的clang和gcc将其优化为一条 mov / ldr 指令。
uint32_t w = DecodeFixed32(data);
data += 4;
h += w;
h *= m;
h ^= (h >> 16);
}
// Pick up remaining bytes
// 处理剩余的字节
switch (limit - data) {
// 将剩下的字节转化到uint32_t里面
case 3:
// static_cast 表示的是良性转换，含义表示
h += static_cast<uint8_t>(data[2]) << 16;
// FALLTHROUGH_INTENDED宏可以用来注解开关标签之间的隐性落差。真正的定义应该由外部提供。 这个是为不支持的编译器提供的后备版本。
/*
#ifndef FALLTHROUGH_INTENDED
#define FALLTHROUGH_INTENDED \
do { \
} while (0)
#endif
*/
FALLTHROUGH_INTENDED;
case 2:
h += static_cast<uint8_t>(data[1]) << 8;
FALLTHROUGH_INTENDED;
case 1:
h += static_cast<uint8_t>(data[0]);
h *= m;
h ^= (h >> r);
break;
}
return h;
}
扫一扫
252
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
