35张图+万字，Redis文件系统稳稳拿捏住了

指为 Redis 样本戈的构造，构造棒状里两头贮存了连到了 dict 构造的常量； dict 构造，构造棒状里两头贮存了 2 个样本多种类型此表，亦然常仅仅都是用「样本多种类型此表1」，「样本多种类型此表2」只有在 rehash 的时候才用，具棒状什么是 rehash，我在本文的样本多种类型此表嵌套可能会说什么； ditctht 构造，坚指为样本多种类型此表的构造，构造里两头贮存了样本多种类型此表样本多种类型，样本多种类型之同一时间段的每个类型都是连到一个样本多种类型此表路由构造（dictEntry）的常量； dictEntry 构造，坚指为样本多种类型此表路由的构造，构造里两头贮存了 void * key 和 void * value 常量， *key 连到的是 String 单纯，而 *value 则可以连到 String 单纯，也可以连到闭包多种类型的单纯，比如 List 单纯、Hash 单纯、Set 单纯和 Zset 单纯。

特别概述下，void * key 和 void * value 常量连到的是 Redis 单纯，Redis 之同一时间段的每个单纯都由 redisObject 构造坚指为，如上图表：

单纯构造里两头构成的团棒状参数：

type，识别该单纯是什么多种类型的单纯（String 单纯、 List 单纯、Hash 单纯、Set 单纯和 Zset 单纯）； encoding，识别该单纯适用了哪种中层的嵌套； ptr，连到中层嵌套的常量。

我素描了一张 Redis 基团参数对样本戈的全景上图，你就能清晰知道 Redis 单纯和嵌套的关系了：

接下里两头，就尽力忘一下中层嵌套！

二、SDS

亦然则此表达式在 Redis 之同一时间段是很常用的，基团参数对之同一时间段的基团是亦然则此表达式多种类型，参数有时也是亦然则此表达式多种类型。

Redis 是用 C 第二语言借助的，但是它不能必要适用 C 第二语言的 char* 字符串样本多种类型来借助亦然则此表达式，而是自己封装了一个名为恰当动态亦然则此表达式（simple dynamic string，SDS） 的嵌套来坚指为亦然则此表达式，也就是 Redis 的 String 样本多种类型的中层嵌套是 SDS。

既然 Redis 建筑设计了 SDS 构造来坚指为亦然则此表达式，毫无疑问是 C 第二语言的 char* 字符串样本多种类型普遍存在一些缺点。

要明了这一点，取得时来到底 char* 字符串样本多种类型的构造。

1、C 第二语言亦然则此表达式的缺点

C 第二语言的亦然则此表达式回事就是一个字符串样本多种类型，即样本多种类型之同一时间段每个类型是亦然则此表达式之同一时间段的一个字符串。

比如，上图表就是亦然则此表达式“xiaolin”的 char* 字符串样本多种类型的构造：

没人学过 C 第二语言的同学，就可能会好奇为什么终于一个字符串是“”？

在 C 第二语言里两头，对亦然则此表达式转成时，char * 常量只是连到字符串样本多种类型的算起左边，而字符串样本多种类型的整部左边就用“”坚指为，之意是指亦然则此表达式的中止。

因此，C 第二语言准则戈之同一时间段的亦然则此表达式转成给定就通过假定字符串是不是 “” 来决定要绝才会中止转成，如果现阶段字符串不是 “” ，概述亦然则此表达式还没人中止，可以独自转成，如果现阶段字符串是 “” 是则概述亦然则此表达式中止了，就要中止转成。

举个比如问道，C 第二语言给与亦然则此表达式阔度的给定 strlen，就是通过字符串样本多种类型之同一时间段的每一个字符串，并开展计数，等碰见字符串为 “” 后，就可能会中止载入，然后留在从未人口统计到的字符串取参数，即为亦然则此表达式阔度。上图表显示了 strlen 给定的分派方式上：

很微小，C 第二语言给与亦然则此表达式阔度的时间段复杂性是 O（N）（这是一个可以改进型的偏远地区）。

C 第二语言亦然则此表达式用 “” 字符串作为整部标识有个缺点。推论有个亦然则此表达式之同一时间段有个 “” 字符串，这时在转成这个亦然则此表达式时就可能会凯早中止，比如 “xiaolin” 亦然则此表达式，计算出来亦然则此表达式阔度的时候则可能会是 4，如上图表：

因此，除了亦然则此表达式的前面大体上，亦然则此表达式里两头面不用含有 “” 字符串，否则最到时被流程中学毕业入的 “” 字符串将被叫作是亦然则此表达式整部，这个受限使得 C 第二语言的亦然则此表达式状况下留有评注样本，不用留有像上图片、音频、录像带传统文化这样的小数点样本（这也是一个可以改进型的偏远地区）。

另外， C 第二语言准则戈之同一时间段亦然则此表达式的转成给定是很不公共安全的，对流程员很不针锋相对，稍微一不注意，就可能会导致数据流倾倒从新。

举个比如问道，strcat 给定是可以将两个亦然则此表达式拼接在三人。

//将 src 亦然则此表达式拼接到 dest 亦然则此表达式右方

char *strcat(char *dest, const char* src);

C 第二语言的亦然则此表达式是不可能会历史纪录自身的数据流个数的，所以 strcat 给定也就是问道流程员在分派这个给定时，从未为 dest 超过分配了必要多的存储器，可以缩减到 src 亦然则此表达式之同一时间段的所有内容，而一旦这个也就是问道不创立，就可能会频发数据流倾倒从新将就可能会导致流程运自为重新启动，（这是一个可以改进型的偏远地区）。

而且，strcat 给定和 strlen 给定近似于，时间段复杂性也颇高，也都能够到时通过载入亦然则此表达式才能取得目的亦然则此表达式的前面。然后对于 strcat 给定来问道，还要如此一来载入源亦然则此表达式才能未完成特别版，对亦然则此表达式的转成效能不颇高。

好了， 通过以上的分析，我们可以得知 C 第二语言的亦然则此表达式极低之三处以及可以改进型的偏远地区：

给与亦然则此表达式阔度的时间段复杂性为 O（N）； 亦然则此表达式的整部是以 “” 字符串识别，亦然则此表达式里两头面不用构成有 “” 字符串，因此不用留有小数点样本； 亦然则此表达式转成给定不颇高效且不公共安全，比如有数据流倾倒从属于自己可能会，有就可能会导致流程运自为重新启动；

Redis 借助的 SDS 的构造就把右方这些关基团问题补救了，再一我们三人到底 Redis 是如何补救的。

2、SDS 构造建筑设计

上图表就是 Redis 5.0 的 SDS 的嵌套：

构造之同一时间段的每个团棒状参数分别参考下：

len，历史纪录了亦然则此表达式阔度。这样给与亦然则此表达式阔度的时候，状况下够留在这个团棒状参数参数就自为，时间段复杂性状况下够 O（1）。 alloc，超过分配给字符串样本多种类型的室内影间阔度。这样在更改亦然则此表达式的时候，可以通过 alloc - len 计算出来出从新剩余的室内影间个数，可以用来假定室内影间有否假定更改需要，如果不假定的话，就可能会终端将 SDS 的室内影间拓展至分派更改所需的个数，然后才分派大体上的更改转成，所以适用 SDS 既不能够手动更改 SDS 的室内影间个数，也不可能会出从新现下面所问道的数据流倾倒从属于自己关基团问题。 flags，用来坚指为未必相同多种类型的 SDS。一共建筑设计了 5 种多种类型，分别是 sdshdr5、sdshdr8、sdshdr16、sdshdr32 和 sdshdr64，右方在概述区别之三处。 buf[]，字符串样本多种类型，用来留有大体上样本。不仅可以留有亦然则此表达式，也可以留有小数点样本。

总的来问道，Redis 的 SDS 构造在起初字符串样本多种类型底下，减低了三个元样本：len、alloc、flags，用来补救 C 第二语言亦然则此表达式的缺点。

1）O（1）复杂性给与亦然则此表达式阔度

C 第二语言的亦然则此表达式阔度给与 strlen 给定，能够通过载入的模式来人口统计亦然则此表达式阔度，时间段复杂性是 O（N）。

而 Redis 的 SDS 构造因为转为了 len 团棒状参数，那么给与亦然则此表达式阔度的时候，必要留在这个团棒状参数的参数就自为，所以复杂性只有 O（1）。

2）小数点公共安全

因为 SDS 不能够用 “” 字符串来识别亦然则此表达式整部了，而是有个除此以外的 len 团棒状参数来历史纪录阔度，所以可存储构成 “” 的样本。但是 SDS 为了兼容大部分 C 第二语言准则戈的给定， SDS 亦然则此表达式整部还是可能会加上 “” 字符串。

因此， SDS 的 API 都是以三处理事件小数点的模式来三处理事件 SDS 贮普遍存在 buf[] 里两头的样本，流程不可能会对其之同一时间段的样本做任何受限，样本擦除的时候时什么样的，它被存储时就是什么样的。

通过适用小数点公共安全的 SDS，而不是 C 亦然则此表达式，使得 Redis 不仅可以留有评注样本，也可以留有任意PDF的小数点样本。

3）不可能会频发数据流倾倒从新

C 第二语言的亦然则此表达式准则戈凯供的亦然则此表达式转成给定，大多数（比如 strcat 特别版亦然则此表达式给定）都是不公共安全的，因为这些给定把数据流个数有否假定转成需要的管理工作接手开发者来前提，流程内部未必可能会假定数据流个数有否必要用，当频发了数据流倾倒从新就确实导致流程出现异常中止。

所以，Redis 的 SDS 构造里两头引入了 alloc 和 len 团棒状参数，这样 SDS API 通过 alloc - len 计算出来，可以算出从新剩余一般来说的室内影间个数，这样在对亦然则此表达式做更改转成的时候，就可以由流程内部假定数据流个数有否必要用。

而且，当假定出从新数据流个数够时限，Redis 可能会终端将扩大 SDS 的室内影间个数（相等 1MB 翻倍配套，之比 1MB 按 1MB 配套），以假定更改所需的个数。

在拓展 SDS 室内影间之同一时间段，SDS API 可能会优到时检测未能适用室内影间有否必要，如果够的话，API 不仅可能会为 SDS 超过分配更改所须要要的室内影间，还可能会给 SDS 超过分配额外的「未能适用室内影间」。

这样的某种程度是，将会在转成 SDS 时，如果 SDS 室内影间够的话，API 就可能会必要适用「未能适用室内影间」，必需分派存储器超过分配，有效地的减多线程储器超过分配次数。

所以，适用 SDS 即不能够手动更改 SDS 的室内影间个数，也不可能会出从新现数据流倾倒从属于自己关基团问题。

4）浪费存储器室内影间

SDS 构造之同一时间段有个 flags 团棒状参数，坚指为的是 SDS 多种类型。

Redos 一共建筑设计了 5 种多种类型，分别是 sdshdr5、sdshdr8、sdshdr16、sdshdr32 和 sdshdr64。

这 5 种多种类型的主要区别就在于，它们嵌套之同一时间段的 len 和 alloc 团棒状参数的样本多种类型未必相同。

比如 sdshdr16 和 sdshdr32 这两个多种类型，它们的此表述分别如下：

struct originallyattributeoriginally ((originallypackedoriginally)) sdshdr16 {

uint16_t len;

uint16_t alloc;

unsigned char flags;

char buf[];

};

struct originallyattributeoriginally ((originallypackedoriginally)) sdshdr32 {

uint32_t len;

uint32_t alloc;

unsigned char flags;

char buf[];

};

可以注意到：

sdshdr16 多种类型的 len 和 alloc 的样本多种类型都是 uint16_t，坚指为字符串样本多种类型阔度和超过分配室内影间个数不用至少 2 的 16 次方。 sdshdr32 则都是 uint32_t，坚指为坚指为字符串样本多种类型阔度和超过分配室内影间个数不用至少 2 的 32 次方。

之所以 SDS 建筑设计未必相同多种类型的构造棒状，是为了能灵活留有未必相同个数的亦然则此表达式，从而有效地浪费存储器室内影间。比如，在留有小亦然则此表达式时，构造两头改作室内影间也比起少。

除了建筑设计未必相同多种类型的构造棒状，Redis 在编程上还适用了除此以外的编译构建来浪费存储器室内影间，即在 struct 声明了 originallyattributeoriginally ((packed)) ，它的发挥作用是：告诉SQL作废构造棒状在编译补救办法之同一时间段的构建中间，按照大体上改作小数点数开展中间。

比如，sdshdr16 多种类型的 SDS，预设仅仅，SQL可能会按照 16 小数点中间的模式给参数超过分配存储器，这假定，即使一个参数的个数不到 16 个小数点，SQL也可能会给它超过分配 16 个小数点。

举个比如问道，推论右方这个构造棒状，它有两个团棒状参数，多种类型分别是 char 和 int，如下下上图：

#include

struct test1 {

char a;

int b;

} test1;

int main() {

printf("%lu", sizeof(test1));

return 0;

}

大家猜猜这个构造棒状个数是多少？我到时必要问道答案，这个构造棒状个数计算出来出从新来是 8。

这是因为预设仅仅，SQL是适用「小数点中间」的模式超过分配存储器，虽然 char 多种类型只占一个小数点，但是由于团棒状参数里两头有 int 多种类型，它改作了 4 个小数点，所以在团棒状参数为 char 多种类型超过分配存储器时，可能会超过分配 4 个小数点，其之同一时间段这多余的 3 个小数点是为了小数点中间而超过分配的，略低于有 3 个小数点被浪费掉了。

如果就让SQL适用小数点中间的模式开展超过分配存储器，可以选用了 originallyattributeoriginally ((packed)) 未必一定此表述构造棒状，意味著，构造棒状大体上改作多少存储器室内影间，SQL就超过分配多少室内影间。

比如，我用 originallyattributeoriginally ((packed)) 未必一定此表述右方的构造棒状 ，同样构成 char 和 int 两个多种类型的团棒状参数，SQL如下下上图：

#include

struct originallyattributeoriginally((packed)) test2 {

char a;

int b;

} test2;

int main() {

printf("%lu", sizeof(test2));

return 0;

}

这时打印的结果是 5（1 个小数点 char + 4 小数点 int）。

可以看得出从新，这是按照大体上改作小数点数开展超过分配存储器的，这样可以浪费存储器室内影间。

三、链此表

大家最熟悉的嵌套除了样本多种类型大体上，我相信就是链此表了。

Redis 的 List 单纯的中层借助之一就是链此表。C 第二语言本身不能链此表这取参嵌套的，所以 Redis 自己建筑设计了一个链此表嵌套。

1、链此表路由构造建筑设计

到时来到底「链此表路由」构造的样子：

typedef struct listNode {

//同一时间段置路由

struct listNode *pre

//人口为129人路由

struct listNode *next;

//路由的参数

void *value;

} listNode;

有同一时间段置路由和人口为129人路由，可以看的出从新，这个是一个双向链此表。

2、链此表构造建筑设计

不过，Redis 在 listNode 构造棒状思路又封装了 list 这取参嵌套，这样转成出从新去可能会更有效地率，链此表构造如下：

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;

list 构造为链此表凯供了链此表两头常量 head、链此表尾路由 tail、链此表路由为数 len、以及可以自此表述借助的 dup、free、match 给定。

举个比如问道，右方是由 list 构造和 3 个 listNode 构造组成的链此表。

3、链此表的竞争者与缺点

Redis 的链此表借助特性如下：

listNode 链此表路由的构造里两头隐含 prev 和 next 常量，给与某个路由的同一时间段置路由或人口为129人路由的时间段复杂性即可O(1)，而且这两个常量都可以连到 NULL，所以链此表是无环链此表； list 构造因为凯供了此表两头常量 head 和此表尾路由 tail，所以给与链此表的此表两头路由和此表尾路由的时间段复杂性即可O(1)； list 构造因为凯供了链此表路由为数 len，所以给与链此表之同一时间段的路由为数的时间段复杂性即可O(1)； listNode 链此表节适用 void* 常量留有路由参数，并且可以通过 list 构造的 dup、free、match 给定常量为路由设该路由多种类型特定的给定，因此链此表路由可以留有各种未必相同多种类型的参数；

链此表的缺点也是有的：

链此表每个路由两者之间的存储器都是不周内的，假定没人有不错利用 CPU 多线程。能不错利用 CPU 多线程的嵌套就是样本多种类型，因为样本多种类型的存储器是周内的，这样就可以受制于 CPU 多线程来减缓采访。 还有一点，留有一个链此表路由的参数都能够一个链此表路由构造两头的超过分配，存储器负担较大。

因此，Redis 3.0 的 List 单纯在负担比起少的仅仅，可能会选用「压缩成条目」作为中层嵌套的借助，它的竞争者是浪费存储器室内影间，并且是存储器紧凑型的嵌套。

不过，压缩成条目普遍存在效能关基团问题（具棒状什么关基团问题，右方可能会问道），所以 Redis 在 3.2 完整版建筑设计了从属于自己嵌套 quicklist，并将 List 单纯的中层嵌套改由 quicklist 借助。

然后在 Redis 5.0 建筑设计了从属于自己嵌套 listpack，沿用了压缩成条目紧凑型的存储器布置，之后在最从属于自己 Redis 完整版，将 Hash 单纯和 Zset 单纯的中层嵌套借助之一的压缩成条目，换用由 listpack 借助。

四、压缩成条目

压缩成条意在小得多特色，就是它被建筑设计成一种存储器紧凑型的嵌套，改作木头周内的存储器室内影间，不仅可以利用 CPU 多线程，而且可能会针对未必相同阔度的样本，开展可视字符，这种步骤可以有效地地浪费存储器负担。

但是，压缩成条意在缺点也是有的：

不用留有相当多的类型，否则基团入效能就可能会降低； 可选或更改某个类型时，压缩成条目改作的存储器室内影间能够超过超过分配，甚至可能导致快速餐备份的关基团问题。

因此，Redis 单纯（List 单纯、Hash 单纯、Zset 单纯）构成的类型为数较少，或者类型参数略有的状况才可能会适用压缩成条目作为中层嵌套。

再一，就跟大家参考忘下压缩成条目。

1、压缩成条目构造建筑设计

压缩成条目是 Redis 为了节约存储器而开发的，它是由周内存储器块组成的以此类推型嵌套，想像中近似于于样本多种类型。

压缩成条目在此表两头有三个亦然则此表达式：

zlbytes，历史纪录整个压缩成条目改作对存储器小数点数； zltail，历史纪录压缩成条目「尾部」路由一段距离算起地址由多少小数点，也就是条目尾的插值； zllen，历史纪录压缩成条目构成的路由为数； zlend，标识压缩成条意在中止点，比较简单参数 0xFF（十进制255）。

在压缩成条目之同一时间段，如果我们要载入导向第一个类型和终于一个类型，可以通过此表两头三个亦然则此表达式的阔度必要导向，复杂性是 O(1)。而载入其他类型时，就不能这么颇高效了，状况下到时载入，此时的复杂性就是 O(N) 了，因此压缩成条目不适合留有相当多的类型。

另外，压缩成条目路由（entry）的组成如下：

压缩成条目路由构成三大部分内容：

prevlen，历史纪录了「同一时间段一个路由」的阔度； encoding，历史纪录了现阶段路由大体上样本的多种类型以及阔度； data，历史纪录了现阶段路由的大体上样本；

当我们往压缩成条目之同一时间段填充样本时，压缩成条目就可能会根据样本是亦然则此表达式还是取参数，以及样本的个数，可能会适用未必相同室内影间个数的 prevlen 和 encoding 这两个类型里两头留有的信息，这种根据样本个数和多种类型开展未必相同的室内影间个数超过分配的建筑设计思想，亦然是 Redis 为了浪费存储器而选用的。

分别问道下，prevlen 和 encoding 是如何根据样本的个数和多种类型来开展未必相同的室内影间个数超过分配。

压缩成条目里两头的每个路由之同一时间段的 prevlen 未必一定都历史纪录了「同一时间段一个路由的阔度」，而且 prevlen 未必一定的室内影间个数跟同一时间段一个路由阔度参数有关，比如：

如果同一时间段一个路由的阔度相等 254 小数点，那么 prevlen 未必一定能够用 1 小数点的室内影间来留有这个阔度参数； 如果同一时间段一个路由的阔度之比亦然数 254 小数点，那么 prevlen 未必一定能够用 5 小数点的室内影间来留有这个阔度参数；

encoding 未必一定的室内影间个数跟样本是亦然则此表达式还是取参数，以及亦然则此表达式的阔度有关：

如果现阶段路由的样本是取参数，则 encoding 可能会适用 1 小数点的室内影间开展字符。 如果现阶段路由的样本是亦然则此表达式，根据亦然则此表达式的阔度个数，encoding 可能会适用 1 小数点/2小数点/5小数点的室内影间开展字符。

2、快速餐备份

压缩成条目除了载入复杂性颇高的关基团问题，还有一个关基团问题。

压缩成条目可选某个类型或更改某个类型时，如果室内影间不够，压缩成条目改作的存储器室内影间就能够超过超过分配。而当从新填充的类型较大时，就可能会导致后续类型的 prevlen 改作室内影间都频发改变，从而招致「快速餐备份」关基团问题，导致每个类型的室内影间都要超过超过分配，导致采访压缩成条目效能的回升。

下面写到，压缩成条目路由的 prevlen 未必一定可能会根据同一时间段一个路由的阔度开展未必相同的室内影间个数超过分配：

如果同一时间段一个路由的阔度相等 254 小数点，那么 prevlen 未必一定能够用 1 小数点的室内影间来留有这个阔度参数； 如果同一时间段一个路由的阔度之比亦然数 254 小数点，那么 prevlen 未必一定能够用 5 小数点的室内影间来留有这个阔度参数；

以前推论一个压缩成条目之同一时间段有多个周内的、阔度在 250～253 两者之间的路由，如上图表：

因为这些路由阔度参数相等 254 小数点，所以 prevlen 未必一定能够用 1 小数点的室内影间来留有这个阔度参数。

这时，如果将一个阔度之比亦然数 254 小数点的从新路由转为到压缩成条意在此表两头路由，即从新路由将视作 e1 的同一时间段置路由，如上图表：

因为 e1 路由的 prevlen 未必一定只有 1 个小数点个数，没人有留有从新路由的阔度，此时就能够对压缩成条意在室内影间重为超过分配转成，并将 e1 路由的 prevlen 未必一定从原来的 1 小数点个数拓展为 5 小数点个数。

迪伦扑克牌的震荡就此开始。

e1 起初的阔度在 250～253 两者之间，因为刚才的拓展室内影间，此时 e1 的阔度就之比亦然数 254 了，因此起初 e2 留有 e1 的 prevlen 未必一定也须要从 1 小数点拓展至 5 小数点个数。

亦然如拓展 e1 导致了对 e2 拓展一样，拓展 e2 也可能会导致对 e3 的拓展，而拓展 e3 又可能会导致对 e4 的拓展…. 多年来长时间到整部。

这种在特殊仅仅产生的周内多次室内影间拓展转成就叫做「快速餐备份」，就像迪伦扑克牌的震荡一样，第一张扑克牌伤到了，推动了第二张扑克牌伤到；第二张扑克牌伤到，又推动了第三张扑克牌伤到…...

3、压缩成条意在缺点

室内影间拓展转成也就是超过超过分配存储器，因此快速餐备份一旦频发，就可能会导致压缩成条目改作的存储器室内影间要多次超过超过分配，这就可能会必要影响到压缩成条意在采访效能。

所以问道，虽然压缩成条目紧凑型的存储器布置能浪费存储器负担，但是如果留有的类型为数减低了，或是类型变大了，可能会导致存储器超过超过分配，最糟糕的是可能会有「快速餐备份」的关基团问题。

因此，压缩成条目只可能会用于留有的路由为数不多的片中，只要路由为数必要小，即使频发快速餐备份，也是能接纳的。

虽问道如此，Redis 针对压缩成条目在建筑设计上的极低，在不久的完整版之同一时间段，可选建筑设计了两种嵌套：quicklist（Redis 3.2 引入） 和 listpack（Redis 5.0 引入）。这两种嵌套的建筑设计目的，就是如此一来地保持压缩成条目浪费存储器的竞争者，同时补救压缩成条意在「快速餐备份」的关基团问题。

五、样本多种类型此表

样本多种类型此表是一种留有基团参数对（key-value）的嵌套。

样本多种类型此表之同一时间段的每一个 key 都是独一无二的，流程可以根据 key 载入出从新与之关联性的 value，或者通过 key 来备份 value，又或者根据 key 来删减整个 key-value等等。

在说什么压缩成条意在时候，写到过 Redis 的 Hash 单纯的中层借助之一是压缩成条目（最从新 Redis SQL已将压缩成条目换用 listpack）。Hash 单纯的另外一个中层借助就是样本多种类型此表。

样本多种类型此表特性在于，它能以 O(1) 的复杂性快速速基团入样本。打趣到的呢？将 key 通过 Hash 给定的计算出来，就能导向样本在此表之同一时间段的左边，因为样本多种类型此表大体上上是样本多种类型，所以可以通过查找参数快速速基团入到样本。

但是普遍存在的可能会也是有，在样本多种类型此表个数比较简单的仅仅，随着样本不断增加，那么样本多种类型争端的可能性也可能会越少。

补救样本多种类型争端的模式，有很多种。

Redis 选用了「模版样本多种类型」来补救样本多种类型争端，在不配套样本多种类型此表的同一时间段凯下，将很强有所未必相同样本多种类型参数的样本串出从新去，构成页面起，以便这些样本在此表之同一时间段无论如何可以被基团入到。

再一，参考问道问道样本多种类型此表。

1、样本多种类型此表构造建筑设计

Redis 的样本多种类型此表构造如下：

typedef struct dictht {

//样本多种类型此表样本多种类型

dictEntry **table;

//样本多种类型此表个数

unsigned long size;

//样本多种类型此表个数掩码，用于计算出来查找参数

unsigned long sizemask;

//该样本多种类型此表已经有的路由为数

unsigned long used;

} dictht;

可以注意到，样本多种类型此表是一取参样本多种类型（dictEntry **table），样本多种类型的每个类型是一个连到「样本多种类型此表路由（dictEntry）」的常量。

样本多种类型此表路由的构造如下：

typedef struct dictEntry {

//基团参数对之同一时间段的基团

void *key;

//基团参数对之同一时间段的参数

union {

void *val;

uint64_t u64;

int64_t s64;

double d;

}

//连到下一个样本多种类型此表路由，构成链此表

struct dictEntry *next;

} dictEntry;

dictEntry 构造里两头不仅构成连到基团和参数的常量，还构成了连到下一个样本多种类型此表路由的常量，这个常量可以将多个样本多种类型参数有所未必相同的基团参数对页面出从新去，便是来补救样本多种类型争端的关基团问题，这就是模版样本多种类型。

另外，这里两头还跟你凯一下，dictEntry 构造里两头基团参数对之同一时间段的参数是一个「联合棒状 v」此表述的，因此，基团参数对之同一时间段的参数可以是一个连到大体上参数的常量，或者是一个无大写字母的 64 位取参数或有大写字母的 64 位取参数或double 类的参数。这么做的某种程度是可以浪费存储器室内影间，因为当「参数」是取参数或二进位时，就可以将参数的样本附加在 dictEntry 构造里两头，不用如此一来用一个常量连到大体上的参数，从而浪费了存储器室内影间。

2、样本多种类型争端

样本多种类型此表大体上上是一取参样本多种类型，样本多种类型里两头多每一个类型就是一个样本多种类型桶。

当一个基团参数对的基团经过 Hash 给定计算出来后取得样本多种类型参数，如此一来将(样本多种类型参数 % 样本多种类型此表个数)取模计算出来，取得的结果参数就是该 key-value 近似于的样本多种类型类型左边，也就是第几个样本多种类型桶。

什么是样本多种类型争端呢？

举个比如问道，有一个可以贮存 8 个样本多种类型桶的样本多种类型此表。key1 经过样本多种类型给定计算出来后，如此一来将「样本多种类型参数 % 8 」开展取模计算出来，结果参数为 1，那么就近似于样本多种类型桶 1，近似于的，key9 和 key10 分别近似于样本多种类型桶 1 和桶 6。

此时，key1 和 key9 近似于到了有所未必相同的样本多种类型桶之同一时间段，这就频发了样本多种类型争端。

因此，比方问道两个以上为数的 kay 被超过分配到了样本多种类型此表之同一时间段同一个样本多种类型桶上时，此时指为这些 key 频发了争端。

3、模版样本多种类型

Redis 选用了「模版样本多种类型」的步骤来补救样本多种类型争端。

模版样本多种类型是怎么借助的？

借助的模式就是每个样本多种类型此表路由都有一个 next 常量，用于连到下一个样本多种类型此表路由，因此多个样本多种类型此表路由可以用 next 常量组成一个链此表，被超过分配到同一个样本多种类型桶上的多个路由可以用这个链此表连接出从新去，这样就补救了样本多种类型争端。

还是用下面的样本多种类型争端比如问道，key1 和 key9 经过样本多种类型计算出来后，都落在同一个样本多种类型桶，模版样本多种类型的话，key1 就可能会通过 next 常量连到 key9，构成一个单向链此表。

不过，模版样本多种类型或许也很微小，随着链此表阔度的减低，在基团入这一左边上的样本的足足就可能会减低，毕竟链此表的基团入的时间段复杂性是 O(n)。

要想补救这一关基团问题，就能够开展 rehash，也就是对样本多种类型此表的个数开展拓展。

再一，到底 Redis 是如何借助的 rehash 的。

4、rehash

样本多种类型此表构造建筑设计的这一小节，我给大家参考了 Redis 适用 dictht 构造棒状坚指为样本多种类型此表。不过，在大体上适用样本多种类型此表时，Redis 此表述一个 dict 构造棒状，这个构造棒状里两头此表述了两个样本多种类型此表（ht[2]）。

typedef struct dict {

…

//两个Hash此表，交替适用，用于rehash转成

dictht ht[2];

…

} dict;

之所便是表述了 2 个样本多种类型此表，是因为开展 rehash 的时候，能够用上 2 个样本多种类型此表了。

在亦然常免费请求阶段，填充的样本，都可能会擦除到「样本多种类型此表 1」，此时的「样本多种类型此表 2 」 未必能被超过分配室内影间。

随着样本逐步增加，出现出现异常了 rehash 转成，这个补救办法分为三步：

给「样本多种类型此表 2」 超过分配室内影间，一般可能会比「样本多种类型此表 1」 大 2 倍； 将「样本多种类型此表 1 」的样本迁往到「样本多种类型此表 2」 之同一时间段； 迁往未完成后，「样本多种类型此表 1 」的室内影间可能会被无罪释放，并把「样本多种类型此表 2」 设为「样本多种类型此表 1」，然后在「样本多种类型此表 2」 从新创始一个影白的样本多种类型此表，为将会 rehash 做准备。

为了有效地率你表达出来，我把 rehash 这三个补救办法素描在了右方这张上图：

这个补救办法看出从新去恰当，但是回事第二步很有关基团问题，如果「样本多种类型此表 1 」的负担更加大，那么在迁往至「样本多种类型此表 2 」的时候，因为可能会无关大量的样本批量，此时就可能会对 Redis 导致阻断，没人有免费其他请求。

5、渐进式 rehash

为了不必要 rehash 在样本迁往补救办法之同一时间段，因批量样本的足足，影响 Redis 效能的状况，所以 Redis 选用了渐进式 rehash，也就是将样本的迁往的管理工作不如此一来是只用迁往未完成，而是分多次迁往。

渐进式 rehash 补救办法如下：

给「样本多种类型此表 2」 超过分配室内影间； 在 rehash 开展期间，每次样本多种类型此表类型开展可选、删减、载入或者备份转成时，Redis 除了可能会分派近似于的转成大体上，还可能会以此类推将「样本多种类型此表 1 」之同一时间段查找左边上的所有 key-value 迁往到「样本多种类型此表 2」 上； 随着三处理事件客户端倡议的样本多种类型此表转成请求为数越多，之后在某个时间段鱼丸呢，可能会把「样本多种类型此表 1 」的所有 key-value 迁往到「样本多种类型此表 2」，从而未完成 rehash 转成。

这样就机智地把只用大量样本迁往管理工作的负担，重新分配到了多次三处理事件请求的补救办法之同一时间段，不必要了只用 rehash 的足足转成。

在开展渐进式 rehash 的补救办法之同一时间段，可能会有两个样本多种类型此表，所以在渐进式 rehash 开展期间，样本多种类型此表类型的删减、载入、备份等转成都可能会在这两个样本多种类型此表开展。

比如，载入一个 key 的参数的话，到时可能会在「样本多种类型此表 1」 里两头面开展载入，如果没人找出从新，就可能会独自到样本多种类型此表 2 里两头面开展找出从新。

另外，在渐进式 rehash 开展期间，可选一个 key-value 时，可能会被留有到「样本多种类型此表 2 」里两头面，而「样本多种类型此表 1」 则不如此一来开展任何添加转成，这样前提了「样本多种类型此表 1 」的 key-value 为数只可能会减缓，随着 rehash 转成的未完成，之后「样本多种类型此表 1 」就可能会转化成影此表。

6、rehash 出现出现异常状况下

参考了 rehash 那么多，还没人问道什么时仅仅可能会出现出现异常 rehash 转成呢？

rehash 的出现出现异常状况下跟增益系数（load factor）有关系。

增益系数可以通过右方这个式子计算出来：

出现出现异常 rehash 转成的状况下，主要有两个：

当增益系数之比亦然数 1 ，并且 Redis 不能在分派 bgse 请求或者 bgrewiteaof 请求，也就是不能分派 RDB 快速照或不能开展 AOF 重为写的时候，就可能会开展 rehash 转成。 当增益系数之比亦然数 5 时，此时概述样本多种类型争端更加严重为了，不管有不能有在分派 RDB 快速照或 AOF 重为写，都可能会一律开展 rehash 转成。

六、取参数闭包

取参数闭包是 Set 单纯的中层借助之一。当一个 Set 单纯只构成取参数参数类型，并且类型为数不停，就可能会适用取参数集这取参嵌套作为中层借助。

1、取参数闭包构造建筑设计

取参数闭包本质上是木头周内存储器室内影间，它的构造此表述如下：

typedef struct intset {

//字符模式

uint32_t encoding;

//闭包构成的类型为数

uint32_t length;

//留有类型的样本多种类型

int8_t contents[];

} intset;

可以注意到，留有类型的容器是一个 contents 样本多种类型，虽然 contents 被声明为 int8_t 多种类型的样本多种类型，但是大体上上 contents 样本多种类型未必留有任何 int8_t 多种类型的类型，contents 样本多种类型的真亦然多种类型取决于 intset 构造棒状里两头的 encoding 未必一定的参数。比如：

如果 encoding 未必一定参数为 INTSET_ENC_INT16，那么 contents 就是一个 int16_t 多种类型的样本多种类型，样本多种类型之同一时间段每一个类型的多种类型都是 int16_t； 如果 encoding 未必一定参数为 INTSET_ENC_INT32，那么 contents 就是一个 int32_t 多种类型的样本多种类型，样本多种类型之同一时间段每一个类型的多种类型都是 int32_t； 如果 encoding 未必一定参数为 INTSET_ENC_INT64，那么 contents 就是一个 int64_t 多种类型的样本多种类型，样本多种类型之同一时间段每一个类型的多种类型都是 int64_t；

未必相同多种类型的 contents 样本多种类型，假定样本多种类型的个数也可能会未必相同。

2、取参数闭包的从新增转成

取参数闭包可能会有一个从新增规则，就是当我们将一个从新类型转为到取参数闭包里两头面，如果从新类型的多种类型（int32_t）比取参数闭包原先所有类型的多种类型（int16_t）都要粗大时，取参数闭包能够到时开展从新增，也就是按从新类型的多种类型（int32_t）拓展 contents 样本多种类型的室内影间个数，然后才能将从新类型转为到取参数闭包里两头，当然从新增的补救办法之同一时间段，也要确保取参数闭包的有序性。

取参数闭包从新增的补救办法不可能会超过超过分配一个从新多种类型的样本多种类型，而是在起初的样本多种类型上拓展室内影间，然后在将每个类型按较宽多种类型个数分割，如果 encoding 未必一定参数为 INTSET_ENC_INT16，则每个类型的较宽就是 16 位。

举个比如问道，推论有一个取参数闭包里两头有 3 个多种类型为 int16_t 的类型。

以前，往这个取参数闭包之同一时间段转为一个从新类型 65535，这个从新类型能够用 int32_t 多种类型来留有，所以取参数闭包要开展从新增转成，首到时能够为 contents 样本多种类型配套，在起初室内影间的个数底下如此一来配套多 80 位（4x32-3x16=80），这样就能留有下 4 个多种类型为 int32_t 的类型。

配套完 contents 样本多种类型室内影间个数后，能够将之同一时间段的三个类型转视作 int32_t 多种类型，并将转成后的类型放在到亦然确的位右方，并且能够确保中层样本多种类型的有序性不变，整个转成补救办法如下：

取参数闭包从新增有什么某种程度呢？

如果要让一取参样本多种类型同时留有 int16_t、int32_t、int64_t 多种类型的类型，一般来说应该就是必要适用 int64_t 多种类型的样本多种类型。不过这样的话，当如果类型都是 int16_t 多种类型的，就可能会导致存储器浪费的状况。

取参数闭包从新增就更加容易这种状况，如果多年来向取参数闭包添加 int16_t 多种类型的类型，那么取参数闭包的中层借助就多年来是用 int16_t 多种类型的样本多种类型，只有在我们要将 int32_t 多种类型或 int64_t 多种类型的类型添加到闭包时，才可能会对样本多种类型开展从新增转成。

因此，取参数闭包从新增的某种程度是浪费存储器资源。

取参数闭包拥护冬歇期转成吗？

不拥护冬歇期转成，一旦对样本多种类型开展了从新增，就可能会多年来保持从新增后的状态。比如下面的从新增转成的比如问道，如果删减了 65535 类型，取参数闭包的样本多种类型还是 int32_t 多种类型的，未必可能会因此冬歇期为 int16_t 多种类型。

七、踩此表

Redis 只有在 Zset 单纯的中层借助比如说了踩此表，踩此表的竞争者是能拥护超过 O(logN) 复杂性的路由载入。

Zset 单纯是唯一一个同时适用了两取参嵌套来借助的 Redis 单纯，这两取参嵌套一个是踩此表，一个是样本多种类型此表。这样的某种程度是既能开展颇高效的范围基团入，也能开展颇高效串列基团入。

typedef struct zset {

dict *dict;

zskiplist *zsl;

} zset;

Zset 单纯能拥护范围基团入（如 ZRANGEBYSCORE 转成），这是因为它的嵌套建筑设计选用了踩此表，而又能以常数复杂性给与类型二阶（如 ZSCORE 转成），这是因为它同时选用了样本多种类型此表开展查找。

再一，参考的问道下踩此表。

1、踩此表构造建筑设计

链此表在载入类型的时候，因为能够到时同一时间段载入，所以基团入效能更加低，时间段复杂性是O(N)，于是就出从新现了踩此表。踩此表是在链此表思路改进型悄悄的，借助了一种「多层」的有序链此表，这样的某种程度是能快速中学毕业导向样本。

那踩此表粗大什么样呢？我这里两头举个比如问道，上图表展示出了一个等级为 3 的踩此表。

上图之同一时间段两头路由有 L0~L2 三个两头常量，分别连到了未必相同等级的路由，然后每个等级的路由都通过常量连接出从新去：

L0 等级总计 5 个路由，分别是路由1、2、3、4、5； L1 等级总计 3 个路由，分别是路由 2、3、5； L2 等级只有 1 个路由，也就是路由 3 。

如果我们要在链此表之同一时间段载入路由 4 这个类型，状况下从两头开始载入链此表，能够载入 4 次，而适用了踩此表后，状况下够载入 2 次就能导向到路由 4，因为可以在两头路由必要从 L2 等级踩到路由 3，然后如此一来往同一时间段载入找出从新路由 4。

可以注意到，这个载入补救办法就是在多个等级上踩来踩去，终于导向到类型。当负担很大时，踩此表的载入复杂性就是 O(logN)。

那踩此表路由是怎么借助多等级的呢？这就能够看「踩此表路由」的嵌套了，如下：

typedef struct zskiplistNode {

//Zset 单纯的类型参数

sds ele;

//类型二阶参数

double score;

//后向常量

struct zskiplistNode *backward;

//路由的level样本多种类型，留有每层上的同一时间段向常量和大跨度

struct zskiplistLevel {

struct zskiplistNode *forward;

unsigned long span;

} level[];

} zskiplistNode;

Zset 单纯要同时留有类型和类型的二阶，近似于到踩此表路由构造里两头就是 sds 多种类型的 ele 参数和 double 多种类型的 score 参数。每个踩此表路由都有一个后向常量，连到同一时间段一个路由，意在是为了有效地率从踩此表的尾路由开始采访路由，这样倒序载入时很有效地率。

踩此表是一个隐含等级关系的链此表，而且每一等级可以构成多个路由，每一个路由通过常量连接出从新去，借助这一特性就是靠踩此表路由构造棒状之同一时间段的zskiplistLevel 构造棒状多种类型的 level 样本多种类型。

level 样本多种类型之同一时间段的每一个类型代此表踩此表的一层，也就是由 zskiplistLevel 构造棒状坚指为，比如 leve[0] 就坚指为第一层，leve[1] 就坚指为第二层。zskiplistLevel 构造棒状里两头此表述了「连到下一个踩此表路由的常量」和「大跨度」，大跨度时用来历史纪录两个路由两者之间的一段距离。

比如，右方这张上图，展示出了各个路由的大跨度。

第一眼注意到大跨度的时候，以为是载入转成有关，大体上上未必能任何关系，载入转成状况下够用同一时间段向常量就可以未完成了。

大跨度大体上上是为了计算出来这个路由在踩此表之同一时间段的三轮。具棒状打趣的呢？因为踩此表之同一时间段的路由都是按序排列的，那么计算出来某个路由三轮的时候，从两头路由点到该指针的基团入路径上，将路上采访过的所有层的大跨度累加出从新去，取得的结果就是目的路由在踩此表之同一时间段的三轮。

举个比如问道，载入上图之同一时间段路由 3 在踩此表之同一时间段的三轮，从两头路由开始载入路由 3，载入的补救办法只经过了一个层（L3），并且层的大跨度是 3，所以路由 3 在踩此表之同一时间段的三轮是 3。

另外，上图之同一时间段的两头路由回事也是 zskiplistNode 踩此表路由，只不过两头路由的后向常量、二阶、类型参数都可能会被比如说，所以上图之同一时间段省略了这大部分。

关基团问题来了，由谁此表述哪个踩此表路由是两头路由呢？这就参考「踩此表」构造棒状了，如下下上图：

typedef struct zskiplist {

struct zskiplistNode *header, *tail;

unsigned long length;

int level;

} zskiplist;

踩此表构造里两头构成了：

踩此表的两头路由，便于在O(1)时间段复杂性内采访踩此表的两头路由和尾路由； 踩此表的阔度，便于在O(1)时间段复杂性给与踩此表路由的为数； 踩此表的小得多层数，便于在O(1)时间段复杂性给与踩此表之同一时间段层颇高小得多的那个路由的层为数；

2、踩此表路由基团入补救办法

载入一个踩此表路由的补救办法时，踩此表可能会从两头路由的最颇高层开始，到时同一时间段载入每一层。在载入某一层的踩此表路由时，可能会用踩此表路由之同一时间段的 SDS 多种类型的类型和类型的二阶来开展假定，总计两个假定状况下：

如果现阶段路由的二阶「相等」要载入的二阶时，踩此表就可能会采访该层上的下一个路由。 如果现阶段路由的二阶「亦然数」要载入的二阶时，并且现阶段路由的 SDS 多种类型样本「相等」要载入的样本时，踩此表就可能会采访该层上的下一个路由。

如果右方两个状况下都不假定，或者下一个路由为影时，踩此表就可能会适用目同一时间段载入出从属于自己路由的 level 样本多种类型里两头的下一层常量，然后沿着下一层常量独自载入，这就略低于踩到了下一层接着载入。

举个比如问道，上图表有个 3 等级的踩此表。

如果要载入「类型：abcd，二阶：4」的路由，载入的补救办法是这样的：

到时从两头路由的最颇高层开始，L2 连到了「类型：abc，二阶：3」路由，这个路由的二阶比要载入路由的小，所以要采访该层上的下一个路由； 但是该层上的下一个路由是影路由，于是就可能会踩到「类型：abc，二阶：3」路由的下一层告诉，也就是 leve[1]; 「类型：abc，二阶：3」路由的 leve[1] 的下一个常量连到了「类型：abcde，二阶：4」的路由，然后将其和要载入的路由比起。虽然「类型：abcde，二阶：4」的路由的二阶和要载入的二阶有所未必相同，但是现阶段路由的 SDS 多种类型样本「之比」要载入的样本，所以可能会独自踩到「类型：abc，二阶：3」路由的下一层告诉，也就是 leve[0]； 「类型：abc，二阶：3」路由的 leve[0] 的下一个常量连到了「类型：abcd，二阶：4」的路由，该路由亦然是要载入的路由，基团入中止。

3、踩此表路由层数设

踩此表的比邻两层的路由为数的比例可能会影响踩此表的基团入效能。

举个比如问道，上图表的踩此表，第二层的路由为数只有 1 个，而第一层的路由为数有 6 个。

这时，如果想基团入路由 6，那大体就跟链此表的基团入复杂性一样，就能够在第一层的路由之同一时间段依次以此类推载入，复杂性就是 O(N) 了。所以，为了降低基团入复杂性，我们就能够确保比邻层指针数家的关系。

踩此表的比邻两层的路由为数最理想的比例是 2:1，载入复杂性可以降低到 O(logN)。

上图表的踩此表就是，比邻两层的路由为数的比例是 2 : 1。

那怎样才能确保比邻两层的路由为数的比例为 2 : 1 呢？

如果选用可选路由或者删减路由时，来调整踩此表路由以确保比例的步骤的话，可能会导致了额外的负担。

Redis 则选用一种机智的步骤是，踩此表在创始路由的时候，随机转化成每个路由的层数，未必能严谨确保比邻两层的路由为数比例为 2 : 1 的状况。

具棒状的应该是，踩此表在创始路由时候，可能会转化成范围为[0-1]的一个校验，如果这个校验相等 0.25（略低于权重 25%），那么层数就减低 1 层，然后独自转化成下一个校验，直到校验的结果之比 0.25 中止，之后确定该路由的层数。

这样的应该，略低于每减低一层的权重不至少 25%，层数越少，权重越低，层颇高小得多受限是 64。

八、quicklist

在 Redis 3.0 之同一时间段，List 单纯的中层嵌套是双向链此表或者压缩成条目。然后在 Redis 3.2 的时候，List 单纯的中层改由 quicklist 嵌套借助。

回事 quicklist 就是「双向链此表 + 压缩成条目」组合，因为一个 quicklist 就是一个链此表，而链此表之同一时间段的每个类型又是一个压缩成条目。

在下面说什么压缩成条意在时候，我也写到了压缩成条意在极低，虽然压缩成条目是通过紧凑型的存储器布置浪费了存储器负担，但是因为它的构造建筑设计，如果留有的类型为数减低，或者类型变大了，压缩成条目可能会有「快速餐备份」的可能会，一旦频发，可能会导致效能回升。

quicklist 补救办法，通过支配每个链此表路由之同一时间段的压缩成条意在个数或者类型取参数，来妨碍快速餐备份的关基团问题。因为压缩成条目类型越少或越小，快速餐备份导致了的影响就越小，从而凯供了较好的采访效能。

1、quicklist 构造建筑设计

quicklist 的构造棒状跟链此表的构造棒状近似于，都构成了此表两头和此表尾，区别在于 quicklist 的路由是 quicklistNode。

typedef struct quicklist {

//quicklist的链此表两头

quicklistNode *head; //quicklist的链此表两头

//quicklist的链此表两头

quicklistNode *tail;

//所有压缩成条目之同一时间段的总类型取参数

unsigned long count;

//quicklistNodes的取参数

unsigned long len;

} quicklist;

再一到底，quicklistNode 的构造此表述：

typedef struct quicklistNode {

//同一时间段一个quicklistNode

struct quicklistNode *pre //同一时间段一个quicklistNode

//下一个quicklistNode

struct quicklistNode *next; //后一个quicklistNode

//quicklistNode连到的压缩成条目

unsigned char *zl;

//压缩成条意在的小数点个数

unsigned int sz;

//压缩成条意在类型取参数

unsigned int count : 16; //ziplist之同一时间段的类型取参数

} quicklistNode;

可以注意到，quicklistNode 构造棒状里两头构成了同一时间段一个路由和下一个路由常量，这样每个 quicklistNode 构成了一个双向链此表。但是链此表路由的类型不如此一来是单纯留有类型参数，而是留有了一个压缩成条目，所以 quicklistNode 构造棒状里两头有个连到压缩成条意在常量 *zl。

我素描了一张上图，有效地率你表达出来 quicklist 嵌套。

在向 quicklist 添加一个类型的时候，不可能会像普通的链此表那样，必要从另建一个链此表路由。而是可能会检测填充左边的压缩成条目有否能缩减到该类型，如果能缩减到就必要留有到 quicklistNode 构造里两头的压缩成条目，如果不用缩减到，才可能会从另建一个从属于自己 quicklistNode 构造。

quicklist 可能会支配 quicklistNode 构造里两头的压缩成条意在个数或者类型取参数，来妨碍潜在的快速餐备份的可能会，但是这未必能仅仅补救快速餐备份的关基团问题。

九、listpack

quicklist 虽然通过支配 quicklistNode 构造里两头的压缩成条意在个数或者类型取参数，来减缓快速餐备份导致了的效能影响，但是未必能仅仅补救快速餐备份的关基团问题。

因为 quicklistNode 还是用了压缩成条目来留有类型，压缩成条目快速餐备份的关基团问题，出自于它的构造建筑设计，所以要想彻底补救这个关基团问题，能够建筑设计一个从属于自己嵌套。

于是，Redis 在 5.0 从另建筑设计一取参嵌套叫 listpack，意在是替代压缩成条目，它小得多特色是 listpack 之同一时间段每个路由不如此一来构成同一时间段一个路由的阔度了，压缩成条目每个路由亦然因为能够留有同一时间段一个路由的阔度亦然则此表达式，就可能会有快速餐备份的隐患。

我看了 Redis 的 Github，在最从新 6.2 发自为完整版之同一时间段，Redis Hash 单纯、Set 单纯的中层嵌套的压缩成条目还未能被换用 listpack，而 Redis 的最从新SQL（还未能公布完整版）从未将所有比如说压缩成条目中层嵌套的 Redis 单纯换用 listpack 嵌套来借助，估计值不久无论如何，Redis 就可能会公布一个将压缩成条目为 listpack 的发自为完整版。

1、listpack 构造建筑设计

listpack 选用了压缩成条意在很多优秀的建筑设计，比如还是用木头周内的存储器室内影间来紧凑地留有样本，并且为了浪费存储器的负担，listpack 路由可能会选用未必相同的字符模式留有未必相同个数的样本。

我们到时到底 listpack 构造：

listpack 两头构成两个未必一定，分别历史纪录了 listpack 总小数点数和类型为数，然后 listpack 前面也有个整部识别。上图之同一时间段的 listpack entry 就是 listpack 的路由了。

每个 listpack 路由构造如下：

主要构成三个方面内容：

encoding，此表述该类型的字符多种类型，可能会对未必相同阔度的取参数和亦然则此表达式开展字符； data，大体上贮存的样本； len，encoding+data的总阔度；

可以注意到，listpack 不能压缩成条目之同一时间段历史纪录同一时间段一个路由阔度的亦然则此表达式了，listpack 只历史纪录现阶段路由的阔度，当我们向 listpack 转为一个从新类型的时候，不可能会影响其他路由的阔度亦然则此表达式的改变，从而不必要了压缩成条意在快速餐备份关基团问题。

2万字+35张上图，借此这一段话，能帮你破除 Redis 嵌套的迷雾！

>>>>参考资料

《Redis建筑设计与借助》 《Redis 源码剖析与实战》

作者丨松本coding

来源丨公众号：松本coding（ID：CodingLin）

dbaplus小团体欢迎广大技工原作者，原作者邮箱：editor@dbaplus.cn

关心公众号【dbaplus小团体】，给与更多原创技术文章和精选工具下载

。

昆明白癜风最好医院
阳泉哪家白癜风医院好
廊坊哪里治白癜风最好
眼整形
类风湿关节炎患者怎么缓解
谈咳宁乙酰半胱氨酸颗粒对咳嗽咳痰有效果吗
湿气重肠胃不舒服怎么办
英太青凝胶对腱鞘炎有用吗