【夯实基础】万字梳理redis

你的名字 2023-09-27 18:12 130阅读 0赞

## 基础篇 ##

### redis安装 ###

1.  前置环境准备：自己购买云服务器或者使用VMWare本地虚拟机，通过 `yum -y install gcc-c++` 安装 C++ 库环境
2.  下载：通过 redis 官网获取下载地址，打开终端 `cd /opt` 进入 opt 文件夹，通过 wget 命令下载安装包
    
    ![format_png][]
3.  解压：`tar -zxvf redis-7.0.11.tar.gz`
4.  安装：`cd redis-7.0.11` 进入目录，执行 make 命令 `make && make install` ，该过程需要一定的时间，出现以下结果表示安装成功

![format_png 1][]

`cd usr/local/bin` 进入目录，`ll` 查看安装的目录

![format_png 2][]

redis-benchmark:性能测试工具

redis-check-aof：修复有问题的AOF文件

redis-check-rdb：修复有问题的dump.rdb文件

redis-cli：客户端，操作入口

redis-sentinel：redis集群使用

redis-server：Redis服务器启动命令

1.  配置文件修改：`cd /opt/redis-7.0.11` 进入目录，`mkdir /mconfig` 新建目录，`cp redis.conf /mconfig/redis7.conf` 赋值配置文件到新建的文件目录下，`cd mconfig` 进入目录，`vim redis7.conf` 进行配置
    
    默认daemonize no 改为 daemonize yes
    
    默认protected-mode yes 改为 protected-mode no
2.  启动服务：在 /mconfig 目录下，`redis-server redis7.conf` 使用修改后的配置文件启动服务
3.  连接服务：`redis-cli -p 6379` 连接redis 服务，ping 后返回 pong 说明服务连接成功

![format_png 3][]

1.  关闭服务：`shutdown` 关闭服务

#### 【扩展】常用 redis 配置文件说明 ####

<table> 
 <thead> 
  <tr> 
   <th>网络相关</th> 
   <th>说明</th> 
   <th>通用</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>bind 127.0.0.1</td> 
   <td>绑定的IP， 可通过设置 0.0.0.0 则所有IP可连接</td> 
   <td>deamonize yes</td> 
   <td>以守护进程（后台）的方式运行，默认是 no</td> 
  </tr> 
  <tr> 
   <td>protected-mode yes</td> 
   <td>保护模式，设置为yes，只允许我们在本机的回环连接，其他机器无法连接</td> 
   <td>pidfile /var/run/redis_6379.pid</td> 
   <td>deamonize 为 yes 时生效，设置pid文件的目录</td> 
  </tr> 
  <tr> 
   <td>port 6379</td> 
   <td>端口设置</td> 
   <td>loglevel notice</td> 
   <td>日志级别</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
   <td>logfile ''</td> 
   <td>日志文件位置</td> 
  </tr> 
  <tr> 
   <td><strong>持久化相关</strong></td> 
   <td><strong>说明</strong></td> 
   <td>databases 16</td> 
   <td>数据库的数量，默认是16个数据库</td> 
  </tr> 
  <tr> 
   <td>save 900 1</td> 
   <td>持久化频率设置，900s 内，至少有1个 key 进行了修改，将进行持久化操作</td> 
   <td>always-show-logo</td> 
   <td>启动时是否总是显示 LOGO</td> 
  </tr> 
  <tr> 
   <td>stop-writes-on-bgsave-error yes</td> 
   <td>持久化如果出错，是否还需要继续工作 默认为 yes</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>rdbcompression yes</td> 
   <td>是否压缩 rdb 文件，需要消耗 CPU 资源</td> 
   <td><strong>安全相关</strong></td> 
   <td><strong>说明</strong></td> 
  </tr> 
  <tr> 
   <td>rdbchecksum yes</td> 
   <td>保存rdb文件的时候，进行错误校验</td> 
   <td>maxclients 10000</td> 
   <td>设置能连接上 Redis 的最大客户端的数量</td> 
  </tr> 
  <tr> 
   <td>dir ./</td> 
   <td>rdb 文件保存的目录</td> 
   <td>maxmemory</td> 
   <td>redis配置最大的内存容量</td> 
  </tr> 
  <tr> 
   <td>appendonly no</td> 
   <td>aof模式是否开启，默认是不开启使用rdb方式持久化的</td> 
   <td>maxmemory-policy noeviction</td> 
   <td>Redis的内存淘汰策略</td> 
  </tr> 
  <tr> 
   <td>appendfilename "appendonly.aof"</td> 
   <td>aof 持久化的文件的名字</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>appendfsync</td> 
   <td>aof 持久化策略。</td> 
   <td></td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

Redis的内存淘汰策略有哪些：

*  noeviction：当内存不足以容纳新写入数据时，新写入操作会报错；
 *  **allkeys-lru**：当内存不足以容纳新写入数据时，在键空间中，移除最近最少使用的key。（这个是最常用的）；
 *  allkeys-random：当内存不足以容纳新写入数据时，在键空间中，随机移除某个key。设置过期时间的键空间选择性移除；
 *  **volatile-lru**：当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，移除最近最少使用的key；
 *  volatile-random：当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，随机移除某个key；
 *  volatile-ttl：当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，有更早过期时间的key优先移除

### 常用数据类型指令 ###

redis7 提供了10种数据类型，分别是：

*  String：一个key对应一个value，value可以包含任何数据如jpg图片或者序列化的对象 ，value最多可以是512M
 *  List：简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边），底层实际是个双端链表，最多可以包含 2^32 - 1 个元素
 *  Hash： string 类型的 field（字段） 和 value（值） 的映射表，hash 特别适合用于存储对象，每个 hash 可以存储 2^32 - 1 键值对
 *  Set：String 类型的无序集合，集合成员是唯一的，底层通过哈希表实现的，所以添加，删除，查找的复杂度都是 O(1)，集合中最大的成员数为 2^32 - 1
 *  ZSet：有序集合与普通集合set非常相似，不同之处是有序集合的每个成员都关联了一个评分（score）,这个评分（score）被用来按照从最低分到最高分的方式排序集合中的成员，集合的成员是唯一的，但是评分可以是重复了
 *  GEO：用于存储地理位置信息，并对存储的信息进行操作，包括添加地理位置的坐标 / 获取地理位置的坐标 / 计算两个位置之间的距离 / 用户给定的经纬度坐标来获取指定范围内的地理位置集合
 *  HyperLogLog：用来做基数统计
 *  BitMap：位图，由0和1状态表现的二进制位的bit数组
 *  Bitfield：一次性对多个比特位域(指连续的多个比特位)进行操作
 *  Stream：主要用于消息队列，提供了消息的持久化和主备复制功能，可以让任何客户端访问任何时刻的数据，并且能记住每一个客户端的访问位置，还能保证消息不丢失

数据的操作不外乎增删改查，汇整前 5 个数据类型的操作指令

Key 表示键都适用

增相关指令：

<table> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th>增指令</th> 
   <th>说明</th> 
   <th>RedisTemplate</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>String</td> 
   <td>set</td> 
   <td>添加键值对</td> 
   <td>redisTemplate.opsForValue().set</td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>mset [ ...]</td> 
   <td>设置多个 <code>key</code> 的值为各自对应的 value</td> 
   <td>redisTemplate.opsForValue().multiSet</td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>msetnx [ ...]</td> 
   <td>当且仅当所有给定键都不存在时， 为所有给定键设置值。即使只有一个给定键已经存在，该命令也会拒绝执行对所有键的设置操作。</td> 
   <td>redisTemplate.opsForValue().multiSetIfAbsent</td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>setnx</td> 
   <td>当数据库中key不存在时，可以将key-value添加数据库</td> 
   <td>redisTemplate.opsForValue().setIfAbsent</td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>setex</td> 
   <td>添加键值对，并设置超时时间</td> 
   <td>redisTemplate.opsForValue().set</td> 
  </tr> 
  <tr> 
   <td>List</td> 
   <td>lpush</td> 
   <td>将一个或多个值插入到列表<code>key</code> 的头部</td> 
   <td>redisTemplate.opsForList().leftPush / redisTemplate.opsForList().leftPushAll</td> 
  </tr> 
  <tr> 
   <td>List</td> 
   <td>lpushx</td> 
   <td>在当 key 存在并且存储着一个 list 类型值的时候，向值 list 的头部插入 value。 与 LPUSH 相反，当 key 不存在的时候不会进行任何操作。</td> 
   <td>redisTemplate.opsForList().leftPushIfPresent</td> 
  </tr> 
  <tr> 
   <td>List</td> 
   <td>rpush</td> 
   <td>存储在 key 中的列表的尾部插入所有指定的值</td> 
   <td>redisTemplate.opsForList().rightPush / redisTemplate.opsForList().rightPushAll</td> 
  </tr> 
  <tr> 
   <td>List</td> 
   <td>rpushx</td> 
   <td>将值 value 插入到列表 <code>key</code> 的表尾, 当且仅当 <code>key</code> 存在并且是一个列表。 和 <code>RPUSH</code>命令相反, 当 key 不存在时，RPUSHX 命令什么也不做</td> 
   <td>redisTemplate.opsForList().rightPushIfPresent</td> 
  </tr> 
  <tr> 
   <td>List</td> 
   <td>linsert before</td> 
   <td>after</td> 
   <td>把 <code>element</code> 插入到列表 <code>key</code> 中参考值 pivot 的前面或后面</td> 
   <td>redisTemplate.opsForList().leftPush / redisTemplate.opsForList().rightPush</td> 
  </tr> 
  <tr> 
   <td>Hash</td> 
   <td>hset [ ...]</td> 
   <td>存储在 <code>key</code> 中的哈希表的 <code>field</code> 字段赋值 <code>value</code></td> 
   <td>redisTemplate.opsForHash().put</td> 
  </tr> 
  <tr> 
   <td>Hash</td> 
   <td>hmset [ ...]</td> 
   <td>用于同时将多个 field-value (字段-值)对设置到哈希表中</td> 
   <td>redisTemplate.opsForHash().putAll</td> 
  </tr> 
  <tr> 
   <td>Hash</td> 
   <td>hsetnx</td> 
   <td>用于为哈希表中不存在的字段赋值。如果字段已经存在于哈希表中，操作无效</td> 
   <td>redisTemplate.opsForHash().putIfAbsent</td> 
  </tr> 
  <tr> 
   <td>Set</td> 
   <td>sadd [ ...]</td> 
   <td>将一个或多个成员元素加入到集合中</td> 
   <td>redisTemplate.opsForSet().add</td> 
  </tr> 
  <tr> 
   <td>ZSet</td> 
   <td>zadd [ ...]</td> 
   <td>用于将一个或多个 <code>member</code> 元素及其 <code>score</code> 值加入到有序集 <code>key</code></td> 
   <td>redisTemplate.opsForZSet().add / redisTemplate.opsForZSet().addIfAbsent</td> 
  </tr> 
 </tbody> 
</table>

查相关指令：

<table> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th>查指令</th> 
   <th>说明</th> 
   <th>RedisTemplate</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Key</td> 
   <td>ttl</td> 
   <td>返回 key 的剩余过期时间</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>Key</td> 
   <td>keys</td> 
   <td>查找所有匹配给定模式 pattern 的 key</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>Key</td> 
   <td>exists [ ...]</td> 
   <td>用于检查给定 <code>key</code> 是否存在</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>get</td> 
   <td>查询对应键值</td> 
   <td>redisTemplate.opsForValue().get</td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>getrange</td> 
   <td>根据 start 和 end 值返回存储在 key 中的字符串的子串，能取到头尾</td> 
   <td>redisTemplate.opsForValue().get</td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>mget [ ...]</td> 
   <td>返回所有(一个或多个)给定 key 的值</td> 
   <td>redisTemplate.opsForValue().multiGet</td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>strlen</td> 
   <td>获取指定 key 所储存的字符串值的长度</td> 
   <td>redisTemplate.opsForValue().size</td> 
  </tr> 
  <tr> 
   <td>List</td> 
   <td>lindex</td> 
   <td>返回列表 key 里索引 index 位置存储的元素</td> 
   <td>redisTemplate.opsForList().index</td> 
  </tr> 
  <tr> 
   <td>List</td> 
   <td>lrange</td> 
   <td>返回列表中指定区间内的元素，区间以偏移量 START 和 END 指定</td> 
   <td>redisTemplate.opsForList().range</td> 
  </tr> 
  <tr> 
   <td>List</td> 
   <td>lpos [ RANK ] [COUNT ] [MAXLEN ]</td> 
   <td>返回列表中匹配元素的索引</td> 
   <td>redisTemplate.opsForList().indexOf / redisTemplate.opsForList().lastIndexOf</td> 
  </tr> 
  <tr> 
   <td>List</td> 
   <td>llen</td> 
   <td>返回存储在 <code>key</code> 中的列表长度</td> 
   <td>redisTemplate.opsForList().size</td> 
  </tr> 
  <tr> 
   <td>Hash</td> 
   <td>hexists</td> 
   <td>查看哈希表的指定字段<code>field</code> 是否存在</td> 
   <td>redisTemplate.opsForHash().hasKey</td> 
  </tr> 
  <tr> 
   <td>Hash</td> 
   <td>hget</td> 
   <td>返回哈希表中指定字段 <code>field</code> 的值</td> 
   <td>redisTemplate.opsForHash().get</td> 
  </tr> 
  <tr> 
   <td>Hash</td> 
   <td>hmget [ ...]</td> 
   <td>返回哈希表中，一个或多个给定字段（field）的值</td> 
   <td>redisTemplate.opsForHash().multiGet</td> 
  </tr> 
  <tr> 
   <td>Hash</td> 
   <td>hgetall</td> 
   <td>返回存储在 <code>key</code> 中的哈希表中所有的域和值</td> 
   <td>redisTemplate.opsForHash().entries</td> 
  </tr> 
  <tr> 
   <td>Hash</td> 
   <td>hkeys</td> 
   <td>返回存储在 <code>key</code> 中哈希表的所有域(<code>field</code>)</td> 
   <td>redisTemplate.opsForHash().keys</td> 
  </tr> 
  <tr> 
   <td>Hash</td> 
   <td>hvals</td> 
   <td>返回哈希表所有域(field)的值</td> 
   <td>redisTemplate.opsForHash().values</td> 
  </tr> 
  <tr> 
   <td>Hash</td> 
   <td>hlen</td> 
   <td>获取哈希表中字段(fields)的数量</td> 
   <td>redisTemplate.opsForHash().size</td> 
  </tr> 
  <tr> 
   <td>Hash</td> 
   <td>hstrlen</td> 
   <td>返回存储在 <code>key</code> 中的哈希表里， 与给定域 <code>field</code> 相关联的值的字符串长度</td> 
   <td>redisTemplate.opsForHash().lengthOfValue</td> 
  </tr> 
  <tr> 
   <td>Hash</td> 
   <td>hscan [MATCH ] [COUNT ]</td> 
   <td>用于遍历哈希表中的键值对</td> 
   <td>redisTemplate.opsForHash().scan</td> 
  </tr> 
  <tr> 
   <td>Set</td> 
   <td>scard</td> 
   <td>返回集合中元素的数量</td> 
   <td>redisTemplate.opsForSet().size</td> 
  </tr> 
  <tr> 
   <td>Set</td> 
   <td>sdiff [ ...]</td> 
   <td>返回第一个集合与其他集合之间的差异</td> 
   <td>redisTemplate.opsForSet().difference</td> 
  </tr> 
  <tr> 
   <td>Set</td> 
   <td>sdiffstore [ ...]</td> 
   <td>作用和<code>SDIFF</code>类似，不同的是它将结果保存到 <code>destination</code> 集合，而把结果集返回给客户端。</td> 
   <td>redisTemplate.opsForSet().differenceAndStore</td> 
  </tr> 
  <tr> 
   <td>Set</td> 
   <td>sinter [ ...]</td> 
   <td>返回所有给定集合的成员交集</td> 
   <td>redisTemplate.opsForSet().intersect</td> 
  </tr> 
  <tr> 
   <td>Set</td> 
   <td>sunion [ ...]</td> 
   <td>返回所有给定集合的并集</td> 
   <td>redisTemplate.opsForSet().union</td> 
  </tr> 
  <tr> 
   <td>Set</td> 
   <td>smembers</td> 
   <td>返回存储在 <code>key</code> 中的集合的所有的成员</td> 
   <td>redisTemplate.opsForSet().members</td> 
  </tr> 
  <tr> 
   <td>Set</td> 
   <td>sismenber</td> 
   <td>用于判断元素 <code>member</code> 是否集合 <code>key</code> 的成员</td> 
   <td>redisTemplate.opsForSet().isMember</td> 
  </tr> 
  <tr> 
   <td>Set</td> 
   <td>srandmenber []</td> 
   <td>随机返回集合<code>key</code> 中的一个(多个)随机元素</td> 
   <td>redisTemplate.opsForSet().randomMember / redisTemplate.opsForSet().randomMembers / redisTemplate.opsForSet().distinctRandomMembers</td> 
  </tr> 
  <tr> 
   <td>Set</td> 
   <td>sscan [MATCH ] [COUNT ]</td> 
   <td>用于遍历集合中键的元素，SSCAN 继承自<code>SCAN</code></td> 
   <td>redisTemplate.opsForSet().scan</td> 
  </tr> 
  <tr> 
   <td>ZSet</td> 
   <td>zcard</td> 
   <td>返回有序集的成员个数</td> 
   <td>redisTemplate.opsForZSet().size</td> 
  </tr> 
  <tr> 
   <td>ZSet</td> 
   <td>zscore</td> 
   <td>返回有序集 <code>key</code>.中成员 <code>member</code> 的分数</td> 
   <td>redisTemplate.opsForZSet().score</td> 
  </tr> 
  <tr> 
   <td>ZSet</td> 
   <td>zcount</td> 
   <td>返回有序集 <code>key</code> 中， <code>score</code> 值在 <code>min</code> 和 <code>max</code> 之间(默认包括 <code>score</code> 值等于 <code>min</code> 或 <code>max</code> )的成员的数量</td> 
   <td>redisTemplate.opsForZSet().count</td> 
  </tr> 
  <tr> 
   <td>ZSet</td> 
   <td>zrange</td> 
   <td>返回有序集<code>key</code> 中,指定区间内的成员,其中成员的按分数值递增(从小到大)来排序，具有相同分数值的成员按字典序(lexicographical order )来排列。</td> 
   <td>redisTemplate.opsForZSet().range</td> 
  </tr> 
  <tr> 
   <td>ZSet</td> 
   <td>zrevrange</td> 
   <td>返回有序集<code>key</code>中，指定区间内的成员。其中成员的位置按score值递减(从高到低)来排列</td> 
   <td>redisTemplate.opsForZSet().reverseRange</td> 
  </tr> 
  <tr> 
   <td>ZSet</td> 
   <td>zrank</td> 
   <td>返回有序集<code>key</code>中成员<code>member</code>的排名,排名从0开始</td> 
   <td>redisTemplate.opsForZSet().rank</td> 
  </tr> 
  <tr> 
   <td>ZSet</td> 
   <td>zscan [MATCH ] [COUNT ]</td> 
   <td>用于遍历集合中键的元素</td> 
   <td>redisTemplate.opsForZSet().scan</td> 
  </tr> 
 </tbody> 
</table>

改相关指令

<table> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th>改指令</th> 
   <th>说明</th> 
   <th>RedisTemplate</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Key</td> 
   <td>expire</td> 
   <td>设置 <code>key</code> 的过期时间（seconds）</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>getset</td> 
   <td>将键 <code>key</code> 的值设为 <code>value</code> ， 并返回键的旧值</td> 
   <td>redisTemplate.opsForValue().getAndSet</td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>setrange</td> 
   <td>从偏移量 <code>offset</code> 开始， 用 <code>value</code> 参数覆盖键 <code>key</code> 储存的字符串值</td> 
   <td>redisTemplate.opsForValue().set</td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>append</td> 
   <td>用于为指定的 key 追加值</td> 
   <td>redisTemplate.opsForValue().append</td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>incr</td> 
   <td>将 key 中储存的数字值增一,字符串类型的值需表示为数字</td> 
   <td>redisTemplate.opsForValue().increment</td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>incrby</td> 
   <td>key 中储存的数字加上指定的增量值</td> 
   <td>redisTemplate.opsForValue().increment</td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>decr</td> 
   <td>为键 <code>key</code> 储存的数字值减去一</td> 
   <td>redisTemplate.opsForValue().decrement</td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>decrby</td> 
   <td>将键 <code>key</code> 储存的整数值减去减量 <code>decrement</code></td> 
   <td>redisTemplate.opsForValue().decrement</td> 
  </tr> 
  <tr> 
   <td>List</td> 
   <td>lset</td> 
   <td>设置列表 key 中 index 位置的元素值为 <code>element</code></td> 
   <td>redisTemplate.opsForList().set</td> 
  </tr> 
  <tr> 
   <td>Hash</td> 
   <td>hincrby</td> 
   <td>为哈希表 <code>key</code> 中的域 <code>field</code> 的值加上增量 <code>increment</code></td> 
   <td>redisTemplate.opsForHash().increment</td> 
  </tr> 
  <tr> 
   <td>ZSet</td> 
   <td>zincrby</td> 
   <td>为有序集 <code>key</code> 的成员 <code>member</code> 的 <code>score</code> 值加上增量 <code>increment</code></td> 
   <td>redisTemplate.opsForZSet().incrementScore</td> 
  </tr> 
 </tbody> 
</table>

删相关指令

<table> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th>删指令</th> 
   <th>说明</th> 
   <th>RedisTemplate</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Key</td> 
   <td>del</td> 
   <td>删除给定的一个或多个 <code>key</code> 。</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>List</td> 
   <td>ltrim</td> 
   <td>修剪(trim)一个已存在的 list，这样 list 就会只包含指定范围的指定元素</td> 
   <td>redisTemplate.opsForList().trim</td> 
  </tr> 
  <tr> 
   <td>List</td> 
   <td>lpop []</td> 
   <td>删除并返回存储在 <code>key</code> 中的列表的第一个元素或者前 count 个元素</td> 
   <td>redisTemplate.opsForList().leftPop</td> 
  </tr> 
  <tr> 
   <td>List</td> 
   <td>rpop []</td> 
   <td>用于移除并返回列表 <code>key</code> 的最后一个元素或者后 count 个元素</td> 
   <td>redisTemplate.opsForList().rightPop</td> 
  </tr> 
  <tr> 
   <td>List</td> 
   <td>lrem</td> 
   <td>用于从列表 key 中删除前 count 个值等于 <code>element</code> 的元素</td> 
   <td>redisTemplate.opsForList().remove</td> 
  </tr> 
  <tr> 
   <td>Hash</td> 
   <td>hdel [ ...]</td> 
   <td>用于删除哈希表 key 中的一个或多个指定字段</td> 
   <td>redisTemplate.opsForHash().delete</td> 
  </tr> 
  <tr> 
   <td>Set</td> 
   <td>spop []</td> 
   <td>从集合 <code>key</code>中删除并返回一个或多个随机元素</td> 
   <td>redisTemplate.opsForSet().pop</td> 
  </tr> 
  <tr> 
   <td>Set</td> 
   <td>smove</td> 
   <td>用于从集合<code>source</code> 中移动成员<code>member</code> 到集合 <code>destination</code>。</td> 
   <td>redisTemplate.opsForSet().move</td> 
  </tr> 
  <tr> 
   <td>Set</td> 
   <td>srem [ ...]</td> 
   <td>用于在集合中删除指定的元素</td> 
   <td>redisTemplate.opsForSet().remove</td> 
  </tr> 
  <tr> 
   <td>ZSet</td> 
   <td>zpopmax []</td> 
   <td>删除并返回最多<code>count</code>个有序集合<code>key</code>中的最高得分的成员</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>ZSet</td> 
   <td>zpopmin []</td> 
   <td>删除并返回最多<code>count</code>个有序集合<code>key</code>中最低得分的成员</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>ZSet</td> 
   <td>zrem [ ...]</td> 
   <td>从有序集合<code>key</code>中删除指定的成员<code>member</code></td> 
   <td>redisTemplate.opsForZSet().remove</td> 
  </tr> 
 </tbody> 
</table>

更多相关指令可以通过 [redis 命令手册][redis] 或者 [Commands | Redis][Commands _ Redis] 查询

### redis持久化 ###

Redis 提供两种持久化机制 RDB（默认） 和 AOF 机制

#### RDB ####

RDB(Redis DataBase)是Redis默认的持久化方式。按照一定的时间开启一个子进程将内存的数据以快照的形式保存到硬盘中，对应产生的数据文件为dump.rdb。通过配置文件中的save参数来定义快照的周期

![format_png 4][]

redis 6.0 之前的持久化配置

![format_png 5][]

redis 6.2 以上

![format_png 6][]

除了自动触发外，使用 save 和 bgsave 可以手动触发持久化。save 在主程序中执⾏会阻塞当前redis服务器，直到持久化工作完成执行save命令期间，Redis不能处理其他命令，线上禁止使用。bgsave Redis会在后台异步进行快照操作，不阻塞快照同时还可以响应客户端请求,该触发方式会fork一个子进程由子进程复制持久化过程。

优点：

*  适合大规模的数据恢复
 *  按照业务定时备份
 *  对数据完整性和一致性要求不高
 *  RDB 文件在内存中的加载速度要比 AOF 快得多

缺点：

*  在一定间隔时间做一次备份，所以如果redis意外down掉的话，就会丢失从当前至最近一次快照期间的数据，快照之间的数据会丢失
 *  内存数据的全量同步，如果数据量太大会导致I/0严重影响服务器性能
 *  RDB依赖于主进程的fork，在更大的数据集中，这可能会导致服务请求的瞬间延迟。fork的时候内存中的数据被克隆了一份，大致2倍的膨胀性，需要考虑

触发RDB持久化的方式：

*  配置文件中默认的快照配置
 *  手动save/bgsave命令
 *  执行flushall/flushdb命令也会产生dump.rdb文件，但里面是空的，无意义
 *  执行shutdown且没有设置开启AOF持久化
 *  主从复制时，主节点自动触发

#### AOF ####

以日志的形式来记录每个写操作，将Redis执行过的所有写指令记录下来(读操作不记录)，只许追加文件但不可以改写文件。redis启动之初会读取该文件重新构建数据,换言之, redis重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作。

默认情况下，redis是没有开启AOF(append only file)的。开启AOF功能需要设置配置：appendonly yes。

aof 工作流程：

![format_png 7][]

1.  Client 源源不断接收请求命令
2.  命令到达 Redis Server 将命令先放入AOF缓存中进行保存。这里的AOF缓冲区实际上是内存中的一片区域，存在的目的是当这些命令达到一定量以后再写入磁盘，避免频繁的磁盘IO操作。
3.  OF缓冲会根据AOF缓冲区**配置文件的策略**将命令写入磁盘上的AOF文件
4.  随着写入AOF内容的增加为避免文件膨胀，会根据规则进行命令的合并(又称**AOF重写**)，从而起到AOF文件压缩的目的
5.  当Redis Server 服务器重启的时候会从AOF文件载入数据

aof 持久化策略：

*  always： 每次修改都会 sync。消耗性能；
 *  everysec（默认）： 每秒执行一次 sync，可能会丢失1秒的数据；
 *  no ：不执行 sync, 这个时候操作系统自己同步数据，速度最快

aof 重写：同时满足以下两个条件会自动触发重写

*  根据上次重写后的aof大小，判断当前aof大小是不是增长了1倍
 *  重写时满足的文件大小

![format_png 8][]

发送 bgrewriteaof 命令手动触发重写

### redis 事务 ###

数据库中的事务是指对数据库执行一批操作，在同一个事务当中，这些操作最终要么全部执行成功，要么全部失败，不会存在部分成功的情况。

redis事务就是一次性、顺序性、排他性的执行一个队列中的一系列命令。Redis事务功能是通过MULTI、EXEC、DISCARD和WATCH 四个原语实现的，Redis会将一个事务中的所有命令序列化，然后按顺序执行。

# 正常执行
    127.0.0.1:6379> multi
    OK
    127.0.0.1:6379(TX)> set key1 v1
    QUEUED
    127.0.0.1:6379(TX)> set key1 v2
    QUEUED
    127.0.0.1:6379(TX)> exec
    1) OK
    2) OK
    
    # 放弃事务
    127.0.0.1:6379> multi
    OK
    127.0.0.1:6379(TX)> set key1 v1
    QUEUED
    127.0.0.1:6379(TX)> discard
    OK
    
    # 在一个事务中的命令出现错误（编译出错），那么所有的命令都不会执行
    127.0.0.1:6379> multi
    OK
    127.0.0.1:6379(TX)> set key1 v1
    QUEUED
    127.0.0.1:6379(TX)> set key2
    (error) ERR wrong number of arguments for 'set' command
    127.0.0.1:6379(TX)> exec
    (error) EXECABORT Transaction discarded because of previous errors.
    
    # 在一个事务中出现运行错误，那么正确的命令会被执行
    127.0.0.1:6379> multi
    OK
    127.0.0.1:6379(TX)> set key1 v1
    QUEUED
    127.0.0.1:6379(TX)> incr key1
    QUEUED
    127.0.0.1:6379(TX)> exec
    1) OK
    2) (error) ERR value is not an integer or out of range
    
    复制代码

**watch命令是一种乐观锁的实现，Redis在修改的时候会检测数据是否被更改，如果更改了，则执行失败**

![format_png 9][]

第一个窗口蓝色框第5步执行结果返回为空，也就是相当于是失败

redis 事务特性

<table> 
 <thead> 
  <tr> 
   <th>事务特性</th> 
   <th>说明</th> 
   <th>是否支持</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>原子性（Atomicity）</td> 
   <td>Redis中，单条命令是原子性执行的，但事务不保证原子性，且没有回滚。事务中任意命令执行失败，其余的命令仍会被执行。</td> 
   <td>否</td> 
  </tr> 
  <tr> 
   <td>一致性（Consistency）</td> 
   <td>Redis会保证一个事务内的命令依次执行，而不会被其它命令插入</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>隔离性（Isolation）</td> 
   <td>Redis 是单进程程序，并且它保证在执行事务时，不会对事务进行中断，事务可以运行直到执行完所有事务队列中的命令为止。</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>持久性（Durability）</td> 
   <td>当服务器运行在AOF持久化模式下，并且appendfsync选项的值为always时，事务也具有持久性。</td> 
   <td>是</td> 
  </tr> 
 </tbody> 
</table>

### redis 主从复制 ###

对于缓存来说，一般都是用来支撑读高并发的。因此架构做成主从(master-slave)架构，一主多从，主负责写，并且将数据复制到其它的 slave 节点，从节点负责读。所有的读请求全部走从节点。这样也可以很轻松实现水平扩容，支撑读高并发。

主从复制有两种实现模式：1主n从和链式连接

1主n从

![format_png 10][]

链式连接:上一个slave可以是下一个slave的master, slave同样可以接收其他slaves的连接和同步请求,那么该slave作为了链条中下一个的master,可以有效减轻主master的写压力

![format_png 11][]

一主二从模式演示

配置文件修改

# 复制 2 分配置文件作为从机
      [root@localhost mconfig]# cp redis7.conf redis80.conf
      [root@localhost mconfig]# cp redis7.conf redis81.conf
      # 修改 redis80.conf 配置信息
      [root@localhost mconfig]# vim redis80.conf
      daemonize yes
      pidfile /var/run/redis_6380.pid
      dbfilename dump80.rdb
      # 修改 redis81.conf 配置信息
      [root@localhost mconfig]# vim redis81.conf
      daemonize yes
      pidfile /var/run/redis_6381.pid
      dbfilename dump81.rdb
    复制代码

主从复制手动配置

启动并连接到服务，在从机上执行 `slaveof 地址 端口号` ，通过`info replication` 获得信息

![format_png 12][]

各种情况演示

从机是否可以写：否

![format_png 13][]

从机down机后，master 写入，从机重新连接后（配置文件未配置主从关系）是否能连上主机：否

![format_png 14][]

主机shutdown后从机会变为主机吗：否

![format_png 15][]

主机shutdown后，从机能否读，主机重启后，关系是否还在：是

![format_png 16][]

主机shutdown后，从机能否变成主机：是

![format_png 17][]

主从复制流程

![format_png 18][]

1.  当从库和主库建立MS关系后，会向主数据库发送SYNC命令
2.  主库接收到SYNC命令后会开始在后台保存快照(RDB持久化过程)，并将期间接收到的写命令缓存起来
3.  当快照完成后，主Redis会将快照文件和所有缓存的写命令发送给从Redis
4.  从Redis接收到后，会载入快照文件并且执行收到的缓存的命令
5.  之后，主Redis每当接收到写命令时就会将命令发送从Redis，从而保证数据的一致

### redis 哨兵 ###

哨兵是 redis 集群机构中非常重要的一个组件，主要有以下功能：

*  集群监控：负责监控 redis master 和 slave 进程是否正常工作。
 *  消息通知：如果某个 redis 实例有故障，那么哨兵负责发送消息作为报警通知给管理员。
 *  故障转移：如果 master node 挂掉了，会自动转移到 slave node 上。
 *  配置中心：如果故障转移发生了，通知 client 客户端新的 master 地址。

哨兵用于实现 redis 集群的高可用，本身也是分布式的，作为一个哨兵集群去运行，互相协同工作

![format_png 19][]

哨兵模式演示

配置文件修改：自动定义主从关系

```
    # 重新定义 redis79.conf 配置信息
    [root@localhost mconfig]# vim redis79.conf
    daemonize yes
    # bind 172.0.0.1 # 注释掉此项配置
    protected-mode no
    # 指定端口
    port 6379
    # 指定RDB保存目录
    dir /mconfig
    pidfile /var/run/redis_6379.pid
    # 设置密码（主从机保持一致）
    requirepass 111111
    dbfilename dump79.rdb
    
    # 定义 redis80.conf 配置信息
    [root@localhost mconfig]# vim redis80.conf
    daemonize yes
    # bind 172.0.0.1 # 注释掉此项配置
    protected-mode no
    # 指定端口
    port 6380
    # 指定RDB保存目录
    dir /mconfig
    pidfile /var/run/redis_6380.pid
    # 设置密码（主从机保持一致）
    requirepass 111111
    dbfilename dump80.rdb
    # 自动配置主机和密码
    replicaof 192.168.186.130 6379
    masterauth 111111
    
    # 定义 redis81.conf 配置信息
    [root@localhost mconfig]# vim redis81.conf
    daemonize yes
    # bind 172.0.0.1 # 注释掉此项配置
    protected-mode no
    # 指定端口
    port 6381
    # 指定RDB保存目录
    dir /mconfig
    pidfile /var/run/redis_6381.pid
    # 设置密码（主从机保持一致）
    requirepass 111111
    dbfilename dump81.rdb
    # 自动配置主机和密码
    replicaof 192.168.186.130 6379
    masterauth 111111
    ```
    复制代码

![format_png 20][]

哨兵配置文件

3个哨兵都同时在192.168.186.130这台机器进行配置，配置说明

# 设置要监控的master服务器，quorum表示最少有几个哨兵认可客观下线，同意故障迁移的法定票数。
        sentinel monitor <master-name> <ip> <redis-port> <quorum>
        # 如果master设置了密码，配置连接master服务的密码
        sentinel auth-pass <master-name> <password>
        # 指定多少毫秒之后，主节点没有应答哨兵，此时哨兵主观上认为主节点下线
        sentinel down-after-milliseconds <master-name> <milliseconds>
        # 表示允许并行同步的slave个数，当Master挂了后，哨兵会选出新的Master，此时，剩余的slave会向新的master发起同步数据
        sentinel parallel-syncs <master-name> <nums>
        # 故障转移的超时时间，进行故障转移时，如果超过设置的毫秒，表示故障转移失败
        sentinel failover-timeout <master-name> <milliseconds>
        # 配置当某一事件发生时所需要执行的脚本
        sentinel notification-script <master-name> <script-path> 
        # 客户端重新配置主节点参数脚本
        sentinel client-reconfig-script <master-name> <script-path>
    复制代码

哨兵配置项创建：

# sentinel79.conf
        bind 0.0.0.0
        daemonize yes
        protected-mode no
        port 26379
        logfile "/mconfig/log/sentinel79.log"
        pidfile /var/run/redis-sentinel26379.pid
        dir /mconfig
        sentinel monitor mymaster 192.168.186.130 6379 2
        sentinel auth-pass mymaster 111111
        
        # sentinel80.conf
        bind 0.0.0.0
        daemonize yes
        protected-mode no
        port 26380
        logfile "/mconfig/log/sentinel80.log"
        pidfile /var/run/redis-sentinel26380.pid
        dir /mconfig
        sentinel monitor mymaster 192.168.186.130 6379 2
        sentinel auth-pass mymaster 111111
        
        # sentinel81.conf
        bind 0.0.0.0
        daemonize yes
        protected-mode no
        port 26381
        logfile "/mconfig/log/sentinel81.log"
        pidfile /var/run/redis-sentinel26381.pid
        dir /mconfig
        sentinel monitor mymaster 192.168.186.130 6379 2
        sentinel auth-pass mymaster 111111
    复制代码

启动哨兵

`redis-sentinel sentinel79.conf --sentinel`，所有 redis 相关的进程

![format_png 21][]

哨兵启动后的配置和日志信息(主机ip地址因电脑重启导致变动)

![format_png 22][]

![format_png 23][]

哨兵启动后会在日志和配置文件中添加主从机的信息和 sentinel ID

主机 master shutdown

![format_png 24][]

从哨兵日志看，从主机 down 机到重新选出主机会经历三个步骤：

1.  主机下线确认（黄色 mark）：会有 sdown 和 odown 两次确认。sdown(主观不可用)是单个sentinel自己主观上检测到的关于 master 的状态,从 sentinel 的角度来看,如果发送了 ping 心跳后,在一定时间内没有收到合法的回复,就达到了 sdown的条件。odown需要一定数量的 sentinel，多个哨兵达成一致意见才能认为一个 master 客观上已经宕掉。
2.  选举出领导者哨兵(绿色 mark)：当主节点被判断客观下线以后,各个哨兵节点会进行协商,先选举出一个领导者哨兵节点（兵王）并由该领导者节点，也即被选举出的兵王进行 failover (故障迁移)
3.  领导者哨兵选出新的master：依据一定规则选出 master 主机，sentinel leader 执行 slaveof no one 命令让选出来的从节点成为新的主节点，并通过 slaveof 命令让其他节点（包括原来的主节点）成为其从节点

【扩展】Raft 算法和 master 选取规则

![format_png 25][]

监视该主节点的所有哨兵都有可能被选为领导者，选举使用的算法是Raft算法。Raft算法的基本思路**是先到先得**：即在一轮选举中，哨兵A向B发送成为领导者的申请，如果B没有同意过其他哨兵，则会同意A成为领导者

![format_png 26][]

首先根据 redis.conf 配置文件中，选出优先级 slave-priority 或者 replica-priority 最高的从节点(数字越小优先级越高 )，如果都相同，接着判断复制偏移位 offset 最大的从节点，如果还相同，按照字典顺序（ASCII码）选择最小 Run ID 的从节点。

### redis 集群 ###

Redis集群是一个提供在多个Redis节点间共享数据的程序集。集群具有以下特性：

*  可以支持多个 master，每个 master 可以有多个 slave 。
 *  由于Cluster自带Sentinel的故障转移机制，内置了高可用的支持，无需再去使用哨兵功能。
 *  客户端与Redis的节点连接，不再需要连接集群中所有的节点，只需要任意连接集群中的一个可用节点即可。
 *  槽位 slot 负责分配到各个物理服务节点，由对应的集群来负责维护节点、插槽和数据之间的关系。

哈希槽分区

> 集群的 key 空间被分成 16384 个槽，有效地设置了 16384 个主节点的集群大小上限（但是，建议的最大节点大小约为 1000个节点）。集群中的每个主节点处理 16384 个哈希槽的一个子集。 当没有集群重新配置正在进行时（即哈希槽从一个节点移动到另一个节点），集群是稳定的。 当集群稳定时，单个哈希槽将由单个节点提供服务（但是，服务节点可以有一个或多个副本，在网络分裂或故障的情况下替换它,并且可以用于扩展读取陈旧数据是可接受的操作)。

哈希槽分区是一种将数据分散存储在多个节点上的技术，它将所有可能的键映射到一个固定数量的哈希槽中。每个节点负责处理其中一部分哈希槽，这样就可以将数据分布在多个节点上，从而提高了系统的可扩展性和容错性。当需要添加或删除节点时，Redis 会自动将哈希槽重新分配到新的节点上，以保持负载均衡。这种分区技术使得 Redis 可以处理大量的数据，并且可以在不停机的情况下进行扩展和缩减。

![format_png 27][]

哈希槽被分为 16384 个槽位有以下几个原因：

![format_png 28][]

*  更小的心跳包大小：redis 节点需要发送一定数量的 ping 消息作为心跳包，在消息头中最占空间的是 myslots\[CLUSTER\_SLOTS/8\]，当槽位为65536时，这块的大小是: 65536÷8÷1024=8kb ；在消息头中最占空间的是myslots\[CLUSTER\_SLOTS/8\]， 当槽位为16384时，这块的大小是: 16384÷8÷1024=2kb 。
 *  redis 的集群主节点数量基本不可能超过1000个：集群节点越多，心跳包的消息体内携带的数据越多。如果节点过1000个，也会导致网络拥堵。因此redis作者不建议redis cluster节点数量超过1000个。 那么，对于节点数在1000以内的redis cluster集群，16384个槽位够用了。没有必要拓展到65536个。
 *  槽位越小，节点少的情况下，压缩比高，容易传输：Redis主节点的配置信息中它所负责的哈希槽是通过一张bitmap的形式来保存的，在传输过程中会对bitmap进行压缩，但是如果bitmap的填充率slots / N很高的话(N表示节点数)，bitmap的压缩率就很低。 如果节点数很少，而哈希槽数量很多的话，bitmap的压缩率就很低。

3主3从 redis 集群演示：

虚拟机配置

![format_png 29][]

6个 redis 实例配置文件

`cd /mconfig` 进入目录下 `mkdir cluster` 新建 cluster 目录，`vim cluster81.conf`

# cluster81.conf
        bind 0.0.0.0
        daemonize yes
        protected-mode no
        port 6381
        logfile "/mconfig/log/cluster6381.log"
        pidfile /mconfig/cluster6381.pid
        dir /mconfig/cluster
        dbfilename dump6381.rdb
        appendonly yes
        appendfilename "appendonly6381.aof"
        requirepass 111111
        masterauth 111111
         
        cluster-enabled yes
        cluster-config-file nodes-6381.conf
        cluster-node-timeout 5000
        
    复制代码

其他5台只需要修改下端口号相关的配置

启动实例并构建主从关系

`redis-server cluster81.conf` 启动部署的实例

# --cluster-replicas 1 表示为每个master创建一个slave节点 
        redis-cli -a 111111 --cluster create --cluster-replicas 1 192.168.186.131:6381 192.168.186.131:6382 192.168.186.132:6383 192.168.186.132:6384 192.168.186.133:6385 192.168.186.133:6386
    复制代码

![format_png 30][]

选择yes，在这过程中可能会出现卡在 waiting for the cluster to join 上，可以通过 `systemctl stop firewalld.service` 关闭防火墙或者通过 `firewall-cmd --zone=public --add-port=80/tcp --permanent (permanent永久生效，没有此参数重启后失效)`开放端口号

![format_png 31][]

`redis-cli -a 111111 -p 6381 -c` 连接客户端，加上 -c 是防止路由失效。通过 `info replication` `cluster info` `cluster nodes` 查看集群状态

![format_png 32][]

当往 redis 添加 key 值时会根据哈希槽计算映射到对应的 redis master 中去，`cluster keyslot` 查看key所在槽位

![format_png 33][]

容错切换

当某台 master down机后，自动将从机变成主机，原来的主机恢复后仍然为从机，执行 `cluster failover` 后恢复之前的主从关系

![format_png 34][]

服务扩容

准备工作：新建虚拟机，创建配置文件启动服务

![format_png 35][]

服务扩容主要有以下三步：

# 1. 将新增的 6387 作为 master 节点加入原有集群
        # redis-cli -a 密码 --cluster add-node 自己实际IP地址:6387 自己实际IP地址:6381
        redis-cli -a 111111 --cluster add-node 192.168.186.134:6387 192.168.186.131:6381
        # 2. 重新分派槽号
        # redis-cli -a 密码 --cluster reshard IP地址:端口号
        redis-cli -a 111111 --cluster reshard 192.168.186.134:6387
        # 3. 添加 slave 节点
        # redis-cli -a 密码 --cluster add-node ip:新slave端口 ip:新master端口 --cluster-slave --cluster-master-id 新主机节点ID
        redis-cli -a 111111 --cluster add-node 192.168.186.134:6388 192.168.186.134:6387 --cluster-slave --cluster-master-id c9e87379e1aa142ac06a18165e0ed9c061a2cf36
    复制代码

![format_png 36][]

![format_png 37][]

![format_png 38][]

服务缩容

服务缩容可以分为以下几步：

```
    # 从集群中删除 slave 节点
    # redis-cli -a 密码 --cluster del-node ip:从机端口 从机节点ID
    redis-cli -a 111111 --cluster del-node 192.168.186.134:6388 f76af4e8c9a4c91642cdd3e95e8dd55810bd13c9 
    # 清空 master 节点槽号，将槽号重新分配给其他节点
    # redis-cli -a 密码 --cluster reshard IP地址:端口号
    redis-cli -a 111111 --cluster reshard 192.168.186.131:6381
    # 从集群中删除 mater 节点
    # redis-cli -a 密码 --cluster del-node ip:主机端口 主机节点ID
    redis-cli -a 111111 --cluster del-node 192.168.186.134:6387 c9e87379e1aa142ac06a18165e0ed9c061a2cf36
    ```
    复制代码

![format_png 39][]

### redis 线程 ###

Redis的主线程是单线程的，它使用事件驱动模型和I/O多路复用程序来处理客户端请求，而无需为每个客户端请求创建新线程。

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>redis4.0 前</th> 
   <th>redis 6.0后</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>线程模型</td> 
   <td> <p><img alt="" src="https://img-blog.csdnimg.cn/img_convert/6fe62c435240f5e71c96fb93b779ad23.webp?x-oss-process=image/format,png"></p> </td> 
   <td> <p><img alt="" src="https://img-blog.csdnimg.cn/img_convert/e1a5066ee4ace9db5de3974c56f74021.webp?x-oss-process=image/format,png"></p> </td> 
  </tr> 
  <tr> 
   <td>说明</td> 
   <td>I/O 的读和写本身是堵塞的，比如当 socket 中有数据时，Redis 会通过调用先将数据从内核态空间拷贝到用户态空间，再交给 Redis 调用，而这个拷贝的过程就是阻塞的，当数据量越大时拷贝所需要的时间就越多，而这些操作都是基于单线程完成的</td> 
   <td>从Redis6开始，新增了多线程的功能来提高 I/O 的读写性能，主要实现思路是将主线程的 IO 读写任务拆分给一组独立的线程去执行，这样就可以使多个 socket 的读写可以并行化了，采用多路 I/O 复用技术可以让单个线程高效的处理多个连接请求（尽量减少网络IO的时间消耗），将最耗时的Socket的读取、请求解析、写入单独外包出去，剩下的命令执行仍然由主线程串行执行并和内存的数据交互。</td> 
  </tr> 
 </tbody> 
</table>

**文件事件处理器**

Redis基于Reactor模式开发了网络事件处理器，这个处理器被称为文件事件处理器（file event handler）。它的组成结构为4部分：多个套接字、IO多路复用程序、文件事件分派器、事件处理器。文件事件分派器队列的消费是单线程的。

*  文件事件处理器使用 I/O 多路复用（multiplexing）程序来同时监听多个套接字， 并根据套接字目前执行的任务来为套接字关联不同的事件处理器。
 *  当被监听的套接字准备好执行连接应答（accept）、读取（read）、写入（write）、关闭（close）等操作时， 与操作相对应的文件事件就会产生， 这时文件事件处理器就会调用套接字之前关联好的事件处理器来处理这些事件。

虽然文件事件处理器以单线程方式运行， 但通过使用 I/O 多路复用程序来监听多个套接字， 文件事件处理器既实现了高性能的网络通信模型， 又可以很好地与 redis 服务器中其他同样以单线程方式运行的模块进行对接， 这保持了 Redis 内部单线程设计的简单性。

![format_png 40][]

**I/O 多路复用**

由于读写操作等待用户输入或输出都是阻塞的，这会导致某一文件的 I/O 阻塞导致整个进程无法对其它客户提供服务，而 I/O 多路复用就是为了解决这个问题而出现。 I/O 多路复用机制，就是我们说的select，poll，epoll。就是通过其中一种机制，一个进程可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。可以基于一个阻塞对象并同时在多个描述符上等待就绪，而不是使用多个线程(每个文件描述符一个线程，每次new一个线程)，这样可以大大节省系统资源。

简单说，I/O 多路复用的特点是通过 select，poll，epoll 其中一种机制，使得一个进程能同时等待多个文件描述符，而这些文件描述符（套接字描述符）其中的任意一个进入读就绪状态，select，poll，epoll 等函数就可以返回。

文件描述符

文件描述符（File descriptor）是计算机科学中的一个术语，是一个用于表述指向文件的引用的抽象化概念。文件描述符在形式上是一个非负整数。实际上，它是一个索引值，指向内核为每一个进程所维护的该进程打开文件的记录表。当程序打开一个现有文件或者创建一个新文件时，内核向进程返回一个文件描述符。在程序设计中，一些涉及底层的程序编写往往会围绕着文件描述符展开。但是文件描述符这一概念往往只适用于UNIX、Linux这样的操作系统。

![format_png 41][]

### SpringBoot 整合 redis ###

pom 引入

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    复制代码

配置文件

# ========================redis单机=====================
    spring.redis.database=0
    # 修改为自己真实IP
    spring.redis.host=192.168.186.131
    spring.redis.port=6379
    spring.redis.password=111111
    spring.redis.lettuce.pool.max-active=8
    spring.redis.lettuce.pool.max-wait=-1ms
    spring.redis.lettuce.pool.max-idle=8
    spring.redis.lettuce.pool.min-idle=0
    
    # ========================redis集群=====================
    spring.redis.password=111111
    # 获取失败 最大重定向次数
    spring.redis.cluster.max-redirects=3
    spring.redis.lettuce.pool.max-active=8
    spring.redis.lettuce.pool.max-wait=-1ms
    spring.redis.lettuce.pool.max-idle=8
    spring.redis.lettuce.pool.min-idle=0
    #支持集群拓扑动态感应刷新,自适应拓扑刷新是否使用所有可用的更新，默认false关闭
    spring.redis.lettuce.cluster.refresh.adaptive=true
    #定时刷新
    spring.redis.lettuce.cluster.refresh.period=2000
    spring.redis.cluster.nodes=192.168.186.131:6381 192.168.186.131:6382 192.168.186.132:6383 192.168.186.132:6384 192.168.186.133:6385 192.168.186.133:6386
    复制代码

序列化问题配置

import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.JsonTypeInfo;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    /**
     * redis 序列化配置
     *
     * @author pc
     * @date 2023/04/26
     */
    @Configuration
    public class RedisConfig {
    
        @Bean
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
            // 1.创建 redisTemplate 模板
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
    
            // 2.关联 redisConnectionFactory
            redisTemplate.setConnectionFactory(redisConnectionFactory);
    
            // 3. 创建序列化类
            Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
            ObjectMapper objectMapper = new ObjectMapper();
    
            // 4.设置可见度
            objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    
            // 5.启动默认的类型
            objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
                    ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
    
            // 6.序列化类，对象映射设置
            jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
    
            // 7.设置value的转化格式和key的转换格式
            StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
    
            // key 和 hash key 序列化方式采用 string
            redisTemplate.setKeySerializer(stringRedisSerializer);
            redisTemplate.setHashKeySerializer(stringRedisSerializer);
    
            // value 和 hash value 序列化方式采用 jackson
            redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
            redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
    
            redisTemplate.afterPropertiesSet();
            return redisTemplate;
        }
    }
    复制代码

封装

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.ValueOperations;
    import org.springframework.stereotype.Component;
    
    import java.util.concurrent.TimeUnit;
    
    /**
     * redis缓存
     *
     * @author pc
     * @date 2023/02/22
     */
    @Component
    public class RedisCache {
    
        @Autowired
        @Qualifier("redisTemplate")
        private RedisTemplate redisTemplate;
    
    
        /**
         * 缓存基本的对象，Integer、String、实体类等
         *
         * @param key   缓存的键值
         * @param value 缓存的值
         */
        public <T> void setCacheObject(String key, T value) {
            redisTemplate.opsForValue().set(key, value);
        }
    
        /**
         * 缓存基本的对象，Integer、String、实体类等
         *
         * @param key      缓存的键值
         * @param value    缓存的值
         * @param timeout  过期时间
         * @param timeUnit 时间单位
         */
        public<T> void setCacheObject(String key, T value, Integer timeout, TimeUnit timeUnit) {
            redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
        }
    
    
        /**
         * 获取缓存的对象
         *
         * @param key 缓存的键值
         * @return {@link Object}
         */
        public<T> T getCacheObject(String key){
            ValueOperations<String, T> operation = redisTemplate.opsForValue();
            return operation.get(key);
        }
    
        /**
         * 删除单个对象
         *
         * @param key key
         */
        public boolean deleteObject(String key)
        {
            return redisTemplate.delete(key);
        }
    }
    复制代码

##  ##

[format_png]: https://img-blog.csdnimg.cn/img_convert/49f425191fe34854e5732223c42e96ed.webp?x-oss-process=image/format,png
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/636d5e8d17bf92e37491d2861ac7702c.webp?x-oss-process=image/format,png
[format_png 2]: https://img-blog.csdnimg.cn/img_convert/5e90583ae04a419fbd59a47f0ca4f94e.webp?x-oss-process=image/format,png
[format_png 3]: https://img-blog.csdnimg.cn/img_convert/f41c26775a37aa735277850134510294.webp?x-oss-process=image/format,png
[redis]: https://link.juejin.cn?target=https%3A%2F%2Fwww.redis.com.cn%2Fcommands.html
[Commands _ Redis]: https://link.juejin.cn?target=https%3A%2F%2Fredis.io%2Fcommands%2F
[format_png 4]: https://img-blog.csdnimg.cn/img_convert/6f40f142105603efa5792a7312122b80.webp?x-oss-process=image/format,png
[format_png 5]: https://img-blog.csdnimg.cn/img_convert/c4482d208ac49a036744de30ce474521.webp?x-oss-process=image/format,png
[format_png 6]: https://img-blog.csdnimg.cn/img_convert/458b8533d9e8f991e3951240cdfbd667.webp?x-oss-process=image/format,png
[format_png 7]: https://img-blog.csdnimg.cn/img_convert/bc501cc23a4360b00eb0c5c808a71550.webp?x-oss-process=image/format,png
[format_png 8]: https://img-blog.csdnimg.cn/img_convert/56894b88762e3199bd2963f0428e0964.webp?x-oss-process=image/format,png
[format_png 9]: https://img-blog.csdnimg.cn/img_convert/e48cc811eb1c9933ba01f18ce0137bfc.webp?x-oss-process=image/format,png
[format_png 10]: https://img-blog.csdnimg.cn/img_convert/e7bd02af6e27d34b45692781d840db15.webp?x-oss-process=image/format,png
[format_png 11]: https://img-blog.csdnimg.cn/img_convert/172e3fe0fdc2ec205d257d87040b36eb.webp?x-oss-process=image/format,png
[format_png 12]: https://img-blog.csdnimg.cn/img_convert/ffedba2c4b868e5826cd0c1578bb54d1.webp?x-oss-process=image/format,png
[format_png 13]: https://img-blog.csdnimg.cn/img_convert/796647cca7c4340a0a037a4add0f6e6b.webp?x-oss-process=image/format,png
[format_png 14]: https://img-blog.csdnimg.cn/img_convert/efffa04669ba20bc77e362188cf4fc8b.webp?x-oss-process=image/format,png
[format_png 15]: https://img-blog.csdnimg.cn/img_convert/4a41cc4fdcc3444cc3566ae795881a6b.webp?x-oss-process=image/format,png
[format_png 16]: https://img-blog.csdnimg.cn/img_convert/a27078f168be8fa74e3715809a330f52.webp?x-oss-process=image/format,png
[format_png 17]: https://img-blog.csdnimg.cn/img_convert/039254bc8da80364fe183396dc2f3641.webp?x-oss-process=image/format,png
[format_png 18]: https://img-blog.csdnimg.cn/img_convert/a04e89139b4fbefd145d38180b55c40f.webp?x-oss-process=image/format,png
[format_png 19]: https://img-blog.csdnimg.cn/img_convert/7ddb29258355262a849cedac596b4978.webp?x-oss-process=image/format,png
[format_png 20]: https://img-blog.csdnimg.cn/img_convert/3ff9a19f0ede04d41e9bf7f98f410790.webp?x-oss-process=image/format,png
[format_png 21]: https://img-blog.csdnimg.cn/img_convert/d3477b42285b99acf35b014eee088fef.webp?x-oss-process=image/format,png
[format_png 22]: https://img-blog.csdnimg.cn/img_convert/935f795be85190334c579a997be7fa26.webp?x-oss-process=image/format,png
[format_png 23]: https://img-blog.csdnimg.cn/img_convert/bc3051fca13ef8ba1d1fec1474668db7.webp?x-oss-process=image/format,png
[format_png 24]: https://img-blog.csdnimg.cn/img_convert/32cc21a70a769b95cfe2ba0331f9c6bd.webp?x-oss-process=image/format,png
[format_png 25]: https://img-blog.csdnimg.cn/img_convert/b5b5b90907af584252a24830817d9c3f.webp?x-oss-process=image/format,png
[format_png 26]: https://img-blog.csdnimg.cn/img_convert/be4f474f82a12f6742486b92c6292c43.webp?x-oss-process=image/format,png
[format_png 27]: https://img-blog.csdnimg.cn/img_convert/3923f93d52732d1771c5339b35eed3c2.webp?x-oss-process=image/format,png
[format_png 28]: https://img-blog.csdnimg.cn/img_convert/00a421ae697a2690f5879016947eaf12.webp?x-oss-process=image/format,png
[format_png 29]: https://img-blog.csdnimg.cn/img_convert/8d460ce2fb8e857b5fd1bb0bd4f2774b.webp?x-oss-process=image/format,png
[format_png 30]: https://img-blog.csdnimg.cn/img_convert/c64ec4fdb371d9a126244924799166cc.webp?x-oss-process=image/format,png
[format_png 31]: https://img-blog.csdnimg.cn/img_convert/cdea647f2479cd900f6b87dfaf993ce6.webp?x-oss-process=image/format,png
[format_png 32]: https://img-blog.csdnimg.cn/img_convert/ff2dea1ebee81cdc6db2cfe17caaa631.webp?x-oss-process=image/format,png
[format_png 33]: https://img-blog.csdnimg.cn/img_convert/e3ea5fdcfa91d56bd898ebabf9ec027e.webp?x-oss-process=image/format,png
[format_png 34]: https://img-blog.csdnimg.cn/img_convert/56ee0019642036acb45f1377018e4444.webp?x-oss-process=image/format,png
[format_png 35]: https://img-blog.csdnimg.cn/img_convert/03fe3bc2d1b67599f9bbc5f415f366cb.webp?x-oss-process=image/format,png
[format_png 36]: https://img-blog.csdnimg.cn/img_convert/69670d522a22dd6ebf971d525347b5b6.webp?x-oss-process=image/format,png
[format_png 37]: https://img-blog.csdnimg.cn/img_convert/0b13dd73430080fbecb9a2b98ef0d705.webp?x-oss-process=image/format,png
[format_png 38]: https://img-blog.csdnimg.cn/img_convert/71e84d00453dbca4b2def42f9d17b645.webp?x-oss-process=image/format,png
[format_png 39]: https://img-blog.csdnimg.cn/img_convert/0fd08d75998f91866bdfe4473b7bb5b5.webp?x-oss-process=image/format,png
[format_png 40]: https://img-blog.csdnimg.cn/img_convert/ea11c83a434b002e5c2d2f4e597f4072.webp?x-oss-process=image/format,png
[format_png 41]: https://img-blog.csdnimg.cn/img_convert/6b66e109730e97611c1eb95d1f9ddcea.webp?x-oss-process=image/format,png