Redis源码剖析 有序集合对象t_zset实现

有序集合对象其实跟集合对象类似，只不过它多了一个score的参数，集合中的每个元素都有一个分值，在集合中元素是按照score排序的。

有序集合的底层编码也是有两种实现，压缩列表REDIS_ENCODING_ZIPLIST以及跳跃表REDIS_ENCODING_SKIPLIST。和集合的一样，有序集合的编码方式是通过检查第一个被加入的元素来决定的。

ZSET结构

/* RedisObject结构 */
typedef struct redisObject {
    unsigned type:4;  // OBJ_ZSET表示有序集合对象
    unsigned encoding:4;  // 编码字段为OBJ_ENCODING_ZIPLIST或OBJ_ENCODING_SKIPLIST
    unsigned lru:LRU_BITS; // LRU_BITS为24位
    int refcount;
    void *ptr;  // 指向数据部分
} robj;

同其他的对象一样， zset结构也是存储在redisObject结构体中，通过指定 type= OBJ_ZSET 来确定这是一个有序集合对象，当是一个有序集合对象的时候，配套的endoding只能有对应的两种取值。

ZIPLIST编码的有序集合

当用REDIS_ENCODING_ZIPLIST作为有序集合的底层编码时，有序集合中的元素按score值从小到大排序，先保存value，在保存score，示意图如下

          |<--  element 1 -->|<--  element 2 -->|<--   .......   -->|

+---------+---------+--------+---------+--------+---------+---------+---------+
| ZIPLIST |         |        |         |        |         |         | ZIPLIST |
| ENTRY   | member1 | score1 | member2 | score2 |   ...   |   ...   | ENTRY   |
| HEAD    |         |        |         |        |         |         | END     |
+---------+---------+--------+---------+--------+---------+---------+---------+

SKIPLIST编码的有序集合

typedef struct zset {
    dict *dict;
    zskiplist *zsl;
} zset;

当有序集合用REDIS_ENCODING_SKIPLIST编码的时候，并不仅仅是用了跳跃表skiplist，还用到了字典dict。为什么要这么做呢。 跳跃表的优点是能够在O(log_N_)的期望时间内根据分值score对元素进行定位，对于一些范围查找命令，比如ZRANGE能够较好的支持。

但是如果要取出对应元素的分值，或者查看没有某个元素是否在有序集合内，单纯靠跳跃表就不够用了， 因为跳跃表是根据score组织的，不是根据元素值组织的。所以在有序集合中另外用了一个dict来支持这些操作。dict中key就是元素的值，value就是score。这样就能够在O(1)的复杂度内找到对应的分值，或者判断一个元素是否在有序集合中。

ZSET编码转换

如果一个有序集合一开始是用压缩列表REDIS_ENCODING_ZIPLIST作为底层编码，只要满足下边的条件，就会将底层编码转换为REDIS_ENCODING_SKIPLIST：

• ziplist 所保存的元素数量超过服务器属性 server.zset_max_ziplist_entries 的值（默认值为 128 ）
• 新添加元素的长度大于服务器属性 server.zset_max_ziplist_value 的值（默认值为 64 ）

void zsetConvert(robj *zobj, int encoding) {
    zset *zs;
    zskiplistNode *node, *next;
    sds ele;
    double score;
    // 如果已经是目标编码格式，返回
    if (zobj->encoding == encoding) return;
    // 编码格式从ZIPLIST转成SKIPLIST
    if (zobj->encoding == OBJ_ENCODING_ZIPLIST) {
        unsigned char *zl = zobj->ptr;
        unsigned char *eptr, *sptr;
        unsigned char *vstr;
        unsigned int vlen;
        long long vlong;
        // 如果目标编码格式不对，返回错误
        if (encoding != OBJ_ENCODING_SKIPLIST)
            serverPanic("Unknown target encoding");
        // 创建新的zset，底层为SKIPLIST编码，所以需要两个结构体：一个dict和一个skiplist
        zs = zmalloc(sizeof(*zs));
        zs->dict = dictCreate(&zsetDictType,NULL);
        zs->zsl = zslCreate();

        eptr = ziplistIndex(zl,0);
        serverAssertWithInfo(NULL,zobj,eptr != NULL);
        sptr = ziplistNext(zl,eptr);
        serverAssertWithInfo(NULL,zobj,sptr != NULL);
        // 循环遍历ZIPLIST
        while (eptr != NULL) {
            // 获取score
            score = zzlGetScore(sptr);
            serverAssertWithInfo(NULL,zobj,ziplistGet(eptr,&vstr,&vlen,&vlong));
            // 获得对应的元素的值
            if (vstr == NULL)
                ele = sdsfromlonglong(vlong);
            else
                ele = sdsnewlen((char*)vstr,vlen);
            // 根据元素值和score新建node，并插入到dict中
            node = zslInsert(zs->zsl,score,ele);
            serverAssert(dictAdd(zs->dict,ele,&node->score) == DICT_OK);
            zzlNext(zl,&eptr,&sptr);
        }
        // 将zobj指向新的zset
        zfree(zobj->ptr);
        zobj->ptr = zs;
        zobj->encoding = OBJ_ENCODING_SKIPLIST;
    } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST) {
        // 编码格式从SKIPLIST转换成ZIPLIST
        unsigned char *zl = ziplistNew();
        // 检查目标编码格式，错误退出
        if (encoding != OBJ_ENCODING_ZIPLIST)
            serverPanic("Unknown target encoding");

        /* Approach similar to zslFree(), since we want to free the skiplist at
         * the same time as creating the ziplist. */
        zs = zobj->ptr;
        // 释放dict的空间
        dictRelease(zs->dict);
        // skiplist的头节点空间
        node = zs->zsl->header->level[0].forward;
        // 释放表头
        zfree(zs->zsl->header);
        zfree(zs->zsl);
        // 遍历跳跃表
        while (node) {
            // 将元素ele和score添加到ziplist中
            zl = zzlInsertAt(zl,NULL,node->ele,node->score);
            next = node->level[0].forward;
            zslFreeNode(node);
            node = next;
        }
        // 释放zs，并集鞥zobj指向新的zl
        zfree(zs);
        zobj->ptr = zl;
        zobj->encoding = OBJ_ENCODING_ZIPLIST;
    } else {
        serverPanic("Unknown sorted set encoding");
    }
}

ZSET命令

命令	说明
ZADD key score member [[score member] [score member] …]	将一个或多个 member 元素及其 score 值加入到有序集 key 当中
zcard	返回有序集 key 的基数
ZCOUNT key min max	返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量
ZINCRBY key increment member	为有序集 key 的成员 member 的 score 值加上增量 increment
zrange	返回有序集 key 中，指定区间内的成员
zrevrange	返回有序集 key 中，指定区间内的成员
zrangeByScore	返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员
zrank	返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列
zrevrank	返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递减(从大到小)排序
zrem	移除有序集 key 中的一个或多个成员，不存在的成员将被忽略
zscore	返回有序集 key 中，成员 member 的 score 值

ZSET命令实现

ZADD接口实现

区别于其他有多种底层编码格式的实现（比如集合SET），有序集合不是在一个函数中区别不同的底层编码来实现功能，而是分别搞了两套机制，比如ZADD命令，有一个压缩列表编码的 zzlInsert 函数以及跳跃表编码的 zslInsert 函数。在命令一进来的时候，就根据不同的编码格式，调用不同的函数实现。

ZIPLIST的中插入接口

/* Insert (element,score) pair in ziplist. This function assumes the element is
 * not yet present in the list. */
unsigned char *zzlInsert(unsigned char *zl, sds ele, double score) {
    unsigned char *eptr = ziplistIndex(zl,0), *sptr;
    double s;
    // 循环遍历ZIPLIST
    while (eptr != NULL) {
        sptr = ziplistNext(zl,eptr);
        serverAssert(sptr != NULL);
        // 获取分值
        s = zzlGetScore(sptr);
        // 如果分值大于score，说明已经找到了要插入的位置
        if (s > score) {
            /* First element with score larger than score for element to be
             * inserted. This means we should take its spot in the list to
             * maintain ordering. */
            // 在对应位置插入元素和score
            zl = zzlInsertAt(zl,eptr,ele,score);
            break;
        } else if (s == score) {
            /* Ensure lexicographical ordering for elements. */
            // 如果分值相同，按字典序排列
            if (zzlCompareElements(eptr,(unsigned char*)ele,sdslen(ele)) > 0) {
                zl = zzlInsertAt(zl,eptr,ele,score);
                break;
            }
        }

        /* Move to next element. */
        eptr = ziplistNext(zl,sptr);
    }

    /* Push on tail of list when it was not yet inserted. */
    // 如果到了最后，说明前边的score都比目标要小，直接在尾部插入
    if (eptr == NULL)
        zl = zzlInsertAt(zl,NULL,ele,score);
    return zl;
}

SKIPLIST的插入接口在跳跃表那节介绍过，重新贴一下

/* Insert a new node in the skiplist. Assumes the element does not already
 * exist (up to the caller to enforce that). The skiplist takes ownership
 * of the passed SDS string 'ele'. */
 // 跳跃表插入元素
zskiplistNode *zslInsert(zskiplist *zsl, double score, sds ele) {
    zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
    unsigned int rank[ZSKIPLIST_MAXLEVEL];
    int i, level;

    serverAssert(!isnan(score));   　// 判断是否为数字
    x = zsl->header;
    // 从最高的level， 也即跨度最大的level开始查找结点
    for (i = zsl->level-1; i >= 0; i--) {
        /* store rank that is crossed to reach the insert position */
        // 当前是否是最高层， 如果是最高层，rank[i]=0，否则，复制上一层的数值
        rank[i] = i == (zsl->level-1) ? 0 : rank[i+1];
        // 如果当前结点的score值小于传入的score 或者 当前score相等，但是结点的对象不相等
        while (x->level[i].forward &&
                (x->level[i].forward->score < score ||
                    (x->level[i].forward->score == score &&
                    sdscmp(x->level[i].forward->ele,ele) < 0)))
        {
            // 将当前一层的跨度加到rank[i]
            rank[i] += x->level[i].span;
            // 在当前层中向前查找
            x = x->level[i].forward;
        }
        // 当前层位于插入位置前的结点x放入update数组
        update[i] = x;
    }
    /* we assume the element is not already inside, since we allow duplicated
     * scores, reinserting the same element should never happen since the
     * caller of zslInsert() should test in the hash table if the element is
     * already inside or not. */
    // 随机生成小于32的层数
    level = zslRandomLevel();
    // 如果生成的层数大于当前的层数
    if (level > zsl->level) {
        for (i = zsl->level; i < level; i++) {
            // 设定rank数组中大于原level层以上的值为0
            // 同时设定update数组大于原level层以上的数据
            rank[i] = 0;
            update[i] = zsl->header;
            update[i]->level[i].span = zsl->length;
        }
        zsl->level = level;
    }
    // 创建层数为level的新结点
    x = zslCreateNode(level,score,ele);
    for (i = 0; i < level; i++) {
        // 将每一层的前置结点的后续结点指向新结点， 同时设置新结点的后续结点
        x->level[i].forward = update[i]->level[i].forward;
        update[i]->level[i].forward = x;

        /* update span covered by update[i] as x is inserted here */
        // 更新每一层的前置结点和新结点的跨度
        x->level[i].span = update[i]->level[i].span - (rank[0] - rank[i]);
        update[i]->level[i].span = (rank[0] - rank[i]) + 1;
    }

    /* increment span for untouched levels */
    for (i = level; i < zsl->level; i++) {
        update[i]->level[i].span++;
    }

    // 根据最低层的前序结点是否是header结点来设置当前新结点的向后指针
    x->backward = (update[0] == zsl->header) ? NULL : update[0];
    if (x->level[0].forward)
        x->level[0].forward->backward = x;
    else
        zsl->tail = x;
    zsl->length++;
    return x;
}