声明：本文档内容来源于掘金社区钱文品前辈所做的《Redis深度历险：原理和应用实践》一书所作的笔记记录，侵删。

Redis可以用来做什么？

Redis：Remote Dictionnary Service 即远程字典服务

:::info

  1. 记录帖子的点赞数、评论数和点击数 (hash)。
  2. 记录用户的帖子 ID 列表 (排序)，便于快速显示用户的帖子列表 (zset)。
  3. 记录帖子的标题、摘要、作者和封面信息，用于列表页展示 (hash)。
  4. 记录帖子的点赞用户 ID 列表，评论 ID 列表，用于显示和去重计数 (zset)。
  5. 缓存近期热帖内容 (帖子内容空间占用比较大)，减少数据库压力 (hash)。
  6. 记录帖子的相关文章 ID，根据内容推荐相关帖子 (list)。
  7. 如果帖子 ID 是整数自增的，可以使用 Redis 来分配帖子 ID(计数器)。
  8. 收藏集和帖子之间的关系 (zset)。
  9. 记录热榜帖子 ID 列表，总热榜和分类热榜 (zset)。
  10. 缓存用户行为历史，进行恶意行为过滤 (zset,hash)。
    :::

    拓展

string（字符串）

字符串 string 是 Redis 最简单的数据结构。Redis 所有的数据结构都是以唯一的 key 字符串作为名称，然后通过这个唯一 key 值来获取相应的 value 数据。不同类型的数据结构的差异就在于 value 的结构不一样。

image.png

字符串结构使用非常广泛，一个常见的用途就是缓存用户信息。我们将用户信息结构体 使用 JSON 序列化成字符串，然后将序列化后的字符串塞进 Redis 来缓存。同样，取用户 信息会经过一次反序列化的过程。

image.png

Redis 的字符串是动态字符串，是可以修改的字符串，内部结构实现上类似于 Java 的 ArrayList，采用预分配冗余空间的方式来减少内存的频繁分配，如图中所示，内部为当前字 符串实际分配的空间 capacity 一般要高于实际字符串长度 len。当字符串长度小于 1M 时， 扩容都是加倍现有的空间，如果超过 1M，扩容时一次只会多扩 1M 的空间。需要注意的是 字符串最大长度为 512M。 

  1. 127.0.0.1:6379> set name codehole
  2. OK
  3. 127.0.0.1:6379> get name
  4. "codehole"
  5. 127.0.0.1:6379> exists name
  6. (integer) 1
  7. 127.0.0.1:6379> del name
  8. (integer) 1
  9. 127.0.0.1:6379> get name
  10. (nil)
  1. # 可以批量对多个字符串进行读写，节省网络耗时开销
  3. 127.0.0.1:6379> set name1 codehole
  4. OK
  5. 127.0.0.1:6379> set name2 holycoder
  6. OK
  7. 127.0.0.1:6379> mget name1 name2 name3
  8. 1) "codehole"
  9. 2) "holycoder"
  10. 3) "unknown"
  11. 127.0.0.1:6379> mset name1 boy name2 girl name3 unknown
  12. OK
  13. 127.0.0.1:6379> mget name1 name2 name3
  14. 1) "boy"
  15. 2) "girl"
  16. 3) "unknown"
  1. # 可以对 key 设置过期时间，到点自动删除，这个功能常用来控制缓存的失效时间。不过
  2. # 这个「自动删除」的机制是比较复杂的，如果你感兴趣，可以继续深入阅读此书第 26 节
  3. # 《朝生暮死——过期策略》
  5. 127.0.0.1:6379> set name codehole
  6. OK
  7. 127.0.0.1:6379> get name 
  8. "codehole"
  9. 127.0.0.1:6379> expire name 5 # 5s 后过期
  10. (integer) 1
  11. 127.0.0.1:6379> get name # wait for 5s
  12. "codehole"
  13. 127.0.0.1:6379> get name
  14. (nil)
  15. 127.0.0.1:6379> setex name 5 codehole # 5s 后过期，等价于 set+expire
  16. OK
  17. 127.0.0.1:6379> get name
  18. (nil)
  19. 127.0.0.1:6379> setnx name codehole # 如果 name 不存在就执行 set 创建
  20. (integer) 1
  21. 127.0.0.1:6379> get name
  22. "codehole"
  23. 127.0.0.1:6379> setnx name holycoder # 因为 name 已经存在，所以 set 创建不成功
  24. (integer) 0
  25. 127.0.0.1:6379> get name
  26. "codehole" 
  27. # 没有改变
  1. # 如果 value 值是一个整数，还可以对它进行自增操作。自增是有范围的，它的范围是
  2. # signed long 的最大最小值，超过了这个值，Redis 会报错。
  4. 127.0.0.1:6379> set age 30
  5. OK
  6. 127.0.0.1:6379> incr age
  7. (integer) 31
  8. 127.0.0.1:6379> incrby age 4
  9. (integer) 35
  10. 127.0.0.1:6379> incrby age -2
  11. (integer) 33
  12. 127.0.0.1:6379> set codehole 9223372036854775807
  13. OK
  14. 127.0.0.1:6379> incr codehole
  15. (error) ERR increment or decrement would overflow

字符串是由多个字节组成，每个字节又是由 8 个 bit 组成，如此便可以将一个字符串看 成很多 bit 的组合，这便是 bitmap「位图」数据结构，位图的具体使用会放到后面的章节来 讲。 关于字符串的内部结构实现，请阅读此书第 32 节《极度深寒——探索「字符串」内部》

list（列表）

Redis 的列表相当于 Java 语言里面的 LinkedList，注意它是链表而不是数组。这意味着 list 的插入和删除操作非常快，时间复杂度为 O(1)，但是索引定位很慢，时间复杂度为 O(n)，这点让人非常意外。 当列表弹出了最后一个元素之后，该数据结构自动被删除，内存被回收。 Redis 的列表结构常用来做异步队列使用。将需要延后处理的任务结构体序列化成字符 串塞进 Redis 的列表，另一个线程从这个列表中轮询数据进行处理。 

  1. 127.0.0.1:6379> rpush books python java golang 
  2. (integer) 3
  3. 127.0.0.1:6379> llen books
  4. (integer) 3
  5. 127.0.0.1:6379> lpop books
  6. "python"
  7. 127.0.0.1:6379> lpop books
  8. "java"
  9. 127.0.0.1:6379> lpop books
  10. "golang"
  11. 127.0.0.1:6379> lpop books
  12. (nil)
  1. 127.0.0.1:6379> rpush books python java golang 
  2. (integer) 3
  3. 127.0.0.1:6379> rpop books 
  4. "golang"
  5. 127.0.0.1:6379> rpop books 
  6. "java"
  7. 127.0.0.1:6379> rpop books 
  8. "python"
  9. 127.0.0.1:6379> rpop books 
  10. (nil)
  1. 127.0.0.1:6379> rpush books python java golang
  2. (integer) 3
  3. 127.0.0.1:6379> lindex books 1
  4. "java"
  5. 127.0.0.1:6379> lrange books 0 -1
  6. 1) "python"
  7. 2) "java"
  8. 3) "golang"
  9. 127.0.0.1:6379> ltrim books 1 -1
  10. OK
  11. 127.0.0.1:6379> lrange books 0 -1
  12. 1) "java"
  13. 2) "golang"
  14. 127.0.0.1:6379> ltrim books 1 0
  15. OK
  16. 127.0.0.1:6379> llen books
  17. (integer) 0

lindex 相当于 Java链表的 get(int index)方法，它需要对链表进行遍历，性能随着参数 index 增大而变差。 ltrim和字面上的含义不太一样，个人觉得它叫lretain(保留) 更合适一 些，因为 ltrim跟的两个参数 start_index和 end_index定义了一个区间，在这个区间内的值， ltrim要保留，区间之外统统砍掉。我们可以通过 ltrim来实现一个定长的链表，这一点非常有用。index可以为负数，index=-1 表示倒数第一个元素，同样 index=-2 表示倒数第二个元素。

快速列表

image.png

如果再深入一点，你会发现 Redis 底层存储的还不是一个简单的 linkedlist，而是称之为 快速链表 quicklist 的一个结构。 首先在列表元素较少的情况下会使用一块连续的内存存储，这个结构是 ziplist，也即是 压缩列表。它将所有的元素紧挨着一起存储，分配的是一块连续的内存。当数据量比较多的 时候才会改成 quicklist。因为普通的链表需要的附加指针空间太大，会比较浪费空间，而且 会加重内存的碎片化。比如这个列表里存的只是 int 类型的数据，结构上还需要两个额外的指针 prev 和 next 。所以 Redis 将链表和 ziplist 结合起来组成了 quicklist。也就是将多个 ziplist 使用双向指针串起来使用。这样既满足了快速的插入删除性能，又不会出现太大的空间冗余。 关于列表的内部结构实现，请阅读此书第 34 节《极度深寒 —— 探索「压缩列表」内 部》和第 35 节《极度深寒 —— 探索「快速列表」内部》

hash（字典）

Redis 的字典相当于 Java 语言里面的 HashMap，它是无序字典。内部实现结构上同 Java 的 HashMap 也是一致的，同样的数组 + 链表二维结构。第一维 hash 的数组位置碰撞时，就会将碰撞的元素使用链表串接起来。

image.png

不同的是，Redis 的字典的值只能是字符串，另外它们 rehash 的方式不一样，因为 Java 的 HashMap 在字典很大时，rehash 是个耗时的操作，需要一次性全部 rehash。Redis 为了高性能，不能堵塞服务，所以采用了渐进式 rehash 策略。

image.png

渐进式 rehash 会在 rehash 的同时，保留新旧两个 hash 结构，查询时会同时查询两个 hash 结构，然后在后续的定时任务中以及 hash 的子指令中，循序渐进地将旧 hash 的内容 一点点迁移到新的 hash 结构中。

当 hash 移除了最后一个元素之后，该数据结构自动被删除，内存被回收。 hash 结构也可以用来存储用户信息，不同于字符串一次性需要全部序列化整个对象， hash 可以对用户结构中的每个字段单独存储。这样当我们需要获取用户信息时可以进行部分 获取。而以整个字符串的形式去保存用户信息的话就只能一次性全部读取，这样就会比较浪 费网络流量。 hash 也有缺点，hash 结构的存储消耗要高于单个字符串，到底该使用 hash 还是字符 串，需要根据实际情况再三权衡。 

  1. # 命令行的字符串如果包含空格，要用引号括起来
  2. 127.0.0.1:6379> hset books java "think in java"
  3. (integer) 1
  4. 127.0.0.1:6379> hset books golang "concurrency in go"
  5. (integer) 1
  6. 127.0.0.1:6379> hset books python "python cookbook"
  7. (integer) 1
  8. 127.0.0.1:6379> hgetall books # entries(),key 和 value 间隔出现
  9. 1) "java"
  10. 2) "think in java"
  11. 3) "golang"
  12. 4) "concurrency in go"
  13. 5) "python"
  14. 6) "python cookbook"
  15. 127.0.0.1:6379> hlen books
  16. (integer) 3
  17. 127.0.0.1:6379> hget books java
  18. "think in java"
  19. 127.0.0.1:6379> hset books golang "learning go programming" # 因为是更新操作，所以返回0
  20. (integer) 0
  21. # 批量set
  22. 127.0.0.1:6379> hmset books java "effective java" python "learning python" golang "modern golang programming"
  23. OK

同字符串一样，hash 结构中的单个子 key 也可以进行计数，它对应的指令是 hincrby， 和 incr 使用基本一样。 

  1. 127.0.0.1:6379> hincrby user-laoqian age 1
  2. (integer) 1

关于字典的内部结构实现，请阅读此书的第 33 节 《极度深寒——探索「字典」内部》。

set（集合）

Redis 的集合相当于 Java 语言里面的 HashSet，它内部的键值对是无序的唯一的。它的内部实现相当于一个特殊的字典，字典中所有的 value 都是一个值 NULL。 当集合中最后一个元素移除之后，数据结构自动删除，内存被回收。 set 结构可以用来存储活动中奖的用户 ID，因为有去重功能，可以保证同一个用户不会中奖两次。 

  1. 127.0.0.1:6379> sadd books python
  2. (integer) 1
  3. 127.0.0.1:6379> sadd books python # repeat
  4. (integer) 0
  5. 127.0.0.1:6379> sadd books java golang 
  6. (integer) 2
  7. 127.0.0.1:6379> smembers books # 注意顺序，和插入的并不一致，因为set是无序的
  8. 1) "golang"
  9. 2) "python"
  10. 3) "java"
  11. 127.0.0.1:6379> sismember books java # 查询某个value是否存在，相当于contains(0)
  12. (integer) 1
  13. 127.0.0.1:6379> sismember books rust
  14. (integer) 0
  15. 127.0.0.1:6379> scard books # 获取长度相当于count()
  16. (integer) 3
  17. 127.0.0.1:6379> spop books #弹出一个
  18. "golang"

zset（有序集合）

zset 可能是 Redis 提供的最为特色的数据结构，它也是在面试中面试官最爱问的数据结 构。它类似于 Java 的 SortedSet 和 HashMap 的结合体，一方面它是一个 set，保证了内部 value 的唯一性，另一方面它可以给每个 value 赋予一个 score，代表这个 value 的排序权 重。它的内部实现用的是一种叫着「跳跃列表」的数据结构。 zset 中最后一个 value 被移除后，数据结构自动删除，内存被回收。 zset 可以用来存 粉丝列表，value 值是粉丝的用户 ID，score 是关注时间。我们可以对粉丝列表按关注时间 进行排序。 zset 还可以用来存储学生的成绩，value 值是学生的 ID，score 是他的考试成绩。我们 可以对成绩按分数进行排序就可以得到他的名次。 

  1. 127.0.0.1:6379> zadd books 9.0 "think in java"
  2. (integer) 1
  3. 127.0.0.1:6379> zadd books 8.9 "java concurrency"
  4. (integer) 1
  5. 127.0.0.1:6379> zadd books 8.6 "java cookbook"
  6. (integer) 1
  7. 127.0.0.1:6379> zrange books 0 -1
  8. 1) "java cookbook"
  9. 2) "java concurrency"
  10. 3) "think in java"
  11. 127.0.0.1:6379> zrevrange books 0 -1
  12. 1) "think in java"
  13. 2) "java concurrency"
  14. 3) "java cookbook"
  15. 127.0.0.1:6379> zcard books
  16. (integer) 3
  17. 127.0.0.1:6379> zscore books "java concurrency"
  18. "8.9000000000000004"
  19. 127.0.0.1:6379> zrank books "java concurrency"
  20. (integer) 1
  21. 127.0.0.1:6379> zrangebyscore books 0 8.91
  22. 1) "java cookbook"
  23. 2) "java concurrency"
  24. 127.0.0.1:6379> zrangebyscore books -inf 8.91 withscores
  25. 1) "java cookbook"
  26. 2) "8.5999999999999996"
  27. 3) "java concurrency"
  28. 4) "8.9000000000000004"
  29. 127.0.0.1:6379> zrem books "java concurrency"
  30. (integer) 1
  31. 127.0.0.1:6379> zrange books 0 -1
  32. 1) "java cookbook"
  33. 2) "think in java"

跳跃列表（Skip-List）

zset 内部的排序功能是通过「跳跃列表」数据结构来实现的，它的结构非常特殊，也比 较复杂。 因为 zset 要支持随机的插入和删除，所以它不好使用数组来表示。我们先看一个普通的 链表结构。

image.png

拓展