spring redis缓存穿透、缓存击穿、缓存雪崩以及解决方案

最新推荐文章于 2024-08-21 22:37:09 发布

frankoceankanye

最新推荐文章于 2024-08-21 22:37:09 发布

阅读量742

点赞数 16

文章标签：缓存 spring redis

本文链接：https://blog.csdn.net/aumiel/article/details/136601803

版权

一、Redis缓存

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

二、缓存穿透

缓存穿透：缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在，这样缓存永远不会生效，由于缓存中没有数据，请求会直接穿透到数据库中，从而引起数据库的压力过大，严重影响系统的性能。解决缓存穿透的常用方法有两种。

2.1、布隆过滤器

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

优点：内存占用较少，没有多余key
缺点：
- 实现复杂
- 存在误判可能

在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，从而避免了对数据库的查询操作。

2.2、空对象缓存

另外一种解决缓存穿透的方法是采用空对象缓存的方式，即当查询的数据不存在时，将一个空对象缓存到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分钟的过期时间。这样即使缓存中的数据被清空了，也不会引起数据库的压力过大，从而避免了缓存穿透。

三、缓存击穿

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

3.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小时内热点数据被修改了，缓存中的数据就会失效，需要重新查询数据库。

3.2.使用互斥锁

只有一个请求可以获取到互斥锁，然后到DB中将数据查询并返回到Redis，之后所有请求就可以从Redis中得到响应。【缺点：所有线程的请求需要一同等待】

使用setnx作为Redis中的锁。

Redis中查询缓存
- 存在且不为空值，直接返回
- 为空值(比如“”、0等特殊值)，返回失败结果
- 不存在，获取锁
获取锁失败，等待重试
获取成功，查找MySQL
- 不存在，Redis存入空值
- 存在，写入Redis
释放锁，返回结果

    /**
     * 根据id查找商户，先到redis中找，再到MySQL中找
     * @param id
     * @return
     */
    @Override
    public Result queryShopById(Long id) {

        // 用String形式存储JSON
        String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);

        // 如果查询结果不为null，直接返回
        if (StrUtil.isNotBlank(shopJson)) {
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }

        // 否则Redis中查询结果为空，判断是否为“”
        if (shopJson != null) {
            return Result.fail("店铺不存在，请确认id是否正确");
        }

        // 尝试获取锁，
        // 如果没有得到锁，Sleep一段时间
        if (!tryLock(LOCK_SHOP_KEY + id)) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 从开始重试
            return queryShopById(id);
        }

        // 获得了锁，从MySQl中查找
        Shop shop = this.getById(id);
        // 模拟重建的延时
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 不在MySQL中
        if (shop == null) {
            // 将空值写入Redis
            stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
            // 释放锁
            unLock(LOCK_SHOP_KEY + id);
            return Result.fail("店铺不存在，请确认id是否正确");
        }
        else {
            // 在MySQL中，存入redis
            stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
            // 释放锁
            unLock(LOCK_SHOP_KEY + id);
            return Result.ok(shop);
        }
    }

    public boolean tryLock(String key) {
        // 尝试获取锁，set成功返回true，否则返回false
        Boolean getLock = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
        // 避免getLock为null，使用工具类
        return BooleanUtil.isTrue(getLock);
    }

    public void unLock(String key) {
        stringRedisTemplate.delete(key);
    }

四、缓存雪崩

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

4.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中，并增加随机的过期时间。这样即使大量数据在同一时间失效，也不会全部直接访问数据库，从而避免了缓存雪崩的问题。

4.2 使用分布式锁

第二种解决缓存雪崩的方法是使用分布式锁，从而避免大量请求同时访问数据库的情况。在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中。如果没有获取到锁，则等待一段时间再尝试获取锁，这样即使大量请求同时访问系统，也能够保证只有一个请求去查询数据库并缓存数据，从而避免了缓存雪崩的问题。

frankoceankanye

关注

16
点赞
踩
27

收藏

觉得还不错? 一键收藏
1
评论
spring redis缓存穿透、缓存击穿、缓存雪崩以及解决方案

缓存穿透：缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在，这样缓存永远不会生效，由于缓存中没有数据，请求会直接穿透到数据库中，从而引起数据库的压力过大，严重影响系统的性能。解决缓存穿透的常用方法有两种。在上面的代码中，我们先在缓存中查询数据，如果不存在，则去数据库中查询，并将数据缓存到Redis中，并增加随机的过期时间。缓存击穿是指一个非常热点的数据在缓存中过期之后，正好在这个时间段内有大量的请求访问该数据，这些请求会直接穿透到数据库中，从而引起数据库的压力过大，严重影响系统的性能。
复制链接

扫一扫