Redis(五) 列表类型

╰+攻爆jí腚メ 2024-04-20 12:06 64阅读 0赞

![在这里插入图片描述][7a7f9bc6279c4f66a7517fcc7d7a59ff.png]

#### 文章目录 ####

*  前言
 *  列表相关命令
 *   *  LPUSH
     *  LPUSHX
 *  RPUSH
 *   *  RPUSHX
     *  LRANGE
     *  LPOP
     *  RPOP
 *  LINDEX
 *   *  LINSERT
     *  LLEN
     *  LREM
     *  LTRIM
     *  LSET
     *  阻塞版本命令
     *  命令小结
 *  内部编码
 *  列表类型的使用场景
 *   *  消息队列

## 前言 ##

在 Redis 中，列表类型是用于存储一个字符串元素的集合，并且这些元素按照插入顺序进行排序。如图所示：a、b、c、d、e 五个元素从左到右组成了一个有序的列表，列表中的每个字符串称为元素，一个列表最多可以存储 2^32-1 个元素，在 Redis 的列表中，你可以向列表的头部或者尾部进行添加和删除元素等操作。

![在这里插入图片描述][273a042754874678a35482ba1fbd3c08.png]

**列表类型的特点**

1.  列表中的元素是有序的，这意味着可以通过索引下标获取某个元素或者某个范围的元素列表
2.  列表中的元素是允许重复的

## 列表相关命令 ##

### LPUSH ###

LPUSH 将元素从列表的左侧头插放入到列表中。如果 key 已经存在并且value 的类型为 list 的时候，就会在已存在的列表的头部进行插入，如果key 不存在那么会创建一个 key，然后再依次将数据头插到链表中`LPUSH key element [element...]`

时间复杂度：只插入一个元素时，时间复杂度为O(1)，插入多个元素的时候，时间复杂度为O(N)，N为插入的元素的个数  
返回值：插入后 list 的长度

127.0.0.1:6379> lpush key 1 2 3 4
    (integer) 4

因为是头插入列表中的，所以执行完上面的命令之后 key 列表中存在的元素的顺序就是 4 3 2 1。

如果在执行 LPUSH 之前，这个 key 存在的话，并且这个 key 的 value 的数据类型不是 list 类型的话，就会报错。

127.0.0.1:6379> set key2 hello
    OK
    127.0.0.1:6379> lpush key2 5 6 7
    (error) WRONGTYPE Operation against a key holding the wrong kind of value

### LPUSHX ###

LPUSHX 命令是当 key 存在时才将数据依次插入到 list 中，不存在则直接返回。`LPUSHX key element[element...]`

时间复杂度：只插入一个元素时，时间复杂度为O(1)，插入多个元素的时候，时间复杂度为O(N)，N为插入的元素的个数  
返回值：插入后 list 的长度

127.0.0.1:6379> lpush key 1 2 3 4
    (integer) 4
    127.0.0.1:6379> lpushx key 5 6
    (integer) 6
    127.0.0.1:6379> lpushx key1 1 2 3
    (integer) 0

## RPUSH ##

RPUSH 将一个或者多个元素尾插到列表中。如果 key 存在并且 value 类型为 list 类型的话，则直接将元素依次尾插到列表中，不存在则先创建再尾插。`RPUSH key element[element...]`

时间复杂度：只插入一个元素时，时间复杂度为O(1)，插入多个元素的时候，时间复杂度为O(N)，N为插入的元素的个数  
返回值：插入后 list 的长度

OK
    127.0.0.1:6379> rpush key 1 2 3 4
    (integer) 4

依次尾插 1 2 3 4 之后列表中的元素从左到右依次是 1 2 3 4。

### RPUSHX ###

RPUSHX 跟 LPUSHX 类似，这里就不过多介绍了。`RPUSHX key element[element...]`

127.0.0.1:6379> rpush key 1 2 3 4
    (integer) 4
    127.0.0.1:6379> rpushx key 5 6 7
    (integer) 7
    127.0.0.1:6379> rpushx key2 1 2 3 4
    (integer) 0

### LRANGE ###

LRANGE 获取从 start 到 end 区间之间的元素（闭区间）。`LRANGE key start stop`

时间复杂度：O(N)  
返回值：指定区间的元素

127.0.0.1:6379> rpush key 1 2 3 4 5
    (integer) 5
    127.0.0.1:6379> lrange key 0 -1
    1) "1"
    2) "2"
    3) "3"
    4) "4"
    5) "5"

列表中的元素从 0 开始，下标也可以为负数，-1表示倒数第一个元素，0 -1 表示获取列表中的所有元素。如果 start-end 之间的下标发生了越界，redis 不会像 c++ 那样定义为未定义的行为，可能结果恰好是正确的，也可能是错误的，也不会像 Java 那样抛出异常，redis 会尽可能的显示出区间之内的元素。

127.0.0.1:6379> lrange key 1 10
    1) "2"
    2) "3"
    3) "4"
    4) "5"
    127.0.0.1:6379> lrange key 10 20
    (empty array)

既然存在 lrange，那么是否存在 rrange 呢？

127.0.0.1:6379> rrange
    (error) ERR unknown command `rrange`, with args beginning with:

其实这里的 l 指的不是 left，而是 list，所以不存在 rrange。

### LPOP ###

LPOP 命令删除列表中最左侧的元素（即头删）。`LPOP key`

时间复杂度：O(1)  
返回值：删除的值或者nil

127.0.0.1:6379> rpush key 1 2 3 4 5
    (integer) 5
    127.0.0.1:6379> lpop key
    "1"
    127.0.0.1:6379> lrange key 0 -1
    1) "2"
    2) "3"
    3) "4"
    4) "5"
    127.0.0.1:6379> lpop key2  # key2 不存在
    (nil)

### RPOP ###

RPOP 命令删除列表最右侧的元素（即尾删）。`RPOP key`

时间复杂度：O(1)  
返回值：删除的值或者nil

127.0.0.1:6379> rpush key 1 2 3 4 5
    (integer) 5
    127.0.0.1:6379> rpop key
    "5"
    127.0.0.1:6379> lrange key 0 -1
    1) "1"
    2) "2"
    3) "3"
    4) "4"

在 Redis 6.2 版本及以后使用 LPOP 和 RPOP 命令可以指定执行的次数，也就是 `LPOP/RPOP key count`。

Redis 的列表类型底层其实是一个双端队列，双端队列的头插、头删、尾插和尾删的时间复杂度都是 O(1)，速度是非常快的，我们通过使用 RPUSH、LPOP 就可以实现双队列的功能，而使用 RPUSH 和 RPOP 就可以实现栈的功能了。

## LINDEX ##

LINDEX 命令获取从左侧第 index 位置的元素。`LINDEX key index`

时间复杂度：O(N)  
返回值：取出的元素或者nil

为什么这里的时间复杂度是 O(N)，而不是O(1)呢，前面我们说了，redis 的 list 底层是双端队列，这个双端队列是以链表的形式实现的，而不是数组，所以如果操作的不是队首或者队尾，就需要对链表进行遍历，所以时间复杂度为 O(N)。

127.0.0.1:6379> rpush key 1 2 3 4 5
    (integer) 5
    127.0.0.1:6379> lindex key 2
    "3"
    127.0.0.1:6379> lindex key 6 #下标越界返回nil
    (nil)

### LINSERT ###

LINSERT 命令在指定位置插入元素。`LINSERT key <before | after> pivot element`

before 表示在 pivot 之前插入 element，after 表示在 pivot 之后插入。

时间复杂度：O(N)  
返回值：插入后 list 的长度

127.0.0.1:6379> rpush key 1 2 3 4 5
    (integer) 5
    127.0.0.1:6379> linsert key after 2 100
    (integer) 6
    127.0.0.1:6379> lrange key 0 -1
    1) "1"
    2) "2"
    3) "100"
    4) "3"
    5) "4"
    6) "5"
    127.0.0.1:6379> linsert key before 2 300
    (integer) 7
    127.0.0.1:6379> lrange key 0 -1
    1) "1"
    2) "300"
    3) "2"
    4) "100"
    5) "3"
    6) "4"
    7) "5"

那么这就有人问了，既然这里的插入不是按照下标来插入的，而是按照按照具体的元素，那么如果列表中存在多个相同的元素，那么该怎么办呢？

127.0.0.1:6379> rpush key 1 2 2 2 3 4 5
    (integer) 7
    127.0.0.1:6379> linsert key before 2 100
    (integer) 8
    127.0.0.1:6379> lrange key 0 -1
    1) "1"
    2) "100"
    3) "2"
    4) "2"
    5) "2"
    6) "3"
    7) "4"

插入的时候，redis 会从列表的最左侧开始遍历，遇到第一个 pivot 之后就插入，然后就不再遍历了。

### LLEN ###

LLEN 命令获取 list 的长度，也就是 list 中元素的个数。`LLEN key`

时间复杂度：O(N)  
返回值：list 的长度

127.0.0.1:6379> rpush key 1 2 3 4 5
    (integer) 5
    127.0.0.1:6379> llen key
    (integer) 5
    127.0.0.1:6379> llen key1
    (integer) 0

### LREM ###

LREM 命令删除指定的元素。`LREM key count element`，count 是要删除几个 element。count > 0 表示从头向尾开始删除 count 个 element，count < 0 表示从尾向头开始删除 |count|个 element，count = 0 表示列表中存在的所有的值等于 element 的元素。

时间复杂度：O(N)  
返回值：删除的元素的个数

127.0.0.1:6379> rpush key 1 2 2 3 2 4 5
    (integer) 7
    127.0.0.1:6379> lrem key 1 1
    (integer) 1
    127.0.0.1:6379> lrange key 0 -1
    1) "2"
    2) "2"
    3) "3"
    4) "2"
    5) "4"
    6) "5"
    127.0.0.1:6379> lrem key -1 2
    (integer) 1
    127.0.0.1:6379> lrange key 0 -1
    1) "2"
    2) "2"
    3) "3"
    4) "4"
    5) "5"
    127.0.0.1:6379> lrem key 0 2
    (integer) 2
    127.0.0.1:6379> lrange key 0 -1
    1) "3"
    2) "4"
    3) "5"

### LTRIM ###

LTRIM 命令保留 start 和 end 之间的元素，\[start,end\]区间之外的元素都会删除。`LTRIM key start stop`

时间复杂度：O(N)  
返回值：OK

127.0.0.1:6379> rpush key 1 2 3 4 5
    (integer) 5
    127.0.0.1:6379> ltrim key 1 2
    OK
    127.0.0.1:6379> lrange key 0 -1
    1) "2"
    2) "3"
    127.0.0.1:6379> ltrim key 10 11
    OK
    127.0.0.1:6379> lrange key 0 -1
    (empty array)

### LSET ###

LSET 命令修改指定下标的元素。`LSET key index element`

时间复杂度：O(N)  
返回值：修改成功返回OK，下标越界报错

127.0.0.1:6379> rpush key 1 2 3 4 5
    (integer) 5
    127.0.0.1:6379> lset key 2 100
    OK
    127.0.0.1:6379> lrange key 0 -1
    1) "1"
    2) "2"
    3) "100"
    127.0.0.1:6379> lset key 10 100
    (error) ERR index out of range

### 阻塞版本命令 ###

BLPOP 和 BRPOP 是 LPOP 和 RPOP 的阻塞版本，和对应非阻塞版本的命令的作用基本一致，除了：

*  在列表中有元素的情况下，阻塞和非阻塞表现的是一样的。但如果列表中没有元素，非阻塞版本会理解返回 nil，但阻塞版本会根据 timeout，阻塞一段时间。期间 redis 可以执行其他命令，但要求执行阻塞命令的客户端表现为阻塞状态。
 *  命令中如果设置了多个键，就会从左向右遍历键，一旦有一个键对应的列表可以弹出元素，命令立即返回。
 *  如果多个客户端执行弹出命令，则最先执行弹出命令的客户端会先得到相应的元素。

**对于 list 不为空的情况**

127.0.0.1:6379> rpush key 1 2 3 4 5
    (integer) 5
    127.0.0.1:6379> blpop key 30
    1) "key"
    2) "1"
    (error) ERR wrong number of arguments for 'lpop' command
    127.0.0.1:6379> lpop key
    "2"

**list 为空的情况**

**非阻塞的弹出命令**

127.0.0.1:6379> lrange key 0 -1
    (empty array)
    127.0.0.1:6379> lpop key
    (nil)

**阻塞的弹出命令**

客户端1

127.0.0.1:6379> flushall
    OK
    127.0.0.1:6379> lrange key 0 -1
    (empty array)
    127.0.0.1:6379> blpop key 300
    1) "key"
    2) "1"
    (10.85s)

客户端2

127.0.0.1:6379> rpush key 1 2 3
    (integer) 3

![在这里插入图片描述][97f71acf7544428bb039ae5cd643d1ed.png]

**针对多个 key 进行操作**

redis 客户端1

127.0.0.1:6379> flushall
    OK
    127.0.0.1:6379> blpop key1 key2 key2 300
    1) "key2"
    2) "1"
    (10.52s)

redis 客户端2

127.0.0.1:6379> rpush key2 1 2 3 4
    (integer) 4

![在这里插入图片描述][3af26cf59b124bac97822188255d5693.png]

### 命令小结 ###

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>执行效果</th> 
   <th>时间复杂度</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>rpush key value [value …]</td> 
   <td>从list的尾部插入元素</td> 
   <td>O(K)，K是插入元素的个数</td> 
  </tr> 
  <tr> 
   <td>lpush key value [value …]</td> 
   <td>从list的头部插入元素</td> 
   <td>O(K)，K是插入元素的个数</td> 
  </tr> 
  <tr> 
   <td>linsert key before</td> 
   <td>after pivot value</td> 
   <td>在指定元素之前或者之后插入元素</td> 
  </tr> 
  <tr> 
   <td>lrange key start end</td> 
   <td>获取list指定范围内的元素</td> 
   <td>O(S+N)，S是头部到start的偏移量，N是start到end的范围</td> 
  </tr> 
  <tr> 
   <td>lindex key index</td> 
   <td>获取list指定下标的元素</td> 
   <td>O(N)，N是index的偏移量</td> 
  </tr> 
  <tr> 
   <td>llen key</td> 
   <td>获取list的长度</td> 
   <td>O(1)</td> 
  </tr> 
  <tr> 
   <td>lpop key</td> 
   <td>从list的头部删除一个元素</td> 
   <td>O(1)</td> 
  </tr> 
  <tr> 
   <td>rpop key</td> 
   <td>从list的尾部删除一个元素</td> 
   <td>O(1)</td> 
  </tr> 
  <tr> 
   <td>lrem key count value</td> 
   <td>删除list中的元素count次</td> 
   <td>O(N)，M是list长度</td> 
  </tr> 
  <tr> 
   <td>ltrim key start end</td> 
   <td>除了start-end范围之内的元素保留，其他元素都删除</td> 
   <td>O(N)，N为list的长度</td> 
  </tr> 
  <tr> 
   <td>lset key index value</td> 
   <td>修改list指定下标的元素的值</td> 
   <td>O(N)，N是index的偏移量</td> 
  </tr> 
  <tr> 
   <td>blpop brpop</td> 
   <td>阻塞版本的头删和尾删操作</td> 
   <td>O(N)</td> 
  </tr> 
 </tbody> 
</table>

## 内部编码 ##

在 Redis 3.2版本之前，列表的内部编码有两种：

1.  ziplist（压缩列表）：当列表的元素个数小于 list-max-ziplist-entries 配置（默认512个），同时每个元素的长度都小于 list-max-ziplist-value（默认64字节）时，redis 会选择 ziplist 来作为 list 的内部编码实现来减少内存的消耗
2.  linkedlist（链表）：当列表类型无法满足 ziplist 的条件时，redis 会选择 linkedlist 作为列表的内部编码实现

但是从 Redis 3.2版本及以后开始，列表的内部编码就是 quicklist 了，quicklist 是一种结合了 ziplist 和 linkedlist 优点的数据结构，旨在解决纯 linkedlist 占用内存过多的问题，同时保持操作的高效性。

**quicklist 的主要实现特点：**

1.  双向链表结构：quicklist 本质上是一个双向链表，其中每个节点被称为 quicklistNode。每个 quicklistNode 包含了一个指向前一个节点的指针和一个指向后一个节点的指针，从而支持双向遍历。
2.  ziplist 作为节点内容：每个 quicklistNode 的内容是一个 ziplist。ziplist 是一种压缩列表，用于存储一系列连续的、可能具有不同长度的元素。在 ziplist 中，元素紧密排列在一起，通过一系列特殊的编码来减少内存占用。当列表中的元素数量较少或元素较小时，使用 ziplist 可以非常有效地节省内存。
3.  链表和 ziplist 的结合：通过组合双向链表和 ziplist，quicklist 既可以在元素较少时保持较小的内存占用（通过 ziplist），又可以在元素较多时保持高效的插入和删除操作（通过双向链表）。
4.  多个 ziplist 节点：当单个 ziplist 的长度或元素数量超过某个阈值时，Redis 会将 ziplist 分割成多个 ziplist，并将它们作为 quicklistNode 添加到双向链表中。这样可以避免单个 ziplist 过大导致的性能问题。
5.  灵活的阈值配置：Redis 允许用户配置与 quicklist 相关的参数，如单个 ziplist 的最大长度、最大元素数量等。这些参数可以根据实际使用场景进行调整，以优化性能和内存占用。

## 列表类型的使用场景 ##

### 消息队列 ###

Redis 可以使⽤ lpush + brpop 命令组合实现经典的阻塞式⽣产者-消费者模型队列，生产者客户端使用 lpush 从列表左侧插⼊元素，多个消费者客户端使用 brpop 命令阻塞式地从队列中"争抢" 队⾸元素。通过多个客⼾端来保证消费的负载均衡和高可用性。

![在这里插入图片描述][4ad6ad8a731c4195b8a621481a80f178.png]  
**分频道的消息队列**

Redis 同样使用 lpush + brpop 命令，但通过不同的键模拟频道的概念，不同的消费者可以通过 brpop 不同的键值，实现订阅不同频道的理念。

![在这里插入图片描述][69bed5a356d7490da5160b656272298f.png]  
**通过 list 类型可以很好的表示一些数据之间的关系**

![在这里插入图片描述][f8260ade9a8f41f9aebdb4551c084b6b.png]

[7a7f9bc6279c4f66a7517fcc7d7a59ff.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/c02c7acfc9d640959d463b8ff775d067.png
[273a042754874678a35482ba1fbd3c08.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/116ef5a870084a83a71c3765cea17c50.png
[97f71acf7544428bb039ae5cd643d1ed.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/92501309958d458d821bc9ecf8255562.png
[3af26cf59b124bac97822188255d5693.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/50c49682ccdf461b9ceab3be0ff94220.png
[4ad6ad8a731c4195b8a621481a80f178.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/3803d93804db45bfaaaaf20487bd6735.png
[69bed5a356d7490da5160b656272298f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/0db15221fef64df6a78c2fe75a390169.png
[f8260ade9a8f41f9aebdb4551c084b6b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/173e778e3ed74c4a97e567ff2eda9be3.png