Redis列表

来源:
三产
最后修订:
2017年06月12日 09:46:15
 685
Redis列表简介以及对应使用场景

简介

列表可以存储 多个 有序 可重复 的字符串。列表中的每个字符串称为元素(element),一个列表最多可以存储2 ^ 32 - 1个元素。在Redis中,可以对列表两端插入(push)和弹出(pop),还可以获取指定范围的元素列表、获取指定索引下标的元素等。列表是一种比较灵活的数据结构,它可以充当栈和队列的角色,在实际开发上有很多应用场景。

命令

添加操作

从右侧插入元素

RPUSH

自1.0.0可用。

时间复杂度: O(1)

语法:RPUSH key value [value …]
说明:

将一个或多个值 value 插入到列表 key 的表尾(最右侧)。

如果有多个 value 值,那么各个 value 值按从左到右的顺序依次插入到表尾:比如对一个空列表 mylist 执行 RPUSH mylist a b c ,得出的结果列表为 a b c ,等同于执行命令 RPUSH mylist aRPUSH mylist bRPUSH mylist c

如果 key 不存在,一个空列表会被创建并执行 RPUSH 操作。

key 存在但不是列表类型时,返回一个错误。

在 Redis 2.4 版本以前的 RPUSH 命令,都只接受单个 value 值。

返回值:

执行 RPUSH 操作后,表的长度。

示例:
# 一次添加多个元素
coderknock> RPUSH webSiteList https://coderknock.com https://my.oschina.net/coderknock/blog
(integer) 2
# 添加一个重复的元素
coderknock>  RPUSH webSiteList   https://coderknock.com
(integer) 3
# 查看所有元素
coderknock> LRANGE webSiteList 0 -1
1) "https://coderknock.com"
2) "https://my.oschina.net/coderknock/blog"
3) " https://coderknock.com"

从左侧插入元素

LPUSH

自1.0.0可用。

时间复杂度: O(1)

语法:LPUSH key value [value …]
说明:

将一个或多个值 value 插入到列表 key 的表头

如果有多个 value 值,那么各个 value 值按从左到右的顺序依次插入到表头: 比如说,对空列表 mylist 执行命令 LPUSH mylist a b c ,列表的值将是 c b a ,这等同于原子性地执行 LPUSH mylist aLPUSH mylist bLPUSH mylist c 三个命令。

如果 key 不存在,一个空列表会被创建并执行 LPUSH 操作。

key 存在但不是列表类型时,返回一个错误。

在Redis 2.4版本以前的 LPUSH 命令,都只接受单个 value 值。

返回值:

执行 LPUSH 命令后,列表的长度。

示例:
coderknock> LPUSH programmingLanguage java python go js
coderknock> LRANGE programmingLanguage 0 -1
1) "js"
2) "go"
3) "python"
4) "java"
# LPUSH 与 RPUSH 用法相似,只是从左侧(头)插入而已
coderknock> LPUSH webSiteList http://www.coderknock.com
(integer) 4
coderknock> LRANGE webSiteList 0 -1
1) "http://www.coderknock.com"
2) "https://coderknock.com"
3) "https://my.oschina.net/coderknock/blog"
4) "https://my.oschina.net/coderknock/blog"

向某个元素前或者后插入元素

LINSERT

自2.2.0起可用。

时间复杂度:O(N), N 为寻找 pivot 过程中经过的元素数量。

语法: LINSERT key BEFORE|AFTER pivot value 【这里的可选参数一次只能用一个】
说明:

将值 value 插入到列表 key 当中,位于值 pivot 之前或之后。

pivot 不存在于列表 key 时,不执行任何操作。

key 不存在时, key 被视为空列表,不执行任何操作。

如果 key 不是列表类型,返回一个错误。

返回值:

如果命令执行成功,返回插入操作完成之后,列表的长度。

如果没有找到 pivot ,返回 -1

如果 key 不存在或为空列表,返回 0

示例:
coderknock> LPUSH programmingLanguage java ruby
(integer) 6
coderknock> LRANGE programmingLanguage 0 -1
1) "ruby"
2) "java"
3) "js"
4) "go"
5) "python"
6) "java"
# 可以看到当有重复的元素时,只会插入最近的元素
coderknock> LINSERT programmingLanguage BEFORE java javaBefter
(integer) 7
coderknock> LRANGE programmingLanguage 0 -1
1) "ruby"
2) "javaBefter"
3) "java"
4) "js"
5) "go"
6) "python"
7) "java"
coderknock>  LINSERT programmingLanguage AFTER java javaAfter
(integer) 8
coderknock> LRANGE programmingLanguage 0 -1
1) "ruby"
2) "javaBefter"
3) "java"
4) "javaAfter"
5) "js"
6) "go"
7) "python"
8) "java"
# 插入到一个不存在的元素
coderknock>  LINSERT programmingLanguage AFTER c cAfter
(integer) -1
# 对一个不存在的 key 进行操作相当于没有进行任何操作
coderknock> LINSERT noList BEFORE a a
(integer) 0
coderknock> EXISTS noList
(integer) 0

查找

获取指定范围内的元素列表

LRANGE

自1.0.0起可用。

时间复杂度:O()S+N), S 为偏移量 startN 为指定区间内元素的数量。

语法: LRANGE key start stop
说明:

返回列表 key 中指定区间内的元素,区间以偏移量 startstop 指定。

下标(index)参数 startstop 都以 0 为底,也就是说,以 0 表示列表的第一个元素,以 1 表示列表的第二个元素,以此类推。

你也可以使用负数下标,以 -1 表示列表的最后一个元素, -2 表示列表的倒数第二个元素,以此类推。

注意 LRANGE 命令和编程语言中区间函数的区别

假如你有一个包含一百个元素的列表,对该列表执行 LRANGE list 0 10 ,结果是一个包含11个元素的列表,这表明 stop 下标也在 LRANGE 命令的取值范围之内(闭区间),这和某些语言的区间函数可能不一致,比如 Ruby 的 Range.newArray#slice 和 Python 的 range() 函数。

超出范围的下标

超出范围的下标值不会引起错误。

如果 start 下标比列表的最大下标 end ( LLEN list 减去 1 )还要大,那么 LRANGE 返回一个空列表。

如果 stop 下标比 end 下标还要大,Redis将 stop 的值设置为 end

返回值:
示例:
coderknock> LRANGE programmingLanguage 0 -1
1) "ruby"
2) "javaBefter"
3) "java"
4) "javaAfter"
5) "js"
6) "go"
7) "python"
8) "java"
coderknock> LRANGE programmingLanguage 0 -2
1) "ruby"
2) "javaBefter"
3) "java"
4) "javaAfter"
5) "js"
6) "go"
7) "python"
coderknock> LRANGE programmingLanguage  0 4
1) "ruby"
2) "javaBefter"
3) "java"
4) "javaAfter"
5) "js"

获取列表指定索引下标的元素

LINDEX

自1.0.0起可用。

时间复杂度: O(N), N 为到达下标 index 过程中经过的元素数量。

因此,对列表的头元素和尾元素执行 LINDEX 命令,复杂度为O(1)。

语法:LINDEX key index
说明:

返回列表 key 中,下标为 index 的元素。

下标(index)参数 startstop 都以 0 为底,也就是说,以 0 表示列表的第一个元素,以 1 表示列表的第二个元素,以此类推。

你也可以使用负数下标,以 -1 表示列表的最后一个元素, -2 表示列表的倒数第二个元素,以此类推。

如果 key 不是列表类型,返回一个错误。

返回值:

列表中下标为 index 的元素。

如果 index 参数的值不在列表的区间范围内(out of range),返回 nil

示例:
coderknock> LRANGE programmingLanguage 0 -1
1) "ruby"
2) "javaBefter"
3) "java"
4) "javaAfter"
5) "js"
6) "go"
7) "python"
8) "java"
# 从 0 开始 所以 返回的是 javaAfter
coderknock> LINDEX programmingLanguage 3
"javaAfter"
coderknock>  LINDEX programmingLanguage -3
"go"
# 如果 index 参数超出列表范围
coderknock> LINDEX programmingLanguage 8
(nil)
# 如果 key 不存在
coderknock> LINDEX a 0
(nil)
# 如果 index 参数不是一个整数会报错
coderknock> LINDEX programmingLanguage java
(error) ERR value is not an integer or out of range
coderknock> LINDEX programmingLanguage 0.1
(error) ERR value is not an integer or out of range
# embstrKey 不是列表类型
coderknock>  LINDEX embstrKey 0
(error) WRONGTYPE Operation against a key holding the wrong kind of value

获取列表长度

LLEN

自1.0.0起可用。

时间复杂度: O(N), N 为数据库中 key 的数量。

语法:LLEN key
说明:

返回列表 key 的长度。

如果 key 不存在,则 key 被解释为一个空列表,返回 0 .

如果 key 不是列表类型,返回一个错误。

返回值:
示例:
coderknock> LLEN programmingLanguage
(integer) 8
# 如果 key 不存在
coderknock> LLEN a
(integer) 0
# 如果 key 对应的类型不是列表
coderknock> LLEN embstrKey
(error) WRONGTYPE Operation against a key holding the wrong kind of value

删除

从左侧删除元素

LPOP

自1.0.0起可用。

时间复杂度: O(1)。

语法:LPOP key
说明:

移除并返回列表 key 的左侧(头)的元素。

返回值:

列表的左侧(头)的元素。

key 不存在时,返回 nil

示例:
coderknock> LRANGE programmingLanguage 0 -1
1) "ruby"
2) "javaBefter"
3) "java"
4) "javaAfter"
5) "js"
6) "go"
7) "python"
8) "java"
coderknock> LPOP programmingLanguage
"ruby"
coderknock> LRANGE programmingLanguage 0 -1
1) "javaBefter"
2) "java"
3) "javaAfter"
4) "js"
5) "go"
6) "python"
7) "java"
coderknock> LPOP embstrKey
(error) WRONGTYPE Operation against a key holding the wrong kind of value

从列表右侧弹出

RPOP

自1.0.0起可用。

时间复杂度: O(1) 。

语法:
说明:

移除并返回列表 key 的尾(最右侧)元素。

返回值:

列表的尾元素。

key 不存在时,返回 nil

示例:
coderknock> RPOP programmingLanguage
"java"
coderknock> LRANGE programmingLanguage 0 -1
1) "javaBefter"
2) "java"
3) "javaAfter"
4) "js"
5) "go"
6) "python"

删除指定元素

LREM

自1.0.0起可用。

时间复杂度:O(N), N 为列表的长度。

语法:LREM key count value
说明:

根据参数 count 的值,移除列表中与参数 value 相等的元素。

count 的值可以是以下几种:

  • count > 0 : 从表头开始向表尾搜索,移除与 value 相等的元素,数量为 count
  • count < 0 : 从表尾开始向表头搜索,移除与 value 相等的元素,数量为 count 的绝对值。
  • count = 0 : 移除表中所有与 value 相等的值。
返回值:

被移除元素的数量。

因为不存在的 key 被视作空表(empty list),所以当 key 不存在时, LREM 命令总是返回 0

示例:
coderknock> LRANGE lremTest 0 -1
 1) "java"
 2) "php"
 3) "python"
 4) "java"
 5) "go"
 6) "ruby"
 7) "python"
 8) "java"
 9) "javascript"
10) "nodejs"
11) "python"
12) "go"
13) "java"
# 删除前两个 java
coderknock> LREM lremTest 2 java
(integer) 2
coderknock> LRANGE lremTest 0 -1
 1) "php"
 2) "python"
 3) "go"
 4) "ruby"
 5) "python"
 6) "java"
 7) "javascript"
 8) "nodejs"
 9) "python"
10) "go"
11) "java"
# 删除最后两个 python
coderknock> LREM lremTest -2 python
(integer) 2
coderknock> LRANGE lremTest 0 -1
1) "php"
2) "python"
3) "go"
4) "ruby"
5) "java"
6) "javascript"
7) "nodejs"
8) "go"
9) "java"
# 当数量不够的时候只会返回已经删除的个数
coderknock> LREM lremTest 4 python
(integer) 1
coderknock> LREM lremTest 4 python
(integer) 0
# 删除全部的 go
coderknock> LREM lremTest 0 go
(integer) 2
coderknock> LRANGE lremTest 0 -1
1) "php"
2) "ruby"
3) "java"
4) "javascript"
5) "nodejs"
6) "java"

按照所有范围修剪列表

LREM

自1.0.0起可用。

时间复杂度:O(N), N 为被移除的元素的数量。

语法:LTRIM key start stop
说明:

对一个列表进行修剪(trim),就是说,让列表只保留指定区间内的元素,不在指定区间之内的元素都将被删除。

举个例子,执行命令 LTRIM list 0 2 ,表示只保留列表 list 的前三个元素,其余元素全部删除。

参数 startstop 下标(index)都以 0 为底,也就是说,以 0 表示列表的第一个元素,以 1 表示列表的第二个元素,以此类推。

你也可以使用负数下标,以 -1 表示列表的最后一个元素, -2 表示列表的倒数第二个元素,以此类推。

key 不是列表类型时,返回一个错误。

LTRIM 命令通常和 LPUSH 命令或 RPUSH 命令配合使用,举个例子:

LPUSH log newest_log
LTRIM log 0 99

这个例子模拟了一个日志程序,每次将最新日志 newest_log 放到 log 列表中,并且只保留最新的 100 项。注意当这样使用 LTRIM 命令时,时间复杂度是O(1),因为平均情况下,每次只有一个元素被移除。

注意LTRIM命令和编程语言中区间函数的区别

假如你有一个包含一百个元素的列表 list ,对该列表执行 LTRIM list 0 10 ,结果是一个包含11个元素的列表,这表明 stop 下标也在 LTRIM 命令的取值范围之内(闭区间),这和某些语言的区间函数可能不一致,比如Ruby的 Range.newArray#slice 和Python的 range() 函数。

超出范围的下标

超出范围的下标值不会引起错误。

如果 start 下标比列表的最大下标 end ( LLEN list 减去 1 )还要大,或者 start > stopLTRIM 返回一个空列表(因为 LTRIM 已经将整个列表清空)。

如果 stop 下标比 end 下标还要大,Redis将 stop 的值设置为 end

返回值:

被移除元素的数量。

因为不存在的 key 被视作空表(empty list),所以当 key 不存在时, LREM 命令总是返回 0

示例:
# 情况 1: 常见情况, start 和 stop 都在列表的索引范围之内
coderknock> RPUSH ltrimTest 0 1 2 3 4 5 6 7 8 9
(integer) 10
coderknock> LTRIM ltrimTest 1 -1
OK
coderknock> LRANGE ltrimTest 0 -1
1) "1"
2) "2"
3) "3"
4) "4"
5) "5"
6) "6"
7) "7"
8) "8"
9) "9"
# 情况 2: stop 比列表的最大下标还要大
coderknock> LTRIM ltrimTest 3 1000
OK
coderknock> LRANGE ltrimTest 0 -1 # 这里只删除了 之前索引为 0,1,2,3 的元素
1) "4"
2) "5"
3) "6"
4) "7"
5) "8"
6) "9"
# 情况 3: start 和 stop 都比列表的最大下标要大,并且 start < stop
coderknock> LTRIM ltrimTest 1000 1001
OK
coderknock> LRANGE ltrimTest 0 -1 # 此时列表被清空【因为那些索引下,没有元素】
(empty list or set)
# 情况 4:  start > stop
coderknock> RPUSH ltrimTest 0 1 2 3 4 5 6 7 8 9
(integer) 10
coderknock> LTRIM ltrimTest 4 2
OK
coderknock> LRANGE ltrimTest 0 -1 # 列表被清空
(empty list or set)

修改指定元素

LSET

自1.0.0起可用。

时间复杂度:对头元素或尾元素进行 LSET 操作,复杂度为 O(1)。

其他情况下,为 O(N), N 为列表的长度。

语法:LSET key index value
说明:

将列表 key 下标为 index 的元素的值设置为 value

index 参数超出范围,或对一个空列表( key 不存在)进行 LSET 时,返回一个错误。

返回值:

操作成功返回 ok ,否则返回错误信息。

示例:
coderknock> RPUSH lsetTest 0 1 2 3 4 5
(integer) 6
coderknock> LRANGE lsetTest 0 -1
1) "0"
2) "1"
3) "2"
4) "3"
5) "4"
6) "5"
coderknock> LSET lsetTest 2  new2
OK
coderknock> LRANGE lsetTest 0 -1
1) "0"
2) "1"
3) "new2"
4) "3"
5) "4"
6) "5"
# 索引超出时会报错
coderknock> LSET lsetTest  9 new9
(error) ERR index out of range
# key 不存在会报错
coderknock> LSET nonKey  0 1
(error) ERR no such key

阻塞操作

BLPOP

自2.0.0起可用。

时间复杂度: O(1)。

语法:BLPOP key [key …] timeout
说明:

BLPOP 是列表的阻塞式(blocking)弹出原语。

它是 LPOP 命令的阻塞版本,当给定列表内没有任何元素可供弹出的时候,连接将被 BLPOP 命令阻塞,直到等待超时或发现可弹出元素为止。

当给定多个 key 参数时,按参数 key 的先后顺序依次检查各个列表,弹出第一个非空列表的头元素。

非阻塞行为

BLPOP 被调用时,如果给定 key 内至少有一个非空列表,那么弹出遇到的第一个非空列表的头元素,并和被弹出元素所属的列表的名字一起,组成结果返回给调用者。

当存在多个给定 key 时, BLPOP 按给定 key 参数排列的先后顺序,依次检查各个列表。

假设现在有 jobcommandrequest 三个列表,其中 job 不存在, commandrequest 都持有非空列表。考虑以下命令:

BLPOP job command request 0

BLPOP 保证返回的元素来自 command ,因为它是按”查找 job -> 查找 command -> 查找 request “这样的顺序,找到第一个非空列表。

coderknock> DEL job command request           # 确保key都被删除
(integer) 0

coderknock> LPUSH command "update system..."  # 为command列表增加一个值
(integer) 1

coderknock> LPUSH request "visit page"        # 为request列表增加一个值
(integer) 1

coderknock> BLPOP job command request 0       # job 列表为空,被跳过,紧接着 command 列表的第一个元素被弹出。
1) "command"                             # 弹出元素所属的列表
2) "update system..."                    # 弹出元素所属的值

阻塞行为

如果所有给定 key 都不存在或包含空列表,那么 BLPOP 命令将阻塞连接,直到等待超时,或有另一个客户端对给定 key 的任意一个执行 LPUSHRPUSH 命令为止。

超时参数 timeout 接受一个以秒为单位的数字作为值。超时参数设为 0 表示阻塞时间可以无限期延长(block indefinitely) ,客户端会一直阻塞等待。

coderknock> EXISTS job                # 确保两个 key 都不存在
(integer) 0
coderknock> EXISTS command
(integer) 0

coderknock> BLPOP job command 300     # 因为key一开始不存在,所以操作会被阻塞,直到另一客户端对 job 或者 command 列表进行 PUSH 操作。
1) "job"                         # 这里被 push 的是 job
2) "do my home work"             # 被弹出的值
(26.26s)                         # 等待的秒数

coderknock> BLPOP job command 5       # 等待超时的情况,这里设置 5 秒超时就,不再阻塞
(nil)
(5.66s)                          # 等待的秒数

相同的key被多个客户端同时阻塞

相同的 key 可以被多个客户端同时阻塞。

不同的客户端被放进一个队列中,按『先阻塞先服务』(first-BLPOP,first-served)的顺序为 key 执行 BLPOP 命令。

在MULTI/EXEC事务中的BLPOP

BLPOP 可以用于流水线(pipline,批量地发送多个命令并读入多个回复),但把它用在 MULTI / EXEC 块当中没有意义。因为这要求整个服务器被阻塞以保证块执行时的原子性,该行为阻止了其他客户端执行 LPUSHRPUSH 命令。

因此,一个被包裹在 MULTI / EXEC 块内的 BLPOP 命令,行为表现得就像 LPOP 一样,对空列表返回 nil ,对非空列表弹出列表元素,不进行任何阻塞操作。

# 对非空列表进行操作
coderknock> RPUSH job programming
(integer) 1
coderknock> MULTI
OK
coderknock> BLPOP job 30
QUEUED
coderknock> EXEC           # 不阻塞,立即返回
1) 1) "job"
   2) "programming"
# 对空列表进行操作
coderknock> LLEN job      # 空列表
(integer) 0
coderknock> MULTI
OK
coderknock> BLPOP job 30
QUEUED
coderknock> EXEC         # 不阻塞,立即返回
1) (nil)
返回值:

如果列表为空,返回一个 nil

否则,返回一个含有两个元素的列表,第一个元素是被弹出元素所属的 key ,第二个元素是被弹出元素的值。

示例:

已在说明演示

BRPOP

自2.0.0起可用。

时间复杂度: O(1)。

语法:BRPOPkey [key …] timeout
说明:

BRPOP 是列表的阻塞式(blocking)弹出原语。

它是 RPOP 命令的阻塞版本,当给定列表内没有任何元素可供弹出的时候,连接将被 BRPOP 命令阻塞,直到等待超时或发现可弹出元素为止。

当给定多个 key 参数时,按参数 key 的先后顺序依次检查各个列表,弹出第一个非空列表的尾部元素。

关于阻塞操作的更多信息,请查看 BLPOP 命令, BRPOP 除了弹出元素的位置和 BLPOP 不同之外,其他表现一致。

返回值:

假如在指定时间内没有任何元素被弹出,则返回一个 nil 和等待时长。

反之,返回一个含有两个元素的列表,第一个元素是被弹出元素所属的 key ,第二个元素是被弹出元素的值。

示例:

可以参考 BLPOP 示例

内部编码

列表类型的内部编码有三种。

  • ziplist(压缩列表):当列表的元素个数小于list-max-ziplist-entries配置(默认512个),同时列表中每个元素的值都小于list-max-ziplist-value配置时(默认64字节),Redis会选用ziplist来作为列表的内部实现来减少内存的使用。

  • linkedlist(链表):当列表类型无法满足ziplist的条件时,Redis会使用 linkedlist 作为列表的内部实现。

  • quicklist (快速列表) Redis 3.2 版本及以上才有该内部编码:quicklist 是一个 ziplist 的双向链表。双向链表是由多个节点(Node)组成的。这个描述的意思是:quicklist 的每个节点都是一个 ziplist。双向链表便于在表的两端进行push和pop操作,但是它的内存开销比较大。首先,它在每个节点上除了要保存数据之外,还要额外保存两个指针;其次,双向链表的各个节点是单独的内存块,地址不连续,节点多了容易产生内存碎片。

    ziplist 由于是一整块连续内存,所以存储效率很高。但是,它不利于修改操作,每次数据变动都会引发一次内存的 realloc 。特别是当 ziplist 长度很长的时候,一次 realloc 可能会导致大批量的数据拷贝,进一步降低性能。

    于是,结合了双向链表和 ziplist 的优点,quicklist就应运而生了,在时间和空间上做了一个均衡,能较大程度上提高Redis的效率。压入和弹出操作的时间复杂度都很理想。

使用场景

  • lpush+lpop=Stack(栈)
  • lpush+rpop=Queue(队列)
  • lpsh+ltrim=Capped Collection(有限集合)
  • lpush+brpop=Message Queue(消息队列)