Redis(3)缓存策略

已于 2023-04-20 15:58:15 修改
阅读量539 收藏 1
点赞数 2
分类专栏： redis 文章标签： 缓存 redis
于 2022-10-26 21:53:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43994244/article/details/127527201
版权

Redis缓存策略

redis实现短信登录：https://blog.csdn.net/weixin_43994244/article/details/127518540

缓存

缓存数据存储于代码中,而代码运行在内存中,内存的读写性能远高于磁盘,缓存可以大大降低用户访问并发量带来的服务器读写压力。(速度快，好用)
在这里插入图片描述

实际开发中,会构筑多级缓存来使系统运行速度进一步提升，例如:本地缓存与redis中的缓存并发使用
浏览器缓存：主要是存在于浏览器端的缓存
应用层缓存：可以分为tomcat本地缓存，比如之前提到的map，或者是使用redis作为缓存
数据库缓存：在数据库中有一片空间是 buffer pool，增改查数据都会先加载到mysql的缓存中
CPU缓存：当代计算机最大的问题是 cpu性能提升了，但内存读写速度没有跟上，所以为了适应当下的情况，增加了cpu的L1，L2，L3级的缓存

在这里插入图片描述

缓存更新策略

在这里插入图片描述
业务场景：

  • 低一致性需求：使用内存淘汰机制，例如店铺类型的查询缓存
  • 高一致性需求：主动更新，并以超时剔除作为兜底方案，例如店铺详情查询的缓存 √

主动更新策略：

  • Cache Aside Pattern：由缓存的调用者，在更新数据库的同时更新缓存
    (可控性更高，一致性良好，实现难度一般)
  • Read/Write Through Pattern：缓存与数据库整合为一个服务，由服务来维护一致性，调用者调用该服务，无需关心缓存一致性问题。
    (一致性优秀，实现复杂，开发成本高，性能一般，简化调用者开发)
  • Write Behind Caching Pattern：调用者值操作缓存，由其他线程异步的将缓存数据持久化到数据库，保证最终一致。 (数据库中的多次写合并为一次写(效率高)，维护异步任务复杂，一致性难以保证-----一致性差，性能好，实现复杂)

操作缓存和数据库时需考虑：

1.删除缓存还是更新缓存？

  • 更新缓存：每次更新数据库都更新缓存，无效写操作较多(写多读少，会产生无效更新，并且存在较大的线程安全问题)
  • 删除缓存：更新数据库时让缓存失效，查询时再更新缓存 √ (访问时再更新缓存，没有无效更新，线程安全问题相对较低)

2.如何保证缓存与数据库的操作的同时成功或失效？(原子性)

  • 单体系统：将缓存与数据库操作放在一个事务里
  • 分布式系统：利用TCC等分布式事务方案

3.先操作缓存还是先操作数据库？(线程安全)

  • 先删除缓存，再操作数据库 )安全问题概率较高)
  • 先操作数据库，再删除缓存 √(可能性极低+超时时间，在满足原子性的情况下，安全问题概率较低)

最佳实践
读操作：

  • 缓存命中则直接返回
  • 缓存未命中则查询数据库，并写入缓存，设定超时时间

写操作：

  • 先写数据库，再删除缓存
  • 确保数据库与缓存操作的原子性

添加超时剔除和主动更新

代码举例：给查询商铺的缓存添加超时剔除和主动更新的策略

在这里插入图片描述

1.根据id查询店铺时，如果缓存未命中，则查询数据库，将数据库结果写入缓存，并设置超时时间

  @Override
    public Result queryById(Long id) {
        //1.从reedis中查询商铺类型列表缓存
        String shopJson = stringRedisTemplate.opsForValue().get("cache:shop:" + id);
        //2.redis中存在，直接返回
        if(StrUtil.isNotBlank(shopJson)){
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        //3.redis中不存在，根据id查询数据库
        Shop shop = getById(id);
        //4.数据库中不存在，返回错误
        if(shop == null){
            return Result.fail("店铺不存在！");
        }
        //5.数据库中存在，写入redis，设置过期时间
        stringRedisTemplate.opsForValue().set("cache:shop:" + id,JSONUtil.toJsonStr(shop),30L, TimeUnit.MINUTES);
        //6.返回
        return Result.ok(shop);
    }

2.根据id修改店铺时，先修改数据库，再删除缓存

    @Override
    @Transactional
    public Result updateShop(Shop shop) {
        Long id = shop.getId();
        if(id == null){
            return Result.fail("店铺id不能为空！");
        }
        //1.更新数据库
        updateById(shop);
        //2.删除缓存
        stringRedisTemplate.delete("cache:shop:" + id);
        return Result.ok();
    }

缓存穿透

缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在，这样缓存永远不会生效，这些请求都会打到数据库，不断发起这样的请求，给数据库带来巨大压力。

解决方案：

  • 缓存null值
  • 布隆过滤

预防方案：

  • 增加id的复杂度，避免被猜测id规律并且做好数据的基础格式校验，
  • 加强用户权限校验
  • 做好热点参数的限流

缓存空对象
优点：实现简单，维护方便
缺点：额外的内存消耗(缓存里缓存了很多null，设置TTL)，可能造成短期的不一致
布隆过滤
优点：内存占用较少，没有多余key，缺点：实现复杂，存在误判可能
在这里插入图片描述

缓存空对象

代码举例：解决商品查询的缓存穿透问题—缓存空对象
在这里插入图片描述

 @Override
    public Result queryById(Long id) {
        //1.从reedis中查询商铺类型列表缓存
        String shopJson = stringRedisTemplate.opsForValue().get("cache:shop:" + id);
        //2.redis中存在，有值，直接返回
        if(StrUtil.isNotBlank(shopJson)){
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        //缓存中存在，判断命中是否是空值 ""
        if(shopJson != null){
            return Result.fail("店铺不存在！");
        }
        //3.redis中不存在，根据id查询数据库
        Shop shop = getById(id);
        //4.数据库中不存在，返回错误
        if(shop == null){
            //将空值写入redis
            stringRedisTemplate.opsForValue().set("cache:shop:" + id,"",2L, TimeUnit.MINUTES);
            return Result.fail("店铺不存在！");
        }
        //5.数据库中存在，写入redis，设置过期时间
        stringRedisTemplate.opsForValue().set("cache:shop:" + id,JSONUtil.toJsonStr(shop),30L, TimeUnit.MINUTES);
        //6.返回
        return Result.ok(shop);
    }

布隆过滤器

bitmap(位图)：相当于一个以(bit)位为单位的数组，数组中每个单元只能存储二进制数0/1.
布隆过滤器作用：用于检索一个元素是否存在一个集合中。
id为1 的数据存储时，通过多个hash函数获取hash值，根据hash计算的数将数组对应位置改为1，查询数据时，使用相同hash函数获取hash值，判断对应位置是否为1，都为1，数据存在。
在这里插入图片描述
id为3的数据不存在，
在这里插入图片描述

代码参考：https://blog.csdn.net/qq_38517570/article/details/129386587

缓存雪崩

缓存雪崩是指在同一时段大量的缓存key同时失效或者Redis服务宕机，导致大量请求到达数据库，带来巨大压力。

解决方案：

  • 给不同的Key的TTL添加随机值(同一时段大量的缓存key同时失效)
  • 利用Redis集群提高服务的可用性(Redis服务宕机)
  • 给缓存业务添加降级限流策略(提前做好容错处理，服务降级，快速失败，牺牲部分服务，保护数据库)
  • 给业务添加多级缓存

缓存击穿

缓存击穿问题也叫热点Key问题，就是一个被高并发访问并且缓存重建业务较复杂的key突然失效了，无数的请求访问会在瞬间给数据库带来巨大的冲击。

常见的解决方案：

  • 互斥锁(只有一个创建，其他线程等待，性能差)
    优点：没有额外内存消耗，保证一致性，实现简单
    缺点：线程需要等待，性能受影响，可能死锁风险
  • 逻辑过期(永不过期，新线程查询新数据)
    优点：线程无需等待，性能较好
    缺点：不保证一致性，有额外内存消耗，实现复杂
    在这里插入图片描述

互斥锁

根据id查询商铺信息-互斥锁解决缓存击穿问题
在这里插入图片描述

 @Override
    public Result queryById(Long id) {

        Shop shop = queryWithMutex(id);
        if(shop == null){
            return Result.fail("店铺不存在");
        }
        return Result.ok(shop);
    }

	//互斥锁解决缓存击穿问题
    public Shop queryWithMutex(Long id){
        //1.从reedis中查询商铺类型列表缓存
        String shopJson = stringRedisTemplate.opsForValue().get("cache:shop:"+id);
        //2.redis中存在，有值，直接返回
        if(StrUtil.isNotBlank(shopJson)){
            return JSONUtil.toBean(shopJson, Shop.class);
        }
        //3.缓存中存在，判断命中是否是空值 ""--解决缓存穿透
        if(shopJson != null){
            return null;
        }
        //4.实现缓存重建
        //4.1.获取互斥锁
        String lockKey = "lock:shop:" + id;
        Shop shop = null;
        try {
            boolean isLock = tryLock(lockKey);
            // 4.2 判断否获取成功
            if(!isLock){
                //4.3 失败，则休眠重试
                Thread.sleep(50);
                return queryWithMutex(id);
            }
            //4.4 成功，根据id查询数据库
            shop = getById(id);
            // 5.不存在，返回错误
            if(shop == null){
                //将空值写入redis
                stringRedisTemplate.opsForValue().set("cache:shop:"+id,"",2L,TimeUnit.MINUTES);
                //返回错误信息
                return null;
            }
            //6.写入redis
            stringRedisTemplate.opsForValue().set("cache:shop:"+id,JSONUtil.toJsonStr(shop),30L,TimeUnit.MINUTES);

        }catch (Exception e){
            throw new RuntimeException(e);
        }
        finally {
            //7.释放互斥锁
            unLock(lockKey);
        }
        return shop;
    }

获取锁释放锁方法：

  //获取锁
    private boolean tryLock(String key){
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
        //直接返回有拆箱，可能会有空指针
        return BooleanUtil.isTrue(flag);
    }

    //释放锁
    private void unLock(String key){
        stringRedisTemplate.delete(key);
    }

并发测试结果：
在这里插入图片描述
只调用一次数据库：
在这里插入图片描述

逻辑过期

根据id查询商铺信息-逻辑过期解决缓存击穿问题
在这里插入图片描述
1.创建新的实体类，对原来代码没有侵入性

@Data
public class RedisData {
    //逻辑过期时间
    private LocalDateTime expireTime;
    //存储数据对象(不用对之前对象修改)
    private Object data;
}

2.利用单元测试模拟热点数据提前存入缓存

 public void saveShop2Redis(Long id,Long expireSeconds){
        //1.查询店铺数据
        Shop shop = getById(id);
       //2.封装逻辑过期时间
        RedisData redisData = new RedisData();
        redisData.setData(shop);
        //当前系统时间+ s
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
        //3.写入redis
        stringRedisTemplate.opsForValue().set("cache:shop:"+id,JSONUtil.toJsonStr(redisData));
    }

 @Test
    void saveShop(){
    shopService.saveShop2Redis(1L,10L);
    }

3.业务代码

  //线程池
  private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
  
    public Shop queryWithLogicalExpir(Long id){
        //1.从reedis中查询商铺类型列表缓存
        String shopJson = stringRedisTemplate.opsForValue().get("cache:shop:"+id);
        //2.redis中不存在，直接返回
        if(StrUtil.isBlank(shopJson)){
            return null;
        }
        //3.redis中存在，判断缓存是否过期
        //把json反序列化为对象
        RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
        Shop shop = JSONUtil.toBean((JSONObject)redisData.getData(), Shop.class);
        LocalDateTime expireTime = redisData.getExpireTime();
        if(expireTime.isAfter(LocalDateTime.now())){
            //4.未过期，直接返回店铺信息
            return shop;
        }
        //5.已过期，需要缓存重建
        //5.1获取互斥锁
        String lockKey = "lock:shop:" + id;
        if(tryLock(lockKey)){
            //5.2成功，开启独立线程，实现缓存重建
            //线程池
            CACHE_REBUILD_EXECUTOR.submit(()->{
                try {
                    this.saveShop2Redis(id,20L);
                } catch (Exception e) {
                    e.printStackTrace();
                }finally {
                    //释放锁
                    unLock(lockKey);
                }
            });
        }
        //5.3获取失败，返回过期的店铺信息
        return shop;
    }

封装Redis工具类


@Slf4j
@Component
public class CacheClient {

    private final StringRedisTemplate stringRedisTemplate;

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

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

    /**
     * 将任意Java对象序列化为json并存储在string类型的key中，并且可以设置TTL过期时间
     */
    public void set(String key, Object value, Long time, TimeUnit unit){
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value),time,unit);
    }

    /**
     * 将任意Java对象序列化为json并存储在string类型的key中，并且可以设置逻辑过期时间，用于处理缓存击穿问题
     */
    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),time,unit);
    }

    /**
     *根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题
     * @param keyPrefix redis的key前缀
     * @param id 传入参数id
     * @param type 类结构
     * @param dbFallBack 数据库查询逻辑
     * @param <R> 泛型
     * @param <ID> 泛型
     *     Function<ID,R> <ID>参数类型，R返回值类型
     * @return
     */
    public <R,ID> R queryWithPassThrough(String keyPrefix, ID id, Class<R> type, Function<ID,R> dbFallBack, Long time, TimeUnit unit){
        String key = keyPrefix+id;
        //1.从reedis中查询商铺类型列表缓存
        String json = stringRedisTemplate.opsForValue().get(key + id);
        //2.redis中存在，有值，直接返回
        if(StrUtil.isNotBlank(json)){
            return JSONUtil.toBean(json,type);
        }
        //缓存中存在，判断命中是否是空值 ""
        if(json != null){
            return null;
        }
        //3业务逻辑，需要调用者传数据库查询逻辑(有参有返回值的函数)
       R r = dbFallBack.apply(id);
        //4.数据库中不存在，返回错误
        if(r == null){
            //将空值写入redis
            stringRedisTemplate.opsForValue().set(key," ",2L, TimeUnit.MINUTES);
            return null;
        }
        //5.数据库中存在，写入redis，设置过期时间
        this.set(key,r,time,unit);
        //6.返回
        return r;
    }

    /**
     * 根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题
     */
    public <ID,R> R queryWithLogicalExpire(String keyPrefix, ID id, Class<R> type, Function<ID,R> dbFallBack, Long time, TimeUnit unit){
        String key = keyPrefix+id;
        //1.从reedis中查询商铺类型列表缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        //2.redis中不存在，直接返回
        if(StrUtil.isBlank(json)){
            return null;
        }
        //3.redis中存在，判断缓存是否过期
        //把json反序列化为对象
        RedisData redisData = JSONUtil.toBean(json, RedisData.class);
        R r = JSONUtil.toBean((JSONObject)redisData.getData(), type);
        LocalDateTime expireTime = redisData.getExpireTime();
        if(expireTime.isAfter(LocalDateTime.now())){
            //4.未过期，直接返回店铺信息
            return r;
        }
        //5.已过期，需要缓存重建
        //5.1获取互斥锁
        String lockKey = "lock:shop:" + id;
        if(tryLock(lockKey)){
            //5.2成功，开启独立线程，实现缓存重建
            //线程池
            CACHE_REBUILD_EXECUTOR.submit(()->{
                try {
                    // 查询数据库
                    R r1 = dbFallBack.apply(id);
                    // 重建缓存
                    this.setWithLogicalExpire(key,r1,time,unit);
                } catch (Exception e) {
                    e.printStackTrace();
                }finally {
                    //释放锁
                    unLock(lockKey);
                }
            });
        }
        //5.3获取失败，返回过期的店铺信息
        return r;
    }

    /**
     *互斥锁解决缓存击穿
     */
    public <ID,R> R queryWithMutex(String keyPrefix, ID id, Class<R> type, Function<ID,R> dbFallBack, Long time, TimeUnit unit){
        String key = keyPrefix+id;
        //1.从reedis中查询商铺类型列表缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        //2.redis中存在，有值，直接返回
        if(StrUtil.isNotBlank(json)){
            return JSONUtil.toBean(json, type);
        }
        //3.缓存中存在，判断命中是否是空值 ""--解决缓存穿透
        if(json != null){
            return null;
        }
        //4.实现缓存重建
        //4.1.获取互斥锁
        String lockKey = "lock:shop:" + id;
        R r= null;
        try {
            boolean isLock = tryLock(lockKey);
            // 4.2 判断否获取成功
            if(!isLock){
                //4.3 失败，则休眠重试
                Thread.sleep(50);
                return queryWithMutex(keyPrefix,id,type,dbFallBack,time,unit);
            }
            //4.4 成功，根据id查询数据库
            r = dbFallBack.apply(id);
            // 5.不存在，返回错误
            if(r == null){
                //将空值写入redis
                stringRedisTemplate.opsForValue().set(key,"",2L,TimeUnit.MINUTES);
                //返回错误信息
                return null;
            }
            //6.写入redis
            this.set(key,r,time,unit);
        }catch (Exception e){
            throw new RuntimeException(e);
        }
        finally {
            //7.释放互斥锁
            unLock(lockKey);
        }
        return r;
    }


    //获取锁
    private boolean tryLock(String key){
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
        //直接返回有拆箱，可能会有空指针
        return BooleanUtil.isTrue(flag);
    }

    //释放锁
    private void unLock(String key){
        stringRedisTemplate.delete(key);
    }
}

在ShopServiceImpl 中：

 @Override
    public Result queryById(Long id) {

        //解决缓存穿透
        Shop shop = cacheClient.queryWithPassThrough("cache:shop:", id, Shop.class, this::getById, 30L, TimeUnit.MINUTES);

        //解决缓存击穿
        //Shop shop = cacheClient.queryWithLogicalExpire("cache:shop:", id, Shop.class, this::getById, 30L, TimeUnit.MINUTES);

        //互斥锁解决缓存击穿
        //Shop shop = cacheClient.queryWithMutex("cache:shop:", id, Shop.class, this::getById, 30L, TimeUnit.MINUTES);
        if(shop == null){
            return Result.fail("店铺不存在");
        }
        return Result.ok(shop);
    }
言烬
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redis 三种缓存更新策略
sanylove的博客
07-09 1768
今天聊聊redis 三种缓存更新策略分别是：Cache Aside（旁路缓存）策略；Read/Write Through（读穿 / 写穿）策略；Write Back（写回）策略；其中 Cache Aside策略是redis和Mysql使用的更新策略，另外两种策略主要使用在计算机系统上。
redis的缓存更新策略
FadePeople
09-22 2484
redis的缓存更新策略
Redis 的缓存策略
扎哇太枣糕的笔记博客
05-14 2159
  各位小伙伴们大家好，欢迎来到这个小扎扎的Redis 6专栏，在这个系列专栏中我对B站黑马的Redis教程进行一个总结，鉴于 看到就是学到、学到就是赚到 精神，这波依然是血赚 ┗|｀O′|┛
深入学习 Redis - 如何使用 Redis 作缓存？缓存更新策略？使用需要注意哪些问题（工作/重点）
CYK_byte的博客
09-19 3132
缓存可以理解为，将常用的数据从放到一个访问速度更快的的地方，方便更快的随时读取. 也就是说，速度快的设备，可以作为速度慢的设备的缓存，加快读取速度。
Redis缓存更新和同步策略、缓存穿透、缓存击穿、缓存雪崩
qq_62767608的博客
12-04 2229
方法来表示获取锁，该方法含义是 redis 中如果没有这个key，则插入成功，返回1，在 stringRedisTemplate 中返回true， 如果有这个key则插入失败，则返回0，在stringRedisTemplate返回false，我们可以通过true，或者是false，来表示是否有线程成功插入key，成功插入的key的线程我们认为他就是获得到锁的线程。当代计算机最大的问题是 cpu性能提升了，但内存读写速度没有跟上，所以为了适应当下的情况，增加了cpu的L1，L2，L3级的缓存。
Redis缓存常用4种策略原理详解
09-08
主要介绍了Redis缓存常用4种策略原理详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
【redis】– 缓存（redis作为缓存使用）
01-07
文章目录1.redis的回收策略redis的LRU回收算法2.关于redis作为缓存时出现的击穿，穿透，雪崩问题1.击穿2.穿透3.缓存雪崩 redis有两种使用方式一是作为数据库使用，二是作为缓存使用。 将redis作为缓存，当你新增数据...
php-redis-cache:PHP Redis Cache缓存策略技术
05-16
1 使用方法 使用composer下载 yeszao/... $redis = new \Redis(); $redis->connect('redis'); // ***主要是这一行*** return (new Cache($redis))->get($this, $name, $arguments); } } 其中，yeszao\cache\Cache对
Redis持久化策略详解
05-27
Redis持久化策略详解
Redis--缓存更新策略及最佳实践
CJPSR的博客
07-20 574
本文将为您介绍 Redis 中常见的缓存更新策略以及最佳实践。
Redis缓存更新策略以及常见缓存问题
buhuisuanfa的博客
07-17 1962
缓存就是数据交换的缓冲区(Cache)，是存储数据的临时地方，一般读写性能较好，常见缓存：Web应用中缓存有什么作用呢？降低后端负载提高读写效率，降低响应时间数据的一致性成本代码维护成本运维成本。
Redis 缓存(Cache)
最新发布
ikun66666的博客
02-19 1692
Redis 缓存(Cache)
Redis-缓存更新策略
weixin_45535519的博客
12-10 2244
Redis常见的缓存更新策略有三种，分别是Cache Aside Pattern(旁路缓存模式)、Read/Write Through Pattern(读写穿透模式)以及Write Behind Pattern (异步缓存写入模式)三种。三种模式各有优劣，不存在最佳模式，根据具体的业务场景选择适合自己的缓存读写模式即可。以下将分别介绍三种模式。
【六】redis缓存策略
ymony的博客
07-23 461
低一致性业务建议配置最大内存和淘汰策略的方式使用。高一致性业务可以结合使用超时剔除和主动更新，这样即使主动更新出了问题，也能保证数据过期时间后删除脏数据。
Redis缓存实现及其常见问题解决方案
栗筝i的博客
09-19 2069
Redis 是一个开源的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。Redis 支持多种类型的数据结构，如字符串、哈希、列表、集合、有序集合等。此外，Redis 还提供了一系列的特性，如数据持久化、事务和发布订阅等。 然而，如何利用 Redis 实现高效的缓存机制呢？这就是我们今天要探讨的主题。在这篇文章中，我们将详细介绍 Redis 的缓存实现，包括其读写策略、过期策略和淘汰策略等。我们希望通过这篇文章，帮助读者更好地理解和使用 Redis，从而提高自己的系统性能。
Redis中三种常见的缓存策略
m0_56556747的博客
03-02 722
写：先查cache，cache中不存在，直接更新db，cache中存在先更新cache再更新db（cache和db异步更新）读：先去cache中读，如果cache中读到数据就返回，读不到数据就去db读，先将db的数据写到cache中，在返回。读：先去cache中读，如果cache中读到就返回，读不到就去db中读，然后进行返回，最后将数据加到cache中去。读：先去cache中读，cache中存在就返回，不存在就去db中读，将读到的数据写入cache再返回。写：先更新db中的数据，再删除cache中的数据。
Redis三种常用的缓存读写策略，这些你都知道吗？
duan18888的博客
05-09 6064
一、Redis三种常用的缓存读写策略 Redis有三种读写策略分别是：旁路缓存模式策略、读写穿透策略、异步缓存写入策略。 这三种缓存读写策略各有优势，不存在最佳，需要我们根据实际的业务场景选择最合适的。 二、旁路缓存模式（Cache Aside Pattern） 旁路缓存模式是我们平时使用比较多的一个缓存读写模式，比较适合读请求比较多的场景。 旁路缓存模式中服务端需要同时维护DB和Cache，并且是以DB的结果为准。 读写步骤 写： 先更新DB。 然后直接删除cache。 如下图：
redis缓存更新策略
teternity的博客
10-06 2966
redis缓存更新策略
Redis总结
bool的博客
12-15 385
黑马程序员 Redis教程 P1：Redis介绍 mysql数据库，数据库以“文件形式存储在硬盘”里边。 Redis 什么是Redis Redis是远程数据服务，内存高速缓存数据库，支持丰富的数据结构，如String、list、hash、set、sorted set，可持久化，保证了数据安全。Redis是做数据缓存的。 缓存有两种类型：数据缓存、页面缓存 使用缓存减轻数据库的负载。 在开发的时候如果有一些数据在短时间之内不会发生变化，而他们还要被频繁的访问，为了提高用户的请求速度和降低网站的负载，
redis的缓存策略
09-02
Redis的缓存策略有多种，常见的包括以下几种： 1. LRU（Least Recently Used）：最近最少使用。Redis会根据数据的访问时间来淘汰最不常用的数据。 2. LFU（Least Frequently Used）：最不经常使用。Redis根据数据...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值