当前位置：首页 > article >正文

优惠券平台（十一）：布隆过滤器、缓存空值、分布式组合的双重判定锁解决缓存穿透问题

article 2025/2/8 14:34:27

业务背景

在上一节中，我们讨论了正常用户在访问优惠券时可能遇到的缓存击穿问题，并介绍了缓存预热、缓存永不过期、分布式锁、双重判定锁、分片分布式锁等技术来应对这些问题。然而，还有一个问题需要解决：如果用户频繁访问数据库中不存在的数据，就无法有效使用缓存，每次都需要访问数据库，这将导致数据库承受较大的压力。这也就是缓存穿透问题。

什么是缓存穿透？

缓存穿透是指由于请求没有办法命中缓存，因此就会直接打到数据库，当请求量较大时，大量的请求就可能会直接把数据库打挂。

通常情况下，缓存是为了提高数据访问速度，避免频繁查询数据库。但如果攻击者故意请求缓存中不存在的数据，就会导致缓存不命中，请求直接访问数据库。

没有经过缓存穿透处理的业务伪代码如下：

public String selectUser(String userId) {
    String cacheData = cache.get(userId);
    if (StrUtil.isBlank(cacheData)) {
        String dbData = userMapper.selectId(userId);
        if (StrUtil.isNotBlank(dbData)) {
            cahce.set(userId, dbData);
            cacheData = dbData;
        } else {
            throw new RuntimeException();
        }
    }
    return cacheData;
}

缓存穿透常见解决方案

1. 空对象缓存

当查询结果为空时，也将结果进行缓存，但是设置一个较短的过期时间。这样在接下来的一段时间内，如果再次请求相同的数据，就可以直接从缓存中获取，而不是再次访问数据库，可以一定程度上解决缓存穿透问题。

缓存空值逻辑伪代码实现如下：

public String selectUser(String userId) {
    String cacheData = cache.get(userId);
    if (StrUtil.isBlank(cacheData)) {
        // 判断 Key 是否包含空值缓存，存在直接返回，不存在继续流程
        Boolean cacheIsNull = cache.hasKey("is-null_" + userId);
        if (cacheIsNull) {
            throw new RuntimeException();
        }
        String dbData = userMapper.selectId(userId);
        if (StrUtil.isNotBlank(dbData)) {
            cahce.set(userId, dbData);
            cacheData = dbData;
        } else {
            // 查询数据库中不存在数据，添加空值缓存并返回
            cache.set("is-null_" + userId, 较短过期时间);
            throw new RuntimeException();
        }
    }
    return cacheData;
}

这种方式是比较简单的一种实现方案，会存在一些弊端。那就是当短时间内存在大量恶意请求，缓存系统会存在大量的内存占用。

2. 布隆过滤器

2.1 什么是布隆过滤器

布隆过滤器是一种数据结构，用于快速判断一个元素是否存在于一个集合中。它以牺牲一定的准确性为代价，换取了存储空间的极大节省和查询速度的显著提升。

具体来说，布隆过滤器包含一个位数组和一组哈希函数。位数组的初始值全部置为 0。在插入一个元素时，将该元素经过多个哈希函数映射到位数组上的多个位置，并将这些位置的值置为 1。

在查询一个元素是否存在时，会将该元素经过多个哈希函数映射到位数组上的多个位置，如果所有位置的值都为 1，则认为元素存在；如果存在任一位置的值为 0，则认为元素不存在。

2.2 布隆过滤器优缺点

在查询一个元素是否存在时，会将该元素经过多个哈希函数映射到位数组上的多个位置，如果所有位置的值都为 1，则认为元素存在；如果存在任一位置的值为 0，则认为元素不存在。那么就可能会出现误判情况，比如lemon本身不存在，但经过哈希函数映射后的桶位都是1则误判为存在。

2.3 布隆过滤器解决缓存穿透

可以将所有存量数据全部放入布隆过滤器，然后如果缓存中不存在数据，紧接着判断布隆过滤器是否存在，如果存在访问数据库请求数据，如果不存在直接返回错误响应即可。

伪代码如下：

public String selectUser(String userId) {
    String cacheData = cache.get(userId);
    if (StrUtil.isBlank(cacheData)) {
        if (!bloomFilter.contains(fullShortUrl)) {
            throw new RuntimeException();
        }
        String dbData = userMapper.selectId(userId);
        if (StrUtil.isNotBlank(dbData)) {
            cahce.set(userId, dbData);
            cacheData = dbData;
        }
    }
    return cacheData;
}

因为布隆过滤器的误判是误判不存在的数据存在，不可能误判存在的数据不存在，所以只要布隆过滤器不存在则一定不存在。

但是这种问题还是会有一些小概率问题，那就是如果使用一种小概率误判的缓存进行攻击，依然会对数据库造成比较大的压力。这个怎么理解呢？

比如说一个优惠券 ID 是 1827975299049058306，我通过优惠券 ID 规则，模拟一个不存在的但很相近的，比如 1827975299049058307，去碰撞那个误判的概率；

怎么判断这个数据是不是存在？就是看接口的响应时间，直接查询缓存和布隆过滤器是绝对的毫秒级，比如 5 毫秒，而且性能基本上比较恒定。那我们就可以根据相应时间是否大于 5 毫秒，因为误判了还会查一次数据库；

如果查询第一次大于 5 毫秒且数据返回为空，那就证明这是个碰撞漏网之鱼，直接拿高并发访问即可，还是会请求到数据库。

布隆过滤器+空值缓存+分布式锁

如果说缓存不存在，那么就通过布隆过滤器进行初步筛选，然后判断是否存在缓存空值，如果存在直接返回失败。如果不存在缓存空值，使用锁机制避免多个相同请求同时访问数据库。最后，如果请求数据库为空，那么将为空的 Key 进行空对象值缓存。

在获取到锁后，不止对正常缓存双重判定，同时也要对空值缓存对象做双重判定。

多重方案伪代码如下所示：

public String selectUser(String userId) {
    String cacheData = cache.get(userId);
    if (StrUtil.isBlank(cacheData)) {
        // 判断 Key 是否存在布隆过滤器，存在则继续流程，否则直接返回
        if (!bloomFilter.contains(fullShortUrl)) {
            throw new RuntimeException();
        }

        // 判断 Key 是否包含空值缓存，存在直接返回，不存在继续流程
        Boolean cacheIsNull = cache.hasKey("is-null_" + userId);
        if (cacheIsNull) {
            throw new RuntimeException();
        }

        // 获取分布式锁
        Lock lock = getLock(userId);
        lock.lock();

        try {
            // 拿到锁之后进行双重判定，如果缓存已经存在则直接返回即可
            cacheData = cache.get(userId);
            if (StrUtil.isNotBlank(cacheData)) {
                return cacheData;
            }

            // 拿到锁之后进行双重判定，如果空值缓存已经存在则直接终止流程即可
            cacheIsNull = cache.hasKey("is-null_" + userId);
            if (!cacheIsNull) {
                throw new RuntimeException();
            }

            // 根据用户标识查询数据库记录
            String dbData = userMapper.selectId(userId);
            if (StrUtil.isNotBlank(dbData)) {
                cahce.set(userId, dbData);
                cacheData = dbData;
            } else {
                // 查询数据库中不存在数据，添加空值缓存并返回
                cache.set("is-null_" + userId, 较短过期时间);
                throw new RuntimeException();
            }
        } finally {
            lock.unlock();
        }
    }
    return cacheData;
}

这样多重方案解决缓存穿透问题感觉已经很全面了，只要不出现极端场景，大概率能涵盖大部分工作当中的业务场景。