Redis底层实现原理之五大基础结构

文章目录

[1. 基础结构和编码类型](#1. 基础结构和编码类型)
[2. 编码类型和数据结构实现](#2. 编码类型和数据结构实现)
- [2.1 字符串（String）](#2.1 字符串（String）)
- [2.2 压缩列表（listpack）](#2.2 压缩列表（listpack）)
- [2.3 哈希表（hashtable）](#2.3 哈希表（hashtable）)
- [2.4 快速列表（quicklist）](#2.4 快速列表（quicklist）)
- [2.5 整数集合（intset）](#2.5 整数集合（intset）)
- [2.6 跳表（skiplist）](#2.6 跳表（skiplist）)

1. 基础结构和编码类型

Redis所有的值对象都是用RedisObject进行存储的，其结构如下：

C 复制代码

typedef struct redisObject {
    unsigned type:4;        // 数据类型（String, Hash, List, Set, ZSet）
    unsigned encoding:4;    // 当前使用的底层编码（如 int, embstr, hashtable 等）
    unsigned lru:24;        // LRU 时间戳或 LFU 计数
    int refcount;           // 引用计数，用于内存回收
    void *ptr;              // 指向实际数据的指针
} robj;

非int数值一个RedisObject固定开销16字节：

type：4位 = 0.5字节
encoding：4位 = 0.5字节
lru：24位 = 3字节
refcount：32位 = 4字节
ptr：64位 = 8字节（OBJ_ENCODING_INT直接存的是整数值，少了指针消耗）

type（数据逻辑类型）：对应五大基础类型：

OBJ_STRING：字符串String，基础数据类型
OBJ_HASH：哈希表Hash，存储键值对，在紧凑性和性能间权衡
OBJ_LIST：列表List，存储有序的字符串元素
OBJ_SET：集合Set，存储唯一、无序的字符串元素
OBJ_ZSET：有序集合ZSet，存储有序且唯一的对象，权衡有序性、性能和内存

encoding（编码方式）：标识ptr指针引用的实际底层实现数据结构，和type对应关系：

OBJ_STRING（字符串） ：保存最基础的字符串、整数和浮点数
1. OBJ_ENCODING_INT ：
  - 条件：整数值小于LONG_MAX，即64位符号整数，-2⁶³~2⁶³-1
  - 数据结构和特点：整数值类型int，ptr直接存储整数值
2. OBJ_ENCODING_EMBSTR ：
  - 条件：字符串长度≤44字节
  - 数据结构和特点：短字符串类型embstr（SDS），RedisObject和SDS结构在一块连续内存中
3. OBJ_ENCODING_RAW ：
  - 条件：字符串长度>44字节
  - 数据结构和特点：长字串类型raw（SDS），RedisObject和SDS分别在两块内存中分配
OBJ_HASH（哈希表） ：用于存储多个字段的映射关系，如同一个key下id=XX，name=XX
1. OBJ_ENCODING_LISTPACK ：
  - 条件：字段和值的字符串长度≤hash-max-listpack-value（默认64）且字段数量<=hash-max-listpack-entries（默认512）
  - 数据结构和特点：底层使用listpack，仅适用于少量键值对的情况
2. OBJ_ENCODING_HT ：
  - 条件：不满足listpack
  - 数据结构和特点：使用字典Dict，标准的哈希结，增删改查为O(1)，较耗内存
OBJ_LIST（列表） ：保存存入数据顺序的简单列表，可用于简单的队列保存
1. OBJ_ENCODING_QUICKLIST ：
  - 条件：默认
  - 数据结构和特点：使用quickList，双向链表和listpack的混合结构，每个链表节点指向一个listpack
OBJ_SET（集合） ：无需且唯一的集合，可用于快速搜索或获取交集等
1. OBJ_ENCODING_INTSET ：
  - 条件：集合中元素都是整数值且元素数量<=set-max-intset-entries（默认512）
  - 数据结构和特点：底层使用intset，内存效率极高，支持二分查找
2. OBJ_ENCODING_HT ：
  - 条件：不满足intset
  - 数据结构和特点：使用字典Dict，标准的哈希结，增删改查为O(1)，较耗内存
OBJ_ZSET（有序集合） ：带有权重值的排序且唯一集合，常用于排行榜等场景
1. OBJ_ENCODING_LISTPACK ：
  - 条件：元素数量≤zset-max-listpack-entries（默认128）且所有成员长度 ≤ zset-max-listpack-value(默认64字节)
  - 数据结构和特点：底层使用listpack，仅适用于少量键值对的情况
2. OBJ_ENCODING_SKIPLIST ：
  - 条件：不满足listpack
  - 数据结构和特点：使用跳跃表skiplist+字典dict的混合结构，兼具排查+查找性能，内存开销最大

2. 编码类型和数据结构实现

编码类型一共有8种：

OBJ_ENCODING_INT：字符整数
OBJ_ENCODING_EMBSTR：embstr字符串
OBJ_ENCODING_RAW：raw字符串
OBJ_ENCODING_LISTPACK：listpack压缩列表
OBJ_ENCODING_HT：hashtable哈希表
OBJ_ENCODING_QUICKLIST：quicklist快速列表
OBJ_ENCODING_INTSET：intset整数集合
OBJ_ENCODING_SKIPLIST：skiplist跳表

2.1 字符串（String）

对应编码类型：

OBJ_ENCODING_INT
OBJ_ENCODING_EMBSTR
OBJ_ENCODING_RAW

SDS（Simple Dynamic String）结构体如下：

C 复制代码

struct __attribute__ ((__packed__)) sdshdr8 {
    uint8_t len;        /* 已使用的字节数 */
    uint8_t alloc;       /* 申请的总字节数（不包括头结构和结尾空字符） */
    unsigned char flags;/* 类型标志（3位表示类型，5位未使用） */
    char buf[];         /* 柔性数组，存放实际的字符串内容（以'\0'结尾） */
};

SDS类型：

sdshdr5 ：
- flags：SDS_TYPE_5
- 最大len：2⁵ = 32
- alloc：未使用，已分配长度记录在flags的高5位
sdshdr8 ：
- flags：SDS_TYPE_8
- len：0 ~ 2⁸ - 1 = 0 ~ 255
- alloc：2⁸ - 1 = 255
sdshdr16 ：
- flags：SDS_TYPE_16
- len：0 ~ 2¹⁶ - 1
- alloc：2¹⁶ - 1
sdshdr32 ：
- flags：SDS_TYPE_32
- len：0 ~ 2³² - 1
- alloc：2³² - 1
sdshdr64 ：
- flags：SDS_TYPE_64
- len：0 ~ 2⁶⁴ - 1
- alloc：2⁶⁴ - 1

在Redis 7.2.4中，sdshdr5被弃用，被sdshdr8代替

embstr和RedisObject分配在一个内存块，通常一个内存块为64字节，最大长度=RedisObject（16字节） - sdshdr8（结构体3字节）- '\0'（1字节）=64-16-3-1=44字节

SDS可以向上扩容，但无法向下降级，如sdshdr8可以变成sdshdr16，但sdshdr32无法变成sdshdr16

2.2 压缩列表（listpack）

适用于少量数据的哈希表和有序集合

listpack本质上是一个字节数组，常说的listpack总大小、entry数量和entry数组只是逻辑化的概念，在listpack中都存储在同一个字节数组中。结构如下：

复制代码

listpack结构示意：
|total_bytes|num_elements|entry1|entry2|...|entryN|LP_EOF|

entry结构示意：
|encoding_type|entry_data|entry_len|

listpack结构：

total_bytes：总大小，占4字节
num_elements：entry数量，占2字节
entry：逻辑元素节点
LP_EOF：结束符，占1字节

entry结构：

encoding_type：编码类型，根据第一个字节决定数据类型和存储方式
entry_data：不同编码类型对应存储的内容
entry_len ：
- 存储内容：存储了encoding_type和entry_data两部分的总字节数
- 未结束标识：字节最高位是1
- 结束标识：字节最高位是0
- 有效数据位：字节的低七位

当做有序集合使用时，会使用二分搜索查找合适的位置进行插入，再将后面的元素往后挪

2.3 哈希表（hashtable）

适用于哈希表和集合

数据结构底层是Dict，使用链表解决哈希冲突，结构如下：

C 复制代码

typedef struct dict {
    dictType *type;  // 指向一系列特定于类型函数的指针（哈希函数、键比较函数等）
    void *privdata;  // 传递给上述函数的可选私有数据
    dictht ht[2];    // 两个哈希表（dictht结构）
    long rehashidx;  // rehash 进度索引，-1 表示未在进行 rehash
    int16_t pauserehash; // 如果 >0，则 rehash 被暂停
} dict;
typedef struct dictht {
    dictEntry **table;      // 指向桶数组的指针（每个元素是 dictEntry 链表的头指针）
    unsigned long size;     // 桶数组的大小（总是 2 的幂次）
    unsigned long sizemask; // 用于计算索引的掩码，等于 size-1
    unsigned long used;     // 哈希表中已有的键值对数量
} dictht;
typedef struct dictEntry {
    void *key;               // 键（通常为 sds 字符串）
    union {
        void *val;           // 值（可以指向任何类型，如另一个 sds、redisObject 等）
    } v;                     // 值的联合体
    struct dictEntry *next;  // 指向下一个 dictEntry，形成链表
} dictEntry;

未进行扩容缩容时默认使用的是ht[0]

dictht中sizemask=size-1，额外保存sizemask是为了空间换时间，计算key时减少一次相减运算

查找哈希桶过程：

计算key哈希值
使用sizemask位运算计算桶位置
若桶有链表则遍历链表key是否相同

哈希冲突时，桶节点插入使用的是头插法，即新增的节点会靠前

哈希表新增达到阈值后将会自动扩容，而删除桶数量到达阈值后会触发缩容，扩容和缩容会使用渐进式rehash来完成

渐进式Rehash：

触发条件 ：
- 负载因子：used / size
- 扩容：
  - 未执行BGSAVE/BGREWRITEAOF：负载因子≥1，正常扩容
  - 执行BGSAVE/BGREWRITEAOF：负载因子≥5，Redis持久化时避免扩容消耗内存
- 缩容：负载因子<0.1，避免表空间浪费
扩容大小计算 ：已使用桶数量*2的最小2次幂
- 示例：used=5，5*2=10，10的下个2次幂=16，扩容后大小=16
缩容大小结算 ：已使用桶数量的最小2次幂
- 示例：used=5，5的下个2次幂=8，缩容大小=8
处理流程 ：
1. 初始化：为ht[1]根据扩容缩容分配空间，设置rehashidx=0
2. 分步迁移 ：将ht[0]的key迁移到ht[1]
  - 增删改查触发：执行操作外，还会将ht[0]中rehashidx的桶迁移到ht[1]中，并将rehashidx加一
  - 定时任务：Redis的定时任务隔段时间检测迁移一批桶
  - key的重哈希：key做迁移时，会使用ht[1]的容量大小重新做一次哈希再迁入
3. 双表操作 ：
  - 查询：先后ht[0]和ht[1]，ht[0]查询到返回，否则接着查询ht[1]
  - 更新：增删改操作只会操作ht[1]
4. 完成切换 ：
  - 条件：rehashidx=ht[0].size，即全部迁移完毕
  - 桶操作：释放ht[0]，将ht[1]设置为新的ht[0]，ht[1]再分配空的哈希表
  - 其它参数：设置rehashidx=-1
相比一次性迁移优势 ：
1. 避免阻塞：不会因为扩缩容导致服务不可用
2. 平滑过渡：对客户端透明，无影响
3. 高校内存管理：扩容和缩容代价较小，可以兼顾性能和内存使用效率

2.4 快速列表（quicklist）

quicklist在Redis7.0之前使用的是ziplist，后续使用的是listpack

双向链表+listpack的混合，其结构如下：

C 复制代码

typedef struct quicklist {
    quicklistNode *head;       // 指向链表头节点的指针
    quicklistNode *tail;       // 指向链表尾节点的指针
    unsigned long count;       // 所有 listpack 中元素条目（entry）的总和
    unsigned long len;         // 链表中 quicklistNode 节点的数量
    int fill : 16;             // 单个节点 listpack 的容量控制策略
    unsigned int compress : 16; // 压缩深度，表示链表两端不被压缩的节点个数
} quicklist;

typedef struct quicklistNode {
    struct quicklistNode *prev; // 指向前一个节点的指针
    struct quicklistNode *next; // 指向后一个节点的指针
    unsigned char *lp;          // 指向该节点内存储的 listpack 的指针
    unsigned int sz;            // 该 listpack 占用的内存字节大小
    unsigned int count : 16;    // 该 listpack 中包含的元素条目（entry）数量
    unsigned int encoding : 2;  // 编码方式，表示节点数据是否被压缩
    unsigned int container : 2;  // 数据容器类型，标识 *lp 指向的是 listpack
} quicklistNode;

通过list-max-listpack-size属性来限制每个节点中listpack中的元素数量：

正值：每个listpack存储的元素（entry）数量
负值：每个listpack的最大内存字节数，属于枚举值：
- -1 ：大小不超过4KB
- -2 ：大小不超过8KB（默认值）
- -3 ：大小不超过16KB
- -4 ：大小不超过32KB
- -5 ：大小不超过64KB

通过list-compress-depth属性配置compress压缩深度，内部使用LZF压缩算法对listpack进行无损压缩：

0：不压缩任何节点
1：quicklist两端各有1个节点不压缩，中间节点压缩
2：quicklist两端各有2个节点不压缩，中间节点压缩
3：quicklist两端各有3个节点不压缩，中间节点压缩

2.5 整数集合（intset）

仅适用于整个集都是整数且数量较少的场景，其结构体如下：

C 复制代码

typedef struct intset {
    uint32_t encoding;   // 编码方式，决定contents数组的实际类型
    uint32_t length;     // 集合中元素的数量
    int8_t contents[];   // 柔性数组，用于保存实际的整数值（按升序排列）
} intset;

encoding编码方式：

INTSET_ENC_INT16：表示contents数组是int16_t类型的数组，每个元素占2字节
INTSET_ENC_INT32：表示contents数组是int32_t类型的数组，每个元素占4字节
INTSET_ENC_INT64：表示contents数组是int64_t类型的数组，每个元素占8字节

contents：柔性数组，实际类型由encoding决定。数组中元素按大小升序排序，且不重复

添加元素过程：

检查编码和升级判断 ：判断当前编码是否满足新增元素范围
1. 计算新编码空间：若是INT16升级到INT32，根据新类型确定总空间大小
2. 重新分配内存：为整个intset重新分配内存
3. 倒序迁移数据：从后往前遍历原contents数组元素，并把原数组元素迁移到新数组
查找插入位置 ：
- 编码升级：新插入的元素不符合原范围，即一定比原来的元素大或小，插入头或尾即可
- 使用原编码：使用二分查找确定新元素位置，若已存在则退出
移动元素并插入：将所有元素向后移动一位并在当前位置放入新元素
更新长度：length字段加一

删除元素过程：

查找插入位置：使用二分查找确定新元素位置
移动元素：将需要删除元素的后面元素统一往前挪一位
更新长度：length字段减一

intset的空间利用：

特点：重空间轻性能
正常扩容：每次加一元素容量
编码升级：原数组数量*新编码大小+新编码元素大小
缩容：删除时减一元素容量

intset只有新增和删除，没有更新操作

intset每次新增或删除都会进行扩容或缩容，即使客户端一次性操作批量数据也一样

2.6 跳表（skiplist）

适用于ZSet有序集合，当数据量大于配置阈值时将会使用跳表skiplist+哈希字典表dict的组合方式来实现，其结构如下：

C 复制代码

typedef struct zset {
    dict *dict;        /* 字典：维护 member -> score 的映射，用于 O(1) 查找分值 */
    zskiplist *zsl;    /* 跳跃表：按分值排序存储所有元素，支持高效的范围操作 */
} zset;

/* 跳跃表整体结构 */
typedef struct zskiplist {
    struct zskiplistNode *header, *tail; /* 指向头节点和尾节点的指针 */
    unsigned long length;     /* 跳跃表中节点的数量（不包括头节点） */
    int level;                /* 当前跳跃表中除头节点外，节点的最大层级 */
} zskiplist;

/* 跳跃表节点 */
typedef struct zskiplistNode {
    sds ele;                /* 成员（member） */
    double score;           /* 分值（score） */
    struct zskiplistNode *backward; /* 后退指针（指向前一个节点） */
    struct zskiplistLevel {
        struct zskiplistNode *forward;  /* 前进指针（指向该层下一个节点） */
        unsigned long span;  /* 跨度（记录该层中前进指针指向的节点与当前节点的距离） */
    } level[];               /* 多层索引数组（层级在节点创建时根据幂次定律随机生成） */
} zskiplistNode;

使用跳表为基础数据结构的有序集合ZSet可分为两部分：

跳跃表：实现了数据按分数排序的功能
哈希字典表：提供数据或分数的映射查询

关于ZSet中跳表的构建：

基本概念 ：
- 最大层数：整个跳表允许的最高层数，Redis7固定为32，Redis6固定为64
- 概率因子：固定0.25，插入时节点层数+1的概率
- 链表节点 ：
  - 头尾节点：跳表固定存的节点指针，其中头节点固定有32层最大层数
  - 数据节点：每个数据对应的跳表节点，保存了数据+分数
- 节点层数：各个节点所拥有的的最大层数，最少为1，通过概率因子随机增长层数
- 对应层数跨度：若当前节点为N，代表N层中当前节点到下个节点之间在L0层所跨越的节点数量
核心机制 ：
- 基础链表：每个跳表都有一条包含所有数据节点的基础链表，即L0层链表，其它链表指针都是指向该链表的节点
- 最大层数：跳表支持维护的最大链表数量
- 节点层数：数据节点最大支持在多少条链表中记录同层的顺序关系
- 遍历方式：从最高层往下，同层从左往右遍历
- 节点插入删除：基本的单向链表插入删除步骤
- L0的backward指针：指向在L0层的上个节点，用于反向遍历

假设需要往跳表中依次插入12 -> 7 -> 15 -> 5 -> 10 -> 1 -> 3七个节点，提前假设各个节点随机的层数关系如下：

12：2层
7：3层
15：1层
5：2层
10：4层
1：1层
3：2层

构建数据示例如下：

新增12节点：12节点有2层，维护L0和L1链表

L1: Header -> 12 -> NULL
L0: Header -> 12 -> NULL
新增7节点：7节点有3层，最大层数更新为3，维护L0、L1和L2链表

L2: Header -> 7 -> NULL
L1: Header -> 7 -> 12 -> NULL
L0: Header -> 7 -> 12 -> NULL
新增15节点：15节点只有1层，维护L0链表

L2: Header -> 7 -> NULL
L1: Header -> 7 -> 12 -> NULL
L0: Header -> 7 -> 12 -> 15 -> NULL
新增5节点：5节点有2层，维护L0和L1链表

L2: Header -> 7 -> NULL
L1: Header -> 5 -> 7 -> 12 -> NULL
L0: Header -> 5 -> 7 -> 12 -> 15 -> NULL
新增10节点：10节点有4层，最大层数更新为4，维护L0、L1、L2和L3链表

L3: Header -> 10 -> NULL
L2: Header -> 7 -> 10 -> NULL
L1: Header -> 5 -> 7 -> 10 -> 12 -> NULL
L0: Header -> 5 -> 7 -> 10 -> 12 -> 15 -> NULL
新增1节点：1节点只有1层，维护L0链表

L3: Header -> 10 -> NULL
L2: Header -> 7 -> 10 -> NULL
L1: Header -> 5 -> 7 -> 10 -> 12 -> NULL (注意：Header在L1指向的是5，不是1)
L0: Header -> 1 -> 5 -> 7 -> 10 -> 12 -> 15 -> NULL
新增3节点：5节点有2层，维护L0和L1链表

L3: Header -> 10 -> NULL
L2: Header -> 7 -> 10 -> NULL
L1: Header -> 3 -> 5 -> 7 -> 10 -> 12 -> NULL
L0: Header -> 1 -> 3 -> 5 -> 7 -> 10 -> 12 -> 15 -> NULL

最终链表如下，很形容的诠释了跳表二字：
L3 L2 L1 L1 L1 L1 L0 L0 L0 L0 L0 L0 1 3 5 7 10 12 15

链表中查找3的步骤：

L3链表：3<10，下降到L2链表
L2链表：3<7，下降到L1链表
L1链表：3<5 -> 3=3，返回结果