Redis数据结构

---

Redis数据结构

1. 动态字符串SDS

我们知道Redis的key都是字符串，而value值一般都是字符串或者字符集合，所以字符串是Redis最常用的一种数据结构。Redis是通过C语言编写的，但Redis并没有直接是用C语言的字符串，因为C语言的字符类型有很多问题。

char* str = "hello";

C语言的字符串是以\0结尾的，而如果我们想在Redis中存储\0的时候就会变得很尴尬。

比如：

• 获取字符串长度需要通过运算
• 不可修改

Redis构建了一种新的字符串结构，称为：动态字符串(SimpleDynamic Stirng)，简称SDS

比如说，使用执行以下SET命令后，Redis会在底层创建两个SDS，一个是包含name的SDS，另一个是包含张三的SDS

127.0.0.1:6379> set name 张三

SDS底层是一个C语言的结构体，

struct __attribute__ ((__packed__)) sdshdr32 {
    uint32_t len; /* buf已经保存的字符串字节个数，不包含结束标识符 */
    uint32_t alloc; /* buf申请的总的字节数，不包含结束标识 */
    unsigned char flags; /* 不同的SDS的头类型，用来控制SDS头的大小 */
    char buf[];
};

Redis提供了多种SDS的结构体来存放不同大小的数据，通过flags来区分。

#define SDS_TYPE_5  0
#define SDS_TYPE_8  1
#define SDS_TYPE_16 2
#define SDS_TYPE_32 3
#define SDS_TYPE_64 4

假设一个SDS中存放的是一个name

SDS之所以叫做动态字符串，是因为它具备动态扩容的能力，例如一个内容为test的SDS

假设我们要给SDS追加一段字符串，aa，这里首先会申请内存空间：

• 如果新字符串小于1M，则新空间为扩展后字符串长度的两倍+1
• 如果新字符串大于1M，则新空间为扩展后字符串长度+1M+1。称为内存预分配

为啥要进行内存预分配？因为想要申请内存空间，需要进行系统调用，而这个过程是非常消耗时间的，所以Redis为了效率，就在扩容时多申请一点空间，减少扩容次数。

SDS的优点：

• 获取字符串长度的时间复杂度为O(1)
• 支持动态扩容
• 减少内存分配次数

2. IntSet

IntSet是Redis中set集合的一种实现方式，基于整数数组来实现，并且具备长度可变、有序等特征。

IntSet的结构如下：

typedef struct intset {
    uint32_t encoding;// 编码方式，支持存放16位、32位、64位整数
    uint32_t length;//元素个数
    int8_t contents[];//整形数组，存储数据集合
} intset;

• contents存放的是数组首元素的地址
• 数组元素的大小由encoding编码方式决定
• 规定编码方式是为了方便以后查询数据通过指针寻址

其中的encoding包含三种模式，表示存储的整数大小不同：

/* Note that these encodings are ordered, so:
 * INTSET_ENC_INT16 < INTSET_ENC_INT32 < INTSET_ENC_INT64. */
#define INTSET_ENC_INT16 (sizeof(int16_t)) // 2个字节。类似于Java中的short
#define INTSET_ENC_INT32 (sizeof(int32_t)) // 4个字节，类似于Java中的int
#define INTSET_ENC_INT64 (sizeof(int64_t))// 8个字节 ，类似于Java中的long

为了方便查找，Redis会将intset中所有的整数按照升序依次保存在contents数组中，结构如图：

现在，数组中每个数字都在int16_t的范围内，因此采用的编码方式是INTSET_ENC_INT16，每部分占用的字节大小为：

• encoding：4字节
• length：4字节
• contents：2字节*3=6字节

IntSet升级

现在，假设有一个intset，元素为{5,10，20}，采用的编码是INTSET_ENC_INT16，则每个整数占2字节：

我们向该其中添加一个数字：50000，这个数字超出了int16_t的范围，intset会自动升级编码方式到合适的大小。

以当前案例来说流程如下：

1. 升级编码为INTSET_ENC_INT32, 每个整数占4字节，并按照新的编码方式及元素个数扩容数组
2. 从数组最后一个元素开始从后向前拷贝，倒序依次将数组中的元素拷贝到扩容后的正确位置
3. 最后，将inset的encoding属性改为INTSET_ENC_INT32，将length属性改为4

IntSet新增流程

intset *intsetAdd(intset *is, int64_t value, uint8_t *success) {
    uint8_t valenc = _intsetValueEncoding(value); // 获取当前插入数据的编码
    uint32_t pos;// 要插入的位置
    if (success) *success = 1;
    // 判断编码是不是超过了当前intset的编码
    if (valenc > intrev32ifbe(is->encoding)) {
        // 插入元素超出当前编码范围，需要升级编码
        return intsetUpgradeAndAdd(is,value);
    } else {
        // 在当前intset中查找值和插入的value一样的元素的下标pos
        // 使用二分查找来定位元素下标
        if (intsetSearch(is,value,&pos)) {
            if (success) *success = 0;// 找到了则无需插入，直接返回失败
            return is;
        }
        // 数组扩容
        is = intsetResize(is,intrev32ifbe(is->length)+1);
        // 移动数组中pos之后的元素到pos+1,给新元素腾出空间
        if (pos < intrev32ifbe(is->length)) intsetMoveTail(is,pos,pos+1);
    }
    // 插入新元素
    _intsetSet(is,pos,value);
    // 重置元素长度
    is->length = intrev32ifbe(intrev32ifbe(is->length)+1);
    return is;
}

编码升级代码

/* Upgrades the intset to a larger encoding and inserts the given integer. */
static intset *intsetUpgradeAndAdd(intset *is, int64_t value) {
    // 获取当前intset编码
    uint8_t curenc = intrev32ifbe(is->encoding);
    // 获取新编码
    uint8_t newenc = _intsetValueEncoding(value);
    int length = intrev32ifbe(is->length);
    // 判断新元素是大于0还是小于0，小于0插入队首、大于0插入队尾
    int prepend = value < 0 ? 1 : 0;
    // 重置编码为新编码
    is->encoding = intrev32ifbe(newenc);
    // 重置数组大小
    is = intsetResize(is,intrev32ifbe(is->length)+1);

    // 倒序遍历，逐个搬运元素到新的位置，_intsetGetEncoded按照旧的编码方式查询元素
    // _intsetSet按照新的编码方式插入元素
    while(length--)
        _intsetSet(is,length+prepend,_intsetGetEncoded(is,length,curenc));

    // 插入新元素，prepend决定是队首还是队尾
    if (prepend)
        _intsetSet(is,0,value);
    else
        _intsetSet(is,intrev32ifbe(is->length),value);
    // 修改数组长度
    is->length = intrev32ifbe(intrev32ifbe(is->length)+1);
    return is;
}

intset是使用二分查找来查找元素是否已经存在，就算元素不存在同时二分查找也能定位到新的元素的插入位置

static uint8_t intsetSearch(intset *is, int64_t value, uint32_t *pos) {
    // 初始化二分查找需要的下标
    int min = 0, max = intrev32ifbe(is->length)-1, mid = -1;
    int64_t cur = -1;

    // 如果数组为空直接插入
    if (intrev32ifbe(is->length) == 0) {
        if (pos) *pos = 0;
        return 0;
    } else {
        // 数组不为空，判断value是否大于数组中最大值，小于最小值
        if (value > _intsetGet(is,max)) {
            // 大于最大值插入到尾
            if (pos) *pos = intrev32ifbe(is->length);
            return 0;
        } else if (value < _intsetGet(is,0)) {
            // 小于最小值，插入到头
            if (pos) *pos = 0;
            return 0;
        }
    }
    // 开始二分
    while(max >= min) {
        mid = ((unsigned int)min + (unsigned int)max) >> 1;
        cur = _intsetGet(is,mid);
        if (value > cur) {
            min = mid+1;
        } else if (value < cur) {
            max = mid-1;
        } else {
            break;
        }
    }
    // 判断要插入的新元素是否在数组中已经存在
    if (value == cur) {
        if (pos) *pos = mid;
        return 1;
    } else {
        if (pos) *pos = min;
        return 0;
    }
}

小结：

IntSet可以看做事特殊的整数数组

1. Redis会保证intset的元素唯一有序
2. 具备编码升级机制，可以节省内空间
3. 底层采用二分查找来查询元素

当然当数据量非常大时，IntSet的查询效率就会变低，毕竟二分的时间复杂度为$O(logn)$

3. Dict

我们知道Redis是一个键值型（Key-Value Pair）的数据库，我们可以根据键实现快速的增删改查。而键与值的映射关系正是通过Dict来实现的,底层使用数组+链表实现，并使用头插法进行插入

Dict由三部分组成，分别是：哈希表（DictHashTable）、哈希节点（DictEntry）、字典（Dict）

typedef struct dictht {
    // 指向哈希表的二级指针(指向entry数组)
    // entry数组的每个元素都是一个指针
    dictEntry **table;
    // 哈希表大小
    unsigned long size;
    // 哈希表的掩码，sizemask=size-1
    //  用于定位哈希表的下标 sizemask&hash
    unsigned long sizemask;
    // 哈希表中节点entry个数
    unsigned long used;
} dictht;

哈希表节点结构体

typedef struct dictEntry {
    void *key;// 键
    // 联合体
    union {
        void *val;
        uint64_t u64;
        int64_t s64;
        double d;
    } v;//值
    struct dictEntry *next;//下一个节点指针
} dictEntry;

字典

typedef struct dict {
    // dict类型，内置不同的hash函数
    dictType *type;
    // 私有数据，在做特殊hash运算时使用
    void *privdata;
    // 一个Dict包含两个哈希表，其中一个是当前存数据的，另外一个为空，rehash时使用
    dictht ht[2];
    // rehash的进度，-1表示未进行
    long rehashidx;
    // rehash是否暂停,0则继续
    int16_t pauserehash;
} dict;

dict结构

Dict扩容

Dict中的HashTable就是数组结合单向链表的实现，采用头插法进行元素插入，当集合中元素较多时，必然导致哈希冲突增多，链表过长，则查询效率会大大降低。

Dict在每次新增键值对时都会检查负载因子（LoadFactor = used/size） ，满足以下两种情况时会触发哈希表扩容的时机：

• 哈希表的 LoadFactor >= 1，并且服务器没有执行 RDB或者 AOF等后台进程；
• 哈希表的 LoadFactor > 5 ，此时说明哈希冲突已经非常严重了，无论有没有在RDB或者AOF都会直接进行扩容

static int _dictExpandIfNeeded(dict *d)
{
    // 如果正在rehash，则直接返回
    if (dictIsRehashing(d)) return DICT_OK;

    // 如果哈希表为空，则初始化默认哈希表大小为 4
    if (d->ht[0].size == 0) return dictExpand(d, DICT_HT_INITIAL_SIZE);

    // 但负载因子(used/size)达到1以上，并且当前没有有进行 bgrewrite等子进程操作
    // 或者负载因子超过5，则进行dictExpand，也就是扩容
    if (d->ht[0].used >= d->ht[0].size &&
        (dict_can_resize ||
         d->ht[0].used/d->ht[0].size > dict_force_resize_ratio) &&
        dictTypeExpandAllowed(d))
    {
        // 扩容大小为used+1,底层会对扩容做判断，实际上找的是第一个大于等于used+1的2^n
        return dictExpand(d, d->ht[0].used + 1);
    }
    return DICT_OK;
}

Dict收缩

Dict除了扩容以外，每次删除元素时，也会对负载因子做检查，当LoadFactor < 0.1 时，会做哈希表收缩：

如果此时正在rehash或者AOF、RDB则会直接返回不进行收缩

int dictResize(dict *d)
{
    unsigned long minimal;
    // 如果正在做bgsave或者bgrewriteo或者reshash则直接返回
    if (!dict_can_resize || dictIsRehashing(d)) return DICT_ERR;
    // 获取used，也就是entry
    minimal = d->ht[0].used;
    if (minimal < DICT_HT_INITIAL_SIZE)
        // 如收缩大小不能小于4
        minimal = DICT_HT_INITIAL_SIZE;
    // 重置大小minimal，其实是第一个大于等于minimal的2^n
    return dictExpand(d, minimal);
}

Dict的rehash并不是一次性完成的。试想一下，如果Dict中包含数百万的entry，要在一次rehash完成，极有可能导致主线程阻塞。因此Dict的rehash是分多次、渐进式的完成，因此称为渐进式rehash。流程如下：

1. 计算新hash表的size，值取决于当前要做的是扩容还是收缩：
   • 如果是扩容，则新size为第一个大于等于dict.ht[0].used + 1的$2^n$
   • 如果是收缩，则新size为第一个大于等于dict.ht[0].used的$2^n$ （不得小于4）
2. 按照新的size申请内存空间，创建dictht，并赋值给dict.ht[1]设置dict.rehashidx = 0，表示开始rehash
3. 每次执行新增、查询、修改、删除操作时，都检查一下dict.rehashidx是否大于-1，如果是则将dict.ht[0].table[rehashidx]的entry链表rehash到dict.ht[1]，并且将rehashidx++。直至dict.ht[0]的所有数据都rehash到dict.ht[1]
4. 将dict.ht[1]赋值给dict.ht[0]，给dict.ht[1]初始化为空哈希表，释放原来的dict.ht[0]的内存
5. 将rehashidx赋值为-1，代表rehash结束
6. 在rehash过程中，新增操作，则直接写入ht[1]，查询、修改和删除则会在dict.ht[0]和dict.ht[1]依次查找并执行。这样可以确保ht[0]的数据只减不增，随着rehash最终为空

rehashidx表示rehash到哪个hash桶了

在rehash的时候，新增操作时在ht[1]的，其它操作是在ht[0]何ht[1]同时进行的

Dict的结构：

• 类似java的HashMap，底层是数组加链表来解决哈希冲突
• Dict包含两个哈希表，ht[0]平常用，ht[1]用来rehash

Dict的伸缩：

• 当LoadFactor大于5或者LoadFactor大于1并且没有子进程任务时，Dict扩容
• 当LoadFactor小于0.1时，Dict收缩
• 扩容大小为第一个大于等于used + 1的2^n
• 收缩大小为第一个大于等于used 的2^n
• Dict采用渐进式rehash，每次访问Dict时执行一次rehash
• urehash时ht[0]只减不增，新增操作只在ht[1]执行，其它操作在两个哈希表

小结：

• Dict的是通过数组链表来实现的，链表的每个节点包含Key和val，key和val是一个指针，指向的都是一个个SDS对象
• Dict在内存中大量的使用指针，所以说这些数据都不是连续的。这种模式的问题就存在问题就是由于内存不连续容易产生内存碎片，而指针也是需要占用空间的，所以大量的指针会占用内存空间。

4. ZipList

ZIpList(压缩列表)，是一种特殊的“双端链表”，由一系列特殊编码的连续内存块组成，可以在任意一端进行压入/弹出操作, 并且该操作的时间复杂度为 O(1)。

属性	类型	长度	用途
zlbytes	uint32_t	4字节	记录整个压缩列表占用的内存字节数
zltail	uint32_t	4字节	记录压缩列表表尾节点距离压缩列表的起始地址有多少字节，通过这个偏移量，可以确定表尾节点的地址。
zllen	uint16_t	2字节	记录了压缩列表包含的节点数量。最大值为UINT16_MAX （65534），如果超过这个值，此处会记录为65535，但节点的真实数量需要遍历整个压缩列表才能计算得出
entry	列表节点	不定	压缩列表包含各个节点，节点的长度由节点的内容决定
zlend	uint8_t	1字节	特殊值 0xFF （十进制 255 ），用于标记压缩列表的末端。

ZipListEntry

ZipList 中的Entry并不像普通链表那样记录前后节点的指针，因为记录两个指针要占用16个字节，浪费内存。而是采用了下面的结构：

• previous_entry_length：前一节点的长度，占1个或5个字节。
  • 如果前一节点的长度小于254字节，则采用1个字节来保存这个长度值
  • 如果前一节点的长度大于254字节，则采用5个字节来保存这个长度值，第一个字节为0xfe，后四个字节才是真实长度数据
• encoding：编码属性，记录content的数据类型（字符串还是整数）以及长度，占用1个、2个或5个字节
• contents：负责保存节点的数据，可以是字符串或整数

注意：ZipList中所有存储长度的数值都采用的是小端序存储

Encoding编码

ZipListEntry中的encoding编码分为字符串和整数两种：

字符串：如果encoding是以“00”、“01”或者“10”开头，则证明content是字符串

编码	编码长度	字符串大小
$00pppppp$	$1bytes$	$<=63bytes$
$	01pppppp	qqqqqqqq
$	10000000	qqqqqqqq

假设我们要保存字符串 “ab”和"ba"

整数：如果encoding是以“11”开始，则证明content是整数，且encoding固定只占用1个字节

编码	编码长度	整数类型
11000000	1	int16_t（2 bytes）
11010000	1	int32_t（bytes）
11100000	1	int64_t（8bytes）
11110000	1	24位有符整数(3bytes)
11111110	1	8位有符整数(1bytes)
1111xxxx	1	直接在xxxx位置保存数值，范围从0001~1101，减1后结果为实际值

ZipList在存储数字$0$到$12$的时候，会将编码格式设置为$1111xxxx$，也就说存储0到12数字的时候不需要contents来保存数据，通过编码就能表示，因为要存储0所以要通过编码减一就能得到对应的数据

比如果说要存储2和5，2的编码为11110011十六进制为f3，5的编码为11110110十六进制为f6，编码减一就得到了数据。如图：

ZipList的连锁更新问题

ZipList的每个Entry都包含previous_entry_length来记录上一个节点的大小，长度是1个或5个字节：

• 如果前一节点的长度小于254字节，则采用1个字节来保存这个长度值
• 如果前一节点的长度大于等于254字节，则采用5个字节来保存这个长度值，第一个字节为0xfe，后四个字节才是真实长度数据

现在，假设我们有N个连续的、长度为250~253字节之间的entry，因此entry的previous_entry_length属性用1个字节即可表示，如图所示：

如果此时在此时在偷节点插入一个260个字节的节点，

此时这个260个字节的节点被插入后，后续的节点的记录前一个节点长度(previous_entry_length)的信息就需要更新，由由于头节点大于254字节那么这个长度就需要5个字节表示，那么就会导致后续的节点大小都大于等于254个字节，开始连续向后更新每个节点的previous_entry_length。

ZipList这种特殊情况下产生的连续多次空间扩展操作称之为连锁更新（Cascade Update)。新增、删除都可能导致连锁更新的发生。

ZipList特性：

1. 压缩列表的可以看做一种连续内存空间的"双向链表"
2. 列表的节点之间不是通过指针连接，而是记录上一节点和本节点长度来寻址，内存占用较低
3. 如果列表数据过多，导致链表过长，可能影响查询性能
4. 增或删较大数据时有可能发生连续更新问题

5. QuickList

ZipList存在一些问题：

• 问题1：ZipList虽然节省内存，但申请内存必须是连续空间，如果内存占用较多，申请内存效率很低。怎么办？

  • 为了缓解这个问题，我们必须限制ZipList的长度和entry大小。

• 问题2：但是我们要存储大量数据，超出了ZipList最佳的上限该怎么办？

  • 我们可以创建多个ZipList来分片存储数据。

• 问题3：数据拆分后比较分散，不方便管理和查找，这多个ZipList如何建立联系？

  Redis在3.2版本引入了新的数据结构QuickList，它是一个双端链表，只不过链表中的每个节点都是一个ZipList

为了避免QuickList中的每个ZipList中entry过多，Redis提供了一个配置项：list-max-ziplist-size来限制。

如果值为正，则代表ZipList的允许的entry个数的最大值

如果值为负，则代表ZipList的最大内存大小，分5种情况：

• -1：每个ZipList的内存占用不能超过4kb
• -2：每个ZipList的内存占用不能超过8kb
• -3：每个ZipList的内存占用不能超过16kb
• -4：每个ZipList的内存占用不能超过32kb
• -5：每个ZipList的内存占用不能超过64kb

其默认值为 ：-2

除了控制ZipList的大小，QuickList还可以对节点的ZipList做压缩。通过配置项list-compress-depth来控制。因为链表一般都是从首尾访问较多，所以首尾是不压缩的。这个参数是控制首尾不压缩的节点个数：

• 0：特殊值，代表不压缩
• 1：标示QuickList的首尾各有1个节点不压缩，中间节点压缩
• 2：标示QuickList的首尾各有2个节点不压缩，中间节点压缩

以此类推

QuickList源码

typedef struct quicklist {
    // 头节点指针
    quicklistNode *head;
    // 尾节点指针
    quicklistNode *tail;
    // 所有ziplist的entry的数量
    unsigned long count;
    // ziplists总数量
    unsigned long len;
    // ziplist的entry上限，默认值-2
    int fill : QL_FILL_BITS;
    // 首尾不压缩的节点数量
    unsigned int compress : QL_COMP_BITS;
    // 内存重新分配时的书签数量以及数组，一般用不到
    unsigned int bookmark_count: QL_BM_BITS;
    quicklistBookmark bookmarks[];
} quicklist;

QuickListNode结构源码

typedef struct quicklistNode {
    // 前驱指针
    struct quicklistNode *prev;
    // 后继指针
    struct quicklistNode *next;
    // 当前节点的ziplist指针
    unsigned char *zl;
    // 当前节点ZipList的字节大小
    unsigned int sz;
    // 当前节点的ZipList的entrt个数
    unsigned int count : 16;
    // 编码方式：1，ZipList; 2，lzf压缩模式
    unsigned int encoding : 2;
    // 数据容器类型(预留)：1,其它，2，ZipList
    unsigned int container : 2;  
    // 是否被解压缩。1：说明被解压了，将来要重新压缩
    unsigned int recompress : 1; 
    // 测试用
    unsigned int attempted_compress : 1; 
    // 预留字段
    unsigned int extra : 10;
} quicklistNode;

6. SkipList

SkipList（跳表）首先是链表，但与传统链表相比有几点差异：

• 元素按照score升序排列存储

• 节点可能包含多个指针，指针跨度不同

也就说跳表是在双向链表的基础上进行了修改，原本双向链表只有两个指针，而跳表的每一个节点都有着多个指针，且这多个指针指向的节点是跳跃了多个节点，而不像普通链表只是指向下一个节点，如下图所示：

注意一下多级索引其实都是同一个节点，画多个只是为了方便表示。

跳表的查询过程

• 跳表的查询和B+树有点类似，都是通过索引来查询数据，B+树的数据都保存到叶子节点，而跳表的数据保存在最低一层的节点上，其他都是一些指针指向对应的节点。
• 如上图假设要查询的4，他会从4级索引开始判断后面的值是否相同，发现大于则判断下一层，也就是3级索引这一层，发现依旧大于就又会去下一层，二级索引这一层进行判断
• 发现小于要查询的值，则会到该层的下一个节点，继续判断发先下一个值就是要找的值4
• 这里的排序是根据节点score值来进行排序和查询的

假如我们要查询9这个节点，如果是普通链表则需要9次才能查询到，而使用调表只需要两次。同样如果查询的是4这个节点，链表遍历需要4次，而跳表只需要3次

跳表结构体

typedef struct zskiplist {
    // 头尾节点指针
    struct zskiplistNode *header, *tail;
    // 节点数量
    unsigned long length;
    // 最大的索引层级，默认是1
    int level;
} zskiplist;

跳表节点结构体

typedef struct zskiplistNode {
    // 节点存储的值
    sds ele;
    // 节点分数，排序、查找
    double score;
    // 前一个节点指针
    struct zskiplistNode *backward;
    struct zskiplistLevel {
        // 下一个节点的指针
        struct zskiplistNode *forward;
        // 索引跨度
        unsigned long span;
    } level[];// 多级索引数组
} zskiplistNode;

内存结构

小结：

• 跳表是一个双向链表，每个节点都包含score和ele值
• 节点按照score值排序，score值一样则按照ele字典排序
• 每个节点都可以包含多层指针，层数是1到32之间的随机数，到底有多少层，底层会根据特定算法来推测多少层比价合适
• 不同层指针到下一个节点的跨度不同，层级越高，跨度越大
• 增删改查效率与红黑树基本一致，实现却更简单

为啥用跳表而不用红黑树？

1. 首先跳表的实现比平衡树简单，只是需要修改节点指向即可，更方便调试
2. 在执行ZRANGE 这种范围查询，跳表实现起来其实更简单，而平衡树需要中序遍历，并且不太好实现
3. 从内存占用方面来说，平衡树的左右孩子节点是固定的，而跳表的索引则是按照特定算法随机生成的，内存占用上其实更有优势

---