13：如何解决缓存穿透？

1：如何解决缓存穿透？

缓存穿透是指由于请求没有办法命中缓冲，因此就会直接打到数据库，当请求量较大时，大量的请求就可能会直接把数据库打挂。通常情况下，缓存是为了提高数据访问速度，避免频繁查询数据库。但如果攻击者故意请求缓存中不存在的数据，就会导致缓存不命中，请求直接访问数据库。

缓存穿透一般有几种解决方案：

（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）： 使用锁

当请求发现缓存不存在时，可以使用锁机制来避免多个相同的请求同时访问数据库，只让一个请求去加载数据，其他请求等待。

这种方式可以解决数据库压力过大问题，如果会出现“误杀”现象，那就是如果缓存中不存在但是数据库存在这种情况，也会等待获取锁，用户等待时间过长，不推荐使用。

public String selectUser(String userId) {
    String cacheData = cache.get(userId);
    if (StrUtil.isBlank(cacheData)) {zh
        Lock lock = getLock("业务标识"); //注意是把 业务标识 作为锁键，而不是userid
        lock.lock();
        try {
            // 拿到锁之后进行双重判定，如果缓存已经存在则直接返回即可
            cacheData = cache.get(userId);
            if (StrUtil.isBlank(cacheData)) {
                String dbData = userMapper.selectId(userId);
                if (StrUtil.isNotBlank(dbData)) {
                    cahce.set(userId, dbData);
                    cacheData = dbData;
                }
            }
        } finally {
            lock.unlock();
        }
    }
    return cacheData;
}

海量不同的恶意请求，对同一个业务请求加锁，而不是对userid加锁，如果说根据 userId 加锁，相当于每个请求都能获取到锁，这个锁也就相当于不存在。与此同时，对海量不同的请求进行加锁，会导致误判，一些好的请求，由于缓存过期，缓存中不存在，但数据库中存在，也会等待锁，导致性能下降

海量相同的请求，里面使用了双重判定锁，只限于缓存中没有数据，但数据库中有数据的请求。

然而第一个恶意请求，请求完数据库后，如果没有则直接返回，并没有进行缓存空值，导致大量的相同请求还是在等待锁，导致性能下降。

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

当海量不同的恶意数据进行访问的时候，先检查缓存中有没有数据，如果没有，再检查布隆过滤器中有没有数据，如果没有，则直接返回。

但是布隆过滤器存在 ” 假阳性 “问题，即误判问题，会认为一个没有的数据存在布隆过滤器中，如果大量的这样的请求访问时候，会直接请求数据库，导致数据库挂掉。

（4）：布隆过滤器+空对象+分布式锁

上面的这些方案或多或少都会有些问题，应该用三者进行组合用来解决缓存穿透问题。

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

        // 获取分布式锁，为什么这里获取业务标识，而不是具体某个 Key？具体见上文分布式锁章节
        Lock lock = getLock("业务标识");
        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;
}

先从缓存中查看数据是否存在，不存在，继续查布隆过滤器，如果布隆过滤器中不存在，则直接返回，如果误判，即假阳性（不存在的数据说存在），则进行缓存空值判断，如果为null，直接返回，不为null，如果此时正好是大量相同的请求打过来，加分布式锁，加双重判定只允许一个请求访问数据库，返回的数据不管是不是空，都放入缓存中。

原文：https://open8gu.com/cache/trending/wtq9uebubeymhwud/