Redis缓存的基本概念和使用

Kevin_Opt

于 2024-05-12 19:28:51 发布

阅读量797

点赞数 11

文章标签：缓存 redis 数据库

本文链接：https://blog.csdn.net/qq_41523340/article/details/138717914

版权

Redis缓存的基本概念和使用

什么是缓存
Redis缓存
缓存更新策略
缓存穿透
缓存雪崩
缓存击穿
缓存工具类封装

什么是缓存

缓存时数据交换的缓冲区，存储数据的临时区，读写性能较好。
例如计算机的三级缓存。CPU的计算速度超过内存的读写速度，为了平衡两者速度，使用了三级缓存，把经常需要读写的数据放到三级缓存中。
例如DNS缓存，浏览器缓存，nginx缓存，JVM进程缓存，Redis缓存，数据库缓存等。
缓存作用：
1、降低后端负载。
2、提高读写效率，降低响应时间。
缓存成本：
1、缓存一致性。
2、复杂度。例如缓存穿透，缓存击穿，缓存雪崩等问题使代码复杂度提升。
3、运维成本。

Redis缓存

客户端先请求Redis缓存，命中缓存则直接返回，没有命中再请求数据库，若数据不存在则返回404，如果数据存在则把新数据写到Redis缓存中，最后返回数据。
例如店铺信息缓存如下：

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public Object queryById(Long id) {
        String key = CACHE_SHOP_KEY + id;
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        if (! StrUtil.isEmpty(shopJson)) {
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        Shop shop = getById(id);
        if (shop == null) {
            return Result.fail("店铺不存在！");
        }
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop));
        stringRedisTemplate.expire(key, CACHE_SHOP_TTL, TimeUnit.MINUTES);
        return Result.ok(shop);
    }
}

缓存更新策略

1、内存淘汰
使用Redis的内存淘汰策略，内存不足时自己淘汰部分数据，下次查询时更新缓存。
应用于一致性要求低，几乎不需要维护成本的场景。
2、超时剔除
给数据添加过期时间，到期后自动删除缓存，下次查询时更新缓存。
应用于一致性要求一般，维护成本较低的场景。
3、主动更新
编写业务逻辑，在修改数据库数据时，更新缓存。
适用一致性较好，维护成本较高的场景。

业务场景：
低一致性需求：使用内存淘汰，比如店铺类型的查询缓存。
高一致性需求：使用主动更新，并添加超时剔除作为兜底，例如店铺详情的缓存。

主动更新策略有哪些？
1、旁路缓存，Cache Aside
缓存调用者在更新数据库时更新缓存。相对可控，实际使用较多。
2、读穿/写穿，Read/Write Through
缓存和数据库整合成一个服务，调用者无需关心数据库和缓存一致性。
3、读后写，Write Behind Caching
调用者只操作缓存，其他线程异步地将数据从缓存持久化到数据库。

旁路缓存具体方案？
1、删除缓存还是更新缓存？
使用删除缓存，因为如果使用更新缓存，每次更新数据库都要更新缓存，如果中间没有读取，那么无效写操作太多。
2、如何保证操作数据库和缓存的同时成功和失败？
单体系统，将数据库和缓存的操作放在一个事务中。
分布式系统，使用TCC等分布式事务。
3、先操作缓存还是先操作数据库？
根据：更新数据库时间更慢，删除缓存时间更快。

如果先删缓存，后更新数据库。
线程1刚把缓存删除，还没有更新缓存，线程2查询缓存未命中，会查询数据库旧值并且更新到缓存中，导致缓存数据是旧值。

如果先更新数据库，再删除缓存。
缓存失效，线程1查询缓存未命中，查询到数据库，线程2刚好修改数据库，并且删除缓存，线程2将旧数据写入缓存。
发生概率较小，因为写入缓存时间较短，需要在线程1查询完数据库写入缓存前，把线程2的更新数据库和删除缓存都完成概率较小。

例如，实现查询商铺的查询缓存添加主动更新和超时剔除策略。
1、查询时，如果缓存未命中，则查询数据库，并且写入缓存，设置超时时间。
2、更新时，先修改数据库，后删除缓存。

@Override
public Object queryById(Long id) {
    String key = CACHE_SHOP_KEY + id;
    String shopJson = stringRedisTemplate.opsForValue().get(key);
    if (! StrUtil.isEmpty(shopJson)) {
        Shop shop = JSONUtil.toBean(shopJson, Shop.class);
        return Result.ok(shop);
    }
    Shop shop = getById(id);
    if (shop == null) {
        return Result.fail("店铺不存在！");
    }
    stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
    return Result.ok(shop);
}

@Override
@Transactional
public Result updateShop(Shop shop) {
    Long id = shop.getId();
    if (id == null) {
        return Result.fail("店铺id不能为空！");
    }
    updateById(shop);
    String key = CACHE_SHOP_KEY + id;
    stringRedisTemplate.delete(key);
    return Result.ok();
}

缓存穿透

缓存穿透：客户端请求的数据在缓存和数据库中都不存在，缓存永远不会生效，会打到数据库。
解决：
1、缓存空对象。
优点：实现简单。
缺点：额外内存消耗，可能有短期数据不一致。
2、布隆过滤器。
优点：内存消耗更小。
缺点：实现复杂，存在误判，不能解决删除元素问题。

编码实现，这里使用缓存空对象。

@Override
public Object queryById(Long id) {
    String key = CACHE_SHOP_KEY + id;
    String shopJson = stringRedisTemplate.opsForValue().get(key);
    if (! StrUtil.isNotBlank(shopJson)) {
        Shop shop = JSONUtil.toBean(shopJson, Shop.class);
        return Result.ok(shop);
    }
    //命中之前缓存的空字符串
    if ("".equals(shopJson)) {
        return Result.fail("店铺不存在！");
    }
    Shop shop = getById(id);
    if (shop == null) {
        //写入空值解决缓存穿透
        stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
        return Result.fail("店铺不存在！");
    }
    stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
    return Result.ok(shop);
}

缓存雪崩

缓存雪崩：同一时段大量缓存key同时失效，或者Redis服务宕机，导致大量请求达到数据库。
解决：
1、给不同key的过期时间ttl设置随机值。
2、使用Redis集群提高服务可用性。
3、添加降级限流策略。
4、添加多级缓存。

缓存击穿

缓存击穿：热点key突然失效，无数请求瞬间达到数据库带来巨大冲击。
解决：
1、互斥锁。重建缓存时，使用一个锁保证只有一个线程能重建缓存。可以结合两次if判断进行双重检查防止后面线程获取锁的开销。
优点：实现简单，保证一致性。
缺点：性能受影响，可能有死锁风险。
2、逻辑过期。即不设置ttl，key永不过期，但是在value中设置expire字段。当线程1发现key过期时，拿到互斥锁，并开启新线程重建缓存。其他线程获取锁失败时直接拿旧数据。
优点：线程无需等待，性能较好。
缺点：一致性更低，有额外内存消耗。
区别：逻辑过期也使用了互斥锁，但是它和互斥锁的区别在于，过期数据依然在Redis中，因此其他线程可以先使用旧数据。

例子：根据id查询商铺，使用互斥锁解决缓存击穿。

    public Shop queryWithMutex(Long id) {
        String key = CACHE_SHOP_KEY + id;
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        if (StrUtil.isNotBlank(shopJson)) {
            return JSONUtil.toBean(shopJson, Shop.class);
        }
        //命中之前缓存的空字符串，解决缓存穿透
        if ("".equals(shopJson)) {
            return null;
        }
        Shop shop = null;
        String lockKey = LOCK_SHOP_KEY + id;
        try {
            while (!tryLock(lockKey)) {
                Thread.sleep(50);
            }
            //双重检查
            shopJson = stringRedisTemplate.opsForValue().get(key);
            if (StrUtil.isNotBlank(shopJson)) {
                return JSONUtil.toBean(shopJson, Shop.class);
            }
            //命中之前缓存的空字符串，解决缓存穿透
            if ("".equals(shopJson)) {
                return null;
            }
            shop = getById(id);
            if (shop == null) {
                //写入空值解决缓存穿透
                stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
                return null;
            }
            stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            unLock(lockKey);
        }
        return shop;
    }

例子：根据id查询商铺，逻辑过期解决缓存击穿例子：

public class RedisData {
    private LocalDateTime expireTime;
    private Object data;
}
public void saveShop2Redis(Long id, Long expireSeconds) {
    Shop shop = getById(id);
    RedisData redisData = new RedisData();
    redisData.setData(shop);
    redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
    stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(redisData));
}

//逻辑过期解决缓存击穿
public Shop queryWithLogicalExpire(Long id) {
    String key = CACHE_SHOP_KEY + id;
    String shopJson = stringRedisTemplate.opsForValue().get(key);
    if (StrUtil.isBlank(shopJson)) {
        return null;
    }
    RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
    LocalDateTime expireTime = redisData.getExpireTime();
    JSONObject jsonObject = (JSONObject) redisData.getData();
    Shop shop = JSONUtil.toBean(jsonObject, Shop.class);
    if (expireTime.isAfter(LocalDateTime.now())) {
        return shop;
    }
    String lockKey = LOCK_SHOP_KEY + id;
    if (tryLock(lockKey)) {
        CACHE_REBUILD_EXECUTOR.execute(()->{
            try {
                saveShop2Redis(id, 30L);
            } catch (Exception e) {
                throw new RuntimeException(e);
            } finally {
                unLock(lockKey);
            }
        });

    }
    return shop;
}

缓存工具类封装

缓存穿透，缓存击穿，缓存雪崩等业务逻辑较复杂，如果每次使用缓存都需要写这部分代码，可以考虑把这部分代码封装成一个工具类。
方法1：将Java对象序列化成JSON字符串并且存储在string类型的Redis中，并且可以设置过期时间。
方法2：将Java对象序列化成JSON字符串并且存储在string类型的Redis中，可以设置逻辑过期时间，解决缓存击穿问题。
方法3：根据指定key查询缓存，并且反序列化成指定类型，利用缓存空值的方式解决缓存穿透。
方法4：根据指定key查询缓存，并且反序列化成执行类型，利用逻辑过期解决缓存击穿。

@Slf4j
@Component
public class CacheClient {

    private final StringRedisTemplate stringRedisTemplate;

    public CacheClient(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

    public void set(String key, Object value, Long time, TimeUnit unit) {
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), time, unit);
    }

    public void setWithLogicalExpire(String key, Object value, Long time, TimeUnit unit) {
        RedisData redisData = new RedisData();
        redisData.setData(value);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
    }

    public <R, ID> R queryWithPassThrough(String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallBack,
                                          Long time, TimeUnit unit) {
        String key = keyPrefix + id;
        String json = stringRedisTemplate.opsForValue().get(key);
        if (StrUtil.isNotBlank(json)) {
            return JSONUtil.toBean(json, type);
        }
        if ("".equals(json)) {
            return null;
        }
        R r = dbFallBack.apply(id);
        if (r == null) {
            //写入空值解决缓存穿透
            stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
            return null;
        }
        set(key, r, time, unit);
        return r;
    }

    public <R, ID> R queryWithLogicalExpire(String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallBack,
                                            Long time, TimeUnit unit) {
        String key = keyPrefix + id;
        String json = stringRedisTemplate.opsForValue().get(key);
        if (StrUtil.isBlank(json)) {
            return null;
        }
        RedisData redisData = JSONUtil.toBean(json, RedisData.class);
        LocalDateTime expireTime = redisData.getExpireTime();
        JSONObject jsonObject = (JSONObject) redisData.getData();
        R r = JSONUtil.toBean(jsonObject, type);
        if (expireTime.isAfter(LocalDateTime.now())) {
            return r;
        }
        String lockKey = LOCK_SHOP_KEY + id;
        if (tryLock(lockKey)) {
            CACHE_REBUILD_EXECUTOR.execute(()->{
                try {
                    R r1 = dbFallBack.apply(id);
                    setWithLogicalExpire(key, r1, time, unit);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    unLock(lockKey);
                }
            });

        }
        return r;
    }

    private boolean tryLock(String key) {
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", LOCK_SHOP_TTL, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(flag);
    }

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