给数据加上缓存

假设现在有如下这样一个查询数据库的方法，它简单的从数据库查询了一批数据。这个方法每次都从数据库中进行查询，如何给这些数据加上缓存，减少数据库压力，提升查询速度呢？

public List<Post> findAllPostByStatus(int pageNum,
										int pageSize,
                                        int status) {
    PageHelper.startPage(pageNum, pageSize);
    return postMapper.findAllPostByStatus(status);
}

可以像下面这样进行简单的修改，查询数据库之前，先查询一次redis缓存，缓存中存在数据则直接返回缓存数据；如果缓存中没有数据则从数据库查询数据，在放入缓存。

public List<Post> findAllPostByStatus(int pageNum,
                                          int pageSize,
                                          int status) {
    String cacheKey = "postListStatus:" 
        + status + ":page:" + pageNum + ":size:" + pageSize;
    // 查询缓存
    String cash = redisUtil.get(cacheKey);
    if (Objects.nonNull(cash)) {
        return JSON.parseArray(cash, Post.class);
    } else {
        PageHelper.startPage(pageNum, pageSize);
        // 未命中缓存，查询数据库
        List<PostVo> postList = postMapper.findAllPosByStatus(status);
        // 存储缓存，设置过期时间1小时
        redisUtil.setExpire(cacheKey, JSON.toJSONString(postVoList), 
                            1, TimeUnit.HOURS);
        return postList;
    }
}

缓存击穿

在高并发时，同时有大量请求同时访问这个key，如果此时缓存过期，或者还没有缓存，导致缓存被击破，直接查询数据库，导致数据库高负载，导致性能下降。

高并发场景多个线程还会将数据重复缓存到缓存中。

解决方案

设置永不过期

可以将可以预期的热点数据，设置为永不过期。

或者可以设定一个算法，当某些数据短时间内请求量增大时，可以设置缓存永不过期，或者延长过期时间。

加锁排队

给查询数据库代码加上同步锁，只让一个线程进行查询，其他线程阻塞进行排队。第一个线程查询完成，更新完成缓存后，后面的线程就能够从缓存获取数据。

public List<Post> findAllPostByStatus(int pageNum,
                                          int pageSize,
                                          int status) {
    String cacheKey = "postListStatus:" 
        + status + ":page:" + pageNum + ":size:" + pageSize;
    // 查询缓存
    String cash = redisUtil.get(cacheKey);
    if (Objects.nonNull(cash)) {
        return JSON.parseArray(cash, Post.class);
    } else {
        synchronized (this) {
            cash = redisUtil.get(cacheKey);
            if (Objects.nonNull(cash)) {
                return JSON.parseArray(cash, PostVo.class);
            }
            PageHelper.startPage(pageNum, pageSize);
            // 未命中缓存，查询数据库
            List<PostVo> postList = postMapper.findAllPostByStatus(status);
            // 存储缓存
            redisUtil.setExpire(cacheKey, JSON.toJSONString(postList), 
                                1, TimeUnit.HOURS);
            return postList;
        }
    }
}

为什么不用分布式锁

如果服务器做了集群，假设有10台服务器，使用线程锁最多情况也只有10个查询请求到数据库，完全能够承受，没有必要使用分布式锁。

缓存雪崩

当缓存同时间大量key失效，或者缓存服务器宕机时，大量请求直接访问数据库，导致数据库高负载，甚至直接宕机。

大量击穿导致系统雪崩。

解决方案

随机过期时间

针对缓存集中过期的情况，可以添加缓存随机失效时间。

// 存储缓存，添加随机过期时间避免雪崩
long expireTime = 3600 + new Random().nextInt(600); // 1小时±10分钟
redisUtil.setExpire(cacheKey, JSON.toJSONString(postVoList), 
                    expireTime, TimeUnit.SECONDS);