深入学习Redis之特性及命令

什么是 Redis

Redis 是完全开源的,遵守 BSD 协议,是一个高性能的 key-value 数据库。

Redis 与其他 key - value 缓存产品有以下三个特点:

  • Redis 支持数据的持久化,可以将内存中的数据保存在磁盘中,重启的时候可以再次加载进行使用。
  • Redis 不仅仅支持简单的 key-value 类型的数据,同时还提供 list,set,zset,hash 等数据结构的存储。
  • Redis 支持数据的备份,即 master-slave 模式的数据备份。

Redis 的特性

特性一:速度快

官网声称可以达到:10 万 QPS

  • 数据是存在内存中的。
  • 使用 C 语言编写。
  • 单线程模型。

Redis 速度快的主要原因就是内存

从快到慢依次是:

  • Register 寄存器
  • L1 Cache 一级缓存
  • L2 Cache 二级缓存
  • Main Memory 主存
  • Local Disk 本地磁盘
  • Remote Disk 远程磁盘
类型每秒读写次数随机读写延迟访问带宽
内存千万级80ns5GB
SSD 盘350000.1-02ms100~300MB
机械盘100 左右10ms100MB 左右

特性二:持久化

Redis 所有数据保存在内存当中,对数据的更新将以异步方式保存到磁盘上。

Redis 支持两种持久化方式:

  1. RDB
  2. AOF

特性三:多种数据结构

五种数据结构

另外在 Redis 从 2.2.0 版本开始新增了三种数据结构:

Bitmaps 和 HyperLogLog 其实本质上是字符串,并不算是真实的数据结构,而 GEO 本质上有序集合实现的。

• BitMaps:可以实现对位的操作。可以把 Bitmaps 想象成一个以位为单位数组,数组中的每个单元只能存 0 或者 1,数组的下标在 bitmaps 中叫做偏移量。单个 bitmaps 的最大长度是 512MB,即 2^32 个比特位。

• HyperLogLog:超小内存唯一值计数。特点是速度快,占用空间小。

• GEO:地理信息定位。

特性四:支持多种客户端语言

  • Java
  • PHP
  • Python
  • Ruby
  • Lua
  • Node
  • ...

特性五:功能丰富

  • 提供发布订阅功能。
  • 支持事务。
  • 支持 Lua 脚本。
  • Pipeline。

特性六:"简单"

  1. Redis 的单机核心代码只有 23.000 行左右。
  2. Redis 不依赖外部库。
  3. Redis 是单线程模型。

特性七:主从复制

主从复制是 Redis 保证高可用的基础

Redis 提供了复制功能,实现了多个相同数据的 Redis 副本。

特性八:高可用、分布式

Redis 从 2.8 版本正式提供了高可用实现 Redis Sentinel,它能够保证 Redis 节点的故障发现和故障自动转移。

Redis 从 3.0 版本正式提供了分布式实现 Redis Cluster,它是 Redis 真正的分布式实现,提供了高可用、读写和容量的扩展性。

Redis 典型应用场景

  • 缓存系统
  • 计数器
  • 消息队列
  • 排行榜
  • 社交网络,例如:粉丝数、关注数、共同关注、时间轴列表
  • 实时系统,Redis 使用 Bitmap 位图来实现布隆过滤功能,例如:垃圾邮件过滤实时处理

安装 Redis(Linux)

wget http://download.redis.io/releases/redis-3.0.7.tar.gz

tar -xzf redis-3.0.7.tar.gz

ln -s redis-3.0.7 redis

cd redis

make && make install

Redis 可执行文件说明

进入 src 目录下:

  • redis-server :Redis 服务器
  • redis-cli :Redis 命令行客户端
  • redis-benchmark :Redis 基准测试工具
  • redis-check-aof :AOF 文件修复工具
  • redis-check-dump:RDB 文件检查工具
  • redis-sentinel :Sentinel 服务器

三种启动方式

  1. 最简启动:可以直接使用redis-server命令以默认参数进行启动。
  2. 动态启动:redis-server –port 6380
  3. 配置文件启动: redis-server configPath

验证:

  • ps -ef | grep redis:(检查 redis 进程是否启动)
  • netstat -antpl | grep redis:(检查 redis 服务端口是否存在)
  • redis-cli -h ip -p port ping:(检查 redis 客户端到 redis 服务端连通性)

三种启动方式比较

生产环境选择配置启动。

单机多实例配置文件可以用端口区分。

启动 Redis

使用下面命令进行启动:

redis-server

连接 Redis

redis-cli -h 127.0.0.1 -p 6379

连接成功后我们就可以做一些操作。

127.0.0.1:6379> set hello world
OK
127.0.0.1:6379> get hello
"world"
127.0.0.1:6379> ping
PONG
127.0.0.1:6379>exit

Redis API 使用和理解

通用命令

KEYS

KEYS [pattern]

查找所有符合给定模式 pattern 的 key , 比如说:

  • KEYS * 匹配数据库中所有 key 。
  • KEYS h?llo 匹配 hello , hallo 和 hxllo 等。
  • KEYS h*llo 匹配 hllo 和 heeeeello 等。
  • KEYS h[ae]llo 匹配 hello 和 hallo ,但不匹配 hillo 。

keys 是 O(n)复杂度所以一般不在生产环境使用,因为 Redis 是单线程架构,使用不当会导致 Redis 阻塞。

DBSIZE

返回当前数据库的 key 的数量。在 Redis 内部有一个计数器来维护 Key 的数量,所以它的复杂度是 O(1)。

EXISTS

检查给定 key 是否存在。

若 key 存在,返回 1 ,否则返回 0 。

DEL

删除给定的一个或多个 key 。

返回被删除 key 的数量。

EXPIRE

为给定 key 设置生存时间,当 key 过期时(生存时间为 0 ),它会被自动删除。

设置成功返回 1 。 当 key 不存在或者不能为 key 设置生存时间时,返回 0 。

TTL

以秒为单位,返回给定 key 的剩余生存时间(TTL, time to live)。

当 key 不存在时,返回 -2 。 当 key 存在但没有设置剩余生存时间时,返回 -1 。 否则,以秒为单位,返回 key 的剩余生存时间。

PERSIST

移除给定 key 的生存时间,并变为永不过期的key。

当生存时间移除成功时,返回 1 . 如果 key 不存在或 key 没有设置生存时间,返回 0 。

TYPE

返回 key 所储存的值的类型。

返回值

  • none (key 不存在)
  • string (字符串)
  • list (列表)
  • set (集合)
  • zset (有序集)
  • hash (哈希表)
  • stream (流)

数据结构和内部编码

redis 对外展现五种数据类型:

  • string
  • hash
  • set
  • zset
  • list

每种数据结构,redis 都提供了不同的内部编码实现方式(内部编码可以通过object encoding key查看),以便使用不同的场景。

127.0.0.1:6379> object encoding hello
"embstr"

string

  • raw:大于 39 个字节的字符串,用简单动态字符串(SDS)来保存,将这个字符串的对象编码设置为 raw。
  • int:8 个字节的长整型,如果一个字符串保存的类型是整数值,并且这个值可以用 long 类型来表示,name 字符串对象会将整数值保存在字符串对象结构的 ptr 属性里面,并将字符串对象的编码设置为 int。
  • embstr:小于等于 39 个字节的字符串,embstr 编码是专门用于保存短字符串的优化编码方式。

embstr 相较于 raw 有以下好处:

  1. embstr 编码将创建字符串对象所需的空间分配的次数从 raw 编码的两次降低为一次。
  2. 释放 embstr 编码的字符串对象只需要调用一次内存释放函数,而释放 raw 编码对象的字符串对象需要调用两次内存释放函数
  3. 因为 embstr 编码的字符串对象的所有数据都保存在一块连续的内存里面,所以这种编码的字符串对象比起 raw 编码的字符串对象能更好地利用缓存带来的优势。

hash

  • ziplist(压缩列表):当哈希类型元素小于has-max-ziplist-entries配置(默认 512 个),同时所有值都小于hash-max-ziplist-value配置(默认 64 个字节)时,redis 会使用 ziplist 作为哈希的内部实现。ziplist 使用更加紧凑的结构实现多个元素的连续存储,所以在节省内存方面比 hashtable 更加优秀。
  • hashtable(哈希表):当哈希类型无法满足 ziplist 的条件时,redis 会使用 hashtable 作为哈希的内部实现。因为 ziplist 的读写效率会下降,而 hashtable 的读写时间复杂度为 O(1)。

list

  • ziplist(压缩列表):当列表类型元素个数小于 hash-max-ziplist-entries 配置(默认 512 个)同时所有值都小于 hash-max-ziplist-value 配置(默认 64 个字节)时,Redis 会使用 ziplist 作为列表的内部实现。
  • linkedlist(链表):当列表类型无法满足条件的时候,redis 会使用 linkedlist 作为列表的内部实现。

set

  • intset(整数集合):当集合中的元素都是整数且元素个数小于set-max-intset-entries配置(默认 512 个)是,redis 会选 intset 作为集合的内部实现,从而减少内存使用。
  • hashtable(哈希表):当集合元素无法满足 intset 的条件时,redis 会使用 hashtable 作为集合的内部实现。

zset

  • ziplist:当有序集合的元素个数小于zset-max-ziplist-entries配置(默认 128 个)同时每个元素的值小于zset-max-ziplist-value配置(默认 64 个字节)时,Redis 会用 ziplist 来作为有序集合的内部实现,ziplist 可以有效减少内存使用。
  • skiplist(跳跃表):当 ziplist 条件不满足的时候,有序集合会使用 skiplist 作为内部 实现,因为 ziplist 的读写效率会下降

字符串类型

特点

  • key 是唯一的,不能重复。
  • value 数据类型可以是多种,比如:字符串、数字、二进制,只是内部把数字、二进制数据转化为字符串。
  • value 也可以是一个 JSON 字符串。
  • value 还可以是序列化对象。
  • value 可以存储最大的数据大小为:512MB。

常用的字符串场景

  • 缓存
  • 计数器
  • 分布式锁

GET

返回与键 key 相关联的字符串值。

如果键 key 不存在, 那么返回特殊值 nil ; 否则, 返回键 key 的值。

如果键 key 的值并非字符串类型, 那么返回一个错误, 因为 GET 命令只能用于字符串值。

SET

将字符串值 value 关联到 key 。

如果 key 已经持有其他值, SET 就覆写旧值, 无视类型。

当 SET 命令对一个带有生存时间(TTL)的键进行设置之后, 该键原有的 TTL 将被清除。

DEL

删除给定的一个或多个 key 。

返回被删除 key 的数量。

INCR

为键 key 储存的数字值加上一。

如果键 key 不存在, 那么它的值会先被初始化为 0 , 然后再执行 INCR 命令。

如果键 key 储存的值不能被解释为数字, 那么 INCR 命令将返回一个错误。

本操作的值限制在 64 位(bit)有符号数字表示之内。

INCR 命令会返回键 key 在执行加一操作之后的值。

DECR

为键 key 储存的数字值减去一。

如果键 key 不存在, 那么键 key 的值会先被初始化为 0 , 然后再执行 DECR 操作。

如果键 key 储存的值不能被解释为数字, 那么 DECR 命令将返回一个错误。

本操作的值限制在 64 位(bit)有符号数字表示之内。

DECR 命令会返回键 key 在执行减一操作之后的值。

INCRBY

为键 key 储存的数字值加上增量 increment 。

如果键 key 不存在, 那么键 key 的值会先被初始化为 0 , 然后再执行 INCRBY 命令。

如果键 key 储存的值不能被解释为数字, 那么 INCRBY 命令将返回一个错误。

本操作的值限制在 64 位(bit)有符号数字表示之内。

在加上增量 increment 之后, 返回键 key 当前的值。

DECRBY

将键 key 储存的整数值减去减量 decrement 。

如果键 key 不存在, 那么键 key 的值会先被初始化为 0 , 然后再执行 DECRBY 命令。

如果键 key 储存的值不能被解释为数字, 那么 DECRBY 命令将返回一个错误。

本操作的值限制在 64 位(bit)有符号数字表示之内。

DECRBY 命令会返回键在执行减法操作之后的值。

SETNX

只在键 key 不存在的情况下, 将键 key 的值设置为 value 。

若键 key 已经存在, 则 SETNX 命令不做任何动作。

SETNX 是『SET if Not eXists』(如果不存在,则 SET)的简写。

命令在设置成功时返回 1 , 设置失败时返回 0 。

SETEX

将键 key 的值设置为 value , 并将键 key 的生存时间设置为 seconds 秒钟。

如果键 key 已经存在, 那么 SETEX 命令将覆盖已有的值。

SETEX 命令的效果和以下两个命令的效果类似:

SET key value
EXPIRE key seconds  # 设置生存时间

SETEX 和这两个命令的不同之处在于 SETEX 是一个原子性(atomic)操作, 它可以在同一时间内完成设置值和设置过期时间这两个操作, 因此 SETEX 命令在储存缓存的时候非常实用。

命令在设置成功时返回 OK 。 当 seconds 参数不合法时, 命令将返回一个错误。

API:SETEX key seconds value

127.0.0.1:6379> setex jack 60 nihao
OK

MGET

返回给定的一个或多个字符串键的值。

如果给定的字符串键里面, 有某个键不存在, 那么这个键的值将以特殊值 nil 表示。

MGET 命令将返回一个列表, 列表中包含了所有给定键的值。

MSET

同时为多个键设置值。

如果某个给定键已经存在, 那么 MSET 将使用新值去覆盖旧值。

MSET 是一个原子性(atomic)操作, 所有给定键都会在同一时间内被设置, 不会出现某些键被设置了但是另一些键没有被设置的情况。

MSET 命令总是返回 OK 。

MSETNX

当且仅当所有给定键都不存在时, 为所有给定键设置值。

即使只有一个给定键已经存在, MSETNX 命令也会拒绝执行对所有键的设置操作。

MSETNX 是一个原子性(atomic)操作, 所有给定键要么就全部都被设置, 要么就全部都不设置, 不可能出现第三种状态。

当所有给定键都设置成功时, 命令返回 1 ; 如果因为某个给定键已经存在而导致设置未能成功执行, 那么命令返回 0 。

API:MSETNX key value [key value …]

127.0.0.1:6379> msetnx jack1 h jack2 e jack3 l  #对不存在的key设置value
(integer) 1
127.0.0.1:6379> msetnx jack1 h jack2 e jack3 l #对存在的key设置value
(integer) 0
127.0.0.1:6379> mget jack1 jack2 jack3  #批量获取key
1) "h"
2) "e"
3) "l"
127.0.0.1:6379>

GETSET

将键 key 的值设为 value , 并返回键 key 在被设置之前的旧值。

如果键 key 没有旧值, 也即是说, 键 key 在被设置之前并不存在, 那么命令返回 nil 。

当键 key 存在但不是字符串类型时, 命令返回一个错误。

APPEND

如果键 key 已经存在并且它的值是一个字符串, APPEND 命令将把 value 追加到键 key 现有值的末尾。

如果 key 不存在, APPEND 就简单地将键 key 的值设为 value , 就像执行 SET key value 一样。

追加 value 之后, 返回键 key 的值的长度。

STRLEN

返回键 key 储存的字符串值的长度。

STRLEN 命令返回字符串值的长度。

当键 key 不存在时, 命令返回 0 。

当 key 储存的不是字符串值时, 返回一个错误。

INCRBYFLOAT

为键 key 储存的值加上浮点数增量 increment 。

如果键 key 不存在, 那么 INCRBYFLOAT 会先将键 key 的值设为 0 , 然后再执行加法操作。

如果命令执行成功, 那么键 key 的值会被更新为执行加法计算之后的新值, 并且新值会以字符串的形式返回给调用者。

当以下任意一个条件发生时, 命令返回一个错误:

  • 键 key 的值不是字符串类型(因为 Redis 中的数字和浮点数都以字符串的形式保存,所以它们都属于字符串类型);
  • 键 key 当前的值或者给定的增量 increment 不能被解释(parse)为双精度浮点数。

在加上增量 increment 之后, 返回键 key 的值。

GETRANGE

返回键 key 储存的字符串值的指定部分, 字符串的截取范围由 start 和 end 两个偏移量决定 (包括 start 和 end 在内)。

负数偏移量表示从字符串的末尾开始计数, -1 表示最后一个字符, -2 表示倒数第二个字符, 以此类推。

GETRANGE 命令会返回字符串值的指定部分。

SETRANGE

从偏移量 offset 开始, 用 value 参数覆写键 key 储存的字符串值。

SETRANGE 命令会返回被修改之后, 字符串值的长度。

Hash 类型

  • 哈希类型也是 key-value 结构,key 是字符串类型,其 value 分为两个部分:field 和 value。
  • 其中 field 部分代表属性,value 代表属性对应的值。

例如上图中,user:1:info为 key,name,age,Date为 user 这个 key 的一些属性,value 是属性对应的值。

在 hash 中,可以为 key 添加一个新的属性和新的值。

比如使用下面的命令向user:1:info这个 key 添加一个新属性 viewCounter,属性对应的值为 100。

hset user:1:info viewCounter 100

特点:

  • 适合存储对象,并且可以像数据库中 update 一个属性一样只修改某一项属性值。
  • field 不能相同,value 可以相同。

适用场景:

hash 变更的数据 user name age,尤其是是用户信息之类的,经常变动的信息。hash 更适合于对象的 存储,String 更加适合字符串存储!

HGET

HGET 命令在默认情况下返回给定域的值。

如果给定域不存在于哈希表中, 又或者给定的哈希表并不存在, 那么命令返回 nil 。

HSET

将哈希表 hash 中域 field 的值设置为 value 。

如果给定的哈希表并不存在, 那么一个新的哈希表将被创建并执行 HSET 操作。

如果域 field 已经存在于哈希表中, 那么它的旧值将被新值 value 覆盖。

当 HSET 命令在哈希表中新创建 field 域并成功为它设置值时, 命令返回 1 ; 如果域 field 已经存在于哈希表, 并且 HSET 命令成功使用新值覆盖了它的旧值, 那么命令返回 0 。

HSETNX

当且仅当域 field 尚未存在于哈希表的情况下, 将它的值设置为 value 。

如果给定field已经存在于哈希表当中, 那么命令将放弃执行设置操作。

如果哈希表 hash 不存在, 那么一个新的哈希表将被创建并执行 HSETNX 命令。

HSETNX 命令在设置成功时返回 1 , 在给定域已经存在而放弃执行设置操作时返回 0 。

HDEL

删除哈希表 key 中的一个或多个指定域,不存在的域将被忽略。

返回被成功移除的域的数量,不包括被忽略的域。

HEXISTS

检查给定域 field 是否存在于哈希表 hash 当中。

HEXISTS 命令在给定域存在时返回 1 , 在给定域不存在时返回 0 。

HLEN

返回哈希表 key 中field的数量。

返回哈希表中field的数量。当 key 不存在时,返回 0 。

HMGET

返回哈希表 key 中,一个或多个给定域的值。

如果给定的域不存在于哈希表,那么返回一个 nil 值。

因为不存在的 key 被当作一个空哈希表来处理,所以对一个不存在的 key 进行 HMGET 操作将返回一个只带有 nil 值的表。

HMSET

同时将多个 field-value (域-值)对设置到哈希表 key 中。

此命令会覆盖哈希表中已存在的域。

如果 key 不存在,一个空哈希表被创建并执行 HMSET 操作。

如果命令执行成功,返回 OK 。

当 key 不是哈希表(hash)类型时,返回一个错误。

HGETALL

返回哈希表 key 中,所有的域和值。

在返回值里,紧跟每个域(field)之后是域的值(value),所以返回值的长度是哈希表大小的两倍。

HVALS

返回哈希表 key 中所有field的值。

当 key 不存在时,返回一个空表。

HKEYS

返回哈希表 key 中的所有field。

当 key 不存在时,返回一个空表。

HINCRBY

为哈希表 key 中的域 field 的值加上增量 increment 。

增量也可以为负数,相当于对给定域进行减法操作。

如果 key 不存在,一个新的哈希表被创建并执行 HINCRBY 命令。

如果域 field 不存在,那么在执行命令前,域的值被初始化为 0 。

对一个储存字符串值的域 field 执行 HINCRBY 命令将造成一个错误。

本操作的值被限制在 64 位(bit)有符号数字表示之内。

最终返回哈希表 key 中域 field 的新值。

List 类型

特点:

  • 链表(双向链表)可演化成栈,队列,在两边插入或者改动值,效率高。
  • 有序。
  • 可以重复。
  • 左右两边插入弹出。

适用场景:

  • 最新消息排行等功能(比如朋友圈的时间线)。
  • 消息队列。

RPUSH

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

如果有多个 value 值,那么各个 value 值按从左到右的顺序依次插入到表尾。

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

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

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

LPUSH

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

如果有多个 value 值,那么各个 value 值按从左到右的顺序依次插入到表头。

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

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

执行 LPUSH 操作后,返回列表的长度。

LINSERT

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

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

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

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

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

如果没有找到 pivot ,返回 -1 。 如果 key 不存在或为空列表,返回 0 。

LPOP

移除并返回列表 key 的头元素。

执行成功返回列表的头元素。 当 key 不存在时,返回 nil 。

RPOP

移除并返回列表 key 的尾元素。

执行成功返回列表的尾元素。 当 key 不存在时,返回 nil 。

LREM

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

count 的值可以是以下几种:

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

返回被移除元素的数量。 因为不存在的 key 被视作空表(empty list),所以当 key 不存在时,返回 0 。

LTRIM

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

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

需要注意的是:

  • 如果 stop 下标比 end 下标还要大,Redis 将 stop 的值设置为 end 。
  • 下标从 0 开始。

命令执行成功时,返回 ok 。

LRANGE

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

需要注意的是:

  • 如果 stop 下标比 end 下标还要大,Redis 将 stop 的值设置为 end 。
  • 下标从 0 开始。
  • 包含start和stop。

命令执行成功时,返回指定区间内的元素。

LINDEX

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

以 0 表示列表的第一个元素,以 1 表示列表的第二个元素,以此类推。

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

LLEN

返回列表 key 的长度。

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

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

LSET

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

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

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

BLPOP

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

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

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

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

API:BLPOP key [key …] timeout

127.0.0.1:6379> blpop list1 list2 0  # 无限期阻塞
1) "list1"                           # 用另一个连接 lpush list1 a
2) "a"                                                   # 被弹出的值
(30.31s)

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

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

BRPOP 和 BLPOP 命令正好相反,就不演示了。

List 的小技巧

  • LPUSH + LPOP = Stack
  • LPUSH + RPOP = Queue
  • LPUSH +BRPOP = Message Queue

Set 类型

左边为 key 是字符串类型,右边为 values,可以将一些字符串进行一些组合,可以向 value 中添加或者删除一个元素。

特点:

  • 哈希表实现,元素不重复。
  • 添加、删除,查找的复杂度都是 O(1)。
  • 为集合提供了求交集、并集、差集等操作。
  • 无序。

适用场景:

  • 共同好友。
  • 利用唯一性,统计访问网站的所有独立 ip。
  • 好友推荐时,根据 tag 求交集,大于某个阈值就可以推荐。

SADD

将一个或多个 member 元素加入到集合 key 当中,已经存在于集合的 member 元素将被忽略。

假如 key 不存在,则创建一个只包含 member 元素作成员的集合。

当 key 不是集合类型时,返回一个错误。

返回被添加到集合中的新元素的数量,不包括被忽略的元素。

SREM

移除集合 key 中的一个或多个 member 元素,不存在的 member 元素会被忽略。

当 key 不是集合类型,返回一个错误。

返回被成功移除的元素的数量,不包括被忽略的元素。

SCARD

返回集合 key 的基数(集合中元素的数量)。

集合的基数。 当 key 不存在时,返回 0 。

API:SCARD key

127.0.0.1:6379> sadd myset a b c d e f
(integer) 6
127.0.0.1:6379> scard myset
(integer) 6

SISMEMBER

判断 member 元素是否集合 key 的成员。

如果 member 元素是集合的成员,返回 1 。 如果 member 元素不是集合的成员,或 key 不存在,返回 0 。

API:SISMEMBER key member

127.0.0.1:6379> sismember myset a  #存在
(integer) 1
127.0.0.1:6379> sismember myset z #不存在
(integer) 0

SRANDMEMBER

如果命令执行时,只提供了 key 参数,那么返回集合中的一个随机元素。

从 Redis 2.6 版本开始, 接受可选的 count 参数:

  • 如果 count 为正数,且小于集合基数,那么命令返回一个包含 count 个元素的数组,数组中的元素各不相同。如果 count 大于等于集合基数,那么返回整个集合。
  • 如果 count 为负数,那么命令返回一个数组,数组中的元素可能会重复出现多次,而数组的长度为 count 的绝对值。

只提供 key 参数时,返回一个元素;如果集合为空,返回 nil 。 如果提供了 count 参数,那么返回一个数组;如果集合为空,返回空数组。

API:SRANDMEMBER key [count]

127.0.0.1:6379> srandmember myset #不填count 随机返回一个
"b"
127.0.0.1:6379> srandmember myset 2 # count为正数
1) "e"
2) "f"
127.0.0.1:6379> srandmember myset -2 # count为负数
1) "e"
2) "a"
127.0.0.1:6379> srandmember myset -2 # count为负数
1) "f"
2) "f"

SMEMBERS

返回集合 key 中的所有成员。

不存在的 key 被视为空集合。

API:SMEMBERS key

127.0.0.1:6379> smembers myset
1) "a"
2) "e"
3) "d"
4) "f"
5) "c"
6) "b"

SPOP

移除并返回集合中的一个随机元素。

返回被移除的随机元素。 当 key 不存在或 key 是空集时,返回 nil 。

API:SPOP key

127.0.0.1:6379> spop myset
"d"

SINTER

返回一个集合的全部成员,该集合是所有给定集合的交集。

不存在的 key 被视为空集。

当给定集合当中有一个空集时,结果也为空集(根据集合运算定律)。

API:SINTER key [key …]

127.0.0.1:6379> smembers set1
1) "a"
2) "c"
3) "d"
4) "b"
5) "e"
127.0.0.1:6379> smembers set2
1) "d"
2) "b"
3) "e"
127.0.0.1:6379> sinter set1 set2  #获取两遍都存在的数据
1) "d"
2) "b"
3) "e"

SUNION

返回一个集合的全部成员,该集合是所有给定集合的并集。

不存在的 key 被视为空集。

API:SUNION key [key …]

127.0.0.1:6379> sunion set1 set2 #获取并集
1) "a"
2) "e"
3) "d"
4) "c"
5) "b"

SDIFF

返回一个集合的全部成员,该集合是所有给定集合之间的差集。

不存在的 key 被视为空集。

API:SDIFF key [key …]

127.0.0.1:6379> sdiff set1 set2 #获取差集
1) "a"
2) "c"

ZSet 类型

左边为 key,是字符串类型。右边为 value,由两部分组成:score 和 value score 表示分值,表示 value 在有序集合中的位置。

集合与有序集合的区别

  • 都没有重复元素。
  • 集合无序,有序集合是有序的。
  • 集合中只有 member,有序集合中有 member+score。

列表与有序集合的区别

  • 列表可以有重复元素,有序集合没有重复元素。
  • 列表有序,有序集合有序。
  • 列表中只有 member,有序集合中有 member+score。

特点:

将 Set 中的元素增加一个权重参数 score,元素按 score 有序排列,天然排序。

适用场景:

  • 1、排行榜。
  • 2、带权重的消息队列。

ZADD

将一个或多个 member 元素及其 score 值加入到有序集 key 当中。

如果某个 member 已经是有序集的成员,那么更新这个 member 的 score 值,并通过重新插入这个 member 元素,来保证该 member 在正确的位置上。

score 值可以是整数值或双精度浮点数。

如果 key 不存在,则创建一个空的有序集并执行 ZADD 操作。

当 key 存在但不是有序集类型时,返回一个错误。

返回被成功添加的新成员的数量,不包括那些被更新的、已经存在的成员。

ZREM

移除有序集 key 中的一个或多个成员,不存在的成员将被忽略。

当 key 存在但不是有序集类型时,返回一个错误。

返回被成功移除的成员的数量,不包括被忽略的成员。

ZSCORE

返回有序集 key 中,成员 member 的 score 值。

如果 member 元素不是有序集 key 的成员,或 key 不存在,返回 nil 。

ZINCRBY

为有序集 key 的成员 member 的 score 值加上增量 increment 。

可以通过传递一个负数值 increment ,让 score 减去相应的值。

当 key 不存在,或 member 不是 key 的成员时, ZINCRBY key increment member 等同于 ZADD key increment member 。

当 key 不是有序集类型时,返回一个错误。

score 值可以是整数值或双精度浮点数。

member 成员的新 score 值,以字符串形式表示。

ZCARD

当 key 存在且是有序集类型时,返回有序集的基数。 当 key 不存在时,返回 0 。

ZRANGE

返回有序集 key 中,指定区间内的成员。

其中成员的位置按 score 值递增(从小到大)来排序。

如果需要从大到小可以使用ZREVRANGE命令。

下标从 0 开始,stop 参数的值比有序集的最大下标还要大,那么 Redis 将 stop 当作最大下标来处理。

可以通过使用 WITHSCORES 选项,来让成员和它的 score 值一并返回。

API:ZRANGE key start stop [WITHSCORES]

127.0.0.1:6379> zadd zset 10 a 20 b 30 c 40 d 50 e
(integer) 5
127.0.0.1:6379> zrange zset  0 2
1) "a"
2) "b"
3) "c"
127.0.0.1:6379> zrange zset  0 2 withscores
1) "a"
2) "10"
3) "b"
4) "20"
5) "c"
6) "30"

ZRANGEBYSCORE

返回有序集 key 中,所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。

可选的 LIMIT 参数指定返回结果的数量及区间(就像 SQL 中的 SELECT LIMIT offset, count ),注意当 offset 很大时,定位 offset 的操作可能需要遍历整个有序集,此过程最坏复杂度为 O(N) 时间。

可以通过使用 WITHSCORES 选项,来让成员和它的 score 值一并返回。

min 和 max 可以是 -inf 和 +inf ,这样一来,你就可以在不知道有序集的最低和最高 score 值的情况下,使用这类命令。

API:ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]

127.0.0.1:6379> ZRANGEBYSCORE zset 10 50 withscores
 1) "a"
 2) "10"
 3) "b"
 4) "20"
 5) "c"
 6) "30"
 7) "d"
 8) "40"
 9) "e"
10) "50"
127.0.0.1:6379> ZRANGEBYSCORE zset -inf +inf
1) "a"
2) "b"
3) "c"
4) "d"
5) "e"

ZCOUNT

返回有序集 key 中, score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。

返回score 值在 min 和 max 之间的成员的数量。

API:ZCOUNT key min max

127.0.0.1:6379> zcount zset 10 30
(integer) 3

ZREMRANGEBYRANK

移除有序集 key 中,指定排名(rank)区间内的所有成员。

区间分别以下标参数 start 和 stop 指出,包含 start 和 stop 在内。

下标参数 start 和 stop 都以 0 为底,也就是说,以 0 表示有序集第一个成员,以 1 表示有序集第二个成员,以此类推。 你也可以使用负数下标,以 -1 表示最后一个成员, -2 表示倒数第二个成员,以此类推。

返回被移除成员的数量。

API:ZREMRANGEBYRANK key start stop

127.0.0.1:6379> zrange zset 0 100 withscores
 1) "a"
 2) "10"
 3) "b"
 4) "20"
 5) "c"
 6) "30"
 7) "d"
 8) "40"
 9) "e"
10) "50"
127.0.0.1:6379> ZREMRANGEBYRANK zset 0 1
(integer) 2
127.0.0.1:6379> zrange zset 0 100 withscores
1) "c"
2) "30"
3) "d"
4) "40"
5) "e"
6) "50"

ZREMRANGEBYSCORE

移除有序集 key 中,所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。

返回被移除成员的数量。

API:ZREMRANGEBYSCORE key min max

127.0.0.1:6379> zremrangebyscore zset 40 50
(integer) 2

ZINTERSTORE

计算给定的一个或多个有序集的交集,其中给定 key 的数量必须以 numkeys 参数指定,并将该交集(结果集)储存到 destination 。

默认情况下,结果集中某个成员的 score 值是所有给定集下该成员 score 值之和。

返回保存到 destination 的结果集的基数。

API:ZINTERSTORE destination numkeys key [key …] [WEIGHTS weight [weight …]] [AGGREGATE SUM|MIN|MAX]

127.0.0.1:6379> zadd test1 10 a 20 b 30 c 40 d 50 e
(integer) 5
127.0.0.1:6379> zadd test2 10 a 20 b 30 c 40 d 50 e
(integer) 5
127.0.0.1:6379> ZINTERSTORE sum_point 2 test1 test2
(integer) 5
127.0.0.1:6379> zrange sum_point  0 -1 withscores
 1) "a"
 2) "20"
 3) "b"
 4) "40"
 5) "c"
 6) "60"
 7) "d"
 8) "80"
 9) "e"
10) "100"

ZUNIONSTORE

计算给定的一个或多个有序集的并集,其中给定 key 的数量必须以 numkeys 参数指定,并将该并集(结果集)储存到 destination 。

默认情况下,结果集中某个成员的 score 值是所有给定集下该成员 score 值之 和 。

WEIGHTS

使用 WEIGHTS 选项,你可以为 每个 给定有序集 分别 指定一个乘法因子(multiplication factor),每个给定有序集的所有成员的 score 值在传递给聚合函数(aggregation function)之前都要先乘以该有序集的因子。

如果没有指定 WEIGHTS 选项,乘法因子默认设置为 1 。

AGGREGATE

使用 AGGREGATE 选项,你可以指定并集的结果集的聚合方式。

默认使用的参数 SUM ,可以将所有集合中某个成员的 score 值之 和 作为结果集中该成员的 score 值;使用参数 MIN ,可以将所有集合中某个成员的 最小 score 值作为结果集中该成员的 score 值;而参数 MAX 则是将所有集合中某个成员的 最大 score 值作为结果集中该成员的 score 值。

返回保存到 destination 的结果集的基数。

127.0.0.1:6379> zrange test3 0 -1 withscores
1) "a"
2) "10"
3) "b"
4) "20"
127.0.0.1:6379> zrange test4 0 -1 withscores
1) "a"
2) "10"
3) "b"
4) "20"
5) "c"
6) "30"
7) "d"
8) "40"
127.0.0.1:6379> zunionstore test5 2 test4 test5 weights 1 3
(integer) 4
127.0.0.1:6379> zrange test5 0 -1 withscores
1) "a"
2) "10"
3) "b"
4) "20"
5) "c"
6) "30"
7) "d"
8) "40"

Redis 命令参考

评论

暂无评论