mirror of
https://github.com/CyC2018/Interview-Notebook.git
synced 2026-11-19 19:13:45 +00:00
Update Redis.md
调整高频标记;与 MySQL 的区别、BITMAP 日活统计、排行榜、跳跃表、AOF、Lua 脚本、单线程和 Redis Cluster 等小节的补充与校对。
This commit is contained in:
+47
-44
@@ -21,9 +21,9 @@
|
||||
* [排行榜](#排行榜)
|
||||
* [其它](#其它)
|
||||
* [四、数据结构](#四数据结构)
|
||||
* [对象编码](#对象编码) 🔥🔥
|
||||
* [对象编码](#对象编码)
|
||||
* [字典](#字典)
|
||||
* [跳跃表](#跳跃表)
|
||||
* [跳跃表](#跳跃表) 🔥🔥
|
||||
* [五、Redis 与 Memcached](#五redis-与-memcached)
|
||||
* [数据类型](#数据类型)
|
||||
* [数据持久化](#数据持久化)
|
||||
@@ -80,11 +80,11 @@ Redis 支持很多特性,例如将内存中的数据持久化到硬盘中,
|
||||
### 与 MySQL 的区别
|
||||
|
||||
- 数据位置:Redis 的数据全部在内存中,容量受内存大小限制;MySQL 的数据在磁盘上,内存中的缓冲池只缓存经常访问的页;
|
||||
- 查询方式:Redis 只能按键访问,值是字符串、哈希、有序集合等数据结构;MySQL 用 SQL 按任意条件查询、联表和聚合,靠索引加速;
|
||||
- 查询方式:Redis 只能按键访问,值是字符串、哈希、有序集合等数据结构(Redis 8 起,带模块构建的版本内置 Redis Query Engine,可以给哈希和 JSON 建二级索引查询);MySQL 用 SQL 按任意条件查询、联表和聚合,靠索引加速;
|
||||
- 事务:MySQL 的事务满足 ACID,出错可以回滚;Redis 的事务只保证一组命令依次执行、不被其它客户端的命令插入,其中一条命令执行出错时,其它命令不会回滚,见 [九、事务](#九事务);
|
||||
- 持久性:MySQL 默认在事务提交时把 redo log 刷到磁盘,提交成功的数据不会因为宕机丢失;Redis 即使开启 AOF 并设置为 everysec,宕机时也可能丢失最近一秒左右的写入。
|
||||
- 持久性:MySQL 默认在事务提交时把 [redo log](MySQL.md#redo-log) 刷到磁盘,提交成功的数据不会因为宕机丢失;Redis 即使开启 AOF 并设置为 everysec(每秒同步一次 AOF 文件,见 [AOF 持久化](#aof-持久化)),宕机时也可能丢失最近一秒左右的写入。
|
||||
|
||||
数据都在内存中时,MySQL 按主键查询也很快。用 50 个连接分别执行 20 万次同一条主键查询和同一个键的 GET,两者每秒都能处理 13 万~17 万次,但 MySQL 用了约 6 个 CPU 核心,每次查询消耗约 36 微秒的 CPU 时间;Redis 只用 1 个核心,每次约 7 微秒(MySQL 8.0、Redis 7.4 实测,见[附录 A1](#a1-mysql-与-redis-的主键查询))。Redis 的优势在于开销小、延迟稳定,以及计数器、排行榜这类 MySQL 不擅长的数据结构;需要持久保存、按多种条件查询的业务数据仍然放在 MySQL 中。两者通常一起使用,Redis 作为缓存,见 [缓存与数据库的一致性](缓存.md#缓存一致性)。
|
||||
数据都在内存中时,MySQL 按主键查询也很快。同一条主键查询和同一个键的 GET 各用 50 个连接共执行 20 万次,两者每秒都能处理 13 万~17 万次,但 MySQL 用了约 6 个 CPU 核心,每次查询消耗约 36 微秒的 CPU 时间;Redis 只用 1 个核心,每次约 7 微秒(MySQL 8.0、Redis 7.4 实测,见[附录 A1](#a1-mysql-与-redis-的主键查询))。Redis 的优势在于开销小(原因见 [单线程为什么快](#单线程为什么快))、延迟稳定,以及计数器、排行榜这类 MySQL 不擅长的数据结构;需要持久保存、按多种条件查询的业务数据仍然放在 MySQL 中。两者通常一起使用,Redis 作为缓存,见 [缓存与数据库的一致性](缓存.md#缓存一致性)。
|
||||
|
||||
与本地缓存(例如 Caffeine)相比,本地缓存在应用进程内,读取不需要网络往返,但每个实例各存一份,更新后难以保持一致,容量也受单机内存限制;Redis 由所有实例共享同一份数据,还能实现分布式锁、全局计数这类需要多个实例协调的功能。两者常组合成[多级缓存](缓存.md#多级缓存)。
|
||||
|
||||
@@ -106,7 +106,7 @@ Redis 支持很多特性,例如将内存中的数据持久化到硬盘中,
|
||||
- HASH:一个对象的多个字段,可以单独读写某个字段,例如用户信息、购物车中每件商品的数量;
|
||||
- ZSET:按分值排序和按范围查找,例如排行榜、按时间排序的 Feed、滑动窗口限流,见 [排行榜](#排行榜) 和 [限流算法](系统设计基础.md#1-限流算法)。
|
||||
|
||||
签到、日活和独立访客数这类统计用 BITMAP 和 HyperLogLog,附近的门店用 GEO,需要消费者组和确认的消息用 Stream。
|
||||
签到、日活和独立访客数这类统计用 BITMAP 和 HyperLogLog,附近的门店用 GEO,需要消费者组和确认的消息用 Stream。部分类型会根据元素的数量和大小选择不同的编码,例如字段较少且字段名、值较短的 HASH 用 listpack,否则改用哈希表,见 [对象编码](#对象编码)。
|
||||
|
||||
需要注意的是,LIST、SET、HASH、ZSET 的元素只增不减时会变成大 Key,对它执行 HGETALL、DEL 会阻塞其它命令,见 [大 Key 与热 Key](缓存.md#大-key-与热-key)。
|
||||
|
||||
@@ -231,7 +231,7 @@ OK
|
||||
|
||||
### BITMAP
|
||||
|
||||
位图(Bitmap)不是一种独立的数据类型,而是 STRING 上按位读写的一组命令:值仍然是 SDS 中的字节数组,TYPE 返回 string,第 offset 位表示整数 offset 是否在集合中。STRING 最大 512 MB,所以 offset 的范围是 0~2<sup>32</sup> − 1。
|
||||
位图(Bitmap)不是一种独立的数据类型,而是 STRING 上按位读写的一组命令:值仍然是简单动态字符串(SDS,见[对象编码](#对象编码))中的字节数组,TYPE 返回 string,第 offset 位表示整数 offset 是否在集合中。STRING 最大 512 MB(2<sup>29</sup> 字节),即 2<sup>32</sup> 位,所以 offset 的范围是 0~2<sup>32</sup> − 1。
|
||||
|
||||
它适合成员能编号为 0~N 的整数、并且只需要记录“是或否”的场景,例如某个用户某天是否签到、某个用户今天是否访问过。主要有以下命令:
|
||||
|
||||
@@ -271,7 +271,7 @@ SETBIT 返回 1 说明今天已经签过,可以据此避免重复发放签到
|
||||
|
||||
#### 2. 日活统计
|
||||
|
||||
用户 ID 是从 1 开始连续分配的整数时,也可以反过来每天一个键 active:{日期},offset 是用户 ID,所有用户当天的状态放在同一个位图中。100 万个用户只需要 10<sup>6</sup> / 8 = 125000 字节,约 122 KB:
|
||||
用户 ID 是从 1 开始连续分配的整数时,也可以反过来每天一个键 active:{日期},offset 是用户 ID,所有用户当天的状态放在同一个位图中。100 万个用户只需要约 10<sup>6</sup> / 8 = 125000 字节(offset 从 0 算起,实际是 125001 字节),约 125 KB:
|
||||
|
||||
```text
|
||||
> setbit active:20261028 1000 1 -- 用户 1000 今天访问过
|
||||
@@ -300,7 +300,7 @@ SETBIT 会把字符串扩展到 offset 所在的字节,中间的内存一次
|
||||
|
||||
- 先把 ID 转换成从 0 开始的连续序号,例如减去起始值,或者为用户另外分配一个自增序号;
|
||||
- 位图很大时按序号分段拆成多个键,键名为序号 / M,offset 为序号 mod M,避免单个大 Key;
|
||||
- 活跃的 ID 很少时改用 SET 或 HyperLogLog:1000 个分布在 1 亿以内的 ID,位图要 12.5 MB,SET 只要 30 KB。按实测每个整数成员在 SET 中约占 38 字节(304 位),活跃 ID 不到 ID 范围的 1/300 时 SET 更省内存。
|
||||
- 活跃的 ID 很少时改用 SET 或 HyperLogLog:1000 个分布在 1 亿以内的 ID,位图要 12.5 MB,SET 只要 30 KB。按实测每个整数成员在 SET 中约占 30~38 字节(240~304 位,随哈希表的大小变化),活跃 ID 不到 ID 范围的 1/300 时 SET 更省内存。
|
||||
|
||||
#### 4. 与布隆过滤器的区别
|
||||
|
||||
@@ -326,7 +326,7 @@ GEO 用于“附近的门店”这类查询:GEOADD 保存经纬度,GEOSEARCH
|
||||
|
||||
命令在服务器上原子执行,多个客户端同时加 1 不会丢失更新;数据在内存中,也适合这种频繁读写的场景。
|
||||
|
||||
如果直接在数据库中计数,所有请求都要更新同一行,行锁让这些更新只能一个接一个地执行。对同一行执行 UPDATE counter SET cnt = cnt + 1,MySQL 用 1、8、50 个连接时每秒都只有 5000~7000 次;Redis 的 INCR 用 50 个连接每秒约 10 万次(macOS 上的 MySQL 8.0、Redis 7.4 实测,见[附录 A6](#a6-热点计数);macOS 的 fsync 不要求磁盘清空写缓存,这组 MySQL 的数字不能直接外推到 Linux 服务器)。
|
||||
如果直接在数据库中计数,所有请求都要更新同一行,行锁让这些更新只能一个接一个地执行。对同一行执行 UPDATE counter SET cnt = cnt + 1,MySQL 用 1、8、50 个连接时每秒都只有 5400~7300 次;Redis 的 INCR 用 50 个连接每秒约 10 万次(macOS 上的 MySQL 8.0、Redis 7.4 实测,见[附录 A6](#a6-热点计数);macOS 的 fsync 不要求磁盘清空写缓存,这组 MySQL 的数字不能直接外推到 Linux 服务器)。
|
||||
|
||||
常用的做法是在 Redis 中计数,再定期把计数写回数据库。单个计数仍然太热时,可以拆成多个键,例如 views:1024:0~views:1024:9,每次随机给其中一个加 1,读取时求和。点赞这类每个用户只能计一次的计数,还要记录点过赞的用户,见下文的 [点赞功能](#点赞功能)。
|
||||
|
||||
@@ -370,11 +370,11 @@ ZREVRANGE rank:likes 0 9 WITHSCORES -- 前 10 名
|
||||
ZREVRANK rank:likes article:1001 -- 第几名,从 0 开始
|
||||
```
|
||||
|
||||
向一个有序集合写入 100 万个成员,占用约 105 MB 内存;查前 10 名、查某个成员的排名和加分都是 O(logN) 的操作,SLOWLOG 记录的服务器执行时间只有几微秒(Redis 7.4 实测,见[附录 A2](#a2-排行榜))。
|
||||
向一个有序集合写入 100 万个成员,占用约 110 MB 内存;查前 10 名、查某个成员的排名和加分都是 O(logN) 的操作(原因见[跳跃表](#跳跃表)),SLOWLOG 记录的服务器执行时间只有几微秒(Redis 7.4 实测,见[附录 A2](#a2-排行榜))。
|
||||
|
||||
分值相同时,Redis 按成员名的字典序排列,而业务上通常要求先达到这个分数的排在前面。可以把时间编进分值:分值 = 点赞数 × 10<sup>10</sup> + (10<sup>10</sup> − 达到这个点赞数的秒级时间戳)。例如 article:1001 和 article:1002 都是 520 个赞,时间戳分别为 1793000000 和 1793000300,分值为 5208207000000 和 5208206999700,先达到的 article:1001 排在前面。需要注意的是,分值是双精度浮点数,只能精确表示 2<sup>53</sup> 以内的整数,这种写法下点赞数不能超过约 90 万,更大时要缩短时间部分的位数。
|
||||
分值相同时,Redis 按成员名的字典序排列,ZREVRANGE 从高到低取时同分成员按字典序倒序,都与时间先后无关,而业务上通常要求先达到这个分数的排在前面。可以把时间编进分值:分值 = 点赞数 × 10<sup>10</sup> + (10<sup>10</sup> − 达到这个点赞数的秒级时间戳)。例如 article:1001 和 article:1002 都是 520 个赞,时间戳分别为 1793000000 和 1793000300,分值为 5208207000000 和 5208206999700,先达到的 article:1001 排在前面。需要注意的是,分值是双精度浮点数,只能精确表示 2<sup>53</sup> 以内的整数,这种写法下点赞数不能超过约 90 万,更大时要缩短时间部分的位数。
|
||||
|
||||
成员上千万时,一个有序集合就成了[大 Key](缓存.md#大-key-与热-key),按 100 万个约 105 MB 估算,1000 万个约 1 GB。可以按分数段拆成多个有序集合,名次等于分数更高的各段的成员数之和,加上在本段中的名次,加分跨段时把成员移到新的段。
|
||||
成员上千万时,一个有序集合就成了[大 Key](缓存.md#大-key-与热-key),按 100 万个约 110 MB 估算,1000 万个约 1.1 GB。可以按分数段拆成多个有序集合,名次等于分数更高的各段的成员数之和,加上在本段中的名次,加分跨段时把成员移到新的段。
|
||||
|
||||
只需要显示“超过了约百分之多少的用户”时,可以按分数区间计数,用户换分时把旧区间的计数减 1、新区间的加 1,不必把每个成员都放进有序集合。同一区间内谁高谁低无从得知,结果是近似值,区间分得越细越准。
|
||||
|
||||
@@ -388,7 +388,7 @@ Set 可以实现交集、并集等操作,从而实现共同好友等功能。
|
||||
|
||||
## 四、数据结构
|
||||
|
||||
### 对象编码 🔥🔥
|
||||
### 对象编码
|
||||
|
||||
同一种数据类型会根据元素的数量和大小选择不同的底层结构,称为编码,可以用 OBJECT ENCODING 查看。元素少时使用 listpack,它把所有元素连续地存放在一块内存中,节省内存,查找时虽然要逐个比较,但元素很少时并不慢;元素增多后转换为查找更快的结构。以下是在 Redis 7.4 上用默认配置验证的结果:
|
||||
|
||||
@@ -404,7 +404,7 @@ Set 可以实现交集、并集等操作,从而实现共同好友等功能。
|
||||
|
||||
<div align="center"> <img src="pics/redis-hash-encoding.png" width="760px"/> </div><br>
|
||||
|
||||
转换后内存明显增加:512 个字段的 HASH 用 listpack 约占 10 KB,再写入一个字段转为 hashtable 后约占 40 KB(Redis 7.4 实测,见[附录 A14](#a14-hash-编码的转换))。
|
||||
转换后内存明显增加:512 个字段的 HASH 用 listpack 约占 10 KB,再写入一个字段转为 hashtable 后约占 37 KB(Redis 7.4 实测,见[附录 A14](#a14-hash-编码的转换))。
|
||||
|
||||
Redis 7.0 之前,HASH、ZSET 和 quicklist 的节点用的是压缩列表(ziplist),每个元素要记录前一个元素的长度,这个长度占 1 或 5 个字节,在中间插入或删除元素时可能让后面的元素依次变长,称为连锁更新;listpack 的每个元素只记录自己的长度,不会连锁更新,但在中间插入时仍要移动后面的数据。小的 LIST 直接用 listpack、SET 的 listpack 编码是 7.2 起才有的。旧的配置名(例如 hash-max-ziplist-entries)在 7.x 中仍可作为新配置名的别名使用。
|
||||
|
||||
@@ -416,7 +416,7 @@ Redis 7.0 之前,HASH、ZSET 和 quicklist 的节点用的是压缩列表(zi
|
||||
|
||||
embstr 编码把对象头和 SDS 放在同一块内存中,只需分配一次,44 字节的上限正好让两者一起放进 64 字节;它是只读的,APPEND 等修改会先把它转为 raw。追加时实际分配的内存见[进阶:对象编码](Redis%20-%20进阶.md#对象编码)。
|
||||
|
||||
值能无损转换为 64 位有符号整数时使用 int 编码(001234、+5 这类写法除外,APPEND 后变为 raw),整数直接存放在对象头的指针字段中,不再分配 SDS,0~9999 还默认共用启动时创建好的对象。所以 1234 比 abcd 省内存,MEMORY USAGE 分别为 56 和 72 字节,其中包括键名和字典项(Redis 7.4 实测,见[附录 A16](#a16-字符串的-int-与-embstr-编码))。
|
||||
值能无损转换为 64 位有符号整数时使用 int 编码(001234、+5 这类写法除外,APPEND 后变为 raw),整数直接存放在对象头的指针字段中,不再分配 SDS,0~9999 还默认共用启动时创建好的对象。所以 1234 比 abcd 省内存,MEMORY USAGE 分别为 56 和 72 字节,其中包括键名和字典项(Redis 7.4 实测,见[附录 A16](#a16-字符串的-int-与-embstr-编码))。Redis 8.2 起键名和值放在同一个对象中,对象头、键名和值合计超过一个缓存行(x86 上为 64 字节)时,不到 44 字节的值也用 raw 编码,整数值也不再共用启动时创建的对象。
|
||||
|
||||
### 字典
|
||||
|
||||
@@ -424,11 +424,11 @@ embstr 编码把对象头和 SDS 放在同一块内存中,只需分配一次
|
||||
|
||||
键越来越多时链表变长,查找变慢,需要扩大桶数组并把所有键重新放一遍,称为 rehash。Redis 用一个线程执行命令,一个有几百万个键的字典一次性 rehash 会让服务器停顿很久,所以采用渐进式 rehash:同时保留新旧两张哈希表,每次对字典增删改查时顺便迁移一个桶,把迁移的开销分摊到之后的操作中。两张表的使用规则和扩容、缩容的条件见[进阶:字典](Redis%20-%20进阶.md#字典)。
|
||||
|
||||
### 跳跃表
|
||||
### 跳跃表 🔥🔥
|
||||
|
||||
跳跃表(skiplist)是有序集合在成员较多时的底层结构,它在一条有序链表上增加了多层索引。
|
||||
|
||||
最底层是包含所有成员、按分值排序的链表。每个节点插入时随机决定层数:以 1/4 的概率升高一层,最多 32 层。所以大约每 4 个节点有 1 个出现在第 2 层,每 16 个节点有 1 个出现在第 3 层,平均每个节点约 1.33 层,即 1.33 个指向后继的指针。这只是期望值,好处是插入节点时不需要调整其它节点的层数。
|
||||
最底层是包含所有成员、按分值排序的链表。每个节点插入时随机决定层数:以 1/4 的概率升高一层,最多 32 层。所以大约每 4 个节点有 1 个出现在第 1 层,每 16 个节点有 1 个出现在第 2 层(与下图一样,最底层记为第 0 层),平均每个节点约 1.33 层,即 1.33 个指向后继的指针。这只是期望值,好处是插入节点时不需要调整其它节点的层数。
|
||||
|
||||
查找时从最高层开始向右走,下一个节点比目标大时下降一层,直到最底层。每层平均只走几步,查找、插入和删除的期望时间复杂度都是 O(logN)。下图演示了查找 26 的过程。
|
||||
|
||||
@@ -442,12 +442,12 @@ embstr 编码把对象头和 SDS 放在同一块内存中,只需分配一次
|
||||
|
||||
MySQL 的索引用 B+ 树,是因为 B+ 树的一个节点存放很多个键,每次读磁盘都取回一整页,减少 I/O 次数;有序集合全部在内存中,没有这个需要。Redis 的作者回答“为什么不用 B 树”时提到:调整升层的概率就能让跳跃表比 B 树更省内存;ZRANGE 这类范围遍历沿底层链表进行,缓存局部性不比平衡树差;实现简单,后来让 ZRANK 做到 O(logN)(见下文的跨度)只改了很少的代码。跳跃表的代价是性能依赖随机数,最坏情况下退化为 O(N),只是概率极小。
|
||||
|
||||
插入时先像查找一样从最高层往下走,记下每一层最后一个排在新成员前面的节点(先比分值,分值相同再比成员名),再随机决定新节点的层数,把它接在这些节点的后面。例如在上图中插入 24,三层记下的节点依次是 15、22、22;随机得到 2 层时,新节点接在第 0 层和第 1 层的 22 之后,第 2 层不变。
|
||||
Redis 的跳跃表还在每个指针上记录了跨度,即这一步跳过了多少个节点,查找时把经过的跨度相加就得到排名,所以 ZRANK 也是 O(logN)。例如上图第 2 层从 head 到 15 跨过 3、7、11、15 四个节点,跨度为 4,所以 15 排在第 4 位(ZRANK 从 0 开始计数,返回 3)。
|
||||
|
||||
插入时先像查找一样从最高层往下走,记下每一层最后一个排在新成员前面的节点(先比分值,分值相同再比成员名),再随机决定新节点的层数,把它接在这些节点的后面。例如在上图中插入 24,三层记下的节点依次是 15、22、22;随机得到 2 层时,新节点接在第 0 层和第 1 层的 22 之后,第 2 层只把 15 的跨度加 1。
|
||||
|
||||
删除时同样先记下每一层的前驱,在被删节点所在的各层让前驱指向它的后继,其它层只把跨度减 1。ZINCRBY 修改分值后位置不变时直接改值,否则先删除再插入。
|
||||
|
||||
Redis 的跳跃表还在每个指针上记录了跨度,即这一步跳过了多少个节点,查找时把经过的跨度相加就得到排名,所以 ZRANK 也是 O(logN)。
|
||||
|
||||
## 五、Redis 与 Memcached
|
||||
|
||||
两者都是非关系型内存键值数据库,主要有以下不同:
|
||||
@@ -458,13 +458,13 @@ Memcached 仅支持字符串类型,而 Redis 支持五种不同的数据类型
|
||||
|
||||
### 数据持久化
|
||||
|
||||
Redis 支持两种持久化策略:RDB 快照和 AOF 日志,而 Memcached 不支持持久化。
|
||||
Redis 支持两种持久化策略:[RDB 快照和 AOF 日志](#八持久化),而 Memcached 不支持持久化。
|
||||
|
||||
### 分布式
|
||||
|
||||
Memcached 不支持分布式,只能通过在客户端使用[一致性哈希](缓存.md#六一致性哈希)来实现分布式存储,这种方式在存储和查询时都需要先在客户端计算一次数据所在的节点。
|
||||
Memcached 的服务器之间互不通信,本身不支持分布式,通常在客户端使用[一致性哈希](缓存.md#六一致性哈希)来实现分布式存储(1.6.23 起也可以由内置的代理选择节点后转发),存储和查询时都需要先计算一次数据所在的节点。
|
||||
|
||||
Redis Cluster 实现了分布式的支持。
|
||||
[Redis Cluster](#redis-cluster) 实现了分布式的支持。
|
||||
|
||||
### 内存管理机制
|
||||
|
||||
@@ -511,7 +511,7 @@ Redis 8.6 又增加了 allkeys-lrm 和 volatile-lrm,按最近一次修改的
|
||||
|
||||
Redis 的 LRU 和 LFU 都是近似实现。精确的 LRU 要用双向链表维护所有键的访问顺序(见 [LRU](缓存.md#七lru)),每个键多两个指针,每次访问都要移动节点。Redis 只在每个对象中用 24 位记录最近一次访问的时间(秒级),淘汰时随机抽取 maxmemory-samples(默认 5)个键,按空闲时间放入一个大小为 16 的候选池,淘汰池中空闲时间最长的键。候选池在多次淘汰之间保留,之前抽到的冷键继续参与比较,所以比每次只看 5 个键更准。抽样数调到 10 时更接近精确的 LRU,代价是多耗一些 CPU。
|
||||
|
||||
LFU 复用这 24 位:高 16 位是上次访问的时间(分钟),低 8 位是对数计数器,最大为 255。新键的计数为 5,每次访问以 1 / (max(计数 − 5, 0) × lfu-log-factor + 1) 的概率加 1,计数越大越难增长;距离上次访问每过 lfu-decay-time 分钟(默认 1),计数减 1,最低减到 0,过去的热点会逐渐冷却。衰减不靠定时遍历,而是在访问或淘汰比较这个键时按经过的分钟数一次算出。例如对一个键执行 10、100、1000、1 万、10 万、100 万次 GET 后,OBJECT FREQ 依次为 6、10、20、52、146、255(Redis 7.4 实测,见[附录 A10](#a10-lfu-计数器))。
|
||||
LFU 复用这 24 位:高 16 位是上次访问的时间(分钟),低 8 位是对数计数器,最大为 255。新键的计数为 5,每次访问以 1 / (max(计数 − 5, 0) × lfu-log-factor + 1) 的概率加 1(lfu-log-factor 默认为 10),计数越大越难增长;距离上次访问每过 lfu-decay-time 分钟(默认 1),计数减 1,最低减到 0,过去的热点会逐渐冷却。衰减不靠定时遍历,而是在访问或淘汰比较这个键时按经过的分钟数一次算出。例如对一个键执行 10、100、1000、1 万、10 万、100 万次 GET 后,OBJECT FREQ 依次为 6、10、20、52、146、255(Redis 7.4 实测,见[附录 A10](#a10-lfu-计数器))。
|
||||
|
||||
选择策略时:
|
||||
|
||||
@@ -533,7 +533,7 @@ save 配置的默认值为 3600 1 300 100 60 10000,表示 1 小时内至少有
|
||||
|
||||
<div align="center"> <img src="pics/redis-rdb-cow.png" width="760px"/> </div><br>
|
||||
|
||||
RDB 文件是紧凑的二进制文件,便于备份,全量复制发送的也是 RDB 快照。系统发生故障时,最后一次快照之后的写入都会丢失。
|
||||
RDB 文件是紧凑的二进制文件,便于备份,[全量复制](#连接过程)发送的也是 RDB 快照。系统发生故障时,最后一次快照之后的写入都会丢失。
|
||||
|
||||
需要注意的是,磁盘满、目录没有写权限时快照会失败。stop-writes-on-bgsave-error 默认开启,配置了 save 条件时,最近一次 BGSAVE 失败后 Redis 拒绝写命令并返回 MISCONF 错误,读命令照常执行,直到下一次快照成功,让应用立刻发现持久化出了问题(Redis 7.4 实测,见[附录 A17](#a17-aof-文件的内容与快照失败))。
|
||||
|
||||
@@ -541,7 +541,7 @@ RDB 文件是紧凑的二进制文件,便于备份,全量复制发送的也
|
||||
|
||||
将写命令添加到 AOF 文件(Append Only File)的末尾。AOF 默认关闭,需要配置 appendonly yes 开启。
|
||||
|
||||
写命令先执行,成功后才追加到内存中的 AOF 缓冲区,执行出错的命令不会进入 AOF。之后主线程在每轮事件循环回复客户端之前,用 write() 把缓冲区写入 AOF 文件。write() 返回时数据只到了操作系统的[页缓存](计算机操作系统%20-%20概述.md#系统调用),调用 fsync 才写到磁盘,同步选项 appendfsync 决定 fsync 的时机:
|
||||
写命令先执行,成功后才追加到内存中的 AOF 缓冲区,执行出错的命令不会进入 AOF。之后主线程在每轮[事件循环](#十事件)回复客户端之前,用 write() 把缓冲区写入 AOF 文件。write() 返回时数据只到了操作系统的[页缓存](计算机操作系统%20-%20概述.md#系统调用),调用 fsync 才写到磁盘,同步选项 appendfsync 决定 fsync 的时机:
|
||||
|
||||
| 选项 | 同步频率 |
|
||||
| :--: | :--: |
|
||||
@@ -550,7 +550,7 @@ RDB 文件是紧凑的二进制文件,便于备份,全量复制发送的也
|
||||
| no | 让操作系统来决定何时同步 |
|
||||
|
||||
- always 选项会严重降低服务器的性能;
|
||||
- everysec 选项比较合适,Redis 每秒执行一次同步对服务器性能几乎没有任何影响,系统崩溃时通常只丢失一秒左右的数据,磁盘繁忙时可能更多;
|
||||
- everysec 选项比较合适,Redis 每秒执行一次同步对服务器性能影响很小,系统崩溃时通常只丢失一秒左右的数据,磁盘繁忙时可能更多;
|
||||
- no 选项并不能给服务器性能带来多大的提升,而且也会增加系统崩溃时数据丢失的数量。
|
||||
|
||||
<div align="center"> <img src="pics/redis-aof-fsync.png" width="760px"/> </div><br>
|
||||
@@ -569,7 +569,7 @@ Redis 7.0 起 AOF 由多个文件组成:重写生成的基础文件,以及
|
||||
|
||||
两种方式的对比:
|
||||
|
||||
- 丢失的数据:RDB 丢失最后一次快照之后的写入,按 save 配置可能是几分钟;AOF 使用 everysec 时约丢失 1 秒;
|
||||
- 丢失的数据:RDB 丢失最后一次快照之后的写入,按 save 配置可能是几分钟,默认配置下写入很少时可能丢失约 1 小时的写入;AOF 使用 everysec 时约丢失 1 秒;
|
||||
- 文件和恢复:RDB 是紧凑的二进制快照,适合备份,数据量大时恢复也快;AOF 的增量文件按协议格式记录文本命令,文件通常更大,但可以直接编辑:误执行 FLUSHALL 后,只要还没有重写,停止服务、备份 AOF 文件,删掉增量文件中的 FLUSHALL 及之后的命令再重启,就能恢复数据;
|
||||
- 开销:RDB 只在生成快照时 fork 子进程,数据量大时 fork 本身可能让主进程停顿;AOF 每次写入都要追加,并且需要定期重写。
|
||||
|
||||
@@ -624,7 +624,7 @@ end
|
||||
return n + 1
|
||||
```
|
||||
|
||||
用 redis-cli --eval coupon.lua coupon:1001:20261030 , 3 86400 连续执行 4 次,返回值依次为 1、2、3、0。如果在客户端先 GET 再 INCR,两个请求可能同时读到 2,都领到第 3 张。释放分布式锁时判断并删除、秒杀时判断并扣减库存也是这种用法,见 [Redis 的 SET NX 指令](分布式.md#redis-的-set-nx-指令) 和 [秒杀系统](系统设计基础.md#六秒杀系统)。
|
||||
用 redis-cli --eval coupon.lua coupon:1001:20261030 , 3 86400 连续执行 4 次,返回值依次为 1、2、3、0。如果在客户端先 GET 再 INCR,两个请求可能同时读到 2,都领到第 3 张。释放分布式锁时判断并删除、秒杀时判断并扣减库存、分布式限流时判断并扣减令牌也是这种用法,见 [Redis 的 SET NX 指令](分布式.md#redis-的-set-nx-指令)、[秒杀系统](系统设计基础.md#六秒杀系统) 和 [分布式限流](系统设计基础.md#2-分布式限流)。
|
||||
|
||||
需要注意的是:
|
||||
|
||||
@@ -654,11 +654,11 @@ Redis 用一个线程执行所有命令,仍然很快,原因主要有以下
|
||||
|
||||
Redis 6.0 加入的 I/O 多线程(io-threads,默认关闭)分担的也是这部分开销:多个 I/O 线程并行读取、解析请求和写回响应,命令仍由主线程逐条执行,不会有两个线程同时修改一个键。6.0 和 7.x 默认只把写回交给 I/O 线程,读取和解析还要打开 io-threads-do-reads,并且主线程分发完任务后要忙等所有 I/O 线程完成。
|
||||
|
||||
8.0 重新实现后,每个 I/O 线程有自己的事件循环,负责普通客户端的读取、解析和写回;命令仍由主线程执行,主从复制、订阅、MONITOR 和阻塞中的连接这类特殊连接的读写也由主线程处理(8.6 起主从复制的连接在完成全量同步后也交给 I/O 线程)。8.0 的 io-threads 把主线程也算作一个,例如 io-threads 4 表示主线程加 3 个 I/O 线程。
|
||||
8.0 重新实现后,每个 I/O 线程有自己的事件循环,负责普通客户端的读取、解析和写回;命令仍由主线程执行,主从复制、订阅、MONITOR 和阻塞中的连接这类特殊连接的读写也由主线程处理(8.6 起主从复制的连接在完成全量同步后也交给 I/O 线程)。io-threads 把主线程也算作一个(6.0 起都是这样),例如 io-threads 4 表示主线程加 3 个 I/O 线程。
|
||||
|
||||
<div align="center"> <img src="pics/redis-io-threads.png" width="760px"/> </div><br>
|
||||
|
||||
除了主线程和 I/O 线程,关闭文件、AOF 刷盘和 UNLINK 释放大 Key 的内存这些耗时操作由后台线程完成,BGSAVE 生成 RDB 快照和重写 AOF 由 fork 出的子进程完成。
|
||||
除了主线程和 I/O 线程,关闭文件、AOF 刷盘(appendfsync 为 everysec 时;always 时由主线程在回复客户端之前刷盘)和 UNLINK 释放大 Key 的内存这些耗时操作由后台线程完成,BGSAVE 生成 RDB 快照和重写 AOF 由 fork 出的子进程完成。
|
||||
|
||||
需要注意的是,单线程也意味着一条慢命令会让所有客户端等待:执行 KEYS *、对大 Key 执行 HGETALL 或 DEL、运行很长的 Lua 脚本时,其它命令都在排队,见 [大 Key 与热 Key](缓存.md#大-key-与热-key)。
|
||||
|
||||
@@ -676,7 +676,7 @@ Redis 6.0 加入的 I/O 多线程(io-threads,默认关闭)分担的也是
|
||||
2. 从服务器清空旧数据,载入快照,再执行缓冲区中的写命令;
|
||||
3. 之后主服务器每执行一条写命令,就把它发给从服务器。
|
||||
|
||||
全量复制的代价很大,所以主服务器把最近发出的写命令保存在复制积压缓冲区(默认 1 MB)中,并给复制流中的每个字节编号,称为偏移量。从服务器断线重连后,发送 PSYNC 时带上复制 ID 和需要的下一个偏移量(已经复制到的偏移量加 1):复制 ID 与主服务器一致(故障转移后,新的主服务器也接受旧主服务器的复制 ID),并且这个偏移量还在积压缓冲区中,就只发送缺少的部分,称为部分重同步;否则重新进行全量复制。下图是三次连接的结果(Redis 7.4 实测,见[附录 A15](#a15-主从复制的全量复制与部分重同步)):
|
||||
全量复制的代价很大,所以主服务器把最近发出的写命令保存在复制积压缓冲区(默认 1 MB)中,并给复制流中的每个字节编号,称为偏移量。从服务器断线重连后,发送 PSYNC 时带上复制 ID(主服务器生成的随机字符串,标识它的这段数据历史,从服务器连接时记下)和需要的下一个偏移量(已经复制到的偏移量加 1):复制 ID 与主服务器一致(故障转移后,新的主服务器也接受旧主服务器的复制 ID),并且这个偏移量还在积压缓冲区中,就只发送缺少的部分,称为部分重同步;否则重新进行全量复制。下图是三次连接的结果(Redis 7.4 实测,见[附录 A15](#a15-主从复制的全量复制与部分重同步)):
|
||||
|
||||
<div align="center"> <img src="pics/redis-psync.png" width="760px"/> </div><br>
|
||||
|
||||
@@ -735,15 +735,15 @@ Redis 有三种常见的部署方式,解决的问题不同:
|
||||
- Sentinel:在主从复制的基础上自动监控和故障转移,但仍然只有一个主服务器负责写入,数据量受单机内存限制;
|
||||
- Redis Cluster:把数据分散到多个主节点上,每个主节点有自己的从节点,同时解决容量和高可用的问题。
|
||||
|
||||
Redis Cluster 把键空间分为 16384 个哈希槽,每个主节点负责一部分槽。槽的数量固定,键所在的槽不随节点数变化,增删节点时只迁移一部分槽。取 16384 是因为节点每次心跳都带着一张 16384 位(2 KB)的槽位图,65536 个槽就要 8 KB;而集群建议不超过约 1000 个主节点,16384 个槽已经够分。下图是一个 3 主 3 从的集群(Redis 7.4 实测,见[附录 A4](#a4-redis-cluster)):
|
||||
Redis Cluster 把键空间分为 16384 个哈希槽,每个主节点负责一部分槽。槽的数量固定,键所在的槽不随节点数变化,增删节点时只迁移一部分槽。取 16384 是因为节点每次心跳(下文集群总线上的 PING、PONG)都带着一张 16384 位(2 KB)的槽位图,65536 个槽就要 8 KB;而集群建议不超过约 1000 个主节点,16384 个槽已经够分。下图是一个 3 主 3 从的集群(Redis 7.4 实测,见[附录 A4](#a4-redis-cluster)):
|
||||
|
||||
<div align="center"> <img src="pics/redis-cluster.png" width="720px"/> </div><br>
|
||||
|
||||
- 客户端向不负责这个槽的节点发送命令时,会收到 MOVED 重定向。例如 user:1001 所在的槽 5712 属于 7002,发给 7001 会收到 MOVED 5712 127.0.0.1:7002。客户端会缓存槽与节点的对应关系,之后直接访问正确的节点;
|
||||
- 一条命令涉及多个键时,这些键必须在同一个槽中,否则报错 CROSSSLOT,Lua 脚本也是如此。可以用哈希标签(hash tag)让相关的键落到同一个槽:只有 {} 中的部分参与计算,{user:1001}:cart 和 {user:1001}:orders 都在槽 5712,但大量键共用同一个哈希标签时会集中到同一个槽,造成数据倾斜;
|
||||
- 一条命令涉及多个键时,这些键必须在同一个槽中,否则报错 CROSSSLOT,Lua 脚本也是如此。可以用哈希标签(hash tag)让相关的键落到同一个槽:只有 {} 中的部分参与计算,{user:1001}:cart 和 {user:1001}:orders 都在槽 5712,但大量键共用同一个哈希标签时会集中到同一个槽,造成数据倾斜;单个热 Key 的写请求仍集中在一个主节点上,增加分片分散不了,读请求可以由从节点分担(可能读到旧数据),处理方法见 [大 Key 与热 Key](缓存.md#大-key-与热-key);
|
||||
- 主节点宕机后,它的一个从节点会被选为新的主节点。cluster-node-timeout 为 5 秒时,停掉一个主节点后约 7~9 秒才恢复写入。主节点被判定下线后、从节点接替之前,整个集群都返回 CLUSTERDOWN,因为 cluster-require-full-coverage 默认为 yes,有槽没有节点负责时所有节点都停止服务,设为 no 后其它槽可以继续读写。
|
||||
|
||||
Redis Cluster 不需要哨兵,节点之间通过集群总线(端口号加 10000)定期互发 PING、PONG,消息中带着自己负责的槽和所知道的其它节点的状态(Gossip 协议),由此完成故障检测和选举。以停掉 7002 为例:
|
||||
Redis Cluster 不需要哨兵,节点之间通过集群总线(默认是端口号加 10000)定期互发 PING、PONG,消息中带着自己负责的槽,以及随机挑选的几个其它节点的状态(Gossip 协议),由此完成故障检测和选举。以停掉 7002 为例:
|
||||
|
||||
1. 其它节点超过 cluster-node-timeout 没有收到 7002 的回复,各自把它标记为 PFAIL(疑似下线);
|
||||
2. 某个节点通过 Gossip 得知多数主节点都认为 7002 疑似下线,把它标记为 FAIL 并广播;
|
||||
@@ -784,7 +784,7 @@ Redis 没有关系型数据库中的表这一概念来将同种类型的数据
|
||||
|
||||
当有用户为一篇文章点赞时,除了要对该文章的 votes 字段进行加 1 操作,还必须记录该用户已经对该文章进行了点赞,防止用户点赞次数超过 1。可以建立文章的已投票用户集合来进行记录。
|
||||
|
||||
为了节约内存,规定一篇文章发布满一周之后,就不能再对它进行投票,文章的已投票集合也随之删除:发布文章时为已投票集合设置一周的过期时间,到期由 Redis 自动删除。集合被删除后 SADD 会重新创建它,所以点赞前还要用 ZSCORE 检查发布时间。
|
||||
为了节约内存,规定一篇文章发布满一周之后,就不能再对它进行投票,文章的已投票集合也随之删除:发布文章时先把作者加入已投票集合(作者不计票),再为它设置一周的过期时间,到期由 Redis 自动删除。这是因为 Redis 中没有空集合,对还不存在的键执行 EXPIRE 不会生效,之后 SADD 创建的集合就没有过期时间。集合被删除后 SADD 会重新创建它,所以点赞前还要用 ZSCORE 从发布时间的有序集合 time: 中查出发布时间(见[对文章进行排序](#对文章进行排序))。
|
||||
|
||||
<div align="center"> <img src="pics/redis-article-vote.png" width="760px"/> </div><br>
|
||||
|
||||
@@ -854,7 +854,7 @@ pipe.execute()
|
||||
|
||||
```text
|
||||
[('article:1003', 9808206999400.0), ('article:1001', 5208207000000.0), ('article:1002', 5208206999700.0)]
|
||||
100 万成员内存 104.7 MB
|
||||
100 万成员内存 104.7 MiB
|
||||
OBJECT ENCODING rank:big -> skiplist
|
||||
SLOWLOG 中的执行时间(微秒)
|
||||
zrevrange [5, 3, 2, 3, 4]
|
||||
@@ -881,7 +881,7 @@ GET: 1618123.00 requests per second, p50=0.415 msec
|
||||
|
||||
### A4 Redis Cluster
|
||||
|
||||
6 个节点 7001~7006 都以 --cluster-enabled yes --cluster-node-timeout 5000 启动,然后创建 3 主 3 从的集群:
|
||||
6 个节点 7001~7006 各自在单独的目录中以 --cluster-enabled yes --cluster-node-timeout 5000 启动(集群配置文件默认是当前目录下的 nodes.conf,不能共用),然后创建 3 主 3 从的集群:
|
||||
|
||||
```bash
|
||||
redis-cli --cluster create 127.0.0.1:7001 127.0.0.1:7002 127.0.0.1:7003 \
|
||||
@@ -909,7 +909,7 @@ OK
|
||||
CROSSSLOT Keys in request don't hash to the same slot
|
||||
```
|
||||
|
||||
然后 kill -9 7002,每 100 毫秒向它的从节点写一次 user:1001,直到返回 OK。下面是第 3 次实验的输出,3 次实验分别在 7.1、8.7、8.8 秒后恢复写入:
|
||||
然后 kill -9 7002,每 100 毫秒向它的从节点执行一次 SET user:1001 bob,直到返回 OK。下面是第 3 次实验的输出,3 次实验分别在 7.1、8.7、8.8 秒后恢复写入:
|
||||
|
||||
```text
|
||||
== 7002 的从节点:7006
|
||||
@@ -1037,7 +1037,7 @@ Redis 7.4.1,向一个 HLL 写入 n 个不同的字符串 user:0~user:{n −
|
||||
1000 个不同元素:PFCOUNT 1007,误差 +0.70%,STRLEN 1910,MEMORY USAGE 2616
|
||||
100000 个不同元素:PFCOUNT 99471,误差 -0.53%,STRLEN 12304,MEMORY USAGE 12856
|
||||
1000000 个不同元素:PFCOUNT 999674,误差 -0.03%,STRLEN 12304,MEMORY USAGE 12856
|
||||
同样 100 万个 user:i 用 SET 保存:used_memory 增加 30080144
|
||||
同样 100 万个 user:i 用 SADD 写入一个 SET:used_memory 增加 30080144
|
||||
```
|
||||
|
||||
元素少时 STRLEN 为 1910 字节,是稀疏编码;稀疏编码超过 hll-sparse-max-bytes(默认 3000 字节)时转为密集编码,逐个写入 u1、u2……时在第 1689 个元素发生转换,之后是 12288 字节的寄存器加 16 字节的头部。再写入 30 组、每组 100 万个不同的字符串:
|
||||
@@ -1079,6 +1079,7 @@ shop:2
|
||||
```python
|
||||
r.execute_command('DEBUG', 'SET-ACTIVE-EXPIRE', 0)
|
||||
for i in range(100000): pipe.set(f'session:{i}', 'x', px=1000)
|
||||
pipe.execute()
|
||||
time.sleep(2)
|
||||
print(stat()); print(r.get('session:7')); print(stat()) # stat() 返回 keys、expires 和 expired_keys
|
||||
r.execute_command('DEBUG', 'SET-ACTIVE-EXPIRE', 1) # 每 5 毫秒查询一次,直到 keys 为 0
|
||||
@@ -1342,6 +1343,8 @@ Background saving started
|
||||
rdb_last_bgsave_status:err
|
||||
> SET k v
|
||||
(error) MISCONF Redis is configured to save RDB snapshots, but it's currently unable to persist to disk. ...
|
||||
> GET pv
|
||||
"1"
|
||||
(恢复目录权限后再执行 BGSAVE)
|
||||
> SET k v
|
||||
OK
|
||||
@@ -1367,7 +1370,7 @@ maxmemory 默认 = 0
|
||||
- [REDIS IN ACTION](https://web.archive.org/web/20210421115011/https://redislabs.com/ebook/foreword/)
|
||||
- [Skip Lists: Done Right](https://ticki.github.io/blog/skip-lists-done-right/)
|
||||
- [论述 Redis 和 Memcached 的差异](http://www.cnblogs.com/loveincode/p/7411911.html)
|
||||
- [Redis 3.0 中文版- 分片](http://wiki.jikexueyuan.com/project/redis-guide)
|
||||
- [Redis 3.0 中文版- 分片](https://web.archive.org/web/20220701192148/https://wiki.jikexueyuan.com/project/redis-guide/)
|
||||
- [Redis 应用场景](http://www.scienjus.com/redis-use-case/)
|
||||
- [Key eviction | Redis](https://redis.io/docs/latest/develop/reference/eviction/)
|
||||
- [EXPIRE | Redis](https://redis.io/docs/latest/commands/expire/)
|
||||
@@ -1384,8 +1387,8 @@ maxmemory 默认 = 0
|
||||
- [WAITAOF | Redis](https://redis.io/docs/latest/commands/waitaof/)
|
||||
- [Redis replication](https://redis.io/docs/latest/operate/oss_and_stack/management/replication/)
|
||||
- [Redis persistence](https://redis.io/docs/latest/operate/oss_and_stack/management/persistence/)
|
||||
- [Transactions | Redis](https://redis.io/docs/latest/develop/interact/transactions/)
|
||||
- [Scripting with Lua | Redis](https://redis.io/docs/latest/develop/interact/programmability/eval-intro/)
|
||||
- [Transactions | Redis](https://redis.io/docs/latest/develop/using-commands/transactions/)
|
||||
- [Scripting with Lua | Redis](https://redis.io/docs/latest/develop/programmability/eval-intro/)
|
||||
- [Redis 7.4.1 源码 dict.c](https://github.com/redis/redis/blob/7.4.1/src/dict.c)
|
||||
- [Redis 7.4.1 源码 t_zset.c](https://github.com/redis/redis/blob/7.4.1/src/t_zset.c)
|
||||
- [Redis 7.4.1 源码 sds.c](https://github.com/redis/redis/blob/7.4.1/src/sds.c)
|
||||
|
||||
Reference in New Issue
Block a user