前言：

最近项目中需要对请求去重，想到的解决方案有2种：

数据库：成本较高，数据量多的话，还要分库分表，查询效率低
布隆过滤：使用简单、成本低，只需要占用很小的内存空间，并且可以设置过期时间；适合大数据量下的去重处理

Bloom Filter 概念

布隆过滤器（英语：Bloom Filter）是1970年由布隆提出的。它实际上是一个很长的二进制向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都远远超过一般的算法，缺点是有一定的误识别率和删除困难-->摘自维基百科

原理：

当一个元素被加入集合时，通过K个散列函数将这个元素映射成一个位数组中的K个点，把它们置为1。检索时，我们只要看看这些点是不是都是1就（大约）知道集合中有没有它了：如果这些点有任何一个0，则被检元素一定不在；如果都是1，则被检元素很可能在。这就是布隆过滤器的基本思想

由上面的概念可知实现一个布隆过滤需要2个基本条件：

二进制向量(位)：引入redis的bit
合适的散列函数：参考guava的实现

Redis中的bit

bit是计算机中的最小单位,值是0或1。redis中，通过设置指定offset的值，将其设置位1，代表该位置已经被占用

注意：offset 参数必须大于或等于 0 ，小于 2^32 (bit 映射被限制在 512 MB 之内)。

API:

SETBIT key offset value:对key设置指定offset上的值
GETBIT key offset:获取key指定offset上对应的值

散列函数：

利用guava实现的64位哈希映射函数把对象key打散成二进制字节数组
再对字节数组分别取低八位和高八位字节进行hash，得到2个hash值
利用hash值，2次取模获取offset，对redis的bit位设1

到这里，一个简易版的布隆过滤就实现了，下面上代码。

添加元素

 public boolean add(String key) {
        //获取字节数据
        byte[] bytes=Hashing.murmur3_128().hashString(key,Charset.forName("UTF-8")).asBytes();
        //hash1函数：低8位
        long hash1 = lowereight(bytes);
        //hash2函数 ：高8位
        long hash2 = uppereight(bytes);

        long combinedHash = hash1;
        //2次hash
        for (int i = 0; i < 2; i++) {
            //对hash值取模：先取正，再取模
            long offeset = (combinedHash & Long.MAX_VALUE) % Integer.MAX_VALUE;
            //判断指定位置是否已经有值
            if (RedisClient.getbit(name,(int) offeset)) {
                return false;
            }
            //设值为1
            RedisClient.setbit(name,(int) offeset);
            combinedHash += hash2;
        }
        return true;
    }

    //低8位：guava的实现
    private long lowereight(byte[] bytes) {
        return Longs.fromByteArray(bytes);
    }
    //高8位：guava的实现
    private long uppereight(byte[] bytes) {
        return Longs.fromBytes(
                bytes[15], bytes[14], bytes[13], bytes[12], bytes[11], bytes[10], bytes[9], bytes[8]);
    }

判断元素是否存在：

和set的过程一致，这里只要2次hash值中的一个位置上有元素（值为1），那么这个元素就已经存在了

public boolean contain(String key) {
        byte[] bytes=Hashing.murmur3_128().hashString(key,Charset.forName("UTF-8")).asBytes();
        long hash1 = lowereight(bytes);
        long hash2 = uppereight(bytes);
        long combinedHash = hash1;
        for (int i = 0; i < 2; i++) {
            long offeset = (combinedHash & Long.MAX_VALUE) % Integer.MAX_VALUE;
            if (RedisClient.getbit(name,(int) offeset)) {
                return true;
            }
            combinedHash += hash2;
        }
        return false;
    }

测试结果：

10万记录，13个误判

@Test
    public void test3(){
        int count=0;
        SBloomFilter bloomFilter=SBloomFilter.getSBloomFilter("selrain");
        for(int i=0;i<100000;i++){
            String key="test"+i;
            if(bloomFilter.contain(key)){
                count++;
            }else {
                bloomFilter.add(key);
            }
        }
        System.out.println(count);
    }

思考：

一般的布隆过率会有2个入参：期望插入次数(number),误判率(false positive probability.),具体hash的次数是通过这2个值计算出来，我这里固定了2次hash；另外redis的bit我也没看到有初始化bit数组的大小的函数，有知道的么
跑数据我发现了占用了200M+内存，内存占用还是很高的，最终用了redisson实现的方案(因为占用的内存更小，大概10M+),不知道做了什么优化？感兴趣的可以看看

参考：

https://segmentfault.com/a/1190000012620152

最后：

小尾巴走一波，欢迎关注我的公众号，不定期分享编程、投资、生活方面的感悟:)