Redis 缓存击穿

缓存击穿是指一个热点 key 在缓存中过期，此时有大量并发请求同时访问这个 key，导致所有请求都打到数据库上，从而压垮数据库。

比如说微博中的热门事件，如果没有把热门事件作为热点词存储到缓存中或者缓存时间到期，那么用户访问这个词时，就会通过缓存，直接访问数据库，引起数据库压力瞬间增大。

它和缓存穿透的区别在于：缓存击穿是指缓存中没有但数据库中有的数据，由于并发用户特别多，同时读缓存没读到数据，同时数据库取数据引起数据库压力瞬间增大，造成过大压力。缓存穿透是指缓存和数据库中都没有的数据，而用户不断发起请求，如发起的数据特别大而不存在的数据

1. 缓存击穿的解决方案

key 可能会在某些时间点被高并发访问，是一种非常热点的数据，这个时候，需要考虑一个问题，缓存被击穿的问题

下面介绍 2 种方法可以有效地解决缓存击穿问题:

预先设置热门数据：在 redis 高峰访问前，把一些热门数据提前存入 redis 中，加大这些热门数据 key 的时长实时调整现场监控哪些数据是热门数据，实时调整 key 的过期时长
使用分布式锁: 就是在缓存失效的时候（判断拿出来的值为空），不是立即去查数据库，先使用缓存工具的某些带成功操作返回值的操作。比如 redis 的 setnx 去 set 一个 mutex key，当操作返回成功时（分布式锁），在查数据库，并回设缓存，最后删除 mutex key 当操作返回失败，证明有线程在查询数据库，当前线程睡眠一段时间在重 s 试整个 get 缓存的方法

2. Springboot 实现

使用互斥锁，保证同一时间只有一个请求去重建缓存，其他请求等待。

@Service
public class UserService {
    @Autowired
    private StringRedisTemplate redisTemplate;

    public User getUserById(Long id) {
        // 1. 先从缓存中查询
        String userJson = redisTemplate.opsForValue().get("user:" + id);
        if (userJson != null) {
            return JSON.parseObject(userJson, User.class);
        }

        // 2. 缓存未命中，尝试获取锁
        String lockKey = "lock:user:" + id;
        boolean locked = redisTemplate.opsForValue().setIfAbsent(lockKey, "1", 10, TimeUnit.SECONDS);

        if (locked) {
            try {
                // 3. 获取锁成功，查询数据库
                User user = userMapper.selectById(id);

                // 4. 将结果写入缓存
                if (user != null) {
                    redisTemplate.opsForValue().set("user:" + id, JSON.toJSONString(user), 30, TimeUnit.MINUTES);
                }

                return user;
            } finally {
                // 5. 释放锁
                redisTemplate.delete(lockKey);
            }
        } else {
            // 6. 获取锁失败，等待一段时间后重试
            try {
                Thread.sleep(100);
                return getUserById(id);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return null;
            }
        }
    }
}

对于热点数据，可以设置永不过期，通过后台异步更新缓存。

@Service
public class UserService {
    @Autowired
    private StringRedisTemplate redisTemplate;

    public User getUserById(Long id) {
        // 1. 先从缓存中查询
        String userJson = redisTemplate.opsForValue().get("user:" + id);
        if (userJson != null) {
            return JSON.parseObject(userJson, User.class);
        }

        // 2. 缓存未命中，查询数据库
        User user = userMapper.selectById(id);

        // 3. 将结果写入缓存，不设置过期时间
        if (user != null) {
            redisTemplate.opsForValue().set("user:" + id, JSON.toJSONString(user));
        }

        return user;
    }

    // 后台定时更新缓存
    @Scheduled(fixedRate = 300000) // 每5分钟执行一次
    public void updateHotUserCache() {
        List<User> hotUsers = userMapper.getHotUsers();
        for (User user : hotUsers) {
            redisTemplate.opsForValue().set("user:" + user.getId(), JSON.toJSONString(user));
        }
    }
}

在缓存即将过期时，提前更新缓存。

@Service
public class UserService {
    @Autowired
    private StringRedisTemplate redisTemplate;

    public User getUserById(Long id) {
        // 1. 先从缓存中查询
        String userJson = redisTemplate.opsForValue().get("user:" + id);
        if (userJson != null) {
            // 2. 检查是否需要提前更新
            Long ttl = redisTemplate.getExpire("user:" + id);
            if (ttl != null && ttl < 300) { // 如果剩余时间小于5分钟
                // 异步更新缓存
                CompletableFuture.runAsync(() -> updateCache(id));
            }
            return JSON.parseObject(userJson, User.class);
        }

        // 3. 缓存未命中，查询数据库
        User user = userMapper.selectById(id);

        // 4. 将结果写入缓存
        if (user != null) {
            redisTemplate.opsForValue().set("user:" + id, JSON.toJSONString(user), 30, TimeUnit.MINUTES);
        }

        return user;
    }

    private void updateCache(Long id) {
        User user = userMapper.selectById(id);
        if (user != null) {
            redisTemplate.opsForValue().set("user:" + id, JSON.toJSONString(user), 30, TimeUnit.MINUTES);
        }
    }
}

3. 注意事项

互斥锁方案要注意死锁问题
热点数据永不过期要注意内存占用
提前更新要注意更新频率
降级策略要考虑数据一致性