一般不太大的公司沒(méi)有人攻擊吞杭，所以也就不太關(guān)注緩存擊穿的問(wèn)題盏浇，看到一篇使用布隆過(guò)濾器可以有效預(yù)防緩存穿透問(wèn)題。原文鏈接

緩存穿透

大家看下這幅圖芽狗，用戶可能進(jìn)行了一次條件錯(cuò)誤的查詢绢掰，這時(shí)候redis是不存在的，按照常規(guī)流程就是去數(shù)據(jù)庫(kù)找了童擎，可是這是一次錯(cuò)誤的條件查詢滴劲，數(shù)據(jù)庫(kù)當(dāng)然也不會(huì)存在，也不會(huì)往redis里面寫值柔昼，返回給用戶一個(gè)空哑芹，這樣的操作一次兩次還好炎辨，可是次數(shù)多了還了得捕透，我放redis本來(lái)就是為了擋一擋，減輕數(shù)據(jù)庫(kù)的壓力碴萧，現(xiàn)在redis變成了形同虛設(shè)乙嘀，每次還是去數(shù)據(jù)庫(kù)查找了，這個(gè)就叫做緩存穿透破喻，相當(dāng)于redis不存在了虎谢，被擊穿了，對(duì)于這種情況很好解決曹质，我們可以在redis緩存一個(gè)空字符串或者特殊字符串婴噩，比如&&，下次我們?nèi)edis中查詢的時(shí)候羽德，當(dāng)取到的值是空或者&&几莽，我們就知道這個(gè)值在數(shù)據(jù)庫(kù)中是沒(méi)有的，就不會(huì)在去數(shù)據(jù)庫(kù)中查詢宅静。

上面這個(gè)是重復(fù)查詢同一個(gè)不存在的值的情況章蚣，如果應(yīng)用每次查詢的不存在的值是不一樣的呢？即使你每次都緩存特殊字符串也沒(méi)用姨夹，因?yàn)樗闹挡灰粯酉舜梗热缥覀兊臄?shù)據(jù)庫(kù)用戶id是111，112磷账，113峭沦，114依次遞增，但是別人要攻擊你逃糟，故意拿-100熙侍，-936，-545這種亂七八糟的key來(lái)查詢，這時(shí)候redis和數(shù)據(jù)庫(kù)這種值都是不存在的蛉抓，人家每次拿的key也不一樣庆尘，你就算緩存了也沒(méi)用，這時(shí)候數(shù)據(jù)庫(kù)的壓力是相當(dāng)大巷送，比上面這種情況可怕的多驶忌，怎么辦呢，這時(shí)候我們今天的主角布隆過(guò)濾器就登場(chǎng)了笑跛。

從一道面試題說(shuō)起

問(wèn)：如何在海量元素中（例如 10 億無(wú)序付魔、不定長(zhǎng)、不重復(fù)）快速判斷一個(gè)元素是否存在飞蹂？好几苍，我們最簡(jiǎn)單的想法就是把這么多數(shù)據(jù)放到數(shù)據(jù)結(jié)構(gòu)里去，比如List陈哑、Map妻坝、Tree，一搜不就出來(lái)了嗎惊窖，比如map.get(),我們假設(shè)一個(gè)元素1個(gè)字節(jié)的字段刽宪，10億的數(shù)據(jù)大概需要 900G 的內(nèi)存空間，這個(gè)對(duì)于普通的服務(wù)器來(lái)說(shuō)是承受不了的界酒，當(dāng)然面試官也不希望聽到你這個(gè)答案圣拄，因?yàn)樘苛税桑覀兛隙ㄊ且靡环N好的方法毁欣，巧妙的方法來(lái)解決庇谆，這里引入一種節(jié)省空間的數(shù)據(jù)結(jié)構(gòu)，位圖凭疮，他是一個(gè)有序的數(shù)組饭耳，只有兩個(gè)值，0 和 1哭尝。0代表不存在哥攘，1代表存在。

有了這個(gè)屌炸天的東西材鹦，現(xiàn)在我們還需要一個(gè)映射關(guān)系逝淹，你總得知道某個(gè)元素在哪個(gè)位置上吧，然后在去看這個(gè)位置上是0還是1桶唐，怎么解決這個(gè)問(wèn)題呢栅葡，那就要用到哈希函數(shù)，用哈希函數(shù)有兩個(gè)好處尤泽，第一是哈希函數(shù)無(wú)論輸入值的長(zhǎng)度是多少欣簇，得到的輸出值長(zhǎng)度是固定的规脸，第二是他的分布是均勻的，如果全擠的一塊去那還怎么區(qū)分熊咽，比如MD5莫鸭、SHA-1這些就是常見(jiàn)的哈希算法。

我們通過(guò)哈希函數(shù)計(jì)算以后就可以到相應(yīng)的位置去找是否存在了横殴，我們看紅色的線被因，24和147經(jīng)過(guò)哈希函數(shù)得到的哈希值是一樣的，我們把這種情況叫做哈希沖突或者哈希碰撞衫仑。哈希碰撞是不可避免的梨与，我們能做的就是降低哈希碰撞的概率。

• 第一種是可以擴(kuò)大維數(shù)組的長(zhǎng)度或者說(shuō)位圖容量文狱，因?yàn)槲覀兊暮瘮?shù)是分布均勻的粥鞋，所以位圖容量越大，在同一個(gè)位置發(fā)生哈希碰撞的概率就越小瞄崇。但是越大的位圖容量呻粹，意味著越多的內(nèi)存消耗，所以我們想想能不能通過(guò)其他的方式來(lái)解決杠袱。
• 第二種方式就是經(jīng)過(guò)多幾個(gè)哈希函數(shù)的計(jì)算尚猿，你想啊窝稿，24和147現(xiàn)在經(jīng)過(guò)一次計(jì)算就碰撞了楣富，那我經(jīng)過(guò)5次，10次伴榔，100次計(jì)算還能碰撞的話那真的是緣分了纹蝴，你們可以在一起了，但也不是越多次哈希函數(shù)計(jì)算越好踪少，因?yàn)檫@樣很快就會(huì)填滿位圖塘安，而且計(jì)算也是需要消耗時(shí)間，所以我們需要在時(shí)間和空間上尋求一個(gè)平衡援奢。

布隆過(guò)濾器

當(dāng)然兼犯，這個(gè)事情早就有人研究過(guò)了，在 1970 年的時(shí)候集漾，有一個(gè)叫做布隆的前輩對(duì)于判斷海量元素中元素是否存在的問(wèn)題進(jìn)行了研究切黔，也就是到底需要多大的位圖容量和多少個(gè)哈希函數(shù)，它發(fā)表了一篇論文具篇，提出的這個(gè)容器就叫做布隆過(guò)濾器纬霞。

大家來(lái)看下這個(gè)圖，我們看集合里面3個(gè)元素驱显，現(xiàn)在我們要存了诗芜，比如說(shuō)a瞳抓，經(jīng)過(guò)f1(a)，f2(a)伏恐，f3(a)經(jīng)過(guò)三個(gè)哈希函數(shù)的計(jì)算孩哑，在相應(yīng)的位置上存入1，元素b翠桦，c也是通過(guò)這三個(gè)函數(shù)計(jì)算放入相應(yīng)的位置臭笆。當(dāng)取的時(shí)候，元素a通過(guò)f1(a)函數(shù)計(jì)算秤掌，發(fā)現(xiàn)這個(gè)位置上是1愁铺，沒(méi)問(wèn)題，第二個(gè)位置也是1闻鉴，第三個(gè)位置上也是 1茵乱，這時(shí)候我們說(shuō)這個(gè)a在布隆過(guò)濾器中是存在的，沒(méi)毛病孟岛，同理我們看下面的這個(gè)d瓶竭，通過(guò)三次計(jì)算發(fā)現(xiàn)得到的結(jié)果也都是1，那么我們能說(shuō)d在布隆過(guò)濾器中是存在的嗎渠羞，顯然是不行的斤贰，我們仔細(xì)看d得到的三個(gè)1其實(shí)是f1(a)，f1(b)次询，f2(c)存進(jìn)去的荧恍，并不是d自己存進(jìn)去的，這個(gè)還是哈希碰撞導(dǎo)致的屯吊，我們把這種本來(lái)不存在布隆過(guò)濾器中的元素誤判為存在的情況叫做假陽(yáng)性（False Positive Probability送巡，F(xiàn)PP）。

我們?cè)賮?lái)看另一個(gè)元素盒卸，e 元素骗爆。我們要判斷它在容器里面是否存在，一樣地要用這三個(gè)函數(shù)去計(jì)算蔽介。第一個(gè)位置是 1摘投，第二個(gè)位置是 1，第三個(gè)位置是 0虹蓄。那么e元素能不能判斷是否在布隆過(guò)濾器中犀呼？ 答案是肯定的，e一定不存在武花。你想啊圆凰，如果e存在的話，他存進(jìn)去的時(shí)候這三個(gè)位置都置為1体箕，現(xiàn)在查出來(lái)有一個(gè)位置是0专钉，證明他沒(méi)存進(jìn)去啊挑童。。通過(guò)上面這張圖加說(shuō)明跃须，我們得出兩個(gè)重要的結(jié)論站叼。

• 從容器的角度來(lái)說(shuō)：
  • 如果布隆過(guò)濾器判斷元素在集合中存在，不一定存在
  • 如果布隆過(guò)濾器判斷不存在菇民，一定不存在
• 從元素的角度來(lái)說(shuō)：
  • 如果元素實(shí)際存在尽楔，布隆過(guò)濾器一定判斷存在
  • 如果元素實(shí)際不存在，布隆過(guò)濾器可能判斷存在

Guava實(shí)現(xiàn)布隆過(guò)濾器

java為什么寫的人多第练，基數(shù)大阔馋，因?yàn)槭情_源的，擁抱開源娇掏，框架多呕寝，輪子多，而且一個(gè)功能的輪子還不止一個(gè)婴梧，光序列化就有fastjson下梢，jackson，gson塞蹭，隨你挑任你選孽江，那布隆過(guò)濾器的輪子就是google提供的guava，我們用代碼來(lái)看一下使用方法

首先引入我們的jar包

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

這里先往布隆過(guò)濾器里面存放100萬(wàn)個(gè)元素番电，然后分別測(cè)試100個(gè)存在的元素和9900個(gè)不存在的元素他們的正確率和誤判率

import com.google.common.base.Charsets;
import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;

public class BL {

    //插入多少數(shù)據(jù)
    private static final int insertions = 1000000;
    //期望的誤判率
    private static double fpp = 0.02;

    public static void main(String[] args) {
        /* 初始化一個(gè)存儲(chǔ)string數(shù)據(jù)的布隆過(guò)濾器,默認(rèn)誤判率是0.03 */
        BloomFilter<String> bf = BloomFilter.create(Funnels.stringFunnel(Charsets.UTF_8), insertions, fpp);
        /* 用于存放所有實(shí)際存在的key岗屏，用于是否存在 */
        Set<String> sets = new HashSet<String>(insertions);
        //用于存放所有實(shí)際存在的key，用于取出
        List<String> lists = new ArrayList<String>(insertions);
        //插入隨機(jī)字符串
        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整除的數(shù)有100個(gè)（100的倍數(shù)）
            String data = i % 100 == 0 ? lists.get(i / 100) : UUID.randomUUID().toString();
            //這里用了might,看上去不是很自信担汤，所以如果布隆過(guò)濾器判斷存在了,我們還要去sets中實(shí)錘
            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個(gè)元素中涎跨，判斷100個(gè)實(shí)際存在的元素洼冻，布隆過(guò)濾器認(rèn)為存在的：" + rightNum);
        System.out.println("在100W個(gè)元素中，判斷9900個(gè)實(shí)際不存在的元素隅很，誤認(rèn)為存在的：" + wrongNum + "撞牢，命中率：" + bingo + "，誤判率：" + percent);
    }
}

輸出結(jié)果：
在100W個(gè)元素中叔营，判斷100個(gè)實(shí)際存在的元素屋彪，布隆過(guò)濾器認(rèn)為存在的：100
在100W個(gè)元素中，判斷9900個(gè)實(shí)際不存在的元素绒尊，誤認(rèn)為存在的：181畜挥，命中率：0.98，誤判率：0.02

我們看到這個(gè)結(jié)果正是印證了上面的結(jié)論婴谱，這100個(gè)真實(shí)存在元素在布隆過(guò)濾器中一定存在蟹但，另外9900個(gè)不存在的元素躯泰，布隆過(guò)濾器還是判斷了216個(gè)存在，這個(gè)就是誤判华糖，原因上面也說(shuō)過(guò)了麦向，所以布隆過(guò)濾器不是萬(wàn)能的，但是他能幫我們抵擋掉大部分不存在的數(shù)據(jù)已經(jīng)很不錯(cuò)了客叉，已經(jīng)減輕數(shù)據(jù)庫(kù)很多壓力了诵竭，另外誤判率0.02是在初始化布隆過(guò)濾器的時(shí)候我們自己設(shè)的，如果不設(shè)默認(rèn)是0.03兼搏，我們自己設(shè)的時(shí)候千萬(wàn)不要設(shè)置為0!

Redis實(shí)現(xiàn)布隆過(guò)濾器

上面使用guava實(shí)現(xiàn)布隆過(guò)濾器是把數(shù)據(jù)放在本地內(nèi)存中卵慰，我們項(xiàng)目往往是分布式的，我們還可以把數(shù)據(jù)放在redis中佛呻，用redis來(lái)實(shí)現(xiàn)布隆過(guò)濾器呵燕，這就需要我們自己設(shè)計(jì)映射函數(shù)，自己度量二進(jìn)制向量的長(zhǎng)度件相，下面貼代碼再扭，大家可以直接拿來(lái)用的，已經(jīng)經(jīng)過(guò)測(cè)試了夜矗。

import com.google.common.hash.Funnel;
import com.google.common.hash.Funnels;
import com.google.common.hash.Hashing;

import java.nio.charset.Charset;

/**
 * 布隆過(guò)濾器核心類 
 * @param <T>
 * @author jack xu
 */
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;
    }
    
    /**
     * 計(jì)算bit數(shù)組長(zhǎng)度     
     * */
    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)));
    }

    /**
     * 計(jì)算hash方法執(zhí)行次數(shù)     
     * */
    private int optimalNumOfHashFunctions(long n, long m) {
        return Math.max(1, (int) Math.round((double) m / n * Math.log(2)));
    }
    
}

這里在操作redis的位圖bitmap泛范，你可能只知道redis五種數(shù)據(jù)類型，string紊撕，list罢荡，hash，set对扶，zset区赵，沒(méi)聽過(guò)bitmap，但是不要緊浪南，你可以說(shuō)他是一種新的數(shù)據(jù)類型笼才，也可以說(shuō)不是，因?yàn)樗谋举|(zhì)還是string络凿，后面我也會(huì)專門寫一篇文章來(lái)介紹數(shù)據(jù)類型以及在他們?cè)诨ヂ?lián)網(wǎng)中的使用場(chǎng)景骡送。

引入對(duì)應(yīng)的Jar包

        <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.3.0</version>
        </dependency>
        <!-- spring-redis -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>2.2.7.RELEASE</version>
        </dependency>

import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;

import java.util.List;

/**
 * redis操作布隆過(guò)濾器
 * @param <T>
 * @author xhj
 */
public class RedisBloomFilter<T> {

    /**
     * 配置連接池參數(shù)
     * */
    public static JedisPoolConfig getPoolConfig() {
        JedisPoolConfig jedisPoolConfig = new redis.clients.jedis.JedisPoolConfig();
        jedisPoolConfig.setMaxTotal(100);
        jedisPoolConfig.setMaxIdle(100);
        jedisPoolConfig.setMinEvictableIdleTimeMillis(50000);
        jedisPoolConfig.setTimeBetweenEvictionRunsMillis(20000);
        jedisPoolConfig.setNumTestsPerEvictionRun(-1);
        jedisPoolConfig.setSoftMinEvictableIdleTimeMillis(10000);
        jedisPoolConfig.setMaxWaitMillis(1000);
        jedisPoolConfig.setTestOnBorrow(true);
        jedisPoolConfig.setTestWhileIdle(true);
        jedisPoolConfig.setTestOnReturn(false);
        jedisPoolConfig.setJmxEnabled(true);
        jedisPoolConfig.setJmxNamePrefix("pool");
        jedisPoolConfig.setBlockWhenExhausted(false);
        return jedisPoolConfig;
    }

    /**
     * 獲取連接工廠
     * */
    public static JedisConnectionFactory getConnectionFactory(JedisPoolConfig poolConfig) {

        JedisConnectionFactory jedisConnetFactory = new JedisConnectionFactory();
        jedisConnetFactory.setPoolConfig(poolConfig);
        jedisConnetFactory.setHostName("127.0.0.1");
        jedisConnetFactory.setPort(6379);

        /**必須執(zhí)行這個(gè)函數(shù),初始化JedisConnectionFactory*/
        jedisConnetFactory.afterPropertiesSet();

        return jedisConnetFactory;
    }

    /**
     * 獲取RedisTemplate實(shí)例
     * */
    public static RedisTemplate getRedisTemplate() {

        JedisPoolConfig jedisPoolConfig = RedisBloomFilter.getPoolConfig();
        JedisConnectionFactory connectionFactory = RedisBloomFilter.getConnectionFactory(jedisPoolConfig);

        RedisTemplate redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(connectionFactory);
        StringRedisSerializer serializer = new StringRedisSerializer();
        redisTemplate.setDefaultSerializer(serializer);
        redisTemplate.setKeySerializer(serializer);
        redisTemplate.setValueSerializer(serializer);

        /**必須執(zhí)行這個(gè)函數(shù),初始化RedisTemplate*/
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    private static RedisTemplate redisTemplate;

    static {
        redisTemplate = getRedisTemplate();
    }

    /**
     * 刪除緩存的KEY
     * @param key KEY
     * */
    public void delete(String key) {
        redisTemplate.delete(key);
    }
    
    /**
     * 根據(jù)給定的布隆過(guò)濾器添加值，在添加一個(gè)元素的時(shí)候使用絮记，批量添加的性能差
     * @param bloomFilterHelper 布隆過(guò)濾器對(duì)象
     * @param key   KEY
     * @param value 值
     * @param <T>   泛型摔踱，可以傳入任何類型的value
     * */
    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);
        }
    }

    /**
     * 根據(jù)給定的布隆過(guò)濾器添加值，在添加一批元素的時(shí)候使用怨愤，批量添加的性能好派敷，使用pipeline方式(如果是集群下，請(qǐng)使用優(yōu)化后RedisPipeline的操作)
     * @param bloomFilterHelper 布隆過(guò)濾器對(duì)象
     * @param key       KEY
     * @param valueList 值，列表
     * @param <T>       泛型篮愉，可以傳入任何類型的value
     * */
    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 {
                connection.openPipeline();
                for (T value : valueList) {
                    int[] offset = bloomFilterHelper.murmurHashOffset(value);
                    for (int i : offset) {
                        connection.setBit(key.getBytes(), i, true);
                    }
                }
                return null;
            }
        });
    }
    
    /**
     * 根據(jù)給定的布隆過(guò)濾器判斷值是否存在
     * @param bloomFilterHelper 布隆過(guò)濾器對(duì)象
     * @param key   KEY
     * @param value 值
     * @param <T>   泛型般眉，可以傳入任何類型的value
     * @return 是否存在
     * */
    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;
    }

}

最后就是測(cè)試類了

import com.google.common.hash.Funnels;
import lombok.extern.slf4j.Slf4j;

import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;

@Slf4j
public class BLRedisTest {

    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個(gè)元素
        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("布隆過(guò)濾器添加{}個(gè)值，耗時(shí)：{}ms", 100, costMs);
        for (int i = 0; i < 1000; i++) {
            boolean result = redisBloomFilter.contains(bloomFilterHelper, "bloom", i + "");
            if (!result) {
                j++;
            }
        }
        log.info("漏掉了{(lán)}個(gè),驗(yàn)證結(jié)果耗時(shí)：{}ms", j, System.currentTimeMillis() - beginTime);
    }

}

輸入結(jié)果：
14:52:46.739 [main] INFO com.example.bl.utils.BLRedisTest - 布隆過(guò)濾器添加100個(gè)值潜支，耗時(shí)：134ms
14:52:47.194 [main] INFO com.example.bl.utils.BLRedisTest - 漏掉了900個(gè),驗(yàn)證結(jié)果耗時(shí)：589ms

注意這里用的是addList甸赃，他的底層是pipelining管道，而add方法的底層是一個(gè)個(gè)for循環(huán)的setBit冗酿，這樣的速度效率是很慢的埠对，但是他能有返回值，知道是否插入成功裁替，而pipelining是不知道的项玛，所以具體選擇用哪一種方法看你的業(yè)務(wù)場(chǎng)景，以及需要插入的速度決定弱判。

布隆過(guò)濾器工作位置

第一步是將數(shù)據(jù)庫(kù)所有的數(shù)據(jù)加載到布隆過(guò)濾器襟沮。第二步當(dāng)有請(qǐng)求來(lái)的時(shí)候先去布隆過(guò)濾器查詢，如果bf說(shuō)沒(méi)有昌腰，第三步直接返回开伏。如果bf說(shuō)有，在往下走之前的流程遭商。ps：另外guava的數(shù)據(jù)加載中只有put方法固灵，小伙們可以想下布隆過(guò)濾器中數(shù)據(jù)刪除和修改怎么辦，為什么沒(méi)有delete的方法劫流？

布隆過(guò)濾器的其他應(yīng)用場(chǎng)景

• 網(wǎng)頁(yè)爬蟲對(duì)URL去重巫玻，避免爬取相同的 URL 地址；
• 反垃圾郵件祠汇，從數(shù)十億個(gè)垃圾郵件列表中判斷某郵箱是否垃圾郵箱仍秤；
• Google Chrome 使用布隆過(guò)濾器識(shí)別惡意 URL；
• Medium 使用布隆過(guò)濾器避免推薦給用戶已經(jīng)讀過(guò)的文章可很；
• Google BigTable诗力，Apache HBbase 和 Apache Cassandra使用布隆過(guò)濾器減少對(duì)不存在的行和列的查找。

好根穷，布隆過(guò)濾器到這里就結(jié)束了姜骡，以后在面試中面試官在問(wèn)到緩存擊穿怎么辦，我相信你應(yīng)該能夠回答的頭頭是道了屿良，就像我這樣通俗易懂的說(shuō)出來(lái)即可，然后在工作中也可以應(yīng)用惫周，比如鑒權(quán)服務(wù)尘惧，當(dāng)用戶登錄的時(shí)候可以先用布隆過(guò)濾器判斷下，而不是直接去redis递递、數(shù)據(jù)庫(kù)查喷橙。