目录
一、布隆过滤器
布隆过滤器(Bloom Filter)是1970年由布隆提出的。它实际上是一个很长的二进制向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。
算法优势:
- 仅仅保留数据的指纹信息,空间效率极高(指纹信息:根据随意映射函数找到对应的二进制向量位置,并标记该位置)
- 查询效率极高,时间复杂度为:O(n)
- 信息安全性较高
算法不足:
- 存在一定的误判
- 数据删除困难
如果想判断一个元素是不是在一个集合里,一般想到的是将集合中所有元素保存起来,然后通过比较确定。链表、树、散列表(又叫哈希表,Hash table)等等数据结构都是这种思路。但是随着集合中元素的增加,我们需要的存储空间越来越大。同时检索速度也越来越慢,上述三种结构的检索时间复杂度分别为:O(n), O(log n), O(n/k)。
布隆过滤器的原理是,当一个元素被加入集合时,通过K个Hash函数将这个元素映射成一个位数组中的K个点,把它们置为1。检索时,我们只要看看这些点是不是都是1就(大约)知道集合中有没有它了:如果这些点有任何一个0,则被检元素一定不在;如果都是1,则被检元素很可能在。这就是布隆过滤器的基本思想。
二、为什么要用布隆过滤器?
通过介绍已经知晓布隆过滤器的作用是检索一个元素是否在集合中。可能有人认为这个功能非常简单,直接放在redis中或者数据库中查询就好了。又或者当数据量较小,内存又足够大时,使用hashMap或者hashSet等结构就好了。但是如果当这些数据量很大,数十亿甚至更多,内存装不下且数据库检索又极慢的情况,我们应该如何去处理?这个时候我们不妨考虑下布隆过滤器,因为它是一个空间效率占用极少和查询时间极快的算法,但是需要业务可以忍受一个判断失误率。
三、布隆过滤器应用场景
- 网页黑名单系统
- 垃圾邮件过滤系统
- 爬虫的网址判重系统
- 解决缓存穿透
对布隆过滤器算法比较感兴趣的朋友,可以自行搜索下,这里暂时不展示
四、布隆过滤器的简单实现
google已经将布隆过滤器封装进jar包,可直接引入依赖调用实现
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>19.0</version>
</dependency>
PS:guava包在19.0版本以上才封装有布隆过滤器的实现
testDemo code
public void testDemo(){
//初始化个数
int initNumber = 200000;
//初始化3个存储String类型的容器
BloomFilter<String> bf = BloomFilter.create(Funnels.stringFunnel(Charsets.UTF_8), initNumber,0.01);
Set<String> sets = new HashSet<String>(initNumber);
List<String> lists = new ArrayList<String>(initNumber);
//向三个容器存入随机字符串数据
for (int i = 0; i < initNumber; i++) {
String uuid = UUID.randomUUID().toString();
bf.put(uuid);
sets.add(uuid);
lists.add(uuid);
}
int wrong = 0;//正确个数
int right = 0;//错误个数
int testNumber = 10000;
for (int i = 0; i < testNumber; i++) {
//按照一定比例的选择bf内肯定存在的值
String test = i%100 == 0 ? lists.get(i/100) : UUID.randomUUID().toString();
if(bf.mightContain(test)){
if(sets.contains(test)){
right++;
}else{
wrong++;
}
}
}
System.out.println("正确个数:"+ right);
System.out.println("错误个数:"+ wrong);
System.out.println("错误率 :"+ ((wrong*1.0)/(testNumber*1.0)));
}
这是简单的调用实现,BloomFilter.create 有三个参数
- Funnel:描述了如何把一个具体的对象类型分解为原生字段值,从而写入
- expectedInsertions:插入一个确定的初始化数值
- fpp:期望的错误率,默认0.03
进入源码查看创建过程
static <T> BloomFilter<T> create(
Funnel<? super T> funnel, long expectedInsertions, double fpp, Strategy strategy) {
checkNotNull(funnel);
checkArgument(
expectedInsertions >= 0, "Expected insertions (%s) must be >= 0", expectedInsertions);
checkArgument(fpp > 0.0, "False positive probability (%s) must be > 0.0", fpp);
checkArgument(fpp < 1.0, "False positive probability (%s) must be < 1.0", fpp);
checkNotNull(strategy);
if (expectedInsertions == 0) {
expectedInsertions = 1;
}
/*
* TODO(user): Put a warning in the javadoc about tiny fpp values,
* since the resulting size is proportional to -log(p), but there is not
* much of a point after all, e.g. optimalM(1000, 0.0000000000000001) = 76680
* which is less than 10kb. Who cares!
*/
//根据初始化数据大小和错误率,计算出可用数组长度
long numBits = optimalNumOfBits(expectedInsertions, fpp);
//根据初始化数据大小和数组长度,计算需要使用到的hash容器个数
int numHashFunctions = optimalNumOfHashFunctions(expectedInsertions, numBits);
try {
return new BloomFilter<T>(new BitArray(numBits), numHashFunctions, funnel, strategy);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("Could not create BloomFilter of " + numBits + " bits", e);
}
}
PS:计算数组长度和容器个数的所需数量,是开发者们测试得出来的较为可靠的值,数据展示在对应方法注释内有提供参考链接,这里就不展示。
如果失误率越低,所需的数组空间也就越大,采用空间作为代价,实际场景根据业务自行调整。
插入过程
public <T> boolean put(
T object, Funnel<? super T> funnel, int numHashFunctions, BitArray bits) {
long bitSize = bits.bitSize();
//这里使用hash算法进行hash运算
byte[] bytes = Hashing.murmur3_128().hashObject(object, funnel).getBytesInternal();
//获取字节数组的低8位进行运算
long hash1 = lowerEight(bytes);
//获取字节数组的高8位进行运算
long hash2 = upperEight(bytes);
boolean bitsChanged = false;
long combinedHash = hash1;
//遍历容器个数,更改对应的位置标识
for (int i = 0; i < numHashFunctions; i++) {
// Make the combined hash positive and indexable
bitsChanged |= bits.set((combinedHash & Long.MAX_VALUE) % bitSize);
combinedHash += hash2;
}
return bitsChanged;
}
判断元素是否存在,原理同插入相似
public <T> boolean mightContain(
T object, Funnel<? super T> funnel, int numHashFunctions, BitArray bits) {
long bitSize = bits.bitSize();
byte[] bytes = Hashing.murmur3_128().hashObject(object, funnel).getBytesInternal();
long hash1 = lowerEight(bytes);
long hash2 = upperEight(bytes);
long combinedHash = hash1;
for (int i = 0; i < numHashFunctions; i++) {
// Make the combined hash positive and indexable
if (!bits.get((combinedHash & Long.MAX_VALUE) % bitSize)) {
return false;
}
combinedHash += hash2;
}
return true;
}
在实际业务中,可在实现类初始化时,将所需判断的所有数据查询导入布隆过滤器,在海量数据中,查询操作也要做对应的优化。
文章参考: