高併發下的redis擊穿，你需要了解下布隆過濾器

在高併發讀的情況下緩存是不可少的。關於高併發緩存方面大小可以參考博主這篇文章

好了接下來進入正題:

大家看下上方的這幅圖，用戶可能進行了一次條件錯誤的查詢，這時候 redis 是不存在的，按照常規流程就是去數據庫找了，可是這是一次錯誤的條件查詢，數據庫當然也不會存在，也不會往 redis 裏面寫值，返回給用戶一個空，這樣的操作一次兩次還好，可是次數多了還了得，我放 redis 本來就是爲了擋一擋，減輕數據庫的壓力，現在 redis 變成了形同虛設，每次還是去數據庫查找了，這個就叫做緩存穿透，相當於 redis 不存在了，被擊穿了，對於這種情況很好解決，我們可以在 redis 緩存一個空字符串或者特殊字符串，比如 &&，下次我們去 redis 中查詢的時候，當取到的值是空或者 &&，我們就知道這個值在數據庫中是沒有的，就不會在去數據庫中查詢。

ps：這裏緩存不存在 key 的時候一定要設置過期時間，不然當數據庫已經新增了這一條記錄的時候，這樣會導致緩存和數據庫不一致的情況。

上面這個是重複查詢同一個不存在的值的情況，如果應用每次查詢的不存在的值是不一樣的呢？即使你每次都緩存特殊字符串也沒用，因爲它的值不一樣，比如我們的數據庫用戶 id 是 111，112，113，114 依次遞增，但是別人要攻擊你，故意拿 - 100，-936，-545 這種亂七八糟的 key 來查詢，這時候 redis 和數據庫這種值都是不存在的，人家每次拿的 key 也不一樣，你就算緩存了也沒用，這時候數據庫的壓力是相當大，比上面這種情況可怕的多，怎麼辦呢，這時候我們今天的主角 布隆過濾器 就登場了。

從一到面試題說起

問：如何在 海量 元素中（例如 10 億無序、不定長、不重複） 快速 判斷一個元素是否存在？好，我們最簡單的想法就是把這麼多數據放到數據結構裏去，比如 List、Map、Tree，一搜不就出來了嗎，比如 map.get(), 我們假設一個元素 1 個字節的字段，10 億的數據大概需要 900G 的內存空間，這個對於普通的服務器來說是承受不了的，當然面試官也不希望聽到你這個答案，因爲太笨了吧，我們肯定是要用一種好的方法，巧妙的方法來解決，這裏引入一種節省空間的數據結構， 位圖 ，他是一個有序的數組，只有兩個值，0 和 1。0 代表不存在，1 代表存在。

有了這個厲害的東西，現在我們還需要一個映射關係，你總得知道某個元素在哪個位置上吧，然後在去看這個位置上是 0 還是 1，怎麼解決這個問題呢，那就要用到哈希函數，用哈希函數有兩個好處，第一是哈希函數無論輸入值的長度是多少，得到的輸出值長度是固定的，第二是他的分佈是均勻的，如果全擠的一塊去那還怎麼區分，比如 MD5、SHA-1 這些就是常見的哈希算法。

我們通過哈希函數計算以後就可以到相應的位置去找是否存在了，我們看紅色的線，24 和 147 經過哈希函數得到的哈希值是一樣的，我們把這種情況叫做 哈希衝突或者哈希碰撞 。哈希碰撞是不可避免的，我們能做的就是降低哈希碰撞的概率， 第一種 是可以擴大維數組的長度或者說位圖容量，因爲我們的函數是分佈均勻的，所以位圖容量越大，在同一個位置發生哈希碰撞的概率就越小。但是越大的位圖容量，意味着越多的內存消耗，所以我們想想能不能通過其他的方式來解決， 第二種 方式就是經過多幾個哈希函數的計算，你想啊，24 和 147 現在經過一次計算就碰撞了，那我經過 5 次，10 次，100 次計算還能碰撞的話那真的是緣分了，你們可以在一起了，但也不是越多次哈希函數計算越好，因爲這樣很快就會填滿位圖，而且計算也是需要消耗時間，所以我們需要在時間和空間上尋求一個平衡。

布隆過濾器

當然，這個事情早就有人研究過了，在 1970 年的時候，有一個叫做布隆的前輩對於判斷海量元素中元素是否存在的問題進行了研究，也就是到底需要多大的位圖容量和多少個哈希函數，它發表了一篇論文，提出的這個容器就叫做布隆過濾器。

集合裏面有 3 個元素, 要把它存到布隆過濾器裏面去，應該怎麼做呢？首先是 a 元素,，這裏我們用 3 次計算，b、c 元素也是一樣.

元素都存進去以後，現在我要來判斷一個元素在這個容器中是否存在，就要使用同樣的三個函數進行計算。

比如 d 元素，我用第一個函數 f1 計算，發現這個位置上是 1，沒問題, 第二個位置也是 1，第三個位置上也是 1。

如果經過三次計算得到的下標位置值都是 1，這種情況下, 能不能確定 d 元素一定在這個容器裏面呢? 實際上是不能的. 比如這張圖裏面，這三個位置分別是把 a、b、c 存進去的時候置成 1， 所以即使 d 元素之前沒有存進去, 也會得到三個 1，判斷返回 true

所以 這個是布隆過濾器的一個很重要的特性，因爲哈希碰撞是不可避免的，所以它會存在一定的誤判率。這種把本來不存在布隆過濾器中的元素誤判爲存在的情況，我們把它叫做 假陽性 (False Positive Probability，FPP)

我們再來看另一個元素, 我們要判斷它在容器中是否存在， 一樣的要用這三個函數去計算，第一個位置是 1，第二個位置是 1，第三個位置是 0

e 元素是不是一定不在這個容器裏面呢？可以確定一定不存在，如果說當時已經把 e 元素存到布隆過濾器裏面去了，那麼這三個位置肯定都是 1，不可能會出現 0。

布隆過濾器的特點，從容器的角度來說：

• 如果布隆過濾器判斷元素在集合中存在, 不一定存在.
• 如果布隆過濾器判斷不存在, 則一定不存在.

從元素的角度來說：

• 如果元素實際存在, 布隆過濾器一定判斷存在
• 如果元素實際不存在, 布隆過濾器可能判斷存在

利用第二個特性, 我們是不是就可以解決持續從數據庫查詢不存在的值的問題呢?

Guava 實現布隆過濾器

java 爲什麼寫的人多，基數大，因爲是開源的，擁抱開源，框架多，輪子多，而且一個功能的輪子還不止一個，光序列化就有 fastjson，jackson，gson，隨你挑任你選，那布隆過濾器的輪子就是 google 提供的 guava，我們用代碼來看一下使用方法

首先引入我們的架包

複製代碼

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

這裏先往布隆過濾器裏面存放 100 萬個元素，然後分別測試 100 個存在的元素和 9900 個不存在的元素他們的正確率和誤判率。

複製代碼

public class BloomFilterDemo {

    //插入多少數據
    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);
    }
}

最後得出的結果

複製代碼

在100W個元素中，判斷100個實際存在的元素，布隆過濾器認爲存在的：100
在100W個元素中，判斷9900個實際不存在的元素，誤認爲存在的：203，命中率：0.98，誤判率：0.02

我們看到這個結果正是印證了上面的結論，這 100 個真實存在元素在布隆過濾器中一定存在，另外 9900 個不存在的元素，布隆過濾器還是判斷了 216 個存在，這個就是誤判，原因上面也說過了，所以布隆過濾器不是萬能的，但是他能幫我們抵擋掉大部分不存在的數據已經很不錯了，已經減輕數據庫很多壓力了，另外誤判率 0.02 是在初始化布隆過濾器的時候我們自己設的，如果不設默認是 0.03， 我們自己設的時候千萬不能設 0!

Redis 實現布隆過濾器

上面使用 guava 實現布隆過濾器是把數據放在本地內存中，我們項目往往是分佈式的，我們還可以把數據放在 redis 中，用 redis 來實現布隆過濾器，這就需要我們自己設計映射函數，自己度量二進制向量的長度，下面貼代碼，大家可以直接拿來用的，已經經過測試了。

複製代碼

/**
 * 布隆過濾器核心類
 *
 * @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;
    }

    /**
     * 計算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 的位圖 bitmap，你可能只知道 redis 五種數據類型，string，list，hash，set，zset，沒聽過 bitmap，但是不要緊，你可以說他是一種新的數據類型，也可以說不是，因爲他的本質還是 string，後面我也會專門寫一篇文章來介紹數據類型以及在他們在互聯網中的使用場景。

複製代碼

/**
 * redis操作布隆過濾器
 *
 * @param <T>
 * @author xhj
 */
public class RedisBloomFilter<T> {
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 刪除緩存的KEY
     *
     * @param key KEY
     */
    public void delete(String key) {
        redisTemplate.delete(key);
    }

    /**
     * 根據給定的布隆過濾器添加值，在添加一個元素的時候使用，批量添加的性能差
     *
     * @param bloomFilterHelper 布隆過濾器對象
     * @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);
        }
    }

    /**
     * 根據給定的布隆過濾器添加值，在添加一批元素的時候使用，批量添加的性能好，使用pipeline方式(如果是集羣下，請使用優化後RedisPipeline的操作)
     *
     * @param bloomFilterHelper 布隆過濾器對象
     * @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;
            }
        });
    }

    /**
     * 根據給定的布隆過濾器判斷值是否存在
     *
     * @param bloomFilterHelper 布隆過濾器對象
     * @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;
    }
}

最後就是測試類了

複製代碼

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);
    }

注意這裏用的是 addList，他的底層是 pipelining 管道，而 add 方法的底層是一個個 for 循環的 setBit，這樣的速度效率是很慢的，但是他能有返回值，知道是否插入成功，而 pipelining 是不知道的，所以具體選擇用哪一種方法看你的業務場景，以及需要插入的速度決定。

布隆過濾器工作位置

第一步是將數據庫所有的數據加載到布隆過濾器。第二步當有請求來的時候先去布隆過濾器查詢，如果 bf 說沒有，第三步直接返回。如果 bf 說有，在往下走之前的流程。
ps：另外 guava 的數據加載中只有 put 方法，小夥們可以想下布隆過濾器中數據刪除和修改怎麼辦，爲什麼沒有 delete 的方法？

布隆過濾器的其他應用場景

• 網頁爬蟲對 URL 去重，避免爬取相同的 URL 地址；
• 反垃圾郵件，從數十億個垃圾郵件列表中判斷某郵箱是否垃圾郵箱；
• Google Chrome 使用布隆過濾器識別惡意 URL；
• Medium 使用布隆過濾器避免推薦給用戶已經讀過的文章；
• Google BigTable，Apache HBbase 和 Apache Cassandra 使用布隆過濾器減少對不存在的行和列的查找。