Redis实战篇教程（二）

最新推荐文章于 2024-07-07 17:47:43 发布
最新推荐文章于 2024-07-07 17:47:43 发布
阅读量147 收藏 1
点赞数 4
文章标签： redis java mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aaaaaaaa273216/article/details/133237769
版权

Redis实战篇教程（二）

文章目录

前言

本系列文章是针对于黑马的Redis教学视频中的实战篇，本篇文章是实战篇的第二部分——缓存更新策略

缓存更新策略

内存淘汰超时剔除主动更新
说明不用自己维护，利用Redis的内存淘汰机制，当内存不足时自动淘汰部分数据，下次查询时更新缓存给缓存数据添加TTL时间，到期后自动删除缓存，下次查询时更新缓存自己编写业务逻辑，在修改数据库的同时，更新缓存
一致性差一般好
维护成本无低高

业务场景：

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

主动更新策略

  • Cache Aside Pattern：自己写代码，在更新数据库的同时更新缓存
  • Read/Write Through Pattern：将缓存和数据库整合为一个服务，有服务来维护一致性，调用者调用该服务，无需关心缓存一致性问题。
  • Write Behind Caching Pattern：调用者只操作缓存，有其他线程异步的将缓存数据持久化到数据库，保证最终一致。

Cache Aside Pattern 优点：可控性高
Read/Write Through Pattern 优点：调用者无需关心缓存一致性问题
Write Behind Caching Pattern 优点：效率较高

Read/Write Through Pattern 缺点：维护这样一个服务是比较复杂的，市面上现成的服务也不好找
Write Behind Caching Pattern 缺点：需要实时监控缓存的数据，一致性难以保证，如果缓存执行上百次，数据库还没操作，如果缓存这时候宕机了，那这些数据就丢失了。

综合优缺点，我们选择 Cache Aside Pattern，可控性高。
但操作缓存和数据库有三个问题需要考虑：

  1. 删除缓存还是更新缓存？
  • 更新缓存：每次更新数据库都更新缓存，无效写操作较多
  • 删除缓存：更新数据库时让缓存失效，查询时再更新缓存
  1. 如何保证缓存与数据库的操作的同时成功或失败
  • 单体系统，将缓存与数据库操作放在一个事务
  • 分布式系统，利用 TCC等分布式事务方案
  1. 先操作缓存还是先操作数据库

这里的流程还是推荐大家看原视频的操作，黑马的百万ppt太强了🤗https://www.bilibili.com/video/BV1cr4y1671t?p=38&vd_source=2be9bcfdb17e0c4fb30c17a7d91482aa

先删除缓存，再操作数据库的正常情况
image.png
先删除缓存，再操作数据库的异常情况（在将要更新数据库时，线程2趁虚而入）
image.png
先操作数据库，再删除缓存正常情况（
image.png
先操作数据库，再删除缓存异常情况（在更新数据库前，就进行查询缓存）
image.png
综上，这两种情况都会发生异常情况，但是 先操作数据库，再删除缓存的可能性较低（因为缓存执行的时间很短）
总结：

  1. 低一致性需求：使用内存淘汰机制，例如商铺类型的查询缓存
  2. 高一致性需求：主动更新，并以超时剔除为兜底方案，例如店铺详情查询的缓存
  • 读操作：
    • 缓存命中则直接返回
    • 缓存未命中则查询数据库，并写入缓存，设定超时时间
  • 写操作
  • 先写数据库，在删除缓存
  • 要保证数据库与缓存操作的原子性。

实现商铺缓存与数据库的读写一致

    public Result update(Shop shop) {
        //1.先更新数据库
        this.updateById(shop);
        Long id = shop.getId();
        if(id==null){
            return Result.fail("店铺id不能未空");
        }
        //2.删除缓存
        stringRedisTemplate.delete(CACHE_SHOP_KEY +id);
        return Result.ok();
    }

由于这个项目没有管理员端，所以这个更新测试可以用 postman 来测试或者也可以在接口文档中进行测试

image.png

缓存穿透的解决思路

缓存穿透是指客户端请求的数据在缓存中都不存在，这样缓存永远都不会生效，这些请求都会打到数据库。
常见的解决方案有两种：

  • 缓存空对象
    • 优点：实现简单，维护方便
    • 缺点：
      • 额外的内存消耗
      • 可能造成数据短期的不一致（当在redis查询id1时，不存在，数据库也不存在，缓存null，就在这时，这条数据插入数据库了，那再查时还是null）
  • 布隆过滤（布隆过滤器里面存的是 byte数组，将对象基于某种算法计算 hash值 ）
    • 优点：内存占用较少，没有多余的key
    • 缺点：
      • 实现复杂
      • 存在误判可能（不存在是真不存在，存在是不一定存在）


解决商铺缓存的缓存穿透问题

    public Result queryById(Long id) {
        //1. 从Redis中查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
        //2.判断缓存是否命中
        if (StrUtil.isNotBlank(shopJson)) {
            //3.缓存命中直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }

        // 判断命中的是否是空值
        if(shopJson!=null){
            return Result.fail("店铺不存在");
        }
        //4.缓存未命中，根据商铺id查询数据库
        Shop shop = this.getById(id);
        if(shop==null){
            stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
            //5. 数据库中查询失败，直接返回
            return Result.fail("店铺不存在");
        }
        //6. 数据库中查询成功，将数据缓存到Redis中
        stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id,JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL, TimeUnit.MINUTES);
        return Result.ok(shop);
    }

其实 布隆过滤 和 设置空值都是相对被动的解决方案，都是别人发起错误请求后，我们想办法拦截，我们也可以主动采取一些措施

  1. 增加 id 的复杂度，避免被猜测 id 的规律
  2. 加强用户权限校验
  3. 做好热点参数的限流

缓存雪崩

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

解决方案：

实战篇中没有写解决缓存雪崩的代码，大家可以去Redis高级篇和这个老师的springCloud课程中看看

缓存击穿

缓存击穿问题也叫热点Key问题，就是一个被高并发访问并且缓存重建业务复杂的Key突然失效了，无数的请求访问会在瞬间给数据库带来巨大的冲击
image.png
常见的解决方案：

  • 互斥锁
  • 逻辑过期

互斥锁
image.png
逻辑过期
image.png

解决方案优点缺点
互斥锁
- 没有额外的内存消耗
- 保证一致性
- 实现简单

- 线程需要等待，性能受影响
- 可能有死锁的风险
逻辑过期
- 线程无需等待，性能较好

- 不保证一致性
- 有额外内存消耗
- 实现复杂

利用互斥锁解决缓存击穿问题


可以用 setnx 命令来做互斥锁
image.png
利

public Shop queryWithMutex(Long id){
        //1. 从Redis中查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
        //2.判断缓存是否命中
        if (StrUtil.isNotBlank(shopJson)) {
            //2.1.缓存命中直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return shop;
        }

        // 判断命中的是否是空值
        if(shopJson!=null){
            return null;
        }
        //2.2 缓存未命中

        // 4.实现缓存重建
        // 4.1 获取互斥锁
        String lockKey=LOCK_SHOP_KEY+id;
        Shop shop = null;
        try {
            boolean isLock = tryLock(lockKey);
            // 4.2 判断是否获取成功
            if(!isLock){
                // 4.3 失败，则休眠并重试
                Thread.sleep(50);
                queryWithMutex(id);
            }
            // 获取锁成功，应再次检查缓存，只有第一次获取锁的时候要重建缓存，其他时候再拿到锁的时候，应该缓存已经重建好了，无需再次重建
            //其实这里跟第一次查询的代码一样，可以封装一个函数，但是就是这个函数的结果
            //不好搞，因为它的两种合适情况一个返回null，一个返回对象,所有如果要判断未命中
            //要再弄个封装类这类的。。。我比较懒，就不弄了😁
            String shopJsonAgain = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
            //2.判断缓存是否命中
            if (StrUtil.isNotBlank(shopJsonAgain)) {
                //2.1.缓存命中直接返回
                return JSONUtil.toBean(shopJsonAgain, Shop.class);

            }
             //判断命中的是否是空值
            if(shopJson!=null){
                return null;
            }
            // 4.4 根据商铺id查询数据库
            shop = this.getById(id);
            Thread.sleep(200);
            if(shop==null){
                stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
                //5. 数据库中查询失败，直接返回
                return null;
            }
            //6. 数据库中查询成功，将数据缓存到Redis中
            stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id,JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }finally {
            //7. 释放互斥锁
            unlock(lockKey);
        }
        return shop;
    }

高并发的测试需要用到 jmeter 测试工具，或者Apifox也可以，我用的是 jmeter，下面把 jmeter的包放在下面
由于语雀不让上传文件😭，我把一个讲解 jmeter 的文章放在下面
https://blog.csdn.net/zuojunyuan/article/details/94152368
image.png
image.png

基于逻辑过期解决缓存击穿问题

{
        //1. 从Redis中查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
        //2.判断缓存是否命中
        if (StrUtil.isBlank(shopJson)) {
            //3.缓存未命中直接返回
            return null;
        }
        // 命中，需要先把json反序列化未对象
        RedisData<Shop> redisData = JSONUtil.toBean(shopJson, new TypeReference<RedisData<Shop>>() {},false);
        //朋友们,
        //        RedisData<Shop> redisData = JSONUtil.toBean(shopJson, RedisData.class);
        //        Shop shop = redisData.getData();
        //这样用泛型转是不对的，会报 
        // class cn.hutool.json.JSONObject cannot be cast to class com.hmdp.entity.Shop (cn.hutool.json.JSONObject and com.hmdp.entity.Shop are in unnamed module of loader 'app')
        Shop shop = redisData.getData();
        LocalDateTime expireTime = redisData.getExpireTime();
        // 判断是否已经过期
        if(expireTime.isAfter(LocalDateTime.now())){
            //未过期
            return shop;
        }
        System.out.println(LocalDateTime.now());
        // 已过期，需要缓存重建
        // 重建 1.获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        boolean isLock = tryLock(lockKey);
        //     2.判断是否获取成功
        if(isLock){
            // 获取锁成功应该再次检查redis缓存是否过期，还是第一个线程获得锁了，然后去缓存重建,然后第二个线程来获取锁，然后之间返回了旧数据
            // 这时候缓存还没重建好了，然后第三个线程来了，然后判断缓存过期了没，由于缓存还没重建好，还是过期，就在这时，缓存重建好了，锁也
            // 释放了，然后刚好第三个线程获得了锁，这时候因为已经刚刚重建好了缓存，不用再查一遍数据库了
            String shopJsonAgain = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
            //2.判断缓存是否命中
            if (StrUtil.isBlank(shopJsonAgain)) {
                //3.缓存命中直接返回
                return null;
            }
            //     3.成功需要开始额外的线程去数据库里查询
            CACHE_REBUILD_EXECUTOR.submit(()->{
                try {
                    this.saveShopToRedis(id,20L);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }finally {
                    //释放锁
                    unlock(lockKey);
                }
            });
        }
        // 返回查询到的数据
        return shop;
    }

这个20秒是为了方便测试数据用的，按理来说应该是几十分钟，所以大家测试的时候不用测试10000条以上的线程，要不然容易报下面的错误
image.png
大家在看这个 jmeter 的响应数的时候，中文可能会乱码，大家可以看这篇文章https://www.cnblogs.com/xiaxiaoxu/p/9607017.html，里面有两种方法解决
还有一个问题，就是Json串转对象的时候，如果大家的RedisData类里面用泛型的话，要用这个方法转

JSONUtil.toBean(shopJson, new TypeReference<RedisData<Shop>>() {},false);

这个在反序列化的时候也是经常用的，具体原理大家可以参考下面这篇文章https://blog.csdn.net/zhuzj12345/article/details/102914545

封装缓存工具类

这个 工具类很强，对于我这种泛型和函数式编程接触较少的人来说，确实是一个很好的提示。
（上面那个RedisData用泛型的话，这里方法参数好像不能用泛型写，我尝试了不行，可能是我比较采，希望会写的小伙伴可以补充一下）😄

package com.hmdp.utils;

import cn.hutool.core.lang.TypeReference;
import cn.hutool.core.util.BooleanUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.hmdp.entity.Shop;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;

import static com.hmdp.utils.RedisConstants.*;

@Component
public class CacheClient {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

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

    public void setWithLogical(String key, Object value, Long time, TimeUnit unit){
        // 设置逻辑过期
        RedisData redisData = new RedisData();
        redisData.setData(value);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
        //  写入Redis
        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;
        //1. 从Redis中查询商铺缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        //2.判断缓存是否命中
        if (StrUtil.isNotBlank(json)) {
            //3.缓存命中直接返回
            return   JSONUtil.toBean(json, type);
        }
        // 判断命中的是否是空值
        if(json!=null){
            return null;
        }
        //4.缓存未命中，根据商铺id查询数据库
        R r = dbFallback.apply(id);
        if(r==null){
            stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
            //5. 数据库中查询失败，直接返回
            return null;
        }
        //6. 数据库中查询成功，将数据缓存到Redis中
        this.set(key,r,time,unit);
        return r;
    }
    private static  final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

    public <R,ID> R queryWithLogicalExpire(String keyPrefix,ID id,Class<R> type,Function<ID,R> dbFallback,
                                           Long time, TimeUnit unit){
        //1. 从Redis中查询商铺缓存
        String key=keyPrefix+id;
        String json = stringRedisTemplate.opsForValue().get(key);
        //2.判断缓存是否命中
        if (StrUtil.isBlank(json)) {
            //3.缓存未命中直接返回
            return null;
        }
        // 命中，需要先把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())){
            //未过期
            return r ;
        }
        System.out.println(LocalDateTime.now());
        // 已过期，需要缓存重建
        // 重建 1.获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        boolean isLock = tryLock(lockKey);
        //     2.判断是否获取成功
        if(isLock){
            // 获取锁成功应该再次检查redis缓存是否过期，还是第一个线程获得锁了，然后去缓存重建,然后第二个线程来获取锁，然后之间返回了旧数据
            // 这时候缓存还没重建好了，然后第三个线程来了，然后判断缓存过期了没，由于缓存还没重建好，还是过期，就在这时，缓存重建好了，锁也
            // 释放了，然后刚好第三个线程获得了锁，这时候因为已经刚刚重建好了缓存，不用再查一遍数据库了
            String shopJsonAgain = stringRedisTemplate.opsForValue().get(key);
            //2.判断缓存是否命中
            if (StrUtil.isBlank(shopJsonAgain)) {
                //3.缓存命中直接返回
                return null;
            }
            //     3.成功需要开始额外的线程去数据库里查询
            CACHE_REBUILD_EXECUTOR.submit(()->{
                try {
                    R r1 = dbFallback.apply(id);
                    this.setWithLogical(key,r,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", 10, TimeUnit.SECONDS);
        // 这里用到了一个 BooleanUtil 将 Boolean类型的 flag 转换为 boolean，如果直接返回Boolean类型的 flag，会自动拆箱，可能会出现null
        return BooleanUtil.isTrue(flag);
    }

    private void unlock(String key){
        stringRedisTemplate.delete(key);

    }
}

总结

本篇内容讲解了Redis的缓存更新策略，可以帮助我们更好的了解如何实现缓存中的数据与数据库的数据进行一定的更新，在下一篇文章中，我们将通过优惠券的秒杀业务将我们上文所述内容进行一个综合的练习

最后，我是Mayphyr，从一点点到亿点点，我们下次再见

Mayphyr
关注
  • 4
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Redis实战记录之限制操作频率
12-16
最近沉迷于业务开发无法自拔 :rolling_on_the_floor_laughing:，有一段时间没有更新博文了，后续博文内容计划把一些业务场景下的实战方案，或者比较好的设计思路进行分享，就不像之前围绕着一个主题，消耗很多的时间...
redis入门教程.zip
02-20
3. **实战篇**：通过实际项目练习，将Redis应用于缓存、队列、计数器等场景。 4. **优化篇**：学习Redis的性能调优，包括内存管理、网络优化等。 文档"redis入门教程.docx"可能包含了以上这些内容的详细解释和实例...
Redis实战篇
啊莫的博客
07-25 5591
Redis实战笔记
黑马Redis视频教程实战篇（二）
qq_38196449的博客
05-27 1299
缓存(Cache)，就是数据交换的缓冲区例1:Static final ConcurrentHashMap map = new ConcurrentHashMap();本地用于高并发例2:static final Cache USER_CACHE = CacheBuilder.newBuilder().build();用于redis等缓存例3:Static final Map map = new HashMap();本地缓存由于其被Static。
Redis全面实战教程
u013328649的博客
01-29 1752
Redis全面实战教程 1.缓存的需求 前端页面广告位数据无需每次查询后台系统的接口，可以在前台系统添加缓存，提高访问首页的速度。 电商网站首页左侧商品类目一栏的数据也可以缓存起来,不用每次打开首页都去数据库读取数据，读取数据库IO开销大。 解决方案：使用缓存。 1.1目前缓存的主流技术 1、Redis 2、Memcached 二者谁的性能更高？ 1、单纯从缓存命中的角度来说，是Memcached要高，Redis和Memcache的差距不大 2、但是，Redis提供的功能更加的强大 二者的区别是什么？ 1、
Redis入门到实战教程（基础篇）笔记
制定持续可量化的目标，不断坚持。
04-25 334
Redis课程介绍导学_哔哩哔哩_bilibilip=1教学来源：Redis课程介绍导学_哔哩哔哩_bilibilip=1。
Redis入门到实战（二、实战片）
白羊座的橙子
11-05 1070
用户将验证码和手机号进行输入，后台从session中拿到当前验证码，然后和用户输入的验证码进行校验，如果不一致，则无法通过校验，如果一致，则后台根据手机号查询用户，如果用户不存在，则为用户创建账号信息，保存到数据库，无论是否存在，都会将用户信息保存到session中，方便后续获得当前登录信息。如果手机号合法，后台此时生成对应的验证码，同时将验证码进行保存，然后再通过短信的方式将验证码发送给用户。用户在提交手机号后，会校验手机号是否合法，如果不合法，则要求用户重新输入手机号。
Redis实战第一篇
qq_43078445的博客
03-30 206
、、@TOC Redis的下载与安装 下载地址：https://github.com/tporadowski/redis/releases。 选择适合自己的版本下载即可，不必多说！ 安装完后目录如下： 开启redis: redis-server.exe redis.windows.conf 效果如下： 为什么要学习Redis mysql不好用吗？ 每一种产品的诞生都有它的理由，Redis也一样。我们先回忆一下Mysql: MySQL是一个关系型数据库管理系统，由瑞典MySQL AB
黑马Redis学习笔记 (基础篇+实战篇)
热门推荐
weixin_51515308的博客
11-24 1万+
传统关系型数据库能满足事务ACID的原则 ，而非关系型数据库往往不支持事务，或者不能严格保证ACID的特性，只能实现基本的一致性。特征：键值（key-value）型，value支持多种不同数据结构，功能丰富单线程，每个命令具备原子性低延迟，速度快（基于内存、IO多路复用、良好的编码）。支持数据持久化(定期将内存搬运到磁盘)支持主从集群、分片集群（数据拆分）支持多语言客户端Redis的官方网站地址：RedisRedis RedisRedis是基于C编写，所以需要先安装Redis所需的gcc依赖 如果有了就跳过
redis实战篇
热爱编程的机械生的救赎
05-19 5118
🏳️‍🌈个人网站：code宝藏 👈，欢迎访问🎉🎉 🙏如果大家觉得博主写的还不错的话，可以点点关注，及时获取我的最新文章 🤝非常感谢大家的支持与点赞👍 📚笔记整理自黑马程序员Redis入门到实战教程 共享session登录问题 集群的session共享问题 session共享问题：多台Tomcat并不共享session存储空间，当请求切换到不同tomcat服务时导致数据丢失的问题。 session的替代方案应该满足： • 数据共享 • 内存存储 • key、value结构 使用Redis实现共享sess.
Redis汇总及实战
weixin_50539646的博客
11-04 1096
本篇文章可以帮助你快速入门redis，同时介绍了一些redis的实战，同时文章中提供了项目代码地址，方便实操
Redis教程实战篇 点评项目，用于学习Redis实战，实战篇代码已完-hm-dianping.zip
01-30
**Redis实战教程——基于点评项目的应用** 在本教程中，我们将深入探讨如何使用Redis这个高性能的键值存储系统来实现一个点评项目的实际应用场景。Redis以其出色的数据结构支持、高速读写性能以及丰富的功能，被...
Redis从入门到精通(十一)Redis实战(八)关注、共同关注和Feed流
04-09
通过学习这些代码，你可以更深入地理解如何在实际项目中运用Redis进行社交网络功能的开发，提升你的Redis实战技能。代码可能涉及了Redis命令的使用，如SET、SADD、SREM、SINTER、ZRANGE等，以及如何在编程语言中与...
布隆过滤器 redis
g3230863的博客
07-04 204
布隆过滤器，redis
8、Redis 的线程模型、I/O 模型和多线程
最新发布
qq_29434541的博客
07-07 684
Redis 基于 Reactor 模式开发了网络事件处理器 - 文件事件处理器（file event handler，简称 FEH）。该处理器是单线程的，所以 Redis 设计为单线程模型。通过 I/O 多路复用同时监听多个 socket，根据 socket 当前执行的事件选择对应的事件处理器。当被监听的 socket 准备好执行 accept、read、write、close 等操作时，FEH 调用 socket 关联的事件处理器处理事件。
【Redis7】零基础篇
为技术发烧而生
07-02 958
a）性能极高-Redis能读的速度是110000次/秒，写的速度是81000次/秒b）Redis数据类型丰富，不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储c）Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用d）Redis支持数据的备份，即master-slave模式的数据备份英文：https://redis.io/中文：https://www.redis.cn/5.0版本是直接升级到。
Redis如何实现主从复制
qq_51967234的博客
07-02 757
发生在初始化阶段，从节点会主动向主节点发出一个同步请求，之后主节点会生成一份当前数据的快照给从节点，从节点在收到数据进行加载后，会完成全量复制。主是主服务器，从是从服务器，主服务器(master ）的数据如果更新了也会同步到从服务器(slave)，一个主服务器可以搭配很多个从服务器，，每一次Master（主）结点发生数据变更之后，会把变化的增量数据同步给从节点，增量复制是通过维护offset复制偏移量来实现的。Redis主从复制包括。
图灵课堂诸葛老师redis实战笔记
07-25
很抱歉，我无法回答关于图灵课堂诸葛老师的redis实战笔记的问题。因为在提供的引用内容中，并没有提到图灵课堂诸葛老师的redis实战笔记。请提供更多相关信息，我将尽力帮助您。 #### 引用[.reference_title] - *1* ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值