跳跃表 《Redis 5 设计与源码分析》

1 跳跃表基于有序列表+分层来实现，跳跃表的实现过程如下

列为节点，行为层数。即每个柱子为节点，柱子上的L0 ~ Ln为层数

从上图可以看出跳跃表有如下性质：

• 跳跃表由很多层构成
• 跳跃表有一个头(header)节点，头节点中有一个n层的结构(L0到Ln），每层的结构包含指向本层的下个节点的指针，指向本层下个节点中间所跨越的节点个数为本层的跨度(span)
• 除头节点外，层数最多的节点的层高为跳跃表的高度(level)。如上图中，level为3，即L0到L2
• 每层都是一个有序链表，数据递增
• 除header节点外，一个元素在上层有序链表中出现，则它一定会在下层有序链表中出现
• 跳跃表每层最后一个节点指向NULL，表示本层有序链表的结束
• 跳跃表拥有一个tail指针，指向跳跃表最后一个节点
• 最底层的有序链表包含所有节点，最底层的节点个数（不包含头节点）为跳跃表的长度(length)。如上图中，length为7

      

• 每个节点包含一个后退指针，头节点和第一个节点指向NULL；其他节点指向最底层的前一个节点。

2 跳跃表是以牺牲空间的形式来达到快速查找的目的。

3 跳跃表节点zskiplistNode的数据结构

typedef struct zskiplistNode {
    sds ele;
    double score;
    struct zskiplistNode *backward;
    struct zskiplistLevel {
        struct zskiplistNode *forward;
        unsigned long span;
    } level[];
} zskiplistNode;

• ele：用于存储字符串类型的数据
• score：用于存储排序的分值
• backward：后退指针，只能指向当前节点最底层的前一个节点，头节点和第一个节点的backward指向NULL
• level：柔性数组。每个节点的数组长度不一样，在生成跳跃表节点时，在redis 6里随机生成一个1～32的值，值越大出现的概率越低。level数组里头又包含以下两个元素
  • forward：指向本层下一个节点，尾节点的forward指向NULL
  • span：forward指向的节点与本节点之间的元素个数。span值越大，跳过的节点个数越多

4 跳跃表是Redis有序集合zset的底层实现方式之一，ele存储有序集合的成员member值，score存储成员score值。所有节点的分值是按从小到大的方式排序的，当有序集合的成员分值score相同时，节点会按member的字典序进行排序。

5 还有一个跳跃表结构zskiplist来管理跳跃表节点zskiplistNode

typedef struct zskiplist {
    struct zskiplistNode *header, *tail;
    unsigned long length;
    int level;
} zskiplist;

• header：指向跳跃表头节点。头节点是一个特殊节点。它的level数组元素个数为32，在有序集合zset中不存储任何member和score值，ele值为NULL，score值为0；也不计入跳跃表的总长度。在初始化时，32个元素的forward都指向NULL，span值都为0。
• tail：指向跳跃表尾节点
• length：跳跃表长度，表示除头节点之外的节点总数
• level：跳跃表的高度

======= 创建跳跃表头节点=======

6 节点层高level，最小值是1，最大值是ZSKIPLIST_MAXLEVEL

#define ZSKIPLIST_MAXLEVEL 32 /* Should be enough for 2^64 elements */

Redis通过zslRandomLevel函数随机生成一个1～32的值作为新建节点的高度，值越大出现的概率越低。节点层高确定后便不会再修改

// server.h
#define ZSKIPLIST_P 0.25      /* Skiplist P = 1/4 */


// t_zset.c
int zslRandomLevel(void) {
    int level = 1;
    while ((random()&0xFFFF) < (ZSKIPLIST_P * 0xFFFF))
        level += 1;
    return (level<ZSKIPLIST_MAXLEVEL) ? level : ZSKIPLIST_MAXLEVEL;
}

7 在创建跳跃表节点时，待创建节点的层高，分值，member等都已确定。对于跳跃表的每个节点，需要申请内存来存储

zskiplistNode *zslCreateNode(int level, double score, sds ele) {
    zskiplistNode *zn =
        zmalloc(sizeof(*zn)+level*sizeof(struct zskiplistLevel));
    zn->score = score;
    zn->ele = ele;
    return zn;
}

一个节点占用的内存大小为zskiplistNode的内存大小与level个zskiplistLevel的内存大小之和

8 头节点是一个特殊的节点

// server.h
#define ZSKIPLIST_MAXLEVEL 32 /* Should be enough for 2^64 elements */


// t_zset.c
zskiplist *zslCreate(void) {
    int j;
    zskiplist *zsl;

    zsl = zmalloc(sizeof(*zsl));
    zsl->level = 1;
    zsl->length = 0;
    zsl->header = zslCreateNode(ZSKIPLIST_MAXLEVEL,0,NULL);
    for (j = 0; j < ZSKIPLIST_MAXLEVEL; j++) {
        zsl->header->level[j].forward = NULL;
        zsl->header->level[j].span = 0;
    }
    zsl->header->backward = NULL;
    zsl->tail = NULL;
    return zsl;
}

9 创建完整跳跃表的步骤：

1. 先创建头节点
2. 再开始创建跳跃表。创建跳跃表的步骤如下
   1. 创建跳跃表结构体对象zsl
   2. 将zsl的头节点指针指向新创建的头节点
   3. 跳跃表层高初始化为1，长度初始化为0，尾节点指向NULL

======= 创建跳跃表头节点 end ========

 

======= 插入节点=======

10 插入节点的步骤：1 查找要插入的位置；2 调整跳跃表高度；3 插入节点；调整backward

10-1 查找要插入的位置

如图3-4 所示的跳跃表，长度为3，高度为2。若要插入一个节点，分值为31，层高为3，则插入节点时查找被更新节点的部分代码如下

    x = zsl->header;
    for (i = zsl->level-1; i >= 0; i--) {
        /* store rank that is crossed to reach the insert position */
        rank[i] = i == (zsl->level-1) ? 0 : rank[i+1];
        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] += x->level[i].span;
            x = x->level[i].forward;
        }
        update[i] = x;
    }

• 变量介绍

1. update[ ]：插入节点时，需要更新被插入节点每层的前一个节点。
2. ruank[ ]：记录当前层从header节点到update[i]节点所经历的步长，在更新update[i]的span和设置新插入节点的span时用到

执行后的跳跃表

10-2 调整跳跃表高度

    level = zslRandomLevel();
    if (level > zsl->level) {
        for (i = zsl->level; i < level; i++) {
            rank[i] = 0;
            update[i] = zsl->header;
            update[i]->level[i].span = zsl->length;
        }
        zsl->level = level;
    }

执行后的跳跃表

10-3 插入节点

    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++;
    }

执行后的跳跃表

10-4 调整backend

    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;

执行后的跳跃表

插入节点完整代码

/* 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;
    for (i = zsl->level-1; i >= 0; i--) {
        /* store rank that is crossed to reach the insert position */
        rank[i] = i == (zsl->level-1) ? 0 : rank[i+1];
        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] += x->level[i].span;
            x = x->level[i].forward;
        }
        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. */
    level = zslRandomLevel();
    if (level > zsl->level) {
        for (i = zsl->level; i < level; i++) {
            rank[i] = 0;
            update[i] = zsl->header;
            update[i]->level[i].span = zsl->length;
        }
        zsl->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++;
    }

    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;
}

 

======= 删除节点=======

11 删除节点的步骤：1 查找要更新的节点；2 设置span和forward

void zslDeleteNode(zskiplist *zsl, zskiplistNode *x, zskiplistNode **update) {
    int i;
    for (i = 0; i < zsl->level; i++) {
        if (update[i]->level[i].forward == x) {
            update[i]->level[i].span += x->level[i].span - 1;
            update[i]->level[i].forward = x->level[i].forward;
        } else {
            update[i]->level[i].span -= 1;
        }
    }
    if (x->level[0].forward) {
        x->level[0].forward->backward = x->backward;
    } else {
        zsl->tail = x->backward;
    }
    while(zsl->level > 1 && zsl->header->level[zsl->level-1].forward == NULL)
        zsl->level--;
    zsl->length--;
}

======= 删除跳跃表=======

void zslFreeNode(zskiplistNode *node) {
    sdsfree(node->ele);
    zfree(node);
}

/* Free a whole skiplist. */
void zslFree(zskiplist *zsl) {
    zskiplistNode *node = zsl->header->level[0].forward, *next;

    zfree(zsl->header);
    while(node) {
        next = node->level[0].forward;
        zslFreeNode(node);
        node = next;
    }
    zfree(zsl);
}

===================================

12 在redis中，有序集合zset的底层实现是采用跳跃表和压缩列表

13 Redis的配置文件中关于有序集合zset底层实现的两个配置

1. zset-max-ziplist-entries 128: zset采用压缩列表时，元素个数最大值。默认值为128
2. zset-max-ziplist-value 64：zset采用压缩列表时，元素的字符串长度最大值。默认值为64

14 zset添加元素的主要逻辑位于t_zset.c的zaddGenericCommand函数中。zset插入第一个元素时，会根据如下两个条件判断是采用跳跃表还是压缩列表

if (zobj == NULL) {
        if (xx) goto reply_to_client; /* No key + XX option: nothing to do. */
        if (server.zset_max_ziplist_entries == 0 ||
            server.zset_max_ziplist_value < sdslen(c->argv[scoreidx+1]->ptr))
        {
            zobj = createZsetObject();
        } else {
            zobj = createZsetZiplistObject();
        }
        dbAdd(c->db,key,zobj);
    }

一般zset_max_ziplist_entries不会配置成0，元素的字符串长度也不会太长，所以创建有序集合zset时，默认使用压缩列表。

zset插入新元素时，如果满足如下调整，zset的底层实现也会由压缩列表转为跳跃表

int zsetAdd(robj *zobj, double score, sds ele, int in_flags, int *out_flags, double *newscore) {
    .....
        } else if (!xx) {
            /* Optimize: check if the element is too large or the list
             * becomes too long *before* executing zzlInsert. */
            zobj->ptr = zzlInsert(zobj->ptr,ele,score);
            if (zzlLength(zobj->ptr) > server.zset_max_ziplist_entries ||
                sdslen(ele) > server.zset_max_ziplist_value)
                zsetConvert(zobj,OBJ_ENCODING_SKIPLIST);
            if (newscore) *newscore = score;
            *out_flags |= ZADD_OUT_ADDED;
            return 1;
        } else {
            *out_flags |= ZADD_OUT_NOP;
            return 1;
        }
    .....
}

但是需要注意的是：zset转为跳跃表后，就不会再重新转为压缩列表。