【第二章 API的理解和使用】2.6、有序集合

in with 0 comment

Redis Redis开发与运维

有序集合

有序集合相对于哈希、列表、集合来说会有一点点陌生，但既然叫有序集合，那么它 和集合必然有着联系，它保留了集合不能有重复成员的特性，但不同的是，有序集合 中的元素可以排序。但是它和列表使用索引下标作为排序依据不同的是，他给每个元 素设置一个分数（score）作为排序的依据。下表为有序集合user:ranking，其中包 含kris、mike、frank、tim、martin、tom，他们的分数分别是1、91、200、 220、250、251，有序集合提供了获取指定分数和元素范围查询、计算成员排名等功 能，合理的使用有序集合，能帮助我们在实际开发中解决很多问题。

scoremember
1kris
91mike
200frank
220tim
250martin
251tom

开发提示：有序集合中的元素不能重复，但是score可以重复 下表给出列表、集合、有序集合三者的异同点：

数据结构是否允许重复元素是否有序有序实现方式应用场景
列表是是索引下标时间轴、消息队列等
集合否否无标签、社交等
有序集合否是分值排行榜系统、社交等

  1. 命令

    1. 集合内

    • 添加成员

      zadd key score member [score member]

      下面操作向有序集合user:ranking添加用户tom和他的分数251：

      127.0.0.1:6379> zadd user:ranking 251 tom
(integer) 1

      返回结果代表成功添加成员的个数：

      127.0.0.1:6379> zadd user:ranking 1 kris 91 mike 200 frank 220 tim 250 martin
(integer) 5

      有关zadd命令有两点需要注意：

      • Redis3.2位zadd命令添加了nx、xx、ch、incr四个选项：

        • nx:member必须不存在，才可以设置成功，用于添加。
        • xx:member必须存在，才可以设置成功，用于更新。
        • ch:返回此次操作后，有序集合元素和分数发生变化的个数。
        • incr:对score做增加，相当于后面介绍的zincrby。

      • 有集合相比集合提供了排序字段，但是也产生了代价，zadd的时间复杂度为O(log(n)),sadd的时间复杂度为O(1)。

    • 计算成员个数

      zcard key

      例如下面操作返回有序集合user:ranking的成员数为5，和集合类型的 scard命令一样，zcard的时间复杂度为O(1).

      127.0.0.1:6379> zcard user:ranking
(integer) 5

    • 计算某个成员的分数

      zscore key member

      tom的分数为251，如果成员不存在则返回nil：

      127.0.0.1:6379> zscore user:ranking tom
"251"
127.0.0.1:6379> zscore user:ranking test
(nil)

    • 计算成员的排名

      zrank key member

      zrevrank key member

      zrank是从分数从低到高返回排名，zrevrank反之。例如下面操作中，tom 在zrank和zrevrank分别排名第5名和第0（排名从0开始计算）。

      127.0.0.1:6379> zrank user:ranking tom
(integer) 5
127.0.0.1:6379> zrevrank user:ranking tom
(integer) 0

    • 删除成员

      zrem key member [member ...]

      下面操作将成员mike从有序集合user:ranking中删除。

      127.0.0.1:6379> zrem user:ranking mike 
(integer) 1

      返回结果为成功删除的个数。

    • 增加成员的分数

      zincrby key increment member

      下面操作给tom增加了9分，分数变为了260分：

      127.0.0.1:6379> zincrby user:ranking 9 tom
"260"

    • 返回指定排名范围的成员

      zrange key start end [withscores]

      zrevrange key start end [withscores]

      有序集合是按照分值排名的，zrange是从低到高返回，zrevrange反之。 下面代码排名最低的是三个成员，如果加上withscores选项，同时会返回 成员的分数：

      127.0.0.1:6379> zrange user:ranking 0 2 withscores
1) "kris"
2) "1"
3) "frank"
4) "200"
5) "tim"
6) "220"
127.0.0.1:6379> 
1) "tom"
2) "260"
3) "martin"
4) "250"
5) "tim"
6) "220"

    • 返回指定分数范围的成员

      zrangebyscore key min max [withscores] [limit offset count]

      zrevrangebyscore key max min [withsocre] [limit offset count]

      其中zrangebyscore按照分数从低到高返回，zrevrangebyscore反之。例 如下面操作从低到高返回200到221分的成员，withscores现象会同时返回 每个成员的分数。[limit offset count]选项可以限制输出的其实位置 和个数：

      127.0.0.1:6379> zrangebyscore user:ranking 200 221 withscore
1) "frank"
2) "200"
3) "tim"
4) "220"
127.0.0.1:6379> zrevrangebyscore user:ranking 200 221 withscores
1) "tim"
2) "220"
3) "frank"
4) "200"

    • 返回指定分数范围成员个数

      zcount key min max

      下面操作返回200到221分的成员的个数：

      127.0.0.1:6379> zcount user:ranking 221 200
(integer) 2

    • 删除指定排名内的升序元素

      zremrangebyrank key start end

      下面操作删除第start到第end名的成员：

      127.0.0.1:6379> zremrangebyrank user:ranking 0 2
(integer) 3

    • 删除指定分数范围的成员

      zremrangebyscore key min max

      下面操作将250分以上的成员全部删除，返回结果为成功删除的个数：

      127.0.0.1:6379> zremrangebyscore user:ranking (250 +inf
(integer) 2
    1. 集合间操作

    下表为有序集合user:ranking:1

    scoremember
    1kris
    91mike
    200frank
    220tim
    250martin
    251tom

    下表为有序集合user:ranking:2

    scoremember
    8james
    77mike
    625martin
    888tom
     
    127.0.0.1:6379> zadd user:ranking:1 1 kris 91 mike 200 frank 220 tim 250 martin 251 tom
(integer) 6
127.0.0.1:6379> zadd user:ranking:2 8 james 77 mike 625 martin 888 tom
(integer) 4

    • 交集

      zinterstore destination numkeys key [key ...] [weights weight [weight ...]] [aggregate sum|min|max]

      这个命令参数较多，下面分别进行说明：

      • destination：交集计算结果保存到这个键。
      • numkeys：需要做交集计算键的个数。
      • key [key ...]：需要做交集计算的键。
      • weights weight [weight ...]：每个键的权重，在做交集计算式，每个键中的每个member会将自己分数乘以这个权重，每个键的权重默认是1.
      • aggregate sum|min|max：计算成员交集后，分值可以按照sum（和）、min（最小值）、max（最大值）做汇总，默认值是sum。

      下面操作对user:ranking:1和user:ranking:2做交集，weights和 aggregate使用了默认配置，可以看到目标键user:ranking:1_inter_2 对分值做了sum操作：

      127.0.0.1:6379> zinteerstore user:ranking:1_inter_2 2 user:ranking:1 user:ranking:2
(integer) 3
127.0.0.1:6379> zrange user:ranking:1_inter_2 0 -1 withscores
1) "mike"
2) "168"
3) "martin"
4) "875"
5) "tom"
6) "1139"

      如果想让user:ranking:2的权重变为0.5，并且聚合效果使用max，可以 执行如下操作：

      127.0.0.1:6379> zinterstore user:ranking:1_inter_2 2 user:ranking:1 user:ranking 2 weights 1 0.5 aggregate max
(integer) 3
127.0.0.1:6379> zrange user:ranking:1_inter_2 0 -1 withscores
1) "mike"
2) "91"
3) "martin"
4) "312.5"
5) "tom"
6) "444"

    • 并集

      zunionstore destination numkeys key [key ...] [weights weight [weight ...]] [aggregate sum|min|max]

      该命令的所有参数和zinterstore是一致的，只不过是做并集计算，例如 下面操作是计算user:ranking:1和user:ranking:2的并集，weights和 aggregate使用了默认配置，可以看到目标键user:ranking:1_union_2 对分值做了sum操作：

      127.0.0.1:6379> zunionstore user:ranking:1_union_2 2 user:ranking:1 user:ranking:2
(integer) 7
127.0.0.1:6379> zrange user:ranking:1_union_2 0 -1 withscores
1) "kris"
2) "1"
3) "james"
4) "8"
5) "mike"
6) "168"
7) "frank"
8) "200"
9) "tim"
10) "220"
11) "martin"
12) "875"
13) "tom"
14) "1139"

    下表为这些命令的时间复杂度：

    命令时间复杂度
    zadd key score member [score member ...]O(k*log(n)),k是添加成员的个数，n是当前有序集合成员个数
    zcard keyO(1)
    zscore key memberO(1)
    zrank key memberO(log(n)),n是当前有序集合成员个数
    zrevrank key memberO(log(n)),n是当前有序集合成员个数
    zrem key member [member ...]O(k*log(n)),k是添加成员的个数，n是当前有序集合成员个数
    zincrby key increment memberO(log(n)),n是当前有序集合成员个数
    zrange key start end [withscores]O(log(n) + k),k是要获取的成员个数，n是当前有序集合成员个数
    zrevrange key start end [withscores]O(log(n) + k),k是要获取的成员个数，n是当前有序集合成员个数
    zrangebyscore key min max [withscores]O(log(n) + k),k是要获取的成员个数，n是当前有序集合成员个数
    zrevrangebyscore key max min [withscores]O(log(n) + k),k是要获取的成员个数，n是当前有序集合成员个数
    zcountO(log(n)),n是当前有序集合成员个数
    zremrangebyrank key start endO(log(n) + k),k是要删除的成员个数，n是当前有序集合成员个数
    zremrangebyscore key min maxO(log(n) + k),k是要删除的成员个数，n是当前有序集合成员个数
    zinterstore destination numkeys key [key ...]O(n*k) + O(m * log(m)),n是成员数最小的有序集合成员个数，k是有序集合的个数，m是结果集中成员个数

    zunionstore destination numkeys key [key ...]O(n*k) + O(m * log(m)),n是成员数最小的有序集合成员个数，k是有序集合的个数，m是结果集中成员个数

  2. 内部编码

    有序结合类型的内部编码有两种：

    • ziplist（压缩列表）：当有序集合的元素个数小于 zset-max-ziplist-entries配置（默认128个），同时每个元素的值都小于 zset-max-ziplist-value配置（默认64字节）时，Redis会用ziplist来作为 有序集合的内部实现，ziplist可以有效减少内存的使用。

    • skiplist（跳跃表）：当ziplist条件不满足是，有序结合会使用skiplist 作为内部实现，因为此时ziplist的读写效率会下降。

    下面用实例来说明：

    1）当元素个数较少且每个元素较小时，内部编码为ziplist：

    127.0.0.1:6379> zadd zsetkey 50 e1 60 e2 30 e3
(integer) 3
127.0.0.1:6379> object encoding zsetkey
"ziplist"

    2.1）当元素超过128个，内部编码变为skiplist：

    127.0.0.1:6379> zadd zsetkey 50 e1 60 e2 30 e3 12 e4 ...忽略... 84 e 129
(integer) 129
127.0.0.1:6379> object encoding zsetkey
"skiplist"

    2.2）当某个元素大于64字节是，内部编码也会变为skiplist：

    127.0.0.1:6379> zadd zsetkey 20 "one string is bigger than 64 byte..."
(integer) 1
127.0.0.1:6379> object encoding zsetkey
"skiplist"

  3. 使用场景

    有序结合比较典型的使用场景就是排行榜系统。例如视频网站需要对用户上传的 视频做排行榜，榜单的维度可能是多个方面的：按照时间、按照播放数量、按照 获得的赞数。本节使用在赞数这个维度，记录每天用户上传视频的排行榜。主要 需要实现以下4个功能。

    （1）添加用户赞数

    例如用户mike上传了一个视频，并获得了3个赞，可以使用有序集合的zadd 和zincrby功能：

     `zad user:ranking:2016_03_15 3 mike`

    如果之后再获得一个赞，可以使用zincrby：

     `zincrby user:ranking:2016_03_15 1 mike`

    （2）取消用户在赞数

    由于各种原因（例如用户注销、用户作弊）需要将用户删除，此时需要将 用户从榜单中删除掉，可以使用zrem。例如删除成员tom：

     `zrem user:ranking:2016_03_15 tom`

    （3）展示获取赞数最多的十个用户

    此功能使用zrevrange命令实现：

     `zrevrangebyrank user:rankin:2016_03_15 0 9`

    （4）展示用户信息以及用户分数

    此功能将用户名作为键后缀，将用户信息保存在哈希类型中，至于用户的 分数和排名可以使用zsore和zrank两个功能：

     `hgetall user:info:tom`

 `zsocre user:ranking:2016_03_15 mike`

 `zrank user:ranking:2016_03_15 mike`

本文由 Meridian 创作，采用 知识共享署名4.0 国际许可协议进行许可
本站文章除注明转载/出处外，均为本站原创或翻译，转载前请务必署名
最后编辑时间为: Jul 25,2019

← → ↓ ↑