欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页

redis灵魂拷问：聊一聊zset使用

程序员文章站 2022-04-02 18:08:30
...

目录

数据结构回顾

常用命令

添加

删除

获取元素个数

获取区间内元素个数

获取元素索引

获取区间内元素

获取所有元素

 查看或增加分数

交集和并集

 pop命令

使用场景 

1.阅读量排行榜

2.销售量排行榜 

3.手机号幸运抽奖

总结 

本文介绍一下redis中zset的使用。首先说一下我本地的实验环境：

redis版本:6.0.7
springboot-redis版本：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>2.1.6.RELEASE</version>
</dependency>

里面使用到的spring-data-redis版本：2.1.9.RELEASE
里面使用到的lettuce连接池版本：5.1.7.RELEASE

数据结构回顾

之前在文章《redis灵魂拷问：聊一聊redis底层数据结构》中讲过redis的数据结构了，zset用到了3种数据结构，压缩列表、跳表，并且使用哈希表来保存value:score键值对。

当同时满足下面2个条件时会用到压缩列表，否则会用跳表：

  • 集合中元素都小于64字节
  • 集合中元素个数小于128个

当然这个也是可以配置的，在redis.conf文件中：

# Similarly to hashes and lists, sorted sets are also specially encoded in
# order to save a lot of space. This encoding is only used when the length and
# elements of a sorted set are below the following limits:
zset-max-ziplist-entries 128
zset-max-ziplist-value 64

 因为使用哈希表保存分数，所以zset查找分数的命令时间复杂度是o(1)。

跳表的数据结构我们再回顾一下，看下图;
redis灵魂拷问：聊一聊zset使用

跳表中的元素是按照分数有序排列的，每个元素都有指向后一个元素的指针，所以跳表可以很方便地进行范围查询，查找一个元素的复杂度是O(log(N)),从这个元素通过指针就可以找到后面的M个元素，所以复杂度是O(log(N)+M)。

常用命令

注意：下面的命令我用java代码来实现，注解中写了每个命令的原生命令和时间复杂度，使用的时候大家可以根据每个命令的复杂度来进行取舍。 

添加

/**
     * ZADD
     * 时间复杂度 O(log(N)),n是sorted set中元素个数
     */
    public void add(){
        //批量添加
        Set<DefaultTypedTuple> zset1 = new HashSet<>();
        zset1.add(new DefaultTypedTuple("v1",30.0));
        zset1.add(new DefaultTypedTuple("v2",20.0));
        zset1.add(new DefaultTypedTuple("v3",40.0));
        zset1.add(new DefaultTypedTuple("v4",10.0));
        //单个添加
        redisTemplate.opsForZSet().add("zset1", zset1);
        //加入后排序[v5, v4, v2, v1, v3]
        redisTemplate.opsForZSet().add("zset1", "v5", 5);
    }

删除

/**
     * ZREM
     * 复杂度O(M*log(N))
     * @return 删除元素个数
     */
    public Long remove(){
        Set<DefaultTypedTuple> zset6 = new HashSet<>();
        zset6.add(new DefaultTypedTuple("v1",30.0));
        zset6.add(new DefaultTypedTuple("v2",20.0));
        zset6.add(new DefaultTypedTuple("v3",40.0));
        zset6.add(new DefaultTypedTuple("v4",10.0));
        zset6.add(new DefaultTypedTuple("v5",5.0));
        redisTemplate.opsForZSet().add("zset6", zset6);
        //返回2
        return redisTemplate.opsForZSet().remove("zset6", "v4", "v5");
    }

    /**
     * ZREMRANGEBYRANK
     * 复杂度O(log(N)+M)
     * @return 删除元素个数
     */
    public Long removeRange(){
        Set<DefaultTypedTuple> zset7 = new HashSet<>();
        zset7.add(new DefaultTypedTuple("v1",10.0));
        zset7.add(new DefaultTypedTuple("v2",20.0));
        zset7.add(new DefaultTypedTuple("v3",30.0));
        zset7.add(new DefaultTypedTuple("v4",40.0));
        zset7.add(new DefaultTypedTuple("v5",50.0));
        redisTemplate.opsForZSet().add("zset7", zset7);
        //返回3,此时zset中只剩[v1,v5]
        return redisTemplate.opsForZSet().removeRange("zset7", 1, 3);
    }

    /**
     * ZREMRANGEBYSCORE
     * 复杂度O(log(N)+M)
     * @return 删除元素个数
     */
    public Long removeRangeByScore(){
        Set<DefaultTypedTuple> zset8 = new HashSet<>();
        zset8.add(new DefaultTypedTuple("v1",10.0));
        zset8.add(new DefaultTypedTuple("v2",20.0));
        zset8.add(new DefaultTypedTuple("v3",30.0));
        zset8.add(new DefaultTypedTuple("v4",40.0));
        zset8.add(new DefaultTypedTuple("v5",50.0));
        redisTemplate.opsForZSet().add("zset8", zset8);
        //返回3,此时zset中只剩[v4,v5]
        return redisTemplate.opsForZSet().removeRangeByScore("zset8", 10, 30);
    }

获取元素个数

/**
     * ZCARD
     * 返回元素个数
     * 复杂度 O(1)
     *
     * @return
     */
    public Long zCard(){
        Set<DefaultTypedTuple> zset1 = new HashSet<>();
        zset1.add(new DefaultTypedTuple("v1",30.0));
        zset1.add(new DefaultTypedTuple("v2",20.0));
        zset1.add(new DefaultTypedTuple("v3",40.0));
        zset1.add(new DefaultTypedTuple("v4",10.0));
        zset1.add(new DefaultTypedTuple("v5",5.0));
        redisTemplate.opsForZSet().add("zset1", zset1);
        //[v5, v4, v2, v1, v3],返回5
        return redisTemplate.opsForZSet().zCard("zset1");
    }

获取区间内元素个数

/**
     * ZCOUNT
     * 时间复杂度O(log(N))
     * 返回分数是min~max之间的元素个数, 闭区间
     * @return
     */
    public Long count(){
        Set<DefaultTypedTuple> zset1 = new HashSet<>();
        zset1.add(new DefaultTypedTuple("v1",30.0));
        zset1.add(new DefaultTypedTuple("v2",20.0));
        zset1.add(new DefaultTypedTuple("v3",40.0));
        zset1.add(new DefaultTypedTuple("v4",10.0));
        zset1.add(new DefaultTypedTuple("v5",5.0));
        redisTemplate.opsForZSet().add("zset1", zset1);
        //["v1",30.0, "v2",20.0, "v3",40.0, "v4",10.0, "v5",5.0],返回2
        return redisTemplate.opsForZSet().count("zset1", 20.0, 30.0);
    }

获取元素索引

/**
     * ZRANK
     * 时间复杂度O(log(N))
     *
     * @return 返回元素的正序索引位置
     */
    public Long rank(){
        Set<DefaultTypedTuple> zset1 = new HashSet<>();
        zset1.add(new DefaultTypedTuple("v1",30.0));
        zset1.add(new DefaultTypedTuple("v2",20.0));
        zset1.add(new DefaultTypedTuple("v3",40.0));
        zset1.add(new DefaultTypedTuple("v4",10.0));
        zset1.add(new DefaultTypedTuple("v5",5.0));
        redisTemplate.opsForZSet().add("zset1", zset1);
        //[v5, v4, v2, v1, v3],这里输出0
        return redisTemplate.opsForZSet().rank("zset1", "v5");
    }

    /**
     * ZREVRANK
     * 时间复杂度O(log(N))
     * 跟rank相反,返回元素逆序的位置
     *
     * @return 返回元素的逆序索引位置
     */
    public Long reverseRank(){
        Set<DefaultTypedTuple> zset1 = new HashSet<>();
        zset1.add(new DefaultTypedTuple("v1",30.0));
        zset1.add(new DefaultTypedTuple("v2",20.0));
        zset1.add(new DefaultTypedTuple("v3",40.0));
        zset1.add(new DefaultTypedTuple("v4",10.0));
        zset1.add(new DefaultTypedTuple("v5",5.0));
        redisTemplate.opsForZSet().add("zset1", zset1);
        //[v5, v4, v2, v1, v3],这里输出4
        return redisTemplate.opsForZSet().reverseRank("zset1", "v5");
    }

获取区间内元素


/**
     * ZRANGE/ZREVRANGE命令
     * 复杂度O(log(N)+M),N是有序集合中的元素,M是返回的元素个数
     *注意：
     * 1.索引下标从0开始
     * 2.ZREVRANGE对应逆序输出,这里不给出示例
     *
     * @return 返回指定索引范围内的元素,注意,这里是闭区间, 如果end传入-1,就是从start到最后一个元素
     */
    public Set range(){
        Set<DefaultTypedTuple> zset1 = new HashSet<>();
        zset1.add(new DefaultTypedTuple("v1",30.0));
        zset1.add(new DefaultTypedTuple("v2",20.0));
        zset1.add(new DefaultTypedTuple("v3",40.0));
        zset1.add(new DefaultTypedTuple("v4",10.0));
        zset1.add(new DefaultTypedTuple("v5",5.0));
        redisTemplate.opsForZSet().add("zset1", zset1);
        //输出[v4, v2, v1, v3],总共5个元素,索引从1开始
        return redisTemplate.opsForZSet().range("zset1", 1, -1);
    }

    /**
     * ZRANGEBYLE/ZRANGEBYLEX命令
     * 复杂度O(log(N)+M),N是有序集合中的元素,M是返回的元素个数
     *注意：
     * 1.这个命令用于元素分数相同的有序集合
     * 2.spring的RedisZSetCommands.Range不生效
     * 3.ZRANGEBYLEX对应逆序输出,当前客户端不支持这个命令
     *
     * @return 返回指定索引范围内的元素
     */
    public Set rangeByLex(){
        Set<DefaultTypedTuple> zset3 = new HashSet<>();
        zset3.add(new DefaultTypedTuple("a",0d));
        zset3.add(new DefaultTypedTuple("b",0d));
        zset3.add(new DefaultTypedTuple("c",0d));
        zset3.add(new DefaultTypedTuple("d",0d));
        zset3.add(new DefaultTypedTuple("e",0d));
        zset3.add(new DefaultTypedTuple("f",0d));
        zset3.add(new DefaultTypedTuple("g",0d));
        redisTemplate.opsForZSet().add("zset3", zset3);

        RedisZSetCommands.Range range = RedisZSetCommands.Range.range();
        //下面range赋值不生效,给lt赋值后返回空
        //range.lt("f");
        range.gt("c");
        RedisZSetCommands.Limit limit = new RedisZSetCommands.Limit();
        limit.offset(0);
        limit.count(5);
        //返回[a, b, c, d, e]
        return redisTemplate.opsForZSet().rangeByLex("zset3", range, limit);
    }

    /**
     * ZRANGEBYSCORE/ZRANGEBYSCORE命令
     * 复杂度O(log(N)+M),N是有序集合中的元素,M是返回的元素个数
     *注意：
     * 这个命令是闭区间
     * ZRANGEBYSCORE命令对应逆序输出
     *
     * @return 返回指定索引范围内的元素
     */
    public Set rangeByScore(){
        Set<DefaultTypedTuple> zset4 = new HashSet<>();
        zset4.add(new DefaultTypedTuple("v1",30.0));
        zset4.add(new DefaultTypedTuple("v2",20.0));
        zset4.add(new DefaultTypedTuple("v3",40.0));
        zset4.add(new DefaultTypedTuple("v4",10.0));
        zset4.add(new DefaultTypedTuple("v5",5.0));
        redisTemplate.opsForZSet().add("zset4", zset4);

        //返回[v4, v2, v1]
        return redisTemplate.opsForZSet().rangeByScore("zset4", 10, 30);
    }

获取所有元素


/**
     * ZSCAN命令
     * 复杂度O(1)
     * 注意：
     *
     *
     * @return 返回指定索引范围内的元素
     */
    public void scan(){
        Set<DefaultTypedTuple> zset9 = new HashSet<>();
        for (int i = 1; i <= 1000; i ++){
            zset9.add(new DefaultTypedTuple("v" + i,i * 10.0));

        }
        redisTemplate.opsForZSet().add("zset9", zset9);

        ScanOptions.ScanOptionsBuilder scanOptionsBuilder = new ScanOptions.ScanOptionsBuilder();
        //这个count参数其实也不起作用,数据量小,比如20个,我们设置了10,会全部输出；数据量10000个,我们输入2000,也是输出1000个
        scanOptionsBuilder.count(2000);
        //这里使用v*竟然匹配不到
        scanOptionsBuilder.match("*");

        Cursor<ZSetOperations.TypedTuple> cursor = redisTemplate.opsForZSet().scan("zset9", scanOptionsBuilder.build());
        System.out.println("======================");
        cursor.forEachRemaining(r -> System.out.println(r.getValue() + ":" + r.getScore()));

        /**
         * 下面是输出1000行中的前5行：
         * v490:4900.0
         * v573:5730.0
         * v643:6430.0
         * v733:7330.0
         * v408:4080.0
         */

    }

 查看或增加分数


/**
     * ZINCRBY命令
     * 增加元素分数
     * 复杂度 O(log(N)),n是zset中元素个数
     *
     * @return 增加分数后的元素值
     */
    public Double incrementScore(){
        Set<DefaultTypedTuple> zset5 = new HashSet<>();
        zset5.add(new DefaultTypedTuple("v1",30.0));
        zset5.add(new DefaultTypedTuple("v2",20.0));
        zset5.add(new DefaultTypedTuple("v3",40.0));
        zset5.add(new DefaultTypedTuple("v4",10.0));
        zset5.add(new DefaultTypedTuple("v5",5.0));
        redisTemplate.opsForZSet().add("zset5", zset5);

        //返回15.0
        return redisTemplate.opsForZSet().incrementScore("zset5", "v5", 10d);
    }
    
    /**
     * ZSCAN命令
     * 复杂度O(1) 
     * @return 查找元素的分数
     */
    public Double score(){
        Set<DefaultTypedTuple> zset14 = new HashSet<>();
        zset14.add(new DefaultTypedTuple("v1",10.0));
        zset14.add(new DefaultTypedTuple("v2",20.0));
        zset14.add(new DefaultTypedTuple("v3",30.0));
        zset14.add(new DefaultTypedTuple("v4",40.0));
        zset14.add(new DefaultTypedTuple("v5",50.0));
        redisTemplate.opsForZSet().add("zset14", zset14);
        //返回30.0
        return redisTemplate.opsForZSet().score("zset14", "v3");
    }

交集和并集


/**
     * ZINTER/ZINTERSTORE
     *
     * 复杂度O(N*K)+O(M*log(M)) ,N是元素少的zset的元素数量，K是2个zset的元素总数，M是返回结果
     */
    public void intersectAndStore(){
        Set<DefaultTypedTuple> zset10 = new HashSet<>();
        zset10.add(new DefaultTypedTuple("v1",10.0));
        zset10.add(new DefaultTypedTuple("v3",30.0));
        zset10.add(new DefaultTypedTuple("v5",50.0));
        zset10.add(new DefaultTypedTuple("v6",60.0));
        redisTemplate.opsForZSet().add("zset10", zset10);

        Set<DefaultTypedTuple> zset11 = new HashSet<>();
        zset11.add(new DefaultTypedTuple("v1",10.0));
        zset11.add(new DefaultTypedTuple("v2",20.0));
        zset11.add(new DefaultTypedTuple("v3",30.0));
        zset11.add(new DefaultTypedTuple("v4",40.0));
        zset11.add(new DefaultTypedTuple("v5",50.0));
        redisTemplate.opsForZSet().add("zset11", zset11);


        redisTemplate.opsForZSet().intersectAndStore("zset10", "zset11", "zsetinter9and11");

        ScanOptions scanOptions = ScanOptions.NONE;

        Cursor<ZSetOperations.TypedTuple> cursor = redisTemplate.opsForZSet().scan("zsetinter9and11", scanOptions);
        System.out.println("======================");
        cursor.forEachRemaining(r -> System.out.println(r.getValue() + ":" + r.getScore()));

        /**
         * 输出结果如下
         * v1:20.0
         * v3:60.0
         * v5:100.0
         */
    }

/**
     * ZUNIONSTORE
     * 
     * 复杂度：O(N)+O(M log(M)),其中N是2个zset的元素总数，M是返回的元素个数
     */
    public void unionAndStore(){
        Set<DefaultTypedTuple> zset12 = new HashSet<>();
        zset12.add(new DefaultTypedTuple("v1",10.0));
        zset12.add(new DefaultTypedTuple("v2",20.0));
        zset12.add(new DefaultTypedTuple("v3",30.0));
        redisTemplate.opsForZSet().add("zset12", zset12);

        Set<DefaultTypedTuple> zset13 = new HashSet<>();
        zset13.add(new DefaultTypedTuple("v4",40.0));
        zset13.add(new DefaultTypedTuple("v5",50.0));
        zset13.add(new DefaultTypedTuple("v6",60.0));
        redisTemplate.opsForZSet().add("zset13", zset13);


        redisTemplate.opsForZSet().unionAndStore("zset12", "zset13", "zsetinter12and13");

        ScanOptions scanOptions = ScanOptions.NONE;

        Cursor<ZSetOperations.TypedTuple> cursor = redisTemplate.opsForZSet().scan("zsetinter12and13", scanOptions);
        System.out.println("======================");
        cursor.forEachRemaining(r -> System.out.println(r.getValue() + ":" + r.getScore()));

        /**
         * 输出结果如下
         * v1:10.0
         * v2:20.0
         * v3:30.0
         * v4:40.0
         * v5:50.0
         * v6:60.0
         */
    }

 pop命令

作为队列2个命令：ZPOPMAX/ZPOPMIN,让当前分数最高/最低的元素出队,复杂度O(log(N)*M) ,当前spring版本客户端不支持。 

使用场景 

zset保存了分数值，所以对于阅读量、点击量排行等场景可以很方便的使用。

1.阅读量排行榜

 假如一个博客网站上有10篇文章，我们要统计今天阅读量排名前2位的文章，我们可以先初始化一个10篇文章的zset，代码如下：

Set<DefaultTypedTuple> articles = new HashSet<>();
articles.add(new DefaultTypedTuple("article1",0d));
articles.add(new DefaultTypedTuple("article2",0d));
articles.add(new DefaultTypedTuple("article3",0d));
articles.add(new DefaultTypedTuple("article4",0d));
articles.add(new DefaultTypedTuple("article5",0d));
articles.add(new DefaultTypedTuple("article6",0d));
articles.add(new DefaultTypedTuple("article7",0d));
articles.add(new DefaultTypedTuple("article8",0d));
articles.add(new DefaultTypedTuple("article9",0d));
articles.add(new DefaultTypedTuple("article10",0d));
redisTemplate.opsForZSet().add("articles", articles);

每当有1篇文章被阅读时，我们就把分数加1，比如第一篇：

redisTemplate.opsForZSet().incrementScore("articles", "article1", 1d);

 日终时，我们找出排名前2位的文章:

redisTemplate.opsForZSet().range("articles", 0, 1);

2.销售量排行榜 

 跟上面的场景类似，假如我们要找出销售量前2位的商品，我们也可以初始化一个商品zset，分数就是销售量，每次售出一件商品时分数值加1，最后range命令去除前2个商品。

3.手机号幸运抽奖

比如我们要对1万个手机号排名，我们可以把姓名作为key，把手机号score存入zset中，代码如下：

Set<DefaultTypedTuple> phones = new HashSet<>();
phones.add(new DefaultTypedTuple("张三",18605556899));
redisTemplate.opsForZSet().add("phones", phones);

我们可以随便找出一个幸运手机号，比如6000

redisTemplate.opsForZSet().range("articles", 5999, 5999);

总结 

zset使用了压缩列表、跳表的数据结构，并且使用哈希表来保存value:score键值对。

range命令得益于底层使用了跳表，复杂度并不高，但是会随着返回元素的数量而增加。zscan命令复杂度很低，但是spring提供的api不友好，超过1000需要分页的时候，就不好用了。元素个数少于1000时使用zscan命令一次取出是最快的。

交集并集的复杂度很高，如果有bigkey的情况，会严重阻塞主线程，建议一般不要使用。可以把2个zset的元素取出来，在应用内存中进行交集并集运算，这样不会阻塞redis主线程。

由于api和版本限制，本文并没有列出zset的所有命令，大家可以查看官网：

https://redis.io/commands/zunionstore

往期文章回顾：

《redis灵魂拷问：为什么响应变慢了》

《redis灵魂拷问：聊一聊主从复制缓冲区》

《redis灵魂拷问：AOF文件可以保存RDB格式吗》

《redis灵魂拷问：聊一聊AOF日志重写》

 《redis灵魂拷问：聊一聊redis底层数据结构》

《redis灵魂拷问：怎么搭建一个哨兵主从集群》

《springboot研究九：lettuce连接池很香，撸撸它的源代码》

                                                                           欢迎关注个人公众号

                                                                 redis灵魂拷问：聊一聊zset使用   

 

相关标签： redis zset java

上一篇： thinkphp写的web在线设计流程图源码

下一篇： 数据模型:PHP框架queryphp教程：入门四 ORM数据模型内容添加

推荐阅读