ziplist设计上的问题，每一次增删改都需要计算前面元素的空间和长度（prevlen），这种设计缺陷非常明显，一旦其中一个entry发生修改，以这个entry后面开始，全部需要重新计算prevlen，因此诞生了连续更新的性能问题。
quicklist
quicklist实际就是双端链表，链表里的每一个节点都是ziplist，这样就可以避免减少了数据插入时内存空间的重新分配，以及内存数据的拷贝。同时每一个节点都会限制ziplist的大小，如果ziplist里面插入的entry过多，就会转化为quicklist增加node方式来存储。
基础结构（其实就是双向链表增删改查结构，没有太吸引人的地方）
typedef struct quicklistNode {
struct quicklistNode *prev;
struct quicklistNode *next;
unsigned char *zl;
unsigned int sz; /* ziplist size in bytes */
unsigned int count : 16; /* count of items in ziplist */
unsigned int encoding : 2; /* RAW==1 or LZF==2 */
unsigned int container : 2; /* NONE==1 or ZIPLIST==2 */
unsigned int recompress : 1; /* was this node previous compressed? */
unsigned int attempted_compress : 1; /* node can't compress; too small */
unsigned int extra : 10; /* more bits to steal for future usage */
} quicklistNode;
/* quicklistLZF is a 4+N byte struct holding 'sz' followed by 'compressed'.
* 'sz' is byte length of 'compressed' field.
* 'compressed' is LZF data with total (compressed) length 'sz'
* NOTE: uncompressed length is stored in quicklistNode->sz.
* When quicklistNode->zl is compressed, node->zl points to a quicklistLZF */
typedef struct quicklistLZF {
unsigned int sz; /* LZF size in bytes*/
char compressed[];
} quicklistLZF;
/* quicklist is a 40 byte struct (on 64-bit systems) describing a quicklist.
* 'count' is the number of total entries.
* 'len' is the number of quicklist nodes.
* 'compress' is: -1 if compression disabled, otherwise it's the number
* of quicklistNodes to leave uncompressed at ends of quicklist.
* 'fill' is the user-requested (or default) fill factor. */
typedef struct quicklist {
quicklistNode *head;
quicklistNode *tail;
unsigned long count; /* total count of all entries in all ziplists */
unsigned long len; /* number of quicklistNodes */
int fill : 16; /* fill factor for individual nodes */
unsigned int compress : 16; /* depth of end nodes not to compress;0=off */
} quicklist;
/* Create a new quicklist with some default parameters. */
quicklist *quicklistNew(int fill, int compress) {
quicklist *quicklist = quicklistCreate();
quicklistSetOptions(quicklist, fill, compress);
return quicklist;
}
/* Add new entry to tail node of quicklist.
*追加元素
* Returns 0 if used existing tail.
* Returns 1 if new tail created. */
int quicklistPushTail(quicklist *quicklist, void *value, size_t sz) {
quicklistNode *orig_tail = quicklist->tail;
assert(sz < UINT32_MAX); /* TODO: add support for quicklist nodes that are sds encoded (not zipped) */
if (likely(
_quicklistNodeAllowInsert(quicklist->tail, quicklist->fill, sz))) {
quicklist->tail->zl =
ziplistPush(quicklist->tail->zl, value, sz, ZIPLIST_TAIL);
quicklistNodeUpdateSz(quicklist->tail);
} else {
quicklistNode *node = quicklistCreateNode();
node->zl = ziplistPush(ziplistNew(), value, sz, ZIPLIST_TAIL);
quicklistNodeUpdateSz(node);
_quicklistInsertNodeAfter(quicklist, quicklist->tail, node);
}
quicklist->count++;
quicklist->tail->count++;
return (orig_tail != quicklist->tail);
}
/* Delete one element represented by 'entry'
*删除元素
* 'entry' stores enough metadata to delete the proper position in
* the correct ziplist in the correct quicklist node. */
void quicklistDelEntry(quicklistIter *iter, quicklistEntry *entry) {
quicklistNode *prev = entry->node->prev;
quicklistNode *next = entry->node->next;
int deleted_node = quicklistDelIndex((quicklist *)entry->quicklist,
entry->node, &entry->zi);
/* after delete, the zi is now invalid for any future usage. */
iter->zi = NULL;
/* If current node is deleted, we must update iterator node and offset. */
if (deleted_node) {
if (iter->direction == AL_START_HEAD) {
iter->current = next;
iter->offset = 0;
} else if (iter->direction == AL_START_TAIL) {
iter->current = prev;
iter->offset = -1;
}
}
/* else if (!deleted_node), no changes needed.
* we already reset iter->zi above, and the existing iter->offset
* doesn't move again because:
* - [1, 2, 3] => delete offset 1 => [1, 3]: next element still offset 1
* - [1, 2, 3] => delete offset 0 => [2, 3]: next element still offset 0
* if we deleted the last element at offet N and now
* length of this ziplist is N-1, the next call into
* quicklistNext() will jump to the next node. */
}listpack
quicklist链表里的每一个node都会指向ziplist，内存占用极大。
listpack沿用ziplist的基础数据结构，采用的连续内存布局，不会去计算前一项的空间长度，只会计算自己的长度，这样可以完全避免连续更新的缺陷，并且做了双向索引的优化。
编码方式
listpack 元素会对不同长度的整数和字符串进行编码
整型编码类型（LP_ENCODING__XX_BIT_INT）
LP_ENCODING_7BIT_UINT
宏定义为0，占1位，7BIT意味着可以存储7Bit无符号整数，加起来一共8位。
LP_ENCODING_13BIT_INT
宏定义为0xC0，二进制位1100 0000，前3位110表示13位编码类型，后面5位，外加1字节，所以一共存储的是13位。
LP_ENCODING_16BIT_INT （2字节无符号整数）
LP_ENCODING_24BIT_INT （3字节无符号整数）
LP_ENCODING_32BIT_INT （4字节无符号整数）
LP_ENCODING_64BIT_INT （8字节无符号整数）
其实以上编码类型全是宏定义来的，认识C的，应该不难理解。后续存储就是按照这些宏来判断计算。
字符串编码类型 （LP_ENCODING__XX_BIT_STR）
LP_ENCODING_6BIT_STR ： 前两位10代表LP_ENCODING_6BIT_STR类型，后面6BIT保存字符串长度，长度不超过63的字符串
LP_ENCODING_12BIT_STR： 前两位1110代表LP_ENCODING_12BIT_STR类型，后面12BIT保存字符串长度，长度不超过4095的字符串
LP_ENCODING_32BIT_STR ：前两位11110000代表LP_ENCODING_32BIT_STR 类型，后面32BIT保存字符串长度。
网上扣了个图，可见字符串设计的更加规范
遍历方式
正向遍历：lpFirst-->lpNext-->lpSkip 调用两个函数lpCurrentEncodedSize 和 lpEncodeBacklen
lpCurrentEncodedSize 函数是根据当前列表项第 1 个字节的取值，来计算当前项的编码类型，并根据编码类型，计算当前项编码类型和实际数据的总长度。然后，lpEncodeBacklen 函数会根据编码类型和实际数据的长度之和，进一步计算列表项最后一部分 entry-len 本身的长度。这样一来，lpSkip 函数就知道当前项的编码类型、实际数据和 entry-len 的总长度了，也就可以将当前项指针向右偏移相应的长度，从而实现查到下一个列表项的目的。
反向遍历 ：
lpPrev函数：保存指向前一项的指针，
lpDecodeBacklen 函数：计算entry-len总长度，遍历可以算出前一项的总长度。
首先，我们根据 listpack 头中记录的 listpack 总长度，就可以直接定位到 listapck 的尾部结束标记。然后，我们可以调用 lpPrev 函数，lpDecodeBacklen 函数会从右向左，逐个字节地读取当前列表项的 entry-len，entry-len返回的是编码类型和实际数据的长度之和，这样就可以计算出前一项的总长度，再结合lpPrev函数指针，就可以逐步从右向左遍历逐个entry了。
