转载：https://zhuanlan.zhihu.com/p/692179021
一、背景介绍
在互联网中，我们经常遇到需要在大量数据中判断目标数据是否存在的情况。例如，在网络爬虫中，我们需要判断某个网址是否已经被访问过。为了实现这一功能，通常需要使用一个容器来存储已访问过的网址。如果将这些数据直接存储在磁盘中，每次判断都要进行磁盘查询，这将导致大量的IO操作，效率较低。因此，我们希望将这些数据保存在内存中。在数据量较小的情况下，可以使用Redis来存储这些数据。但是，当数据量超过上千万时，将会消耗几GB甚至几十GB的内存空间。然而，对于仅需要记录数据是否存在的情况而言，这样使用大量内存显然是浪费的。为了解决这个问题，我们可以使用布隆过滤器(Bloom Filter)。布隆过滤器是一种占用空间少且时间效率高的工具。
二、认识布隆过滤器
2.1 布隆过滤器简介
布隆过滤器（Bloom Filter）是1970年由布隆提出的，它实质上是一个很长的二进制向量和一系列随机映射函数 (Hash函数)。
作用：它是一个空间效率高的概率型数据结构，用来告诉你:一个元素一定不存在或者可能存在。
2.2 优点
-
相比于其它的数据结构，布隆过滤器在空间和时间方面都有巨大的优势。布隆过滤器存储空间和插入/查询时间都是常数（即hash函数的个数）。
-
Hash 函数相互之间没有关系，方便由硬件并行实现。
-
布隆过滤器不需要存储元素本身，在某些对保密要求非常严格的场合有优势。
-
布隆过滤器可以表示全集，其它任何数据结构都不能。解释：布隆过滤器（Bloom Filter）可以“表示全集”的说法，源于其独特的概率特性。具体来说，布隆过滤器并不存储元素本身，而是通过哈希函数映射到一个位数组，形成一个“模糊但紧凑”的数据表示。因此，它具备以下特性，使得可以“表示全集”
-
误判但无遗漏：
- 布隆过滤器可以确定某个元素“可能存在”或“一定不存在”。
- 对于所有可能的输入，布隆过滤器都能做出判断，因此在逻辑上，它可以表示整个可能的输入集合（即“全集”）。
- 由于存在哈希碰撞，可能会误判一个不存在的元素为“存在”，但不会漏掉已加入的元素。
-
有限存储表示无限集合：
- 传统数据结构（如哈希表、集合）需要存储元素本身，无法表示“无限集合”。
- 布隆过滤器通过固定大小的位数组和哈希函数，即可用于查询任意元素是否在集合中，而不必存储所有元素，从而“间接表示全集”。
-
其他数据结构的局限性：
- 哈希表、数组、链表等都必须存储具体的元素，因此它们只能存储有限大小的集合，而无法表示“全集”。
- 逻辑上，“全集”意味着可以对任意元素进行查询，而传统数据结构如果不包含某个元素，就无法返回任何有效结果。
结论：布隆过滤器通过概率方法“模糊地”表示全集，虽然存在误判，但它仍然能处理理论上无限可能的输入，这是其他数据结构无法做到的。因此，在某种意义上，可以说“布隆过滤器可以表示全集，而其他数据结构不能”。
-
2.3 缺点
- 有误判率存在。
- 不支持删除。
2.4 适用场景
- 预防缓存穿透：布隆过滤器快速判断数据是否存在，避免通过查询数据库来判断数据是否存在。
- 网络爬虫：布隆过滤器可以用来去重已经爬取过的URL。
- 邮箱的垃圾邮件过滤。
- 黑白名单。
三、 布隆过滤器原理
3.1 结构
布隆过滤器实现原理就是一个超大位数的数组和多个不同Hash算法函数。假设位数组的长度为 m，哈希函数的个数为 k。如下图，一个长度16位的数组，3个不同Hash算法函数，数组里面存储的是 bit 位，只放 0 和 1，初始为 0。
不同Hash算法函数
指定长度数组
3.2 添加元素
将要添加的元素分别通过k个哈希函数计算得到k个哈希值，这k个hash值对应位数组上的k个位置，然后将这k个位置设置为1。
我们添加一个data1和data2两个元素，两个元素根据三个hash算法函数计算出的值，需要说明一点三个值可能会存在相同的值。
其中data1计算出1、8、13三值，我们把数组中对应的位置设置为1。
Hash1(data1)=1
Hash2(data1)=8
Hash3(data1)=13
如图：
data2计算出2、5、13三值，我们把数组中对应的位置设置为1
Hash1(data2)=2
Hash2(data2)=5
Hash3(data2)=13
如图：
我们发现data1和data2经过hash函数后，出现了一个相同值，这种是正常的，也正是因为这种情况的存在，需要多个函数来保证每个元素尽可能对应数组位置的唯一性，可以看下两个元素在一起的效果。
如图：
当不同元素在不同或者相同的hash函数计算后，得到同一个值，依旧只需要这个位置保持1即可。
3.3 查询元素
将要查询的元素分别通过k个哈希函数计算得到k个哈希值，这k个hash值对应位数组上的k个位置。如果这k个位置中有一个位置为0，则此元素一定不存在集合中。如果这k个位置全部为1，则这个元素可能存在。
我们在刚才添加过data1和data2两个元素的布隆过滤器查询以下三种元素，data1已添加到布隆过滤器元素，data3和data4都是未添加到布隆过滤器元素。
查询data1先根据添加时的三个hash函数计算分别对应值，值分别是1、8、13，然后查询数组中这三个位置的值是否为1。
Hash1(data1)=1
Hash2(data1)=8
Hash3(data1)=13
如图：
我们可以看到数组中1、8、13这三个位置都是1，data1可能存在于该布隆过滤器。我们从添加的角度来看，我们知道data1是一定存在于该布隆过滤器的，为什么还要是说可能呢，是因为查询出来三个位置都为1不能代表这个三个1都是同一个元素添加的，下面我们看下元素data3的查询。
查询data3先根据添加时的三个hash函数计算分别对应值，值分别是2、8、13，然后查询数组中这三个位置的值是否为1。
Hash1(data3)=2
Hash2(data3)=8
Hash3(data3)=13
如图：
我们已知的该布隆过滤器我们没有添加给data3，为什么data3查询出来三个位置的值都为1呢。我们可以看到data3所命中的位置分别是data2添加时把位置2赋值的1，和data1添加时把位置8和位置13赋值的1，都是由其他元素改变的位置对应的值，所以命中位置全部为1。这个元素可能存在。
我们查询一下data4，看下命中位置不全为0的数据。查询data4先根据添加时的三个hash函数计算分别对应值，值分别是2、8、13，然后查询数组中这三个位置的值是否为1。
Hash1(data4)=1
Hash2(data4)=8
Hash3(data4)=12
如图：
我们可以看到data4元素的hash函数3计算之后的值是12，数组位置12的值是0，没有元素在位置12赋值过1。如果data4存在于该布隆过滤器，则一定在添加data4时会把位置12赋值1，此时位置12还是0，则说明该布隆过滤器未添加过data4元素，所以位置中有一个位置为0。则此元素一定不存在布隆过滤器中。
四、布隆过滤器误判率
刚才查询时我们发现data3没有添加过到布隆过滤器，却在布隆过滤器查询到了，这种情况就是布隆过滤器误判了。那可以不存在误判或者减少误判吗？事实上误判是一定存在的，我们可以尽可能减小误判。下面说下如何得到误判率。
4.1 参数
m：布隆过滤器的bit长度。
n：插入过滤器的元素个数。
k：哈希函数的个数。
4.2 误判率公式（推导过程自查）
1、布隆过滤器（Bloom Filter）的误差率指的是误判率（False Positive Rate, FPR），即某个元素实际上不在集合中，但布隆过滤器错误地判断它存在的概率。
误判率的计算公式为：
其中：
- k：哈希函数的数量
- n：插入的元素个数
- m：布隆过滤器的位数组大小
- e：自然常数（约等于 2.718）
由误判率公式可知，在k一定的情况下，当n增加时，误判率增加，m增加时，误判率减少。
五、实现方式
5.1 Guava实现
guava是谷歌开源工具类，其中就有能直接实现布隆过滤器的方法，不需要重复造轮子。
| 方法名 | 功能 | 参数 | 返回值 |
|---|---|---|---|
| put | 添加元素 | put(T object) | boolean |
| mightContain | 检查元素是否存在 | mightContain(T object) | boolean |
| copy | 根据此实例创建一个新的BloomFilte | copy() | BloomFilter |
| approximateElementCount | 已添加到Bloom过滤器的元素的数量 | approximateElementCount() | long |
| expectedFpp | 返回元素存在的错误概率 | expectedFpp() | double |
| isCompatible | 确定给定的Bloom筛选器是否与此Bloom筛选器兼容 | isCompatible(BloomFilter that) | boolean |
| putAll | 通过执行的逐位OR将此Bloom过滤器与另一个Bloom过滤器组合 | putAll(BloomFilter that) | void |
引入依赖
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>23.0</version>
</dependency>测试代码
private static void GuavaBloomFilter() {
// 创建布隆过滤器对象
BloomFilter bloomFilter = BloomFilter.create(Funnels.stringFunnel(Charset.defaultCharset()),EXPECTED_INSERTIONS,FALSE_PROBABILITY);
// 向过滤器中添加元素
bloomFilter.put("element001");
bloomFilter.put("element003");
// 判断元素是否存在
System.out.println(bloomFilter.mightContain("element001"));//true
System.out.println(bloomFilter.mightContain("element002"));//false
// 已添加到Bloom过滤器的元素的数量
System.out.println(bloomFilter.approximateElementCount());// 2
// 返回元素存在的错误概率
System.out.println(bloomFilter.expectedFpp());
}5.2 Redis实现
- 开源Redisson(RBloomFilter)。
- Redis 4.0 官方提供布隆过滤器插件。
- 通过Redis提供的bitMap自己实现。
5.2.1 开源Redisson方式
Redisson方法
| 方法名 | 功能 | 参数 | 返回值 |
|---|---|---|---|
| add | 添加元素 | add(T object) | boolean |
| contains | 检查元素是否存在 | contains(T object) | boolean |
| count | 已添加到Bloom过滤器的元素的数量 | count() | long |
| getExpectedInsertions | 返回的预期插入元素的个数 | getExpectedInsertions() | long |
| getFalseProbability | 返回元素存在的错误概率 | getFalseProbability() | double |
| getHashIterations | 返回每个元素使用的哈希迭代次数 | getHashIterations() | int |
| getSize | 返回此实例所需Redis内存的位数 | getSize() | long |
| tryInit | 初始化Bloom筛选器参数 | tryInit(long expectedInsertions, double falseProbability) | boolean |
| delete | 删除对象 | delete() | boolean |
引入依赖
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>3.22.1</version>
</dependency>测试代码
private static void RedissonBloomFilter() {
Config config = new Config();
config.useSingleServer().setAddress("redis://" + REDIS_IP + ":" + REDIS_PORT);
config.useSingleServer().setPassword(REDIS_PASSWORD);
// 获取客户端
RedissonClient redissonClient = Redisson.create(config);
RBloomFilter<String> bloomFilter = redissonClient.getBloomFilter(BLOOM_FILTER_NAME);
// 初始化布隆过滤器：预期插入量为100000000L,预期错误概率为1%
bloomFilter.tryInit(EXPECTED_INSERTIONS, FALSE_PROBABILITY);
// 插入数据
bloomFilter.add("element001");
bloomFilter.add("element003");
// 判断下面元素是否在布隆过滤器中
System.out.println(bloomFilter.contains("element002"));//false
System.out.println(bloomFilter.contains("element001"));//true
// 已添加到Bloom过滤器的元素的数量
System.out.println(bloomFilter.count());//2
// 预期插入元素的个数
System.out.println(bloomFilter.getExpectedInsertions());//1000000
// 元素存在的错误概率
System.out.println(bloomFilter.getFalseProbability());//0.01
// 每个元素使用的哈希迭代次数
System.out.println(bloomFilter.getHashIterations());
// 实例所需Redis内存的位数
System.out.println(bloomFilter.getSize());
}5.2.2 Redis 4.0 官方提供布隆过滤器插件
基础命令
| 命令 | 功能 | 参数 |
|---|---|---|
| BF.RESERVE | 创建一个大小为capacity，错误率为error_rate的空的Bloom | BF.RESERVE {key} {error_rate} {capacity} [EXPANSION {expansion}] [NONSCALING] |
| BF.ADD | 向key指定的Bloom中添加一个元素itom | BF.ADD {key} {item} |
| BF.MADD | 向key指定的Bloom中添加多个元案 | BF.MADD {key} {item ...} |
| BF.INSERT | 向key指定的Bloom中添加多个元素，添加时可以指定大小和错误率，且可以控制在Bloom不存在的时候是否自动创建 | BF.INSERT {key} [CAPACITY {cap}] [ERROR {error}] [EXPANSION {expansion}] [NOCREATE] [NONSCALING] ITEMS {item ...} |
| BF.EXISTS | 检查一个元秦是否可能存在于key指定的Bloom中 | BF.EXISTS {key} {item} |
| BF.MEXISTS | 同时检查多个元素是否可能存在于key指定的Bloom中 | BF.MEXISTS {key} {item ...} |
| BF.SCANDUMP | 对Bloom进行增量持久化操作 | BF.SCANDUMP {key} {iter} |
| BF.LOADCHUNK | 加载SCANDUMP持久化的Bloom数据 | BF.LOADCHUNK {key} {iter} {data} |
| http://BF.INFO | 查询key指定的Bloom的信息 | http://BF.INFO {key} |
| BF.DEBUG | 查看BloomFilter的内部详细信息(如每层的元素个数，错误率等) | BF.DEBUG (key} |
引入依赖
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>4.2.0</version>
</dependency>测试代码
private static void RedisBloomFilter() {
// 建立连接
BloomFilterCommands bloomFilterCommands = new JedisPooled(REDIS_IP, REDIS_PORT, "", REDIS_PASSWORD);
// 构建布隆过滤器参数
BFReserveParams bfReserveParams = new BFReserveParams();
bfReserveParams.expansion(2);
// 创建一个过滤器
String test = bloomFilterCommands.bfReserve(BLOOM_FILTER_NAME, FALSE_PROBABILITY, EXPECTED_INSERTIONS, bfReserveParams);
// 向过滤器中添加元素
bloomFilterCommands.bfAdd(BLOOM_FILTER_NAME, "element001");
bloomFilterCommands.bfAdd(BLOOM_FILTER_NAME, "element003");
// 判断元素是否存在
System.out.println(bloomFilterCommands.bfExists(BLOOM_FILTER_NAME, "element001"));//true
System.out.println(bloomFilterCommands.bfExists(BLOOM_FILTER_NAME, "element002"));//false
}5.2.3 通过Redis提供的bitMap自己实现
自定义方法
| 方法名 | 功能 | 参数 | 返回值 |
|---|---|---|---|
| add | 添加元素 | add(String key, String element, int expireSec) | boolean |
| contains | 检查元素是否存在 | contains(String key, String element) | boolean |
| getExpectedInsertions | 返回的预期插入元素的个数 | getExpectedInsertions() | long |
| getFalseProbability | 返回元素存在的错误概率 | getFalseProbability() | double |
| getNumHashFunctions | 返回每个元素使用的哈希迭代次数 | getNumHashFunctions() | int |
| getBitmapLength | 返回Bitmap长度 | getBitmapLength() | long |
| BloomFilterUtils | 创建Bloom对象 | BloomFilterUtils(long expectedInsertions, double falseProbability) | BloomFilterUtils |
测试代码
public class BloomFilterUtils {
private static final String BF_KEY_PREFIX = "bf_";
private long numApproxElements;
private double falseProbability;
// hash个数
private int numHashFunctions;
// 数组长度
private int bitmapLength;
private JedisResourcePool jedisResourcePool;
/**
* 构造布隆过滤器。注意：在同一业务场景下，三个参数务必相同
*
* @param numApproxElements 预估元素数量
* @param fpp 可接受的最大误差
* @param jedisResourcePool Codis专用的Jedis连接池
*/
public BloomFilterUtils(Long numApproxElements, double fpp, JedisResourcePool jedisResourcePool) {
this.numApproxElements = numApproxElements;
this.falseProbability = fpp;
this.jedisResourcePool = jedisResourcePool;
// 数组长度 m = (n * lnp)/ln2^2
bitmapLength = (int) (-numApproxElements * Math.log(fpp) / (Math.log(2) * Math.log(2)));
// hash个数 k = (n / m ) * ln2
numHashFunctions = Math.max(1, (int) Math.round((double) bitmapLength / numApproxElements * Math.log(2)));
}
/**
* 取得预估元素数量
*/
public long getExpectedInsertions() {
return numApproxElements;
}
/**
* 返回元素存在的错误概率
*/
public double getFalseProbability() {
return falseProbability;
}
/**
* 取得自动计算的最优哈希函数个数
*/
public int getNumHashFunctions() {
return numHashFunctions;
}
/**
* 取得自动计算的最优Bitmap长度
*/
public int getBitmapLength() {
return bitmapLength;
}
/**
* 计算一个元素值哈希后映射到Bitmap的哪些bit上
*
* @param element 元素值
* @return bit下标的数组
*/
private long[] getBitIndices(String element) {
long[] indices = new long[numHashFunctions];
// 元素 使用MurMurHash3 128位Hash算法转换值
byte[] bytes = Hashing.murmur3_128()
.hashObject(element, Funnels.stringFunnel(Charset.forName("UTF-8")))
.asBytes();
// 低8位转Long值
long hash1 = Longs.fromBytes(
bytes[7], bytes[6], bytes[5], bytes[4], bytes[3], bytes[2], bytes[1], bytes[0]
);
// 高8位转Long值
long hash2 = Longs.fromBytes(
bytes[15], bytes[14], bytes[13], bytes[12], bytes[11], bytes[10], bytes[9], bytes[8]
);
long combinedHash = hash1;
// 双重哈希进行散列
for (int i = 0; i < numHashFunctions; i++) {
indices[i] = (combinedHash & Long.MAX_VALUE) % bitmapLength;
combinedHash += hash2;
}
return indices;
}
/**
* 插入元素
*
* @param key 原始Redis键，会自动加上'bf_'前缀
* @param element 元素值，字符串类型
* @param expireSec 过期时间（秒）
*/
public void add(String key, String element, int expireSec) {
if (key == null || element == null) {
throw new RuntimeException("键值均不能为空");
}
String actualKey = BF_KEY_PREFIX.concat(key);
try (Jedis jedis = jedisResourcePool.getResource()) {
try (Pipeline pipeline = jedis.pipelined()) {
// 遍历元素所有hash结果的bit位置
for (long index : getBitIndices(element)) {
pipeline.setbit(actualKey, index, true);
}
pipeline.syncAndReturnAll();
}
jedis.expire(actualKey, expireSec);
}
}
/**
* 检查元素在集合中是否（可能）存在
*
* @param key 原始Redis键，会自动加上'bf_'前缀
* @param element 元素值，字符串类型
*/
public boolean contains(String key, String element) {
if (key == null || element == null) {
throw new RuntimeException("键值均不能为空");
}
String actualKey = BF_KEY_PREFIX.concat(key);
boolean result = false;
try (Jedis jedis = jedisResourcePool.getResource()) {
// 遍历元素所有hash结果的bit位置
try (Pipeline pipeline = jedis.pipelined()) {
for (long index : getBitIndices(element)) {
pipeline.getbit(actualKey, index);
}
result = !pipeline.syncAndReturnAll().contains(false);
}
}
return result;
}
public static void main(String[] args) {
String path = Path.getCurrentPath() + "/config/zzjodis.properties";
ConfigReadUtil configReadUtil = new ConfigReadUtil(path);
try {
JedisResourcePool jedisResourcePool = RoundRobinJedisPool.
create()
.curatorClient(configReadUtil.getString("jodisZkStr"), 5000)
.zkProxyDir(configReadUtil.getString("zkProxyDir"))
.team(configReadUtil.getString("team"))
.connectionTimeoutMs(configReadUtil.getInt("connectionTimeoutMs"))
.soTimeoutMs(configReadUtil.getInt("soTimeoutMs"))
.appKey(configReadUtil.getString("appKey"))
.password("".equals(configReadUtil.getString("password")) ? null : configReadUtil.getString("password"))
.build();
BloomFilterUtils bloomFilterUtils = new BloomFilterUtils(10000, 0.01, jedisResourcePool);
bloomFilterUtils.add("filter01", "element001", 30 * 60);
System.out.println(bloomFilterUtils.contains("filter01", "element001")); // true
System.out.println(bloomFilterUtils.contains("filter01", "element002")); // false
} catch (Exception e) {
e.printStackTrace();
}
}
}布隆过滤器选择
| 实现方式 | 储存位置 | 适用场景 | 备注 |
|---|---|---|---|
| Guava | 机器 | 单机 | 只需要机器内存不需要其他资源 |
| Redisson | redis | 分布式 | 连接Redis即可使用 |
| Redis插件 | redis | 分布式 | 需要对redis集群进行设置支持布隆过滤器插件 |
| Redis的bitMap | redis | 分布式 | 需要自己实现添加和查询 |
对于分布式服务环境，Guava方式不适合使用，而Redis插件需要复杂的配置和高成本支持。相比之下，Redisson连接Redis并进行插入和查询的方式更适合当前场景，因此最终选择了Redisson方式。
布隆过滤器初始化问题
例如：600万用户情况下，初始化 数据量和 错误率如何设置？
在 600 万用户 的情况下，布隆过滤器的 初始化数据量（位数组大小）和错误率（误判率） 需要合理设置，以在 存储空间、查询速度和误判率 之间取得平衡。
不同误判率下的计算
| 误判率 p | 位数组大小 m | 每个元素占用位数 m/n | 最优哈希函数个数 k |
|---|---|---|---|
| 1% (0.01) | 5.16 × 10⁷ (~ 6.45 MB) | 8.6 bits | 6.2 ≈ 6 |
| 0.1% (0.001) | 8.59 × 10⁷ (~ 10.74 MB) | 14.3 bits | 10 |
| 0.01% (0.0001) | 1.13 × 10⁸ (~ 13.9 MB) | 18.9 bits | 13 |
说明：
- 误判率越低，所需的位数组就越大。
- k 取整数，通常取 6~10 之间。
推荐参数
- 若存储空间有限，查询性能要求高 → 误判率设为 0.01 (1%)，约 6.45MB 空间，6 个哈希函数。
- 若存储空间允许，希望误判率更低 → 误判率设为 0.001 (0.1%)，约 10.74MB 空间，10 个哈希函数。
总结
- 存储空间 m 取 50 100 MB 以内
- 误判率 p 设定在 0.01 ~ 0.001 之间
- 哈希函数 k 设定为 6 ~ 10
这些参数可以在 存储、查询速度和准确率 之间达到良好平衡。
扫一扫
4199
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
