布隆过滤器 -- 转载

最近在复习redis，发现一篇好的文章，在此记录下，请多多指教。转载连接如下：
https://www.cnblogs.com/liyulong1982/p/6013002.html
https://www.cnblogs.com/zc110/articles/13380446.html

典型的应用场景：缓存穿透

算法：

1. 首先需要k个hash函数，每个函数可以把key散列成为1个整数
2. 初始化时，需要一个长度为n比特的数组，每个比特位初始化为0
3. 某个key加入集合时，用k个hash函数计算出k个散列值，并把数组中对应的比特位置为1
4. 判断某个key是否在集合时，用k个hash函数计算出k个散列值，并查询数组中对应的比特位，如果所有的比特位都是1，认为在集合中。

优点：不需要存储key，节省空间
缺点：

1. 误判率：算法判断key在集合中时，有一定的概率key其实不在集合中(解释：Hash面临的问题就是冲突。假设 Hash 函数是良好的，如果我们的位阵列长度为 m 个点，那么如果我们想将冲突率降低到例如 1%, 这个散列表就只能容纳 m/100 个元素。显然这就不叫空间有效了（Space-efficient）。解决方法也简单，就是使用多个 Hash，如果它们有一个说元素不在集合中，那肯定就不在。如果它们都说在，虽然也有一定可能性它们在说谎，不过直觉上判断这种事情的概率是比较低的。)
2. 无法删除

guava实现布隆过滤器

现在相信你对布隆过滤器应该有一个比较感性的认识了，布隆过滤器核心思想其实并不难，难的在于如何设计随机映射函数，到底映射几次，二进制向量的长度设置为多少比较好，这可能就不是一般的开发可以驾驭的了，好在Google大佬给我们提供了开箱即用的组件，来帮助我们实现布隆过滤器，现在就让我们看看怎么Google大佬送给我们的“礼物”吧。

首先在pom引入“礼物”：

<dependency>
    <groupId>com.google.guava</groupId>
     <artifactId>guava</artifactId>
     <version>19.0</version>
 </dependency>

然后就可以测试啦：

private static int size = 1000000;//预计要插入多少数据

private static double fpp = 0.01;//期望的误判率

private static BloomFilter<Integer> bloomFilter = BloomFilter.create(Funnels.integerFunnel(), size, fpp);

public static void main(String[] args) {
    //插入数据
    for (int i = 0; i < 1000000; i++) {
        bloomFilter.put(i);
    }
    int count = 0;
    for (int i = 1000000; i < 2000000; i++) {
        if (bloomFilter.mightContain(i)) {
            count++;
            System.out.println(i + "误判了");
        }
    }
    System.out.println("总共的误判数:" + count);
}

代码简单分析：
我们定义了一个布隆过滤器，有两个重要的参数，分别是 我们预计要插入多少数据，我们所期望的误判率，误判率不能为0。
我向布隆过滤器插入了0-1000000，然后用1000000-2000000来测试误判率。

运行结果：

1999501误判了
1999567误判了
1999640误判了
1999697误判了
1999827误判了
1999942误判了
总共的误判数:10314

现在总共有100万数据是不存在的，误判了10314次，我们计算下误判率

和我们定义的期望误判率0.01相差无几。

redis实现布隆过滤器

上面使用guava实现布隆过滤器是把数据放在本地内存中，无法实现布隆过滤器的共享，我们还可以把数据放在redis中，用 redis来实现布隆过滤器，我们要使用的数据结构是bitmap，你可能会有疑问，redis支持五种数据结构：String，List，Hash，Set，ZSet，没有bitmap呀。没错，实际上bitmap的本质还是String。

可能有小伙伴会说，纳尼，布隆过滤器还没介绍完，怎么又出来一个bitmap，没事，你可以把bitmap就理解为一个二进制向量。

要用redis来实现布隆过滤器，我们需要自己设计映射函数，自己度量二进制向量的长度，这对我来说，无疑是一个不可能完成的任务，只能借助搜索引擎，下面直接放出代码把。

public class RedisMain {
    static final int expectedInsertions = 1000;//要插入多少数据
    static final double fpp = 0.01;//期望的误判率

    //bit数组长度
    private static long numBits;

    //hash函数数量
    private static int numHashFunctions;

    static {
        numBits = optimalNumOfBits(expectedInsertions, fpp);
        numHashFunctions = optimalNumOfHashFunctions(expectedInsertions, numBits);
    }

    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);
        for (int i = 0; i < 1000; i++) {
            long[] indexArray = getIndexArray(String.valueOf(i));
            for (long index : indexArray) {
                jedis.setbit("codebear:bloom", index, true);
            }
        }
        int num = 0;
        for (int i = 1000; i < 2000; i++) {
            long[] indexArray = getIndexArray(String.valueOf(i));
            for (long index : indexArray) {
                if (!jedis.getbit("codebear:bloom", index)) {
                    System.out.println(i + "一定不存在");
                    num++;
                    break;
                }
            }
        }
        System.out.println("一定不存在的有" + num + "个");
    }

    /**
     * 根据key获取bitmap下标
     */
    private static long[] getIndexArray(String key) {
        long hash1 = hash(key);
        long hash2 = hash1 >>> 16;
        long[] result = new long[numHashFunctions];
        for (int i = 0; i < numHashFunctions; i++) {
            long combinedHash = hash1 + i * hash2;
            if (combinedHash < 0) {
                combinedHash = ~combinedHash;
            }
            result[i] = combinedHash % numBits;
        }
        return result;
    }

    private static long hash(String key) {
        return Hashing.MURMUR_HASH.hash(key);
    }

    //计算hash函数个数
    private static int optimalNumOfHashFunctions(long n, long m) {
        return Math.max(1, (int) Math.round((double) m / n * Math.log(2)));
    }

    //计算bit数组长度
    private static long optimalNumOfBits(long n, double p) {
        if (p == 0) {
            p = Double.MIN_VALUE;
        }
        return (long) (-n * Math.log(p) / (Math.log(2) * Math.log(2)));
    }
}

运行结果：

1997一定不存在
1998一定不存在
1999一定不存在
一定不存在的有989个