一起走进布隆过滤器

关于布隆过滤器的定义？

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

布隆过滤器的原理？

布隆过滤器的原理是，当一个元素被加入集合时，通过K个散列函数将这个元素映射成一个位数组中的K个点，把它们置为1。检索时，我们只要看看这些点是不是都是1就（大约）知道集合中有没有它了：如果这些点有任何一个0，则被检元素一定不在；如果都是1，则被检元素很可能在。这就是布隆过滤器的基本思想。
Bloom Filter跟单哈希函数Bit-Map不同之处在于：Bloom Filter使用了k个哈希函数，每个字符串跟k个bit对应。从而降低了冲突的概率。

如果上述讲述对你有点模糊，那么引用网上jack xu的一个例子，个人感觉比较详细一些：

我们看集合里面3个元素，现在我们要存了：
比如说a，经过f1(a)，f2(a)，f3(a)经过三个哈希函数的计算，在相应的位置上存入1，元素b，c也是通过这三个函数计算放入相应的位置。当取的时候，元素a通过f1(a)函数计算，发现这个位置上是1，没问题，第二个位置也是1，第三个位置上也是 1，这时候我们说这个a在布隆过滤器中是存在的，没毛病，同理我们看下面的这个d，通过三次计算发现得到的结果也都是1，那么我们能说d在布隆过滤器中是存在的吗，显然是不行的，我们仔细看d得到的三个1其实是f1(a)，f1(b)，f2©存进去的，并不是d自己存进去的，这个还是哈希碰撞导致的，我们把这种本来不存在布隆过滤器中的元素误判为存在的情况叫做假阳性（False Positive Probability，FPP）。

我们再来看另一个元素，e 元素。我们要判断它在容器里面是否存在，一样地要用这三个函数去计算。第一个位置是 1，第二个位置是 1，第三个位置是 0。那么e元素能不能判断是否在布隆过滤器中？ 答案是肯定的，e一定不存在。你想啊，如果e存在的话，他存进去的时候这三个位置都置为1，现在查出来有一个位置是0，证明他没存进去啊。。通过上面这张图跟说明，我们得出两个重要的结论：

从容器角度：
如果布隆过滤器判断元素在集合中存在，不一定存在。
如果布隆过滤器判断不存在，一定不存在。
从元素角度：
如果元素实际存在，布隆过滤器一定判断存在。
如果元素实际不存在，布隆过滤器可能判断存在。

布隆过滤器攻克缓存穿透？

简而言之，言而简之就是我们先把我们数据库的数据都加载到我们的过滤器中，比如数据库的id现在有：1、2、3。

那就用id：1 为例子他在上图中经过三次hash之后，把三次原本值0的地方改为1。

下次数据进来查询的时候如果id的值是1，那么我就把1拿去三次hash 发现三次hash的值，跟上面的三个位置完全一样，那就能证明过滤器中有1的。
反之如果不一样就说明不存在了。

那应用的场景在哪里呢？一般我们都会用来防止缓存击穿。

简单来说就是你数据库的id都是1开始然后自增的，那我知道你接口是通过id查询的，我就拿负数去查询，这个时候，会发现缓存里面没这个数据，我又去数据库查也没有，一个请求这样，100个，1000个，10000个呢？你的DB基本上就扛不住了，如果在缓存里面加上这个，是不是就不存在了，你判断没这个数据就不去查了，直接return一个数据为空不就好了嘛。

布隆过滤器的实现？

Google中的Guava提供了一种Bloom Filter的实现。

在使用bloom filter时，绕不过的两点是预估数据量n以及期望的误判率fpp，

在实现bloom filter时，绕不过的两点就是hash函数的选取以及bit数组的大小。
对于一个确定的场景，我们预估要存的数据量为n，期望的误判率为fpp，然后需要计算我们需要的Bit数组的大小m，以及hash函数的个数k，并选择hash函数。

bit数组的大小：

根据预估数据量n以及误判率fpp，bit数组大小的m的计算方式：

hash函数的选取：

由预估数据量n以及bit数组长度m，可以得到一个hash函数的个数k：

​哈希函数的选择对性能的影响应该是很大的，一个好的哈希函数要能近似等概率的将字符串映射到各个Bit。选择k个不同的哈希函数比较麻烦，一种简单的方法是选择一个哈希函数，然后送入k个不同的参数。
哈希函数个数k、位数组大小m、加入的字符串数量n的关系可以参考Bloom Filters - the math，Bloom_filter-wikipedia。

基于Guava布隆过滤器？

首先引入jar包：

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

这里先往布隆过滤器里面存放100万个元素，然后分别测试100个存在的元素和9900个不存在的元素他们的正确率和误判率：

		//插入多少数据
        private static final int insertions = 1000000;
        //期望的误判率
        private static double fpp = 0.02;

        public static void main(String[] args) {
	        //初始化一个存储string数据的布隆过滤器,默认误判率是0.03        
	        BloomFilter<String> bf = BloomFilter.create(Funnels.stringFunnel(Charsets.UTF_8), insertions, fpp);
	        //用于存放所有实际存在的key，用于是否存在
	        Set<String> sets = new HashSet<String>(insertions);
	        //用于存放所有实际存在的key，用于取出
	        List<String> lists = new ArrayList<String>(insertions);
	        //插入随机字符串
	        for (int i = 0; i < insertions; i++) {
	            String uuid = UUID.randomUUID().toString();
	            bf.put(uuid);
	            sets.add(uuid);
	            lists.add(uuid);
	        }
	        int rightNum = 0;
	        int wrongNum = 0;
	        for (int i = 0; i < 10000; i++) {
	            // 0-10000之间，可以被100整除的数有100个（100的倍数）
	            String data = i % 100 == 0 ? lists.get(i / 100) : UUID.randomUUID().toString();
	
	            //这里用了might,看上去不是很自信，所以如果布隆过滤器判断存在了,我们还要去sets中实锤
	            if (bf.mightContain(data)) {
	                if (sets.contains(data)) {
	                    rightNum++;
	                    continue;
	                }
	                wrongNum++;
	            }
	        }
	        BigDecimal percent = new BigDecimal(wrongNum).divide(new BigDecimal(9900), 2, RoundingMode.HALF_UP);        
	        BigDecimal bingo = new BigDecimal(9900 - wrongNum).divide(new BigDecimal(9900), 2, RoundingMode.HALF_UP);        
	        System.out.println("在100W个元素中，判断100个实际存在的元素，布隆过滤器认为存在的：" + rightNum);        
	        System.out.println("在100W个元素中，判断9900个实际不存在的元素，误认为存在的：" + wrongNum + "，命中率：" + bingo + "，误判率：" + percent);
      }

运行结果如下：

基于Redis实现布隆过滤器？

guava实现布隆过滤器是把数据放在本地内存中，我们项目往往是分布式的，我们还可以把数据放在redis中，用redis来实现布隆过滤器，这就需要我们自己设计映射函数，自己度量二进制向量的长度。

/**
*布隆过滤器核心类
*/
public class BloomFilterHelper<T> {
            private int numHashFunctions;
            private int bitSize;
            private Funnel<T> funnel;

            public BloomFilterHelper(int expectedInsertions) {
                this.funnel = (Funnel<T>) Funnels.stringFunnel(Charset.defaultCharset());        
                bitSize = optimalNumOfBits(expectedInsertions,  0.03);        
                numHashFunctions = optimalNumOfHashFunctions(expectedInsertions, bitSize);
            }

            public BloomFilterHelper(Funnel<T> funnel, int expectedInsertions, double fpp) {
                this.funnel = funnel;        
                bitSize = optimalNumOfBits(expectedInsertions, fpp);        
                numHashFunctions = optimalNumOfHashFunctions(expectedInsertions, bitSize);
            }

            public int[] murmurHashOffset(T value) {
                int[] offset = new int[numHashFunctions];        
                long hash64 = Hashing.murmur3_128().hashObject(value, funnel).asLong();        
                int hash1 = (int) hash64;        
                int hash2 = (int) (hash64 >>> 32);
                for (int i = 1; i <= numHashFunctions; i++) {
                    int nextHash = hash1 + i * hash2;            
                    if (nextHash < 0) {                
                        nextHash = ~nextHash;            
                    }            
                    offset[i - 1] = nextHash % bitSize;
                }
                return offset;
            }

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

            /**
             * 计算hash方法执行次数
             */
            private int optimalNumOfHashFunctions(long n, long m) {
                return Math.max(1, (int) Math.round((double) m / n * Math.log(2)));
            }
        }

Redis操作布隆过滤器？

public class RedisBloomFilter<T> {
            @Autowired
            private RedisTemplate redisTemplate;
            /**
             * 删除缓存的KEY
             *
             * @param key KEY
             */
            public void delete(String key) {
                redisTemplate.delete(key);
            }

            /**
             * 根据给定的布隆过滤器添加值，在添加一个元素的时候使用，批量添加的性能差
             */
            public <T> void add(BloomFilterHelper<T> bloomFilterHelper, String key, T value) {
                int[] offset = bloomFilterHelper.murmurHashOffset(value);
                for (int i : offset) {
                    redisTemplate.opsForValue().setBit(key, i, true);
                }
            }

            /**
             *根据给定的布隆过滤器添加值，在添加一批元素的时候使用，批量添加的性能好，使用pipeline方式(如果是集群下，请使用优化后RedisPipeline的操作)
             */
            public <T> void addList(BloomFilterHelper<T> bloomFilterHelper, String key, List<T> valueList) {
                redisTemplate.executePipelined(new RedisCallback<Long>() {
                    @Override
                    public Long doInRedis(RedisConnection connection) throws DataAccessException {
                        for (T value : valueList) {
                            int[] offset = bloomFilterHelper.murmurHashOffset(value);
                            for (int i : offset) {
                                connection.setBit(key.getBytes(), i, true);
                            }
                        }
                        return null;
                    }
                });
            }

			/**
			*根据给定的布隆过滤器判断值是否存在
			*/
            public <T> boolean contains(BloomFilterHelper<T> bloomFilterHelper, String key, T value) {        
                int[] offset = bloomFilterHelper.murmurHashOffset(value);        
                for (int i : offset) {            
                    if (!redisTemplate.opsForValue().getBit(key, i)) {                
                        return false;            
                    }        
                }        
                return true;    
            }

        }

测试类：

		public static void main(String[] args) {        
                RedisBloomFilter redisBloomFilter = new RedisBloomFilter();        
                int expectedInsertions = 1000;        
                double fpp = 0.1;        
                redisBloomFilter.delete("bloom");        
                BloomFilterHelper<CharSequence> bloomFilterHelper = new BloomFilterHelper<>(Funnels.stringFunnel(Charset.defaultCharset()), expectedInsertions, fpp);        
                int j = 0;        
                // 添加100个元素        
                List<String> valueList = new ArrayList<>();        
                for (int i = 0; i < 100; i++) {            
                    valueList.add(i + "");        
                }        
                long beginTime = System.currentTimeMillis();        
                redisBloomFilter.addList(bloomFilterHelper, "bloom", valueList);        
                long costMs = System.currentTimeMillis() - beginTime;        
                log.info("布隆过滤器添加{}个值，耗时：{}ms", 100, costMs);        
                for (int i = 0; i < 1000; i++) {            
                    boolean result = redisBloomFilter.contains(bloomFilterHelper, "bloom", i + "");            
                    if (!result) {                
                        j++;            
                    }        
                }        
                log.info("漏掉了{}个,验证结果耗时：{}ms", j, System.currentTimeMillis() - beginTime);    
            }

布隆过滤器的其他应用场景？

1.网页爬虫对URL去重，避免爬取相同的 URL 地址；
2.反垃圾邮件，从数十亿个垃圾邮件列表中判断某邮箱是否垃圾邮箱；
3.Google Chrome 使用布隆过滤器识别恶意 URL；
4.Medium 使用布隆过滤器避免推荐给用户已经读过的文章；
5.Google BigTable，Apache HBbase 和 Apache Cassandra使用布隆过滤器减少对不存在的行和列的查找。