Redis-五种数据结构之列表（ziplist、quicklist）

列表

文章目录

列表
- 压缩列表-ziplist
- - ziplist 定义
  - 级联更新
- 快速列表-quicklist
- - quicklistNode 定义
  - quicklist 定义
  - quicklist常用操作
  - 其他操作
  - quicklist 相对于普通链表优点
  - quick应用场景
  - 在redis 中使用quicklist

列表数据类型可以存储一组按插入顺序排序的字符串，他很灵活，支持两端插入、弹出数据可以充当栈和队列的角色。

压缩列表-ziplist

链表和数组都可以实现列表类型，Redis 使用的是链表结构，下面是一种常见的链表实现方式：

typedef struct listNode {
    struct listNode *prev;  //上一个数据节点
    struct listNode *next;	//下一个数据节
    void *value;   			//数据内容
} listNode;

typedef struct list {
    listNode *head;
    listNode *tail;
    void *(*dup)(void *ptr);
    void (*free)(void *ptr);
    int (*match)(void *ptr, void *key);
    unsigned long len;
} list;

Redis 内部使用该链表来保存运行数据，比如主服务器下的所有从服务器的信息。

但Redis 并不使用该链表来保存用户列表的数据，因为他对内存管理不够友好，原因如下：

链表的每个节点都占用一块独立的内存，导致了内存碎片古过多。
链表节点中前后节点指针占用过多的额外内存。

那数组就可以完美的解决这两个问题

ziplist就是一个类似数组的紧凑型链表，他会申请一整块的内存，在这个内存上存放所有的数据，

这就是ziplist的设计思想。

ziplist 定义

ziplist 的总体布局如下

…

zlbytes：ziplist的长度。 4字节
zltail：ziplist头部到末尾元素的长度，通过zltail字段可以很方便获取末尾元素的地址。4字节
zllen：元素的个数，最大可以存放65535个元素。2字节
zlend：结束标志，值固定为0xFF。
entry: ziplist 中保存的节点 1字节

节点布局

entry-data : 该节点元素，即节点存储的数据
prevlen: 记录前驱节点的长度，该属性的长度为1字节或者5字节
- 如果前一个元素长度小于254，则该属性占用1byte
- 否则，第一个字节固定为254，剩余4byte存放前一个元素的长度，不为255的原因是255和结尾标志重复

enconding:表示编码类型有以下几种：

字符串编码：字符串类型有1、2、5三种编码长度，前两位表示编码类型，剩余位表示字符串长度

00|aaaaaa：存储长度小于等于63byte的字符串。
01|aaaaaa bbbbbbbb：存储长度小于等于16383byte的字符串。
10|...... bbbbbbbb cccccccc dddddddd eeeeeeee：存储长度小于等于4294967295byte的字符串，'.'固定为0。

整型编码

1100 0000：表示16位有符号整数，entry-data占用2byte。
1101 0000：表示32位有符号整数，entry-data占用4byte。
1110 0000：表示64位有符号整数，entry-data占用8byte。
1111 0000：表示24位有符号整数，entry-data占用3byte。
1111 1110：表示8位有符号整数，entry-data占用1byte。
1111 0001 - 1111 1101：没有entry-data部分，依次表示整数0-12。

级联更新

级联更新是指因为插入、删除、更新等操作导致后续连续多个元素出现更新的现象。核心原因是ziplist的每个元素存放着上一个元素的长度。最差情况下，后面所有元素都得更新，但是这种情况很少见。

快速列表-quicklist

quicklist 的设计思想很简单，将一个ziplist 拆分成多个短的ziplist ,避免插入或者删除元素时会导致大量内存拷贝

**quicklist 其实就是简单的双链表，但每个双链表节点中保存一个 ziplist，**然后每个 ziplist 中存一批 list 中的数据 (具体 ziplist 大小可配置)，这样既可以避免大量链表指针带来的内存消耗，也可以避免 ziplist 更新导致的大量性能损耗，将大的 ziplist 化整为零。

quicklistNode 定义

typedef struct quicklistNode {
    struct quicklistNode *prev;
    struct quicklistNode *next;
    unsigned char *zl; 				// quicklist节点对应的ziplist -指向了一个 ziplist 结构
    unsigned int sz;                // ziplist的字节数 
    unsigned int count : 16; 		// ziplist的元素数量
    unsigned int encoding : 2; 		// 数据类型，2表示节点已压缩，1表示节点未压缩
    unsigned int container : 2;     // 目前固定为2 表示使用ziplist 存储数据
    unsigned int recompress : 1; 	// 1表示暂时解压，后续需要时再将其解压- 表示该节点是否需要重新压缩。
    unsigned int attempted_compress : 1; // 节点无法压缩；太小了 
    unsigned int extra : 10; 		// 预留暂未使用
} quicklistNode;

quicklist 定义

当链表很长时，中间节点的访问频率较低，这时Redis 会将中间节点进行压缩，更进一步的节省内存空间–采用LZF压缩

//压缩后的节点定义
typedef struct quicklistLZF {
    size_t sz; // 压缩后的ziplist大小
    char compressed[];//存放压缩后的ziplist字节数组
} quicklistLZF;

typedef struct quicklist {
    quicklistNode *head; /* 头结点 */
    quicklistNode *tail; /* 尾结点 */
    unsigned long count; /* 在所有的ziplist中的entry总数 */
    unsigned long len; /* quicklist节点总数 */
    int fill : QL_FILL_BITS; /* 16位，每个节点的最大容量 */
    unsigned int compress : QL_COMP_BITS; /* 16位，quicklist的压缩深度，0表示所有节点都不压缩，否则就表示从两端开始有多											少个节点不压缩 */
    unsigned int bookmark_count: QL_BM_BITS; /*4位，bookmarks数组的大小，bookmarks是一个可选字段，用来quicklist重新													分配内存空间时使用，不使用时不占用空间*/
    quicklistBookmark bookmarks [];
} quicklist;

其中，fill 和 compress 是两个重要的字段，它们决定了 quicklist 的内存和性能特性。

fill 表示每个 quicklistNode 节点的最大容量，不同的数值有不同的含义，默认是 -2，当然也可以配置为其他数值，具体数值含义如下：

fill	含义
-1	每个 quicklistNode 节点的 ziplist 所占字节数不能超过 4kb。
-2	每个 quicklistNode 节点的 ziplist 所占字节数不能超过 8kb。（默认配置&建议配置）
-3	每个 quicklistNode 节点的 ziplist 所占字节数不能超过 16kb。
-4	每个 quicklistNode 节点的 ziplist 所占字节数不能超过 32kb。
-5	每个 quicklistNode 节点的 ziplist 所占字节数不能超过 64kb。
任意正数	表示：ziplist 结构所最多包含的 entry 个数，最大为 215215。

compress 表示 quicklist 的压缩深度，0 表示所有节点都不压缩，否则就表示从两端开始有多少个节点不压缩。例如，compress 为 1 表示从两端开始，有 1 个节点不做 LZF 压缩。LZF 是种无损压缩算法。Redis 为了节省内存空间，会将 quicklist 的节点用 LZF 压缩后存储，但这里不是全部压缩，可以配置 compress 的值。

在这里插入图片描述

quicklist常用操作

创建

quicklist *quicklistCreate(void); // 创建quicklist
quicklist *quicklistNew(int fill, int compress); // 用一些指定参数创建一个新的quicklist
void quicklistSetCompressDepth(quicklist *quicklist, int depth); // 设置压缩深度

头插和尾插

void quicklistPushHead(quicklist *quicklist, void *value, size_t sz); // 头插
void quicklistPushTail(quicklist *quicklist, void *value, size_t sz); // 尾插

头删和尾删

int quicklistPop(quicklist *quicklist, int where, unsigned char **data, size_t *sz, long long *slong); // 头删或尾删

查找

查找操作需要遍历整个 quicklist，对每个 ziplist 进行查找。如果找到了匹配的元素，就返回一个 quicklistEntry 结构体，表示该元素在哪个 ziplist 中，以及在 ziplist 中的位置。

typedef struct quicklistEntry {
    const quicklist *quicklist; //指向所属的quicklist的指针
    quicklistNode *node;		//指向所属的quicklistNode节点的指针
    unsigned char *zi;			//指向当前ziplist结构的指针
    unsigned char *value;		//查找到的元素如果是字符串，则存在value字段
    long long longval;			//查找到的元素如果是整数，则存在longval字段	
    size_t sz;					//保存当前元素的长度
    int offset;					//保存查找到的元素距离压缩列表头部/尾部隔了多少个节点
} quicklistEntry;

int quicklistIndex(const quicklist *quicklist, const long long idx, quicklistEntry *entry); // 根据索引查找元素
void quicklistRewind(const quicklist *quicklist, quicklistIter **iter); // 创建一个从头开始的迭代器
void quicklistRewindTail(const quicklist *quicklist, quicklistIter **iter); // 创建一个从尾开始的迭代器
int quicklistNext(quicklistIter *iter, quicklistEntry *node); // 迭代器获取下一个元素
void quicklistReleaseIterator(quicklistIter *iter); // 释放迭代器

删除

删除操作需要先找到要删除的元素在哪个 ziplist 中，然后调用 ziplist 的删除函数删除该元素。如果删除后导致 ziplist 空了，就把整个 ziplist 节点从链表中删除

void quicklistDelEntry(quicklistIter *iter, quicklistEntry *entry); // 删除迭代器指向的元素
int quicklistDelRange(quicklist *quicklist, const long start, const long stop); // 删除指定范围内的元素

其他操作

除了上面介绍的操作，quicklist 还有一些其它的操作，例如：

quicklistRotate(quicklist *quicklist); // 将尾部的元素移动到头部
quicklistDup(quicklist *orig); // 复制一个 quicklist
quicklistRelease(quicklist *quicklist); // 释放一个 quicklist
quicklistCompare(unsigned char *p1, unsigned char *p2, int p2_len); // 比较两个元素是否相等