如何解决缓存穿透、缓存击穿、缓存雪崩？才能使数据库幸免于难

叁歲伎倆 2024-03-25 15:22 6阅读 0赞

随着互联网应用的不断发展，应用程序越来越复杂，同时面对的数据量也越来越大，对于性能的要求也越来越高。缓存技术的应用已经成为了许多互联网应用的必备技术之一。SpringBoot作为一款优秀的Java开发框架，在缓存方面也提供了一些优秀的解决方案，可以帮助我们解决缓存穿透、缓存击穿、缓存雪崩等问题。

![b16efd0bad0047b4b37f5668c1fc4b64.png][]

## 一、Redis缓存 ##

Redis是一个高性能的键值对存储数据库，也是一个基于内存的数据结构存储系统，同时也支持持久化数据存储。Redis提供了丰富的数据结构，包括字符串、哈希、列表、集合、有序集合等。在缓存方面，Redis最大的优点就是支持数据的持久化存储，同时也具有很好的性能和扩展性。

## 二、缓存穿透 ##

缓存穿透是指查询一个不存在的数据，由于缓存中没有数据，请求会直接穿透到数据库中，从而引起数据库的压力过大，严重影响系统的性能。解决缓存穿透的常用方法有两种：

1.  **布隆过滤器**

布隆过滤器是一种高效的数据结构，可以判断一个元素是否存在于一个集合中，同时也可以减轻数据库的压力。在使用布隆过滤器的时候，首先将所有的数据hash到一个位图中，如果查询的数据在位图中不存在，那么直接返回不存在，从而避免了对数据库的查询操作。

在SpringBoot中，我们可以使用Guava提供的布隆过滤器实现缓存穿透的解决方案。例如：

@Bean
    public BloomFilter bloomFilter() {
        return BloomFilter.create(Funnels.stringFunnel(Charset.defaultCharset()), 100000, 0.001);
    }
    
    @Override
    public User getUserById(String id) {
        // 先从布隆过滤器中查询是否存在
        if (!bloomFilter.mightContain(id)) {
            return null;
        }
        // 如果存在，则查询Redis中的缓存数据
        User user = redisTemplate.opsForValue().get(id);
        if (user == null) {
            // 如果Redis中不存在，则查询数据库
            user = userDao.getUserById(id);
            if (user != null) {
                // 将数据缓存到Redis中
                redisTemplate.opsForValue().set(id, user);
            } else {
                // 如果数据库中也不存在，则将该id加入到布隆过滤器中
                bloomFilter.put(id);
            }
        }
        return user;
    }

在上面的代码中，首先通过布隆过滤器判断请求的数据是否存在于集合中，如果不存在，则直接返回null，从而避免了对数据库的查询操作。

1.  **空对象缓存**

另外一种解决缓存穿透的方法是采用空对象缓存的方式，即当查询的数据不存在时，将一个空对象缓存到Redis中。这样下次查询同样不存在的数据时，就可以直接从Redis中获取到一个空对象，从而避免了对数据库的查询操作。

在SpringBoot中，我们可以通过设置Redis缓存的过期时间来实现空对象缓存的解决方案。例如：

@Override
    public User getUserById(String id) {
        User user = redisTemplate.opsForValue().get(id);
        if (user == null) {
            // 如果Redis中不存在，则查询数据库
            user = userDao.getUserById(id);
            if (user != null) {
                // 将数据缓存到Redis中
                redisTemplate.opsForValue().set(id, user);
            } else {
                // 如果数据库中也不存在，则将一个空对象缓存到Redis中，设置过期时间防止缓存雪崩
                redisTemplate.opsForValue().set(id, new User(), 5, TimeUnit.MINUTES);
            }
        }
        return user;
    }

在上面的代码中，当查询的数据不存在时，我们将一个空对象缓存到Redis中，并设置了5分钟的过期时间。这样即使缓存中的数据被清空了，也不会引起数据库的压力过大，从而避免了缓存穿透。

## 三、缓存击穿 ##

缓存击穿是指一个非常热点的数据在缓存中过期之后，正好在这个时间段内有大量的请求访问该数据，这些请求会直接穿透到数据库中，从而引起数据库的压力过大，严重影响系统的性能。解决缓存击穿的常用方法有两种：

1.  **设置热点数据永不过期**

一种解决缓存击穿的方法是将热点数据设置为永不过期，从而避免缓存失效的问题。但是这种方法存在一个缺点，就是热点数据可能会被修改，如果不及时更新缓存，可能会导致缓存中的数据与实际数据不一致。

在SpringBoot中，我们可以通过设置Redis缓存的过期时间来实现设置热点数据永不过期的解决方案。例如：

@Override
    public User getHotUserById(String id) {
        User user = redisTemplate.opsForValue().get(id);
        if (user == null) {
            // 如果Redis中不存在，则查询数据库
            user = userDao.getHotUserById(id);
            if (user != null) {
                // 将数据缓存到Redis中，设置过期时间为1小时
                redisTemplate.opsForValue().set(id, user, 1, TimeUnit.HOURS);
            }
        }
        return user;
    }

在上面的代码中，我们将热点数据的过期时间设置为1小时，从而避免了缓存击穿的问题。但是这种方法存在一个缺点，就是如果在1小时内热点数据被修改了，缓存中的数据就会失效，需要重新查询数据库。

1.  **延迟缓存双写策略**

另外一种解决缓存击穿的方法是采用延迟缓存双写策略，即在缓存中查询数据时，如果数据不存在，不立即去数据库中查询，而是先在缓存中写入一个空对象，然后再去数据库中查询数据并更新缓存，从而避免了缓存击穿的问题。

在SpringBoot中，我们可以通过设置Redis缓存的过期时间来实现延迟缓存双写策略的解决方案。例如：

@Override
    public User getHotUserById(String id) {
        User user = redisTemplate.opsForValue().get(id);
        if (user == null) {
            // 如果Redis中不存在，则写入一个空对象
            redisTemplate.opsForValue().set(id, new User(), 5, TimeUnit.MINUTES);
            // 去数据库中查询数据并更新缓存
            user = userDao.getHotUserById(id);
            if (user != null) {
                redisTemplate.opsForValue().set(id, user, 1, TimeUnit.HOURS);
            }
        }
        return user;
    }

在上面的代码中，我们先在缓存中写入一个空对象，并设置了5分钟的过期时间，然后再去数据库中查询数据并更新缓存。这样即使在查询数据的过程中，大量请求访问了该数据，也不会直接穿透到数据库中，从而避免了缓存击穿的问题。

## 四、缓存雪崩 ##

缓存雪崩是指当缓存中的大量数据在同一时间失效，导致大量请求直接访问数据库，从而引起数据库的压力过大，严重影响系统的性能。解决缓存雪崩的常用方法有三种：

1.  **缓存数据的随机过期时间**

一种解决缓存雪崩的方法是在缓存数据的过期时间上增加随机因素，从而避免大量数据在同一时间失效的情况。在SpringBoot中，我们可以通过设置Redis缓存的过期时间和一个随机值来实现这个解决方案。例如：

@Override
    public List<User> getUserList() {
        List<User> userList = redisTemplate.opsForValue().get("userList");
        if (userList == null) {
            // 如果Redis中不存在，则查询数据库
            userList = userDao.getUserList();
            if (userList != null && userList.size() > 0) {
                // 将数据缓存到Redis中，并增加随机的过期时间
                int random = new Random().nextInt(600) + 600;
                redisTemplate.opsForValue().set("userList", userList, random, TimeUnit.SECONDS);
        }
    }
    return userList;     
      }

在上面的代码中，我们先在缓存中查询数据，如果不存在，则去数据库中查询，并将数据缓存到Redis中，并增加随机的过期时间。这样即使大量数据在同一时间失效，也不会全部直接访问数据库，从而避免了缓存雪崩的问题。

**2. 预热缓存**

另外一种解决缓存雪崩的方法是在系统启动时预热缓存，将系统中的热点数据提前加载到缓存中，从而避免了大量请求同时访问数据库的情况。在SpringBoot中，我们可以通过编写一个启动时执行的方法，来实现预热缓存的解决方案。例如：

@Component
    public class CacheInit implements CommandLineRunner {
      @Autowired
    private UserDao userDao;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Override
    public void run(String... args) throws Exception {
        List<User> userList = userDao.getUserList();
        if (userList != null && userList.size() > 0) {
            // 将数据缓存到Redis中，并设置过期时间为1小时
            for (User user : userList) {
                redisTemplate.opsForValue().set(user.getId(), user, 1, TimeUnit.HOURS);
            }
        }
    }
    }

在上面的代码中，我们在系统启动时执行run方法，在该方法中先去数据库中查询热点数据，然后将数据缓存到Redis中，并设置过期时间为1小时。这样即使缓存中的数据在同一时间失效，也能够保证系统中的热点数据始终被缓存，从而避免了缓存雪崩的问题。

**3. 使用分布式锁**

最后一种解决缓存雪崩的方法是使用分布式锁，从而避免大量请求同时访问数据库的情况。在SpringBoot中，我们可以通过Redisson来实现分布式锁的解决方案。例如：

@Override
        public List<User> getUserList() {
            List<User> userList = redisTemplate.opsForValue().get("userList");
            if (userList == null) {
                // 如果Redis中不存在，则尝试获取分布式锁
                RLock lock = redissonClient.getLock("userListLock");
                try {
                    // 尝试加锁，并设置锁的过期时间为5秒
                    boolean success = lock.tryLock(5, TimeUnit.SECONDS);
                    if (success) {
                        // 如果获取到了锁，则查询数据库并将数据缓存到Redis中
                        userList = userDao.getUserList();
                        if (userList != null && userList.size() > 0) {
                            redisTemplate.opsForValue().set("userList", userList, 1, TimeUnit.HOURS);
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 释放锁
                    lock.unlock
                }
            } return userList;
        }

在上面的代码中，我们先在缓存中查询数据，如果不存在，则尝试获取分布式锁，如果获取到了锁，则查询数据库并将数据缓存到Redis中。如果没有获取到锁，则等待一段时间再尝试获取锁，这样即使大量请求同时访问系统，也能够保证只有一个请求去查询数据库并缓存数据，从而避免了缓存雪崩的问题。

## 总结 ##

如何利用好缓存，加快访问速度，提高并发的同时还不出现问题是一个优秀架构的关键，在开发过程中我经常会遇到一些问题，比如缓存穿透、缓存击穿和缓存雪崩，这些问题会导致系统性能下降、数据库负载过高等问题，因此必须采取一些措施来解决这些问题。

在实际应用中，需要根据系统的实际情况和性能要求来选择合适的机制，也可以采用多种机制来解决缓存问题。

[b16efd0bad0047b4b37f5668c1fc4b64.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/f3d210ab3fa64a73a8cd30633bca86f6.png