Redis源碼解析-基礎數據-ziplist(壓縮列表)
太長不看版html
- 壓縮列表是一種爲節約空間而實現的線性數據結構，本質上是字節數組。
- 壓縮列表元素能夠爲整數或字符串。
- 壓縮列表在快速列表、列表對象和哈希對象中都有使用。
- 壓縮列表添加(平均複雜度O(n))與刪除節點(平均複雜度O(n))，可能會觸發連鎖更新(平均複雜度O(n^2))，由於觸發機率不高因此不影響性能。
- 由於節點存儲數據可能爲字符串，而字符串匹配爲O(n)複雜度，因此壓縮列表查找節點平均複雜度爲O(n^2)。
本篇解析基於redis 5.0.0版本，本篇涉及源碼文件爲ziplist.c, ziplist.h。git
什麼是壓縮列表
/* Create a new empty ziplist. */
unsigned char *ziplistNew(void) {
unsigned int bytes = ZIPLIST_HEADER_SIZE+1;
unsigned char *zl = zmalloc(bytes);
// ...
return zl;
}
複製代碼
從上述建立代碼中能夠看出，壓縮列表本質上就是一個字節數組，其是redis使用字節數組實現的線性數據結構，其元素能夠是整數或者字符串。在快速列表、列表對象和哈希對象中都有使用，通常用在元素較少且元素字節數較小的狀況下。github
爲何要實現壓縮列表？ redis
由於爲了儘量的節約內存。設想下如今有兩個元素: 整數1和字符串'abc'，兩個節點 數據自己只有佔8個字節(64位機器中)。 使用單向鏈表的話須要多加兩個向後指針，佔用24個字節，其中鏈表節點數據佔用16個字節是數據自己大小的兩倍。 而此例中壓縮列表存儲只須要每一個節點記錄前一節點長度(1字節)、節點自己編碼信息(1字節)(具體規則後邊解釋)，總共佔用10個字節。segmentfault
壓縮列表的構成
#define ZIP_END 255 /* Special "end of ziplist" entry. */
#define ZIPLIST_BYTES(zl) (*((uint32_t*)(zl)))
#define ZIPLIST_TAIL_OFFSET(zl) (*((uint32_t*)((zl)+sizeof(uint32_t))))
#define ZIPLIST_LENGTH(zl) (*((uint16_t*)((zl)+sizeof(uint32_t)*2)))
#define ZIPLIST_HEADER_SIZE (sizeof(uint32_t)*2+sizeof(uint16_t))
#define ZIPLIST_END_SIZE (sizeof(uint8_t))
/* Create a new empty ziplist. */
unsigned char *ziplistNew(void) {
unsigned int bytes = ZIPLIST_HEADER_SIZE+1;
unsigned char *zl = zmalloc(bytes);
// 壓縮列表總字節長度
ZIPLIST_BYTES(zl) = intrev32ifbe(bytes);
// 尾部節點字節距離
ZIPLIST_TAIL_OFFSET(zl) = intrev32ifbe(ZIPLIST_HEADER_SIZE);
// 壓縮列表節點個數
ZIPLIST_LENGTH(zl) = 0;
// 255特殊結尾值
zl[bytes-1] = ZIP_END;
return zl;
}
複製代碼
壓縮列表由總字節長度(4字節)，尾節點偏移量(4字節)，節點數量(2字節)，節點以及值爲255的特殊結束符(1字節)組成,經過列表的開始地址向後偏移尾節點偏移量個字節，能夠以O(1)時間複雜度獲取尾節點信息。數組
壓縮列表自身的信息只佔用了11個字節，而鏈表光是頭指針和尾指針存儲就須要16個字節，因此針對數據量少的狀況(節點少且節點小)採用壓縮列表會比較划算。 bash
intrev32ifbe函數爲大小端轉換函數，統一轉換爲小端存儲。爲何要進行轉換？ 數據結構
由於壓縮列表的操做中涉及到的位運算不少，若是不統一的話會出現混亂。後續的全部位運算都是在小端存儲的基礎上進行的。大小端知識點戳此瞭解curl
壓縮列表節點的構成
typedef struct zlentry {
// 前一節點長度信息的長度
unsigned int prevrawlensize;
// 前一節點長度
unsigned int prevrawlen;
// 當前節點長度信息長度
unsigned int lensize;
// 當前節點長度
unsigned int len;
// 當前節點頭部信息長度
unsigned int headersize;
// 當前節點數據編碼
unsigned char encoding;
unsigned char *p;
} zlentry;
void zipEntry(unsigned char *p, zlentry *e) {
// 前一節點長度信息解析
ZIP_DECODE_PREVLEN(p, e->prevrawlensize, e->prevrawlen);
// 當前節點數據長度與編碼信息解析
ZIP_DECODE_LENGTH(p + e->prevrawlensize, e->encoding, e->lensize, e->len);
e->headersize = e->prevrawlensize + e->lensize;
e->p = p;
}
複製代碼
如前所述，壓縮列表本質上是字節數組，redis爲了操做計算方便定義了zlentry結構體。進行操做計算時，將字節數組中包含的信息按照規則解析到zlentry結構體中，方便後續的計算。從存儲角度來看，壓縮列表節點分爲三部分：函數
- 前一節點長度信息
- 當前節點數據長度與編碼信息
- 節點數據
下圖爲壓縮列表節點各部分組成與zlentry結構體長度字段示意圖：
前一節點長度信息
#define ZIP_BIG_PREVLEN 254
#define ZIP_DECODE_PREVLENSIZE(ptr, prevlensize) do { \ if ((ptr)[0] < ZIP_BIG_PREVLEN) { \ (prevlensize) = 1; \ } else { \ (prevlensize) = 5; \ } \ } while(0);
#define ZIP_DECODE_PREVLEN(ptr, prevlensize, prevlen) do { \ ZIP_DECODE_PREVLENSIZE(ptr, prevlensize); \ if ((prevlensize) == 1) { \ (prevlen) = (ptr)[0]; \ } else if ((prevlensize) == 5) { \ assert(sizeof((prevlen)) == 4); \ memcpy(&(prevlen), ((char*)(ptr)) + 1, 4); \ memrev32ifbe(&prevlen); \ } \ } while(0);
複製代碼
前一節點長度小於254時，使用1個字節保存前一節點的長度信息。
前一節點長度大於254時，使用5個字節保存前一節點的長度信息。首個字節固定爲254，後續的4個字節用來存儲長度信息。
宏定義爲何要寫成do {} while(0);
寫成do {} while(0); 是爲了保證無論在調用代碼中怎麼使用分號和大括號，該宏老是能確保其行爲是一致的。錯誤示例以下：
#define TEST() test1(); test2();
// 此時test2必然被執行，不符合預期
if (a > 0)
TEST();
#define TEST() { test1(); test2(); }
// 此時就會出現語法錯誤
if (a > 0)
TEST();
複製代碼
當前節點數據長度與編碼信息
/* Different encoding/length possibilities */
#define ZIP_STR_MASK 0xc0 /* 11000000 */
#define ZIP_STR_06B (0 << 6) /* 00000000 */
#define ZIP_STR_14B (1 << 6) /* 01000000 */
#define ZIP_STR_32B (2 << 6) /* 10000000 */
#define ZIP_INT_16B (0xc0 | 0<<4) /* 11000000 */
#define ZIP_INT_32B (0xc0 | 1<<4) /* 11010000 */
#define ZIP_INT_64B (0xc0 | 2<<4) /* 11100000 */
#define ZIP_INT_24B (0xc0 | 3<<4) /* 11110000 */
#define ZIP_INT_8B 0xfe /* 11111110 */
/* 4 bit integer immediate encoding |1111xxxx| with xxxx between * 0001 and 1101. */
#define ZIP_INT_IMM_MASK 0x0f /* 00001111 */
#define ZIP_INT_IMM_MIN 0xf1 /* 11110001 */
#define ZIP_INT_IMM_MAX 0xfd /* 11111101 */
#define ZIP_ENTRY_ENCODING(ptr, encoding) do { \ (encoding) = (ptr[0]); \ if ((encoding) < ZIP_STR_MASK) (encoding) &= ZIP_STR_MASK; \ } while(0)
#define ZIP_DECODE_LENGTH(ptr, encoding, lensize, len) do { \ ZIP_ENTRY_ENCODING((ptr), (encoding)); \ if ((encoding) < ZIP_STR_MASK) { \ if ((encoding) == ZIP_STR_06B) { \ (lensize) = 1; \ (len) = (ptr)[0] & 0x3f; \ } else if ((encoding) == ZIP_STR_14B) { \ (lensize) = 2; \ (len) = (((ptr)[0] & 0x3f) << 8) | (ptr)[1]; \ } else if ((encoding) == ZIP_STR_32B) { \ (lensize) = 5; \ (len) = ((ptr)[1] << 24) | \ ((ptr)[2] << 16) | \ ((ptr)[3] << 8) | \ ((ptr)[4]); \ } else { \ panic("Invalid string encoding 0x%02X", (encoding)); \ } \ } else { \ (lensize) = 1; \ (len) = zipIntSize(encoding); \ } \ } while(0);
unsigned int zipIntSize(unsigned char encoding) {
switch(encoding) {
case ZIP_INT_8B: return 1;
case ZIP_INT_16B: return 2;
case ZIP_INT_24B: return 3;
case ZIP_INT_32B: return 4;
case ZIP_INT_64B: return 8;
}
if (encoding >= ZIP_INT_IMM_MIN && encoding <= ZIP_INT_IMM_MAX)
return 0; /* 4 bit immediate */
panic("Invalid integer encoding 0x%02X", encoding);
return 0;
}
int zipTryEncoding(unsigned char *entry, unsigned int entrylen, long long *v, unsigned char *encoding) {
long long value;
if (entrylen >= 32 || entrylen == 0) return 0;
if (string2ll((char*)entry,entrylen,&value)) {
if (value >= 0 && value <= 12) {
*encoding = ZIP_INT_IMM_MIN+value;
// ...
return 1;
}
return 0;
}
複製代碼
編碼與對應數據長度以下表所示：
| 編碼 | 長度信息的長度 | 數據長度 |
|---|---|---|
| ZIP_STR_06B(00bbbbbb)(前兩位標記編碼，後6位存儲長度) | 1個字節 | 長度<=63的字節數組 |
| ZIP_STR_14B(01bbbbbb xxxxxxxx)(前2位爲編碼後14位爲長度) | 2個字節 | 長度<=16383的字節數組 |
| ZIP_STR_06B(10______ aaaaaaaa bbbbbbbb cccccccc)(前2位標記編碼以後6位留空，後24位爲長度) | 5字節 | 長度<=4294967295的字節數組 |
| ZIP_INT_16B(11000000) | 2字節 | int16_t(short)類型整數 |
| ZIP_INT_32B(11010000) | 4字節 | int32_t(int)類型整數 |
| ZIP_INT_64B(11100000) | 8字節 | int64_t(long long)類型整數 |
| ZIP_INT_24B(11110000) | 3字節 | 3字節長的有符號整數 |
| ZIP_INT_8B(11111110) | 1字節 | 1字節長的有符號整數 |
| 1111 xxxx | 4位 | 0-12的無符號整數(此時該節點沒有content部分，數據存儲在encoding部分) |
按照數據的類型和大小，匹配不一樣的編碼，思路和以前分析過的基礎類型sds使用5中頭部信息同樣，都是爲了最大化壓縮佔用空間。
壓縮列表相關操做
更新節點
#define ZIPLIST_HEAD 0
#define ZIPLIST_TAIL 1
#define ZIPLIST_HEADER_SIZE (sizeof(uint32_t)*2+sizeof(uint16_t))
#define ZIPLIST_ENTRY_HEAD(zl) ((zl)+ZIPLIST_HEADER_SIZE)
#define ZIPLIST_ENTRY_END(zl) ((zl)+intrev32ifbe(ZIPLIST_BYTES(zl))-1)
unsigned char *ziplistPush(unsigned char *zl, unsigned char *s, unsigned int slen, int where) {
unsigned char *p;
// 頭部或尾部插入節點
p = (where == ZIPLIST_HEAD) ? ZIPLIST_ENTRY_HEAD(zl) : ZIPLIST_ENTRY_END(zl);
return __ziplistInsert(zl,p,s,slen);
}
unsigned char *ziplistInsert(unsigned char *zl, unsigned char *p, unsigned char *s, unsigned int slen) {
/// 插入節點至p指針指向元素前方
return __ziplistInsert(zl,p,s,slen);
}
unsigned char *__ziplistInsert(unsigned char *zl, unsigned char *p, unsigned char *s, unsigned int slen) {
size_t curlen = intrev32ifbe(ZIPLIST_BYTES(zl)), reqlen;
unsigned int prevlensize, prevlen = 0;
size_t offset;
int nextdiff = 0;
unsigned char encoding = 0;
long long value = 123456789;
/* Find out prevlen for the entry that is inserted. */
if (p[0] != ZIP_END) {
// 插入位置不在尾部
ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);
} else {
// 插入位置在尾部
unsigned char *ptail = ZIPLIST_ENTRY_TAIL(zl);
// 尾節點存在取長度，不存在長度爲0(列表爲空時不存在)
if (ptail[0] != ZIP_END) {
prevlen = zipRawEntryLength(ptail);
}
}
// s指針指向新增節點數據 slen爲數據長度
// 肯定數據編碼。數據長度，爲整數時返回對應固定長度，爲字符串使用slen
if (zipTryEncoding(s,slen,&value,&encoding)) {
reqlen = zipIntSize(encoding);
} else {
reqlen = slen;
}
// 加上前一節點長度信息的長度
reqlen += zipStorePrevEntryLength(NULL,prevlen);
// 加上編碼與長度信息的長度
// 此時reqlen爲新加入節點的總體長度
reqlen += zipStoreEntryEncoding(NULL,encoding,slen);
int forcelarge = 0;
//
nextdiff = (p[0] != ZIP_END) ? zipPrevLenByteDiff(p,reqlen) : 0;
// 修復bug,詳細分析見:https://segmentfault.com/a/1190000018878466?utm_source=tag-newest
if (nextdiff == -4 && reqlen < 4) {
nextdiff = 0;
forcelarge = 1;
}
offset = p-zl;
// 調整內存大小
zl = ziplistResize(zl,curlen+reqlen+nextdiff);
p = zl+offset;
// 非空列表插入
if (p[0] != ZIP_END) {
// 將p節點後移(沒有移動p節點前一節點長度信息)，留出當前節點位置
memmove(p+reqlen,p-nextdiff,curlen-offset-1+nextdiff);
// 寫入p節點前一節點長度信息(要插入節點的長度)
if (forcelarge)
zipStorePrevEntryLengthLarge(p+reqlen,reqlen);
else
zipStorePrevEntryLength(p+reqlen,reqlen);
// 更新尾節點偏移量
ZIPLIST_TAIL_OFFSET(zl) =
intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+reqlen);
zipEntry(p+reqlen, &tail);
if (p[reqlen+tail.headersize+tail.len] != ZIP_END) {
ZIPLIST_TAIL_OFFSET(zl) =
intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+nextdiff);
}
} else {
// 空列表插入，只更新尾節點偏移量
ZIPLIST_TAIL_OFFSET(zl) = intrev32ifbe(p-zl);
}
// 連鎖更新
if (nextdiff != 0) {
offset = p-zl;
zl = __ziplistCascadeUpdate(zl,p+reqlen);
p = zl+offset;
}
// 寫入前一節點長度信息
p += zipStorePrevEntryLength(p,prevlen);
// 寫入節點編碼與長度信息
p += zipStoreEntryEncoding(p,encoding,slen);
// 寫入數據
if (ZIP_IS_STR(encoding)) {
memcpy(p,s,slen);
} else {
zipSaveInteger(p,value,encoding);
}
// 增長列表長度
ZIPLIST_INCR_LENGTH(zl,1);
return zl;
}
複製代碼
連鎖更新
unsigned char *__ziplistCascadeUpdate(unsigned char *zl, unsigned char *p) {
size_t curlen = intrev32ifbe(ZIPLIST_BYTES(zl)), rawlen, rawlensize;
size_t offset, noffset, extra;
unsigned char *np;
zlentry cur, next;
while (p[0] != ZIP_END) {
// 解析當前節點信息
zipEntry(p, &cur);
// 當前節點總長
rawlen = cur.headersize + cur.len;
// 保存當前節點長度信息所需長度
rawlensize = zipStorePrevEntryLength(NULL,rawlen);
// 列表末尾，中止遍歷
if (p[rawlen] == ZIP_END) break;
// 解析下一節點信息
zipEntry(p+rawlen, &next);
/* Abort when "prevlen" has not changed. */
if (next.prevrawlen == rawlen) break;
if (next.prevrawlensize < rawlensize) {
/* The "prevlen" field of "next" needs more bytes to hold * the raw length of "cur". */
offset = p-zl;
// 下一節點因 前一節點長度信息 字段長度變動引起的自身長度變化大小
extra = rawlensize-next.prevrawlensize;
// 內存從新分配
zl = ziplistResize(zl,curlen+extra);
p = zl+offset;
/* Current pointer and offset for next element. */
np = p+rawlen;
noffset = np-zl;
// 若是下一節點不是尾節點，則須要更新 尾部節點偏移量
if ((zl+intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))) != np) {
ZIPLIST_TAIL_OFFSET(zl) =
intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+extra);
}
/* Move the tail to the back. */
memmove(np+rawlensize,
np+next.prevrawlensize,
curlen-noffset-next.prevrawlensize-1);
zipStorePrevEntryLength(np,rawlen);
p += rawlen;
curlen += extra;
} else {
// 若是 next節點本來的 前一節點長度信息 字段長度能夠容納新插入節點的長度信息，則直接寫入並退出遍歷
if (next.prevrawlensize > rawlensize) {
/* This would result in shrinking, which we want to avoid. * So, set "rawlen" in the available bytes. */
zipStorePrevEntryLengthLarge(p+rawlen,rawlen);
} else {
zipStorePrevEntryLength(p+rawlen,rawlen);
}
/* Stop here, as the raw length of "next" has not changed. */
break;
}
}
return zl;
}
複製代碼
前邊咱們看到了壓縮列表節點的各個字段都是變長的，若是前一節點長度發生變化，可能會引發後一節點的長度發生變化(若是前一節點的長度以前小於254，變動後大於254，則後一節點的 前一節點長度信息佔用字節會從1個字節變爲5個字節)。考慮一種極端狀況，插入節點後續的節點長度都是介於250～253之間，此時插入一個節點長度大於254的節點，會引起連鎖更新，以下圖所示：
連鎖更新最壞狀況下帶來的性能消耗是災難性的，爲何還能夠放心的使用？
- 觸發的條件(剛好存在多個連續的長度介於250～253之間的節點 )使得其觸發的機率很低
- 壓縮列表的應用場景(節點數量較少且節點數據長度較小)以及長度剛好介於250-～253之間的狀況出現狀況較低使得即使出現了連鎖更新，須要更新的節點也沒有幾個。
因此壓縮列表插入節點的平均複雜度爲O(n)。
查找節點
unsigned char *ziplistFind(unsigned char *p, unsigned char *vstr, unsigned int vlen, unsigned int skip) {
int skipcnt = 0;
unsigned char vencoding = 0;
long long vll = 0;
// 遍歷壓縮列表 skip爲查找前跳過skip個節點
while (p[0] != ZIP_END) {
unsigned int prevlensize, encoding, lensize, len;
unsigned char *q;
ZIP_DECODE_PREVLENSIZE(p, prevlensize);
ZIP_DECODE_LENGTH(p + prevlensize, encoding, lensize, len);
q = p + prevlensize + lensize;
if (skipcnt == 0) {
/* Compare current entry with specified entry */
if (ZIP_IS_STR(encoding)) {
// 數據爲字符串，判斷字符串相等複雜度爲O(n)
if (len == vlen && memcmp(q, vstr, vlen) == 0) {
return p;
}
} else {
if (vencoding == 0) {
// 首次比對時，對傳入值進行解碼
if (!zipTryEncoding(vstr, vlen, &vll, &vencoding)) {
/* If the entry can't be encoded we set it to * UCHAR_MAX so that we don't retry again the next * time. */
vencoding = UCHAR_MAX;
}
/* Must be non-zero by now */
assert(vencoding);
}
/* Compare current entry with specified entry, do it only * if vencoding != UCHAR_MAX because if there is no encoding * possible for the field it can't be a valid integer. */
if (vencoding != UCHAR_MAX) {
long long ll = zipLoadInteger(q, encoding);
if (ll == vll) {
return p;
}
}
}
/* Reset skip count */
skipcnt = skip;
} else {
/* Skip entry */
skipcnt--;
}
/* Move to next entry */
p = q + len;
}
return NULL;
}
複製代碼
由於節點中存在字符串，且字符串相等比對的複雜度爲O(n), 因此壓縮列表查找節點的複雜度爲O(n^2)。
刪除節點
unsigned char *ziplistDelete(unsigned char *zl, unsigned char **p) {
size_t offset = *p-zl;
zl = __ziplistDelete(zl,*p,1);
/* Store pointer to current element in p, because ziplistDelete will * do a realloc which might result in a different "zl"-pointer. * When the delete direction is back to front, we might delete the last * entry and end up with "p" pointing to ZIP_END, so check this. */
*p = zl+offset;
return zl;
}
/* Delete a range of entries from the ziplist. */
unsigned char *ziplistDeleteRange(unsigned char *zl, int index, unsigned int num) {
unsigned char *p = ziplistIndex(zl,index);
return (p == NULL) ? zl : __ziplistDelete(zl,p,num);
}
unsigned char *__ziplistDelete(unsigned char *zl, unsigned char *p, unsigned int num) {
unsigned int i, totlen, deleted = 0;
size_t offset;
int nextdiff = 0;
zlentry first, tail;
// 刪除的首個節點
zipEntry(p, &first);
for (i = 0; p[0] != ZIP_END && i < num; i++) {
// 跳過全部要刪除的節點
p += zipRawEntryLength(p);
deleted++;
}
// first.p指向第一個要被刪除節點的首地址
// p指向的是最後一個刪除節點的下一節點的首地址, totlen大於0表示須要刪除節點
totlen = p-first.p; /* Bytes taken by the element(s) to delete. */
if (totlen > 0) {
if (p[0] != ZIP_END) {
// 獲取p節點 【前一節點長度信息】 字段與首個被刪除節點 【前一個節點長度信息】 字段的差值
// zipPrevLenByteDiff 的返回值有三種可能：
// 1）新舊兩個節點的【前一個節點長度信息】字段長度 相等，返回 0
// 2）新節點【前一個節點長度信息】字段長度 > 舊節點【前一個節點長度信息】字段長度，返回 5 - 1 = 4
// 3）舊節點【前一個節點長度信息】字段長度 > 新節點【前一個節點長度信息】字段長度，返回 1 - 5 = -4
nextdiff = zipPrevLenByteDiff(p,first.prevrawlen);
// 根據差值，向前向後偏移 p指針
p -= nextdiff;
// 將首個被刪除節點【前一節點長度信息】寫入p指針指向的節點
zipStorePrevEntryLength(p,first.prevrawlen);
// 更新尾節點偏移量
ZIPLIST_TAIL_OFFSET(zl) =
intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))-totlen);
/* When the tail contains more than one entry, we need to take * "nextdiff" in account as well. Otherwise, a change in the * size of prevlen doesn't have an effect on the *tail* offset. */
zipEntry(p, &tail);
/* 若是p節點不是尾節點, 則尾節點偏移量須要加上nextdiff的變動量 由於尾節點偏移量是指列表首地址到尾節點首地址的距離 p節點的 【前一節點長度信息】 字段的長度變化隻影響它字段以後的信息地址。 p節點爲尾節點時，爲節點首地址在【前一節點長度信息】字段前邊，因此不受影響。*/
if (p[tail.headersize+tail.len] != ZIP_END) {
ZIPLIST_TAIL_OFFSET(zl) =
intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+nextdiff);
}
/* Move tail to the front of the ziplist */
memmove(first.p,p,
intrev32ifbe(ZIPLIST_BYTES(zl))-(p-zl)-1);
} else {
/* The entire tail was deleted. No need to move memory. */
// 一直刪除到尾節點，不須要變動中間節點，只須要調整下尾節點偏移量
ZIPLIST_TAIL_OFFSET(zl) =
intrev32ifbe((first.p-zl)-first.prevrawlen);
}
/* Resize and update length */
offset = first.p-zl;
// 從新分配內存大小
zl = ziplistResize(zl, intrev32ifbe(ZIPLIST_BYTES(zl))-totlen+nextdiff);
// 減小節點長度
ZIPLIST_INCR_LENGTH(zl,-deleted);
p = zl+offset;
// 若是最後一個被刪除節點的下一節點的【前一個節點長度信息】字段長度 須要變動，則可能會觸發連鎖更新
if (nextdiff != 0)
zl = __ziplistCascadeUpdate(zl,p);
}
return zl;
}
複製代碼
由於可能會觸發連鎖更新，因此刪除操做最壞複雜度爲O(n^2)，平均複雜度爲O(n)。
相關文章
- 1. Redis源碼分析-壓縮列表ziplist
- 2. Redis之壓縮列表ziplist
- 3. 【Redis源碼分析】Redis的壓縮列表ZipList
- 4. Redis學習(6)——壓縮列表（ziplist）
- 5. Redis 探究：壓縮列表 ziplist
- 6. Redis學習——壓縮列表ziplist
- 7. redis 5.0.7 源碼閱讀——壓縮列表ziplist
- 8. redis 底層數據結構 壓縮列表 ziplist
- 9. redis數據結構實現--壓縮列表(ziplist)
- 10. Redis(6) —— 底層數據結構 —— ziplist（壓縮列表）
- 更多相關文章...
- • XML DOM 解析器 - XML DOM 教程
- • Kotlin 基礎語法 - Kotlin 教程
- • Flink 數據傳輸及反壓詳解
- • Scala 中文亂碼解決
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章