[docs update]redis 数据结构完善

2025-06-16 18:10:13 +08:00 · 2022-07-18 18:43:07 +08:00 · 2022-07-18 18:43:07 +08:00 · eaf56cbe49
commit eaf56cbe49
parent a600b8d8ca
2 changed files with 504 additions and 296 deletions
--- a/docs/database/redis/redis-data-structures.md
+++ b/docs/database/redis/redis-data-structures.md
@ -0,0 +1,504 @@
 你可以自己本机安装 redis 或者通过 redis 官网提供的[在线 redis 环境](https://try.redis.io/)来实际体验 Redis。
 ![try-redis](./images/redis-all/try-redis.png)
 你可以在 Redis 官网上找到 Redis 数据结构非常详细的介绍：[Redis Data Structures](https://redis.com/redis-enterprise/data-structures/) 。未来随着 Redis 新版本的发布，可能会有新的数据结构出现，通过查阅 Redis 官网对应的介绍，你总能获取到最靠谱的信息。
 ## 基本数据结构
 ### String（字符串）
 #### 介绍
 String 是 Redis 中最简单同时也是最常用的一个数据结构。它是一种二进制安全的数据结构，可以用来存储任何类型的数据比如字符串、整数、浮点数、图片（图片的 base64 编码或者解码或者图片的路径）、序列化后的对象。
 ![](https://redis.com/wp-content/uploads/2019/07/data-structures-_strings.svg?&auto=webp&quality=85,75&width=800)
 虽然 Redis 是用 C 语言写的，但是 Redis 并没有使用 C 的字符串表示，而是自己构建了一种 **简单动态字符串**（simple dynamic string，**SDS**）。相比于 C 的原生字符串，Redis 的 SDS 不光可以保存文本数据还可以保存二进制数据，并且获取字符串长度复杂度为 O(1)（C 字符串为 O(N)）,除此之外，Redis 的 SDS API 是安全的，不会造成缓冲区溢出。
 #### 常用命令
 | 命令                           | 介绍                             |
 | ------------------------------ | -------------------------------- |
 | SET key value                  | 设置指定 key 的值                |
 | SETNX key value                | 只有在 key 不存在时设置 key 的值 |
 | GET key                        | 获取指定 key 的值                |
 | MSET key1 value1 key2 value2 … | 设置一个或多个指定 key 的值      |
 | MGET key1 key2 ...             | 获取一个或多个指定 key 的值      |
 | STRLEN key                     | 返回 key 所储存的字符串值的长度  |
 | INCR key                       | 将 key 中储存的数字值增一        |
 | DECR key                       | 将 key 中储存的数字值减一        |
 | EXISTS key                     | 判断指定 key 是否存在            |
 | DEL key（通用）                | 删除指定的 key                   |
 | EXPIRE key seconds（通用）     | 给指定 key 设置过期时间          |
 更多 Redis String 命令以及详细使用指南，请查看 Redis 官网对应的介绍：https://redis.io/commands/?group=string 。
 **基本操作** ：
 ```bash
 > SET key value
 OK
 > GET key
 "value"
 > EXISTS key
 (integer) 1
 > STRLEN key
 (integer) 5
 > DEL key
 (integer) 1
 > GET key
 (nil)
 ```
 **批量设置** ：
 ```bash
 > MSET key1 value1 key2 value2
 OK
 > MGET key1 key2 # 批量获取多个 key 对应的 value
 1) "value1"
 2) "value2"
 ```
 **计数器（字符串的内容为整数的时候可以使用）：**
 ```bash
 > SET number 1
 OK
 > INCR number # 将 key 中储存的数字值增一
 (integer) 2
 > GET number
 "2"
 > DECR number # 将 key 中储存的数字值减一
 (integer) 1
 > GET number
 "1"
 ```
 **设置过期时间（默认为永不过期）**：
 ```bash
 > EXPIRE key 60
 (integer) 1
 > SETNX key 60 value # 设置值并设置过期时间
 OK
 > TTL key
 (integer) 56
 ```
 #### 应用场景
 **需要计数的场景**
 比如用户的访问次数、热点文章的点赞转发数量等等。
 ### List（列表）
 #### 介绍
 Redis 中的 List 其实就是链表数据结构的实现。我在 [线性数据结构 :数组、链表、栈、队列](https://javaguide.cn/cs-basics/data-structure/linear-data-structure.html) 这篇文章中详细介绍了链表这种数据结构，我这里就不多做介绍了。
 许多高级编程语言都内置了链表的实现比如 Java 中的 `LinkedList`，但是 C 语言并没有实现链表，所以 Redis 实现了自己的链表数据结构。Redis 的 List 的实现为一个 **双向链表**，即可以支持反向查找和遍历，更方便操作，不过带来了部分额外的内存开销。
 ![img](https://redis.com/wp-content/uploads/2019/07/data-structures-_lists.svg?&auto=webp&quality=85,75&width=500)
 #### 常用命令
 | 命令                        | 介绍                                       |
 | --------------------------- | ------------------------------------------ |
 | RPUSH key value1 value2 ... | 在指定列表的尾部（右边）添加一个或多个元素 |
 | LPUSH key value1 value2 ... | 在指定列表的头部（左边）添加一个或多个元素 |
 | LSET key index value        | 将指定列表索引 index 位置的值设置为 value  |
 | LPOP key                    | 移除并获取指定列表的第一个元素(最左边)     |
 | RPOP key                    | 移除并获取指定列表的最后一个元素(最右边)   |
 | LLEN key                    | 获取列表元素数量                           |
 | LRANGE key start end        | 获取列表 start 和 end 之间 的元素          |
 更多 Redis List 命令以及详细使用指南，请查看 Redis 官网对应的介绍：https://redis.io/commands/?group=list 。
 **通过 `RPUSH/LPOP` 实现队列** ：
 ```bash
 > RPUSH myList value1
 (integer) 1
 > RPUSH myList value2 value3
 (integer) 3
 > LPOP myList
 "value1"
 > LRANGE myList 0 1
 1) "value2"
 2) "value3"
 > LRANGE myList 0 -1
 1) "value2"
 2) "value3"
 ```
 **通过 `RPUSH/RPOP` 实现栈：**
 ```bash
 > RPUSH myList2 value1 value2 value3
 (integer) 3
 > RPOP myList2 # 将 list的头部(最右边)元素取出
 "value3"
 ```
 我专门画了一个图方便大家理解 `RPUSH` , `LPOP` , `lpush` , `RPOP` 命令：
 ![redis list](./images/redis-all/redis-list.png)
 **通过 `LRANGE` 查看对应下标范围的列表元素** ：
 ```bash
 > RPUSH myList value1 value2 value3
 (integer) 3
 > LRANGE myList 0 1
 1) "value1"
 2) "value2"
 > LRANGE myList 0 -1
 1) "value1"
 2) "value2"
 3) "value3"
 ```
 通过 `LRANGE` 命令，你可以基于 List 实现分页查询，性能非常高！
 **通过 `LLEN` 查看链表长度** ：
 ```bash
 > LLEN myList
 (integer) 3
 ```
 #### 应用场景
 **Timeline 信息流展示**
 Timeline 信息流中内存都是按照时间来排序，比较典型的产品有微信朋友圈、QQ 空间、微博关注者动态、Twitter 最新推文。
 像这种场景，Redis List 就非常适合用来作为存储数据结构了。
 **消息队列**
 Redis List 数据结构可以用来做消息队列，只是功能过于简单，不建议这样做。
 相对来说，Redis 5.0 新增加的一个数据结构 `Stream` 更适合做消息队列一些，只是功能依然非常简陋。和专业的消息队列相比，还是有很多欠缺的地方比如消息丢失和堆积问题不好解决。
 ### Hash（哈希）
 #### 介绍
 Hash 是一个 String 类型的 field 和 value 的映射表，特别适合用于存储对象，后续操作的时候，你可以直接仅仅修改这个对象中的某个字段的值。
 Hash 类似于 JDK1.8 前的 `HashMap`，内部实现也差不多(数组 + 链表)。不过，Redis 的 Hash 做了更多优化。
 ![](https://redis.com/wp-content/uploads/2019/07/data-structures-_hashes.svg?&auto=webp&quality=85,75&width=800)
 #### 常用命令
 | 命令                                      | 介绍                                                     |
 | ----------------------------------------- | -------------------------------------------------------- |
 | HSET key field value                      | 设置指定哈希表中指定字段的值                             |
 | HSETNX key field value                    | 只有指定字段不存在时设置指定字段的值                     |
 | HMSET key field1 value1 field2 value2 ... | 同时将一个或多个 field-value (域-值)对设置到指定哈希表中 |
 | HGET key field                            | 获取指定哈希表中指定字段的值                             |
 | HMGET key field1 field2                   | 获取指定哈希表中一个或者多个指定字段的值                 |
 | HGETALL key                               | 获取指定哈希表中所有的键值对                             |
 | HEXISTS key field                         | 查看指定哈希表中指定的字段是否存在                       |
 | HDEL key field1 field2 ...                | 删除一个或多个哈希表字段                                 |
 | HLEN key                                  | 获取指定哈希表中字段的数量                               |
 更多 Redis Hash 命令以及详细使用指南，请查看 Redis 官网对应的介绍：https://redis.io/commands/?group=hash 。
 **模拟对象数据存储** ：
 ```bash
 > HMSET userInfoKey name "guide" description "dev" age "24"
 OK
 > HEXISTS userInfoKey name # 查看 key 对应的 value中指定的字段是否存在。
 (integer) 1
 > HGET userInfoKey name # 获取存储在哈希表中指定字段的值。
 "guide"
 > HGET userInfoKey age
 "24"
 > HGETALL userInfoKey # 获取在哈希表中指定 key 的所有字段和值
 1) "name"
 2) "guide"
 3) "description"
 4) "dev"
 5) "age"
 6) "24"
 > HSET userInfoKey name "GuideGeGe"
 > HGET userInfoKey name
 "GuideGeGe"
 ```
 #### 应用场景
 对象数据的存储。
 ### Set（集合）
 #### 介绍
 Redis 中的 Set 类型是一种无序集合，集合中的元素没有先后顺序但都唯一，有点类似于Java 中的 `HashSet` 。当你需要存储一个列表数据，又不希望出现重复数据时，Set 是一个很好的选择，并且 Set 提供了判断某个元素是否在一个 Set 集合内的重要接口，这个也是 List 所不能提供的。
 你可以基于 Set 轻易实现交集、并集、差集的操作，比如你可以将一个用户所有的关注人存在一个集合中，将其所有粉丝存在一个集合。这样的话，Set 可以非常方便的实现如共同关注、共同粉丝、共同喜好等功能。这个过程也就是求交集的过程。 
 ![](https://redis.com/wp-content/uploads/2019/07/data-structures-_sets.svg?&auto=webp&quality=85,75&width=800)
 #### 常用命令
 | 命令                                  | 介绍                                      |
 | ------------------------------------- | ----------------------------------------- |
 | SADD key member1 member2 ...          | 向指定集合添加一个或多个元素              |
 | SMEMBERS key                          | 获取指定集合中的所有元素                  |
 | SCARD key                             | 获取指定集合的元素数量                    |
 | SISMEMBER key member                  | 判断指定元素是否在指定集合中              |
 | SINTER key1 key2 ...                  | 获取给定所有集合的交集                    |
 | SINTERSTORE destination key1 key2 ... | 将给定所有集合的交集存储在 destination 中 |
 | SUNION key1 key2 ...                  | 获取给定所有集合的并集                    |
 | SUNIONSTORE destination key1 key2 ... | 将给定所有集合的并集存储在 destination 中 |
 | SDIFF key1 key2 ...                   | 获取给定所有集合的差集                    |
 | SDIFFSTORE destination key1 key2 ...  | 将给定所有集合的差集存储在 destination 中 |
 更多 Redis Set 命令以及详细使用指南，请查看 Redis 官网对应的介绍：https://redis.io/commands/?group=set 。
 **基本操作** ：
 ```bash
 > SADD mySet value1 value2
 (integer) 2
 > SADD mySet value1 # 不允许有重复元素，因此添加失败
 (integer) 0
 > SMEMBERS mySet
 1) "value1"
 2) "value2"
 > SCARD mySet
 (integer) 2
 > SISMEMBER mySet value1
 (integer) 1
 > SADD mySet2 value2 value3
 (integer) 2
 ```
 - `mySet` : `value1`、`value2` 。
 - `mySet2 ` ： `value2` 、`value3` 。
 **求交集** ：
 ```bash
 > SINTERSTORE mySet3 mySet mySet2
 (integer) 1
 > SMEMBERS mySet3
 1) "value2"
 ```
 **求并集** ：
 ```bash
 > SUNION mySet mySet2
 1) "value3"
 2) "value2"
 3) "value1"
 ```
 **求差集** ：
 ```bash
 > SDIFF mySet mySet2 # 差集是由所有属于 mySet 但不属于 A 的元素组成的集合
 1) "value1"
 ```
 #### 应用场景
 当我们需要存放的数据不能重复，并且需要获取多个数据源交集、并集和差集的时候（比如共同好友） Set 就非常适合。
 ### Sorted Set（有序集合）
 #### 介绍
 Sorted Set 类似于 Set，但和 Set 相比，Sorted Set 增加了一个权重参数 `score`，使得集合中的元素能够按 `score` 进行有序排列，还可以通过 `score` 的范围来获取元素的列表。有点像是 Java 中 `HashMap` 和 `TreeSet` 的结合体。
 ![](https://redis.com/wp-content/uploads/2019/07/data-structures-_sorted-sets.svg?&auto=webp&quality=85,75&width=500)
 #### 常用命令
 | 命令                                          | 介绍                                                         |
 | --------------------------------------------- | ------------------------------------------------------------ |
 | ZADD key score1 member1  score2 member2  ...  | 向指定有序集合添加一个或多个元素                             |
 | ZCARD KEY                                     | 获取指定有序集合的元素数量                                   |
 | ZSCORE key member                             | 获取指定有序集合中指定元素的 score 值                        |
 | ZINTERSTORE destination numkeys key1 key2 ... | 将给定所有有序集合的交集存储在 destination 中，对相同元素对应的 score 值进行 SUM 聚合操作，numkeys 为集合数量 |
 | ZUNIONSTORE destination numkeys key1 key2 ... | 求并集，其它和 ZINTERSTORE 类似                              |
 | ZDIFF  destination numkeys key1 key2 ...      | 求差集，其它和 ZINTERSTORE 类似                              |
 | ZRANGE key start end                          | 获取指定有序集合 start 和 end 之间的元素                     |
 | ZREVRANGE key start end                       | 获取指定有序集合 start 和 end 之间的元素（score从高到底）    |
 | ZREVRANK key member                           | 获取指定有序集合中指定元素的排名(score 从大到小排序)         |
 更多 Redis Sorted Set 命令以及详细使用指南，请查看 Redis 官网对应的介绍：https://redis.io/commands/?group=sorted-set 。
 **基本操作** ：
 ```bash
 > ZADD myZset 2.0 value1 1.0 value2
 (integer) 2
 > ZCARD myZset
 2
 > ZSCORE myZset value1
 2.0
 > ZRANGE myZset 0 1
 1) "value2"
 2) "value1"
 > ZREVRANGE myZset 0 1
 1) "value1"
 2) "value2"
 > ZADD myZset2 4.0 value2 3.0 value3
 (integer) 2
 ```
 - `myZset` : `value1`(2.0)、`value2`(1.0) 。
 - ` myZset2 ` ： `value2` （4.0）、`value3`(3.0) 。
 **获取指定元素的排名** ：
 ```bash
 > ZREVRANK myZset value1
 0
 > ZREVRANK myZset value2
 1
 ```
 **求交集** ：
 ```bash
 > ZINTERSTORE myZset3 2 myZset myZset2
 1
 > ZRANGE myZset3 0 1 WITHSCORES
 value2
 5
 ```
 **求并集** ：
 ```bash
 > ZUNIONSTORE myZset4 2 myZset myZset2
 3
 > ZRANGE myZset4 0 2 WITHSCORES
 value1
 2
 value3
 3
 value2
 5
 ```
 **求差集** ：
 ```bash
 > ZDIFF 2 myZset myZset2 WITHSCORES
 value1
 2
 ```
 #### 应用场景
 需要对数据根据某个权重进行排序的场景。比如在直播系统中，实时排行信息包含直播间在线用户列表，各种礼物排行榜，弹幕消息（可以理解为按消息维度的消息排行榜）等信息。
 ## 特殊数据结构
 ### sorted set
 ### bitmap
 1. **介绍：** bitmap 存储的是连续的二进制数字（0 和 1），通过 bitmap, 只需要一个 bit 位来表示某个元素对应的值或者状态，key 就是对应元素本身 。我们知道 8 个 bit 可以组成一个 byte，所以 bitmap 本身会极大的节省储存空间。
 2. **常用命令：** `setbit` 、`getbit` 、`bitcount`、`bitop`
 3. **应用场景：** 适合需要保存状态信息（比如是否签到、是否登录...）并需要进一步对这些信息进行分析的场景。比如用户签到情况、活跃用户情况、用户行为统计（比如是否点赞过某个视频）。
 ```bash
 # SETBIT 会返回之前位的值（默认是 0）这里会生成 7 个位
 > setbit mykey 7 1
 (integer) 0
 > setbit mykey 7 0
 (integer) 1
 > getbit mykey 7
 (integer) 0
 > setbit mykey 6 1
 (integer) 0
 > setbit mykey 8 1
 (integer) 0
 # 通过 bitcount 统计被被设置为 1 的位的数量。
 > bitcount mykey
 (integer) 2
 ```
 针对上面提到的一些场景，这里进行进一步说明。
 **使用场景一：用户行为分析**
 很多网站为了分析你的喜好，需要研究你点赞过的内容。
 ```bash
 # 记录你喜欢过 001 号小姐姐
 > setbit beauty_girl_001 uid 1
 ```
 **使用场景二：统计活跃用户**
 使用时间作为 key，然后用户 ID 为 offset，如果当日活跃过就设置为 1
 那么我该如何计算某几天/月/年的活跃用户呢(暂且约定，统计时间内只要有一天在线就称为活跃)，有请下一个 redis 的命令
 ```bash
 # 对一个或多个保存二进制位的字符串 key 进行位元操作，并将结果保存到 destkey 上。
 # BITOP 命令支持 AND 、 OR 、 NOT 、 XOR 这四种操作中的任意一种参数
 BITOP operation destkey key [key ...]
 ```
 初始化数据：
 ```bash
 > setbit 20210308 1 1
 (integer) 0
 > setbit 20210308 2 1
 (integer) 0
 > setbit 20210309 1 1
 (integer) 0
 ```
 统计 20210308~20210309 总活跃用户数: 1
 ```bash
 > bitop and desk1 20210308 20210309
 (integer) 1
 > bitcount desk1
 (integer) 1
 ```
 统计 20210308~20210309 在线活跃用户数: 2
 ```bash
 > bitop or desk2 20210308 20210309
 (integer) 1
 > bitcount desk2
 (integer) 2
 ```
 **使用场景三：用户在线状态**
 对于获取或者统计用户在线状态，使用 bitmap 是一个节约空间且效率又高的一种方法。
 只需要一个 key，然后用户 ID 为 offset，如果在线就设置为 1，不在线就设置为 0。
 ## 参考
 - Redis Data Structures ：https://redis.com/redis-enterprise/data-structures/ 。
 - Redis Commands ： https://redis.io/commands/ 。
--- a/docs/database/redis/redis-questions-01.md
+++ b/docs/database/redis/redis-questions-01.md
@ -113,303 +113,7 @@ Redis 5.0 新增加的一个数据结构 `Stream` 可以用来做消息队列，
 ## Redis 常见数据结构
 你可以自己本机安装 redis 或者通过 redis 官网提供的[在线 redis 环境](https://try.redis.io/)。
 ![try-redis](./images/redis-all/try-redis.png)
 ### string
 1. **介绍** ：string 数据结构是简单的 key-value 类型。虽然 Redis 是用 C 语言写的，但是 Redis 并没有使用 C 的字符串表示，而是自己构建了一种 **简单动态字符串**（simple dynamic string，**SDS**）。相比于 C 的原生字符串，Redis 的 SDS 不光可以保存文本数据还可以保存二进制数据，并且获取字符串长度复杂度为 O(1)（C 字符串为 O(N)）,除此之外，Redis 的 SDS API 是安全的，不会造成缓冲区溢出。
 2. **常用命令：** `set,get,strlen,exists,decr,incr,setex` 等等。
 3. **应用场景：** 一般常用在需要计数的场景，比如用户的访问次数、热点文章的点赞转发数量等等。
 下面我们简单看看它的使用！
 **普通字符串的基本操作：**
 ```bash
 127.0.0.1:6379> set key value #设置 key-value 类型的值
 OK
 127.0.0.1:6379> get key # 根据 key 获得对应的 value
 "value"
 127.0.0.1:6379> exists key  # 判断某个 key 是否存在
 (integer) 1
 127.0.0.1:6379> strlen key # 返回 key 所储存的字符串值的长度。
 (integer) 5
 127.0.0.1:6379> del key # 删除某个 key 对应的值
 (integer) 1
 127.0.0.1:6379> get key
 (nil)
 ```
 **批量设置** :
 ```bash
 127.0.0.1:6379> mset key1 value1 key2 value2 # 批量设置 key-value 类型的值
 OK
 127.0.0.1:6379> mget key1 key2 # 批量获取多个 key 对应的 value
 1) "value1"
 2) "value2"
 ```
 **计数器（字符串的内容为整数的时候可以使用）：**
 ```bash
 127.0.0.1:6379> set number 1
 OK
 127.0.0.1:6379> incr number # 将 key 中储存的数字值增一
 (integer) 2
 127.0.0.1:6379> get number
 "2"
 127.0.0.1:6379> decr number # 将 key 中储存的数字值减一
 (integer) 1
 127.0.0.1:6379> get number
 "1"
 ```
 **过期（默认为永不过期）**：
 ```bash
 127.0.0.1:6379> expire key  60 # 数据在 60s 后过期
 (integer) 1
 127.0.0.1:6379> setex key 60 value # 数据在 60s 后过期 (setex:[set] + [ex]pire)
 OK
 127.0.0.1:6379> ttl key # 查看数据还有多久过期
 (integer) 56
 ```
 ### list
 1. **介绍** ：**list** 即是 **链表**。链表是一种非常常见的数据结构，特点是易于数据元素的插入和删除并且可以灵活调整链表长度，但是链表的随机访问困难。许多高级编程语言都内置了链表的实现比如 Java 中的 **LinkedList**，但是 C 语言并没有实现链表，所以 Redis 实现了自己的链表数据结构。Redis 的 list 的实现为一个 **双向链表**，即可以支持反向查找和遍历，更方便操作，不过带来了部分额外的内存开销。
 2. **常用命令:** `rpush,lpop,lpush,rpop,lrange,llen` 等。
 3. **应用场景:** 发布与订阅或者说消息队列、慢查询。
 下面我们简单看看它的使用！
 **通过 `rpush/lpop` 实现队列：**
 ```bash
 127.0.0.1:6379> rpush myList value1 # 向 list 的头部（右边）添加元素
 (integer) 1
 127.0.0.1:6379> rpush myList value2 value3 # 向list的头部（最右边）添加多个元素
 (integer) 3
 127.0.0.1:6379> lpop myList # 将 list的尾部(最左边)元素取出
 "value1"
 127.0.0.1:6379> lrange myList 0 1 # 查看对应下标的list列表， 0 为 start,1为 end
 1) "value2"
 2) "value3"
 127.0.0.1:6379> lrange myList 0 -1 # 查看列表中的所有元素，-1表示倒数第一
 1) "value2"
 2) "value3"
 ```
 **通过 `rpush/rpop` 实现栈：**
 ```bash
 127.0.0.1:6379> rpush myList2 value1 value2 value3
 (integer) 3
 127.0.0.1:6379> rpop myList2 # 将 list的头部(最右边)元素取出
 "value3"
 ```
 我专门画了一个图方便小伙伴们来理解：
 ![redis list](./images/redis-all/redis-list.png)
 **通过 `lrange` 查看对应下标范围的列表元素：**
 ```bash
 127.0.0.1:6379> rpush myList value1 value2 value3
 (integer) 3
 127.0.0.1:6379> lrange myList 0 1 # 查看对应下标的list列表， 0 为 start,1为 end
 1) "value1"
 2) "value2"
 127.0.0.1:6379> lrange myList 0 -1 # 查看列表中的所有元素，-1表示倒数第一
 1) "value1"
 2) "value2"
 3) "value3"
 ```
 通过 `lrange` 命令，你可以基于 list 实现分页查询，性能非常高！
 **通过 `llen` 查看链表长度：**
 ```bash
 127.0.0.1:6379> llen myList
 (integer) 3
 ```
 ### hash
 1. **介绍** ：hash 类似于 JDK1.8 前的 HashMap，内部实现也差不多(数组 + 链表)。不过，Redis 的 hash 做了更多优化。另外，hash 是一个 string 类型的 field 和 value 的映射表，**特别适合用于存储对象**，后续操作的时候，你可以直接仅仅修改这个对象中的某个字段的值。 比如我们可以 hash 数据结构来存储用户信息，商品信息等等。
 2. **常用命令：** `hset,hmset,hexists,hget,hgetall,hkeys,hvals` 等。
 3. **应用场景:** 系统中对象数据的存储。
 下面我们简单看看它的使用！
 ```bash
 127.0.0.1:6379> hmset userInfoKey name "guide" description "dev" age "24"
 OK
 127.0.0.1:6379> hexists userInfoKey name # 查看 key 对应的 value中指定的字段是否存在。
 (integer) 1
 127.0.0.1:6379> hget userInfoKey name # 获取存储在哈希表中指定字段的值。
 "guide"
 127.0.0.1:6379> hget userInfoKey age
 "24"
 127.0.0.1:6379> hgetall userInfoKey # 获取在哈希表中指定 key 的所有字段和值
 1) "name"
 2) "guide"
 3) "description"
 4) "dev"
 5) "age"
 6) "24"
 127.0.0.1:6379> hkeys userInfoKey # 获取 key 列表
 1) "name"
 2) "description"
 3) "age"
 127.0.0.1:6379> hvals userInfoKey # 获取 value 列表
 1) "guide"
 2) "dev"
 3) "24"
 127.0.0.1:6379> hset userInfoKey name "GuideGeGe" # 修改某个字段对应的值
 127.0.0.1:6379> hget userInfoKey name
 "GuideGeGe"
 ```
 ### set
 1. **介绍 ：** set 类似于 Java 中的 `HashSet` 。Redis 中的 set 类型是一种无序集合，集合中的元素没有先后顺序。当你需要存储一个列表数据，又不希望出现重复数据时，set 是一个很好的选择，并且 set 提供了判断某个成员是否在一个 set 集合内的重要接口，这个也是 list 所不能提供的。可以基于 set 轻易实现交集、并集、差集的操作。比如：你可以将一个用户所有的关注人存在一个集合中，将其所有粉丝存在一个集合。Redis 可以非常方便的实现如共同关注、共同粉丝、共同喜好等功能。这个过程也就是求交集的过程。
 2. **常用命令：** `sadd,spop,smembers,sismember,scard,sinterstore,sunion` 等。
 3. **应用场景:** 需要存放的数据不能重复以及需要获取多个数据源交集和并集等场景
 下面我们简单看看它的使用！
 ```bash
 127.0.0.1:6379> sadd mySet value1 value2 # 添加元素进去
 (integer) 2
 127.0.0.1:6379> sadd mySet value1 # 不允许有重复元素
 (integer) 0
 127.0.0.1:6379> smembers mySet # 查看 set 中所有的元素
 1) "value1"
 2) "value2"
 127.0.0.1:6379> scard mySet # 查看 set 的长度
 (integer) 2
 127.0.0.1:6379> sismember mySet value1 # 检查某个元素是否存在set 中，只能接收单个元素
 (integer) 1
 127.0.0.1:6379> sadd mySet2 value2 value3
 (integer) 2
 127.0.0.1:6379> sinterstore mySet3 mySet mySet2 # 获取 mySet 和 mySet2 的交集并存放在 mySet3 中
 (integer) 1
 127.0.0.1:6379> smembers mySet3
 1) "value2"
 ```
 ### sorted set
 1. **介绍：** 和 set 相比，sorted set 增加了一个权重参数 score，使得集合中的元素能够按 score 进行有序排列，还可以通过 score 的范围来获取元素的列表。有点像是 Java 中 HashMap 和 TreeSet 的结合体。
 2. **常用命令：** `zadd,zcard,zscore,zrange,zrevrange,zrem` 等。
 3. **应用场景：** 需要对数据根据某个权重进行排序的场景。比如在直播系统中，实时排行信息包含直播间在线用户列表，各种礼物排行榜，弹幕消息（可以理解为按消息维度的消息排行榜）等信息。
 ```bash
 127.0.0.1:6379> zadd myZset 3.0 value1 # 添加元素到 sorted set 中 3.0 为权重
 (integer) 1
 127.0.0.1:6379> zadd myZset 2.0 value2 1.0 value3 # 一次添加多个元素
 (integer) 2
 127.0.0.1:6379> zcard myZset # 查看 sorted set 中的元素数量
 (integer) 3
 127.0.0.1:6379> zscore myZset value1 # 查看某个 value 的权重
 "3"
 127.0.0.1:6379> zrange  myZset 0 -1 # 顺序输出某个范围区间的元素，0 -1 表示输出所有元素
 1) "value3"
 2) "value2"
 3) "value1"
 127.0.0.1:6379> zrange  myZset 0 1 # 顺序输出某个范围区间的元素，0 为 start  1 为 stop
 1) "value3"
 2) "value2"
 127.0.0.1:6379> zrevrange  myZset 0 1 # 逆序输出某个范围区间的元素，0 为 start  1 为 stop
 1) "value1"
 2) "value2"
 ```
 ### bitmap
 1. **介绍：** bitmap 存储的是连续的二进制数字（0 和 1），通过 bitmap, 只需要一个 bit 位来表示某个元素对应的值或者状态，key 就是对应元素本身 。我们知道 8 个 bit 可以组成一个 byte，所以 bitmap 本身会极大的节省储存空间。
 2. **常用命令：** `setbit` 、`getbit` 、`bitcount`、`bitop`
 3. **应用场景：** 适合需要保存状态信息（比如是否签到、是否登录...）并需要进一步对这些信息进行分析的场景。比如用户签到情况、活跃用户情况、用户行为统计（比如是否点赞过某个视频）。
 ```bash
 # SETBIT 会返回之前位的值（默认是 0）这里会生成 7 个位
 127.0.0.1:6379> setbit mykey 7 1
 (integer) 0
 127.0.0.1:6379> setbit mykey 7 0
 (integer) 1
 127.0.0.1:6379> getbit mykey 7
 (integer) 0
 127.0.0.1:6379> setbit mykey 6 1
 (integer) 0
 127.0.0.1:6379> setbit mykey 8 1
 (integer) 0
 # 通过 bitcount 统计被被设置为 1 的位的数量。
 127.0.0.1:6379> bitcount mykey
 (integer) 2
 ```
 针对上面提到的一些场景，这里进行进一步说明。
 **使用场景一：用户行为分析**
 很多网站为了分析你的喜好，需要研究你点赞过的内容。
 ```bash
 # 记录你喜欢过 001 号小姐姐
 127.0.0.1:6379> setbit beauty_girl_001 uid 1
 ```
 **使用场景二：统计活跃用户**
 使用时间作为 key，然后用户 ID 为 offset，如果当日活跃过就设置为 1
 那么我该如何计算某几天/月/年的活跃用户呢(暂且约定，统计时间内只要有一天在线就称为活跃)，有请下一个 redis 的命令
 ```bash
 # 对一个或多个保存二进制位的字符串 key 进行位元操作，并将结果保存到 destkey 上。
 # BITOP 命令支持 AND 、 OR 、 NOT 、 XOR 这四种操作中的任意一种参数
 BITOP operation destkey key [key ...]
 ```
 初始化数据：
 ```bash
 127.0.0.1:6379> setbit 20210308 1 1
 (integer) 0
 127.0.0.1:6379> setbit 20210308 2 1
 (integer) 0
 127.0.0.1:6379> setbit 20210309 1 1
 (integer) 0
 ```
 统计 20210308~20210309 总活跃用户数: 1
 ```bash
 127.0.0.1:6379> bitop and desk1 20210308 20210309
 (integer) 1
 127.0.0.1:6379> bitcount desk1
 (integer) 1
 ```
 统计 20210308~20210309 在线活跃用户数: 2
 ```bash
 127.0.0.1:6379> bitop or desk2 20210308 20210309
 (integer) 1
 127.0.0.1:6379> bitcount desk2
 (integer) 2
 ```
 **使用场景三：用户在线状态**
 对于获取或者统计用户在线状态，使用 bitmap 是一个节约空间且效率又高的一种方法。
 只需要一个 key，然后用户 ID 为 offset，如果在线就设置为 1，不在线就设置为 0。
 ## Redis 线程模型