redis-跳表

一、内存分配

#define increment_used_memory(_n) do { \
    if (zmalloc_thread_safe) { \
        pthread_mutex_lock(&used_memory_mutex);  \
        used_memory += _n; \
        pthread_mutex_unlock(&used_memory_mutex); \
    } else { \
        used_memory += _n; \
    } \
} while(0)

static void zmalloc_oom(size_t size) {
    fprintf(stderr, "zmalloc: Out of memory trying to allocate %zu bytes\n",
        size);
    fflush(stderr);
    abort();
}

void *zmalloc(size_t size) {
    void *ptr = malloc(size+PREFIX_SIZE);

    if (!ptr) zmalloc_oom(size);
#ifdef HAVE_MALLOC_SIZE
    increment_used_memory(redis_malloc_size(ptr));
    return ptr;
#else
    *((size_t*)ptr) = size;
    increment_used_memory(size+PREFIX_SIZE);
    return (char*)ptr+PREFIX_SIZE;
#endif
}

Q：为什么要这样设计？

A：用于保存分配的空间大小。 Redis 这样做是为了能够：

用途	说明
统计内存	Redis 有个 used_memory 的全局变量，用于追踪总分配内存
实现 zfree()	在 zfree(ptr) 时回到 ptr - PREFIX_SIZE，知道该 free 多大
跨平台兼容	某些系统不支持 malloc_size()，必须自己实现记录机制

案例：

ptr = zmalloc(100); // 实际申请了 100 + 8 = 108 字节 Redis 实际在内存里分成两段：

[ size_t (记录100) ][ 100字节真正可用空间 ]
 ^                  ^
 |                  |
 ptr - 8            ptr（返回给用户）

这段 PREFIX_SIZE 的内容是 Redis 自己写进去的：

*((size_t*)ptr) = size;

然后返回的是后面的空间：

return (char*)ptr + PREFIX_SIZE;

二、跳表的结构

typedef struct redisObject {
    unsigned type:4;
    unsigned encoding:4;
    unsigned lru:REDIS_LRU_BITS; /* lru time (relative to server.lruclock) */
    int refcount;
    void *ptr;
} robj;

字段说明：

字段	说明
type	表示这个对象是哪种类型，比如字符串（REDIS_STRING）、有序集合（REDIS_ZSET）
encoding	同一种类型的数据可能有多种存储方式（比如 ZSET 可以是 ziplist 或 skiplist）
lru	用于内存回收策略，比如 LRU，表示最后一次访问时间的抽象
refcount	引用计数，用于内存管理，引用数为 0 时会释放
ptr	指向真实的数据结构（如字符串、哈希表、跳表等）

跳表的结构定义

/* ZSETs use a specialized version of Skiplists */
typedef struct zskiplistNode { // 跳表的节点
    robj *obj;
    double score;
    struct zskiplistNode *backward;
    struct zskiplistLevel {
        struct zskiplistNode *forward;
        unsigned int span;
    } level[];
} zskiplistNode;

typedef struct zskiplist { //跳表的结构
    struct zskiplistNode *header, *tail;
    unsigned long length;
    int level;
} zskiplist;

typedef struct zset {       // 实现由字典和跳表构成
    dict *dict;             // key: 元素成员（sds），value: 分数（double *）
    zskiplist *zsl;         // 跳表结构，按分数排序
} zset;

注意：这里的表头节点和其他的节点有细微区别，表头节点不存储数据的，虽然也有BW,obj,score但是用不上。

关于zskiplistNode节点中的level[]介绍： level[] 是 C99 引入的柔性数组成员，它没有固定大小(默认是0)，必须出现在结构体最后一行。它允许你为结构体动态分配“额外的数组空间”。这里涉及到后面的创建Node的时候的内存分配情况。

三、跳表的代码介绍

3.1 创建跳表

// 创建节点
zskiplistNode *zslCreateNode(int level, double score, robj *obj) {
    // 分配空间
    zskiplistNode *zn = zmalloc(sizeof(*zn)+level*sizeof(struct zskiplistLevel));
    // 赋值
    zn->score = score;
    zn->obj = obj;
    return zn;
}

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

解释1：之前提及的柔性数组的问题，所以我们需要手动的为level分配大小为 level*sizeof(struct zskiplistLevel)的空间

3.2 插入节点

zskiplistNode *zslInsert(zskiplist *zsl, double score, robj *obj) {
    zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
    unsigned int rank[ZSKIPLIST_MAXLEVEL];
    int i, level;

    redisAssert(!isnan(score));
    x = zsl->header;
    
    /* 从最顶层一层一层的向下找
     * 比如当前位于第i层，该层节点x后面的node小于我的插入节点，那么我就往后移
     *       后移的时候：更新rank[i]，相当于我往后移了以后，我目前节点是第几个节点
     * 如果当前层后面的节点大于我的插入节点，那么我就需要向下移动节点，但是移动前，
     * 需要跟新我当前层我最多可以走到了哪个节点
     * 最终，找到一个x，也就是我的新节点要插入到X后面 */
     
    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 &&
                compareStringObjects(x->level[i].forward->obj,obj) < 0))) {
            rank[i] += x->level[i].span;
            x = x->level[i].forward;
        }
        update[i] = x;
    }
    
    /* we assume the key is not already inside, since we allow duplicated
     * scores, and the re-insertion of score and redis object should never
     * happen since the caller of zslInsert() should test in the hash table
     * if the element is already inside or not. */
    // 创建一个新节点,其level层数是随机的
    // 并不是说一定是n,n/2,n/4,n/8这种按照二叉树每层缩短一半（影响插入删除）
    level = zslRandomLevel();
    //判断新节点层数是否超过当前跳跃表最大层数 
    // - zsl->level 存储的是当前整个跳跃表中所有节点的最大层数。 
    // - 如果新生成的随机层数 level 比当前跳跃表的最大层数 zsl->level 还要大， 
    //   意味着跳跃表需要“长高”，需要增加新的层级来容纳这个新节点。
    if (level > zsl->level) {
        // 这个 for 循环遍历所有新增的层级。注意：此时还没有插入节点
        for (i = zsl->level; i < level; i++) {
            rank[i] = 0;
            //在这些新层级 i 上，新节点插入位置的前一个节点必然是跳跃表的头节点
            update[i] = zsl->header;
            // 此时新层级直接会走到末尾，也就是跨越所有节点
            update[i]->level[i].span = zsl->length;
        }
        zsl->level = level;
    }
    x = zslCreateNode(level,score,obj);
    
    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;
}

update[i]: 保存的是在第 i 层，新元素应该插入位置的前一个节点。例如，update[0] 是在最底层 (level 0) 插入位置的前一个节点。

rank[i]: 保存的是从跳跃表头节点出发，沿着第 i 层到达 update[i] 这个节点（不包括 update[i] 自身）总共跨越了多少个节点。特别是 rank[0]，它表示 update[0] 节点在整个跳跃表中的排名（从 0 开始计数，如果想得到 1 开始的排名通常需要 +1，具体看后续逻辑）。

作用是：插入了一个新node以后，我需要更新这个node的各层level指向