缓存穿透解决方案：从基础到高级优化

heromps

于 2024-08-22 20:24:11 发布

阅读量590

点赞数 11

分类专栏： redis 文章标签：缓存

本文链接：https://blog.csdn.net/heromps/article/details/141437145

版权

redis 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

缓存穿透解决方案：从基础到高级优化

缓存穿透是指由于请求无法命中缓存，导致大量请求直接打到数据库。当请求量较大时，可能会导致数据库承受过重压力，甚至崩溃。本文将详细探讨缓存穿透问题的几种常见解决方案，并提供代码示例帮助理解。

1. 缓存穿透问题的背景

通常情况下，缓存是为了提高数据访问速度，避免频繁查询数据库。但如果攻击者故意请求缓存中不存在的数据，或者由于缓存未能命中，就会导致请求直接访问数据库。当请求量过大时，这种情况可能导致数据库压力骤增，甚至崩溃。
为了解决缓存穿透问题，常见的解决方案包括空对象值缓存、使用分布式锁、布隆过滤器，以及多种方法的组合。

2. 解决方案一：空对象值缓存

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

优点：

简单易实现。

缺点：

可能导致短时间内内存占用过大，特别是在存在大量恶意请求时。

伪代码示例：

public String selectUser(String userId) {
    String cacheData = cache.get(userId);
    if (StrUtil.isBlank(cacheData)) {
        Boolean cacheIsNull = cache.hasKey("is-null_" + userId);
        if (cacheIsNull) {
            throw new RuntimeException();
        }
        String dbData = userMapper.selectId(userId);
        if (StrUtil.isNotBlank(dbData)) {
            cache.set(userId, dbData);
            cacheData = dbData;
        } else {
            cache.set("is-null_" + userId, 短过期时间);
            throw new RuntimeException();
        }
    }
    return cacheData;
}

这种方案适用于较简单的应用场景，但对于需要防御大量恶意请求的系统，可能需要更复杂的解决方案。

3. 解决方案二：使用分布式锁

当请求发现缓存不存在时，可以使用分布式锁机制，避免多个相同的请求同时访问数据库。这样，只让一个请求去加载数据，其他请求等待，从而减轻数据库压力。

优点：

有效防止多个相同请求同时打击数据库。

缺点：

存在“误杀”现象，用户等待时间可能较长。

伪代码示例：

public String selectUser(String userId) {
    String cacheData = cache.get(userId);
    if (StrUtil.isBlank(cacheData)) {
        Lock lock = getLock("业务标识");
        lock.lock();
        try {
            cacheData = cache.get(userId);
            if (StrUtil.isBlank(cacheData)) {
                String dbData = userMapper.selectId(userId);
                if (StrUtil.isNotBlank(dbData)) {
                    cache.set(userId, dbData);
                    cacheData = dbData;
                }
            }
        } finally {
            lock.unlock();
        }
    }
    return cacheData;
}

在此方案中，锁标识选择“业务标识”而不是具体的userId，以防止锁的失效。

4. 解决方案三：布隆过滤器

布隆过滤器是一种数据结构，可以用于判断一个元素是否存在于一个集合中。它可以在很大程度上减轻缓存穿透问题，因为它可以快速判断数据是否可能存在于缓存中。

优点：

能有效过滤大多数不存在的请求，降低数据库压力。

缺点：

存在一定的误判概率，可能导致少量错误请求。

伪代码示例：

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

布隆过滤器在大数据量场景下表现良好，适合用来防止大规模缓存穿透。

5. 解决方案四：布隆过滤器+空对象+分布式锁

为了更加完善地解决缓存穿透问题，可以将布隆过滤器、空对象缓存和分布式锁组合使用。具体流程如下：

当缓存不存在时，先通过布隆过滤器进行初步筛选。
如果布隆过滤器判定数据可能存在，则检查是否存在空对象缓存。
如果空对象缓存不存在，再使用分布式锁防止多个相同请求同时访问数据库。
最后，如果数据库查询结果为空，将结果缓存为空对象，以防后续重复查询。

伪代码示例：

public String selectUser(String userId) {
    String cacheData = cache.get(userId);
    if (StrUtil.isBlank(cacheData)) {
        if (!bloomFilter.contains(userId)) {
            throw new RuntimeException();
        }
        Boolean cacheIsNull = cache.hasKey("is-null_" + userId);
        if (cacheIsNull) {
            throw new RuntimeException();
        }
        Lock lock = getLock("业务标识");
        lock.lock();
        try {
            cacheData = cache.get(userId);
            if (StrUtil.isBlank(cacheData)) {
                String dbData = userMapper.selectId(userId);
                if (StrUtil.isNotBlank(dbData)) {
                    cache.set(userId, dbData);
                    cacheData = dbData;
                } else {
                    cache.set("is-null_" + userId, 短过期时间);
                    throw new RuntimeException();
                }
            }
        } finally {
            lock.unlock();
        }
    }
    return cacheData;
}