1.前言

Hello，歡迎大家來到《 Redis 數據結構源碼解析系列》，在《Redis為什么這么快？》一文中我說過 Redis 速度快的一個原因就是其簡單且高效的數據結構。

本系列文章面向各個階段的 Coder 們，新手也不用怕。每一篇文章敖丙都將從命令實戰入門入手，隨后深入源碼解析，最后面試題回顧這三個方向上給各位卷王一一介紹。

2.SDS命令實戰[初來乍到]

SDS 是 Redis 中最簡單的數據結構。Redis 中所有的數據結構都是以唯一的 key 字符串作為名稱，根據 key 獲取value，差異僅在于 value 的數據結構不同。

SDS 在生產環境中使用非常廣泛，比如，我們使用 SDS 做分布式鎖；將對象轉成 JSON 串作為緩存等。在 Redis 面試過程中一旦提及相關數據結構 SDS 一定是繞不過去的話題，它很簡單（或者說看完此文后很簡單），面試官可以不問，但我們不能不懂。

首先我們從命令實戰開始切入吧~（老司機直接跳過）

更多命令查看官網：https://redis.io/commands#string

2. 1設置字符串

格式：set 。其中value的值可以為字節串(byte string)、整型和浮點數。

> set name aobing
OK


2.2 獲取字符串

格式：get 。

> get name
"aobing"


2.3 獲取字符串長度

格式：strlen

> strlen name
(integer) 6


2.4 獲取子串

格式：getrange start end。 獲取字符串的子串，在Redis2.0之前此命令為substr，現使用getrange。返回位移為start(從0開始)和end之間(都包括，而不是像其他語言中的包頭不包尾)的子串?？梢允褂秘撈屏縼硖峁淖址┪查_始的偏移量。

因此-1表示最后一個字符，-2表示倒數第二個，依此類推。該函數通過將結果范圍限制為字符串的實際長度來處理超出范圍的請求(end設置非常大也是到字符串末尾就截止了)。

127.0.0.1:6379> set mykey "This is a string"
OK
127.0.0.1:6379> getrange mykey 0 3
"This"
127.0.0.1:6379> getrange mykey -3 -1
"ing"
127.0.0.1:6379> getrange mykey 0 -1
"This is a string"
127.0.0.1:6379> getrange mykey 10 10000
"string"


2.5 設置子串

格式：setrange offset substr。 返回值：修改后字符串的長度。

從value的整個長度開始，從指定的偏移量覆蓋key處存儲的一部分字符串。如果偏移量大于key處字符串的當前長度，則該字符串將填充零字節以使偏移量適合。

不存在的鍵被視為空字符串，因此此命令將確保它包含足夠大的字符串以能夠將值設置為offset。

注意：您可以設置的最大偏移為2^29 - 1（536870911），因為Redis字符串限制為512 MB。如果您需要超出此大小，可以使用多個鍵。

127.0.0.1:6379> set key1 "hello world"
OK
127.0.0.1:6379> setrange key1 6 redis
(integer) 11
127.0.0.1:6379> get key1
"hello redis"
127.0.0.1:6379> setrange key2 6 redis
(integer) 11
127.0.0.1:6379> get key2
"\x00\x00\x00\x00\x00\x00redis"


2.6 追加子串

格式：append substr 如果key已經存在并且是字符串，則此命令將value在字符串末尾附加。如果key不存在，則會創建它并將其設置為空字符串，因此APPEND在這種特殊情況下 將類似于SET。

127.0.0.1:6379> exists key4
(integer) 0
127.0.0.1:6379> append key4 hello
(integer) 5
127.0.0.1:6379> append key4 world
(integer) 10
127.0.0.1:6379> get key4
"helloworld"


2.7 計數

在使用Redis中我們經常將字符串做為計數器，使用incr命令進行加一。 格式：incr 。 返回值：key遞增后的值。 將存儲的數字key加1。

如果key不存在，則在執行操作之前將其設置為0。

如果key包含錯誤類型的值或包含不能表示為整數的字符串，則返回錯誤。此操作僅限于64位帶符號整數。計數是由范圍的，它不能超過Long.Max，不能低于Long.Min。

2.8 過期和刪除

字符串可以使用del命令進行刪除，也可以使用expire命令設置過期時間，到期自動刪除。我們可以使用ttl命令獲取字符串的壽命（還有多少時間過期）。

格式：del ... 返回值：刪除key的個數

127.0.0.1:6379> SET key1 "Hello"
"OK"
127.0.0.1:6379> SET key2 "World"
"OK"
127.0.0.1:6379> DEL key1 key2 key3
(integer) 2


格式：expire time 返回值：如果設置了超時返回1。如果key不存在返回0。

如何將設置了過期的字符串設置為永久的呢？

生存時間可以通過使用DEL命令來刪除整個 key 來移除，或者被SET和GETSET命令覆寫(overwrite)，這意味著，如果一個命令只是修改一個帶生存時間的 key 的值而不是用一個新的 key 值來代替(replace)它的話，那么生存時間不會被改變。

比如說，對一個 key 執行INCR命令，對一個列表進行LPUSH命令，或者對一個哈希表執行HSET命令，這類操作都不會修改 key 本身的生存時間。

如果使用RENAME對一個 key 進行改名，那么改名后的 key 的生存時間和改名前一樣。

RENAME 命令的另一種可能是，嘗試將一個帶生存時間的 key 改名成另一個帶生存時間的 another_key ，這時舊的 another_key (以及它的生存時間)會被刪除，然后舊的 key 會改名為 another_key ，因此，新的 another_key 的生存時間也和原本的 key 一樣。

使用PERSIST命令可以在不刪除 key 的情況下，移除 key 的生存時間，讓 key 重新成為一個『持久的』(persistent) key 。

127.0.0.1:6379> expire age 100
(integer) 1
127.0.0.1:6379> ttl age
(integer) 97
127.0.0.1:6379> set age 20
OK
127.0.0.1:6379> ttl age
(integer) -1
127.0.0.1:6379> expire age 100
(integer) 1
127.0.0.1:6379> ttl age
(integer) 98
127.0.0.1:6379> rename age age2
OK
127.0.0.1:6379> ttl age2
(integer) 87
127.0.0.1:6379> expire age 100
(integer) 1
127.0.0.1:6379> ttl age
(integer) 96
127.0.0.1:6379> persist age
(integer) 1
127.0.0.1:6379> ttl age
(integer) -1


3.SDS 簡介與特性[八股]

Redis 面試中大概率會提及相關的數據結構，SDS 的八股文大部分人倒背如流，可是沒有讀過源碼，知其然不知其所以然，這可萬萬使不得呀??！

4.SDS 結構模型[老司機]

本次敖丙閱讀的Redis源碼為最新的 Redis6.2.6 和 Redis3.0.0 版本

相信各位看官在聽到 Redis 中的字符串不是簡簡單單的C語言中的字符串，是 SDS（Simple Dynamic String，簡單動態字符串）時以為是造出了啥新類型呢，對此，敖丙想說的是不慌，其實 SDS 內容的源碼底層就是typedef char *sds;。

4.1 數據結構

Redis6.x 的 SDS 的數據結構定義與 Redis3.0.0 相差比較大，但是核心思想不變。先從簡單版本（Redis3.x）開始吧~

struct sdshdr {
//記錄buf數組中已使用字節的數量
//等于SDS所保存字符串的長度
unsigned int len;
//記錄buf數組中未使用字節的數量
unsigned int free;
//char數組，用于保存字符串
char buf[];
};


如下圖所示為字符串"Aobing"在Redis中的存儲形式：

• len 為6，表示這個 SDS 保存了一個長度為5的字符串；
• free 為0，表示這個 SDS 沒有剩余空間；
• buf 是個char類型的數組，注意末尾保存了一個空字符'\0'。

buf 尾部自動追加一個'\0'字符并不會計算在 SDS 的len中，這是為了遵循 C 字符串以空字符串結尾的慣例，使得 SDS 可以直接使用一部分string.h庫中的函數，如strlen

#include
#include
int main()
{
char buf[] = {'A','o','b','i','n','g','\0'};
printf("%s\n",buf); // Aobing
printf("%lu\n",strlen(buf)); // 6
return 0;
}


4.2 苛刻的數據優化

4.2.1 數據結構優化

目前我們似乎得到了一個結構不錯的 SDS ，但是我們能否繼續進行優化呢？

在 Redis3.x 版本中不同長度的字符串占用的頭部是相同的，如果某一字符串很短但是頭部卻占用了更多的空間，這未免太浪費了。所以我們將 SDS 分為三種級別的字符串：

• 短字符串(長度小于32)，len和free的長度用1字節即可；
• 長字符串，用2字節或者4字節；
• 超長字符串，用8字節。

共有五種類型的SDS（長度小于1字節、1字節、2字節、4字節、8字節）

我們可以在 SDS 中新增一個 type 字段來標識類型，但是沒必要使用一個 4 字節的int類型去做！可以使用 1 字節的char類型，通過位運算（3位即可標識2^3種類型）來獲取類型。

如下所示為短字符串(長度小于32)的優化形式：

低三位存儲類型，高5位存儲長度，最多能標識的長度為32，所以短字符串的長度必定小于32。

無需free字段了，32-len即為free

敖丙帶大家分析了一波，接下來看看Redis6.x中是怎么做的吧！

// 注意：sdshdr5從未被使用，Redis中只是訪問flags。
struct __attribute__ ((__packed__)) sdshdr5 {
unsigned char flags; /* 低3位存儲類型, 高5位存儲長度 */
char buf[];
};
struct __attribute__ ((__packed__)) sdshdr8 {
uint8_t len; /* 已使用 */
uint8_t alloc; /* 總長度，用1字節存儲 */
unsigned char flags; /* 低3位存儲類型, 高5位預留 */
char buf[];
};
struct __attribute__ ((__packed__)) sdshdr16 {
uint16_t len; /* 已使用 */
uint16_t alloc; /* 總長度，用2字節存儲 */
unsigned char flags; /* 低3位存儲類型, 高5位預留 */
char buf[];
};
struct __attribute__ ((__packed__)) sdshdr32 {
uint32_t len; /* 已使用 */
uint32_t alloc; /* 總長度，用4字節存儲 */
unsigned char flags; /* 低3位存儲類型, 高5位預留 */
char buf[];
};
struct __attribute__ ((__packed__)) sdshdr64 {
uint64_t len; /* 已使用 */
uint64_t alloc; /* 總長度，用8字節存儲 */
unsigned char flags; /* 低3位存儲類型, 高5位預留 */
char buf[];
};


數據結構和我們分析的差不多嘛！也是加一個標識字段而已，并且不是int類型，而是1字節的char類型，使用其中的3位表示具體的類型。

同時，Redis 中也聲明了5個常量分別表示五種類型的 SDS ，與我們分析的也不謀而合。

#define SDS_TYPE_5 0
#define SDS_TYPE_8 1
#define SDS_TYPE_16 2
#define SDS_TYPE_32 3
#define SDS_TYPE_64 4


4.2.2 uintX_t

對比前后兩版代碼，不難發現在 Redis6.x 中 int 類型也多出了幾種：uint8_t / uint16_t / uint32_t /uint64_t。乍一看以為是新增類型呢，畢竟 C語言里面可沒有這些類型呀！

敖丙初見也是滿頭霧水，畢竟C 語言忘得差不多了。不過我憑借強大的知識儲備(不要face ^_^)猜測這可能是一個別名，C語言中有typedef呀！而_t就是其縮寫。查看相關源碼，果然~~

typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
typedef unsigned long long uint64_t;


4.2.3 對齊填充

在 Redis6.x 的源碼中 SDS 的結構體為struct __attribute__ ((__packed__))與struct有較大的差別，這其實和我們熟知的對齊填充有關。

(1) 舉個栗子

考慮如下結構體：

typedef struct{
char c1;
short s;
char c2;
int i;
} s;


若此結構體中的成員都是緊湊排列的，假設c1的起始地址為0，則s的地址為1，c2的地址為3，i的地址為4。下面用代碼論證一下我們的假設。

#include
typedef struct
{
char c1;
short s;
char c2;
int i;
} s;
int main()
{
s a;
printf("c1 -> %d, s -> %d, c2 -> %d, i -> %d\n",
(unsigned int)(void *)&a.c1 - (unsigned int)(void *)&a,
(unsigned int)(void *)&a.s - (unsigned int)(void *)&a,
(unsigned int)(void *)&a.c2 - (unsigned int)(void *)&a,
(unsigned int)(void *)&a.i - (unsigned int)(void *)&a);
return 0;
}
// 結果為：c1 -> 0, s -> 2, c2 -> 4, i -> 8


尷尬了，和假設差的不是一星半點呀！這就是對齊填充搞的鬼，這啥啥啥呀~

(2) 什么是字節對齊

現代計算機中，內存空間按照字節劃分，理論上可以從任何起始地址訪問任意類型的變量。但實際中在訪問特定類型變量時經常在特定的內存地址訪問，這就需要各種類型數據按照一定的規則在空間上排列，而不是順序一個接一個地存放，這就是對齊。

(3) 對齊原因

為什么需要對齊填充是由于各個硬件平臺對存儲空間的處理上有很大的不同。一些平臺對某些特定類型的數據只能從某些特定地址開始存取。

最常見的是如果不按照適合其平臺的要求對數據存放進行對齊，會在存取效率上帶來損失。

比如有些平臺每次讀都是從偶地址開始，如果一個int型（假設為 32位）存放在偶地址開始的地方，那么一個讀周期就可以讀出，而如果存放在奇地址開始的地方，就可能會需要2個讀周期，并對兩次讀出的結果的高低字節進行拼湊才能得到該int數據，導致在讀取效率上下降很多。

(4) 更改對齊方式

注意：我們寫程序的時候，不需要考慮對齊問題。編譯器會替我們選擇適合目標平臺的對齊策略。

如果我們一定要手動更改對齊方式，一般可以通過下面的方法來改變缺省的對界條件：

• 使用偽指令#pragma pack(n)：C編譯器將按照n個字節對齊；
• 使用偽指令#pragma pack()： 取消自定義字節對齊方式。 另外，還有如下的一種方式(GCC特有語法)：
• __attribute((aligned (n)))： 讓所作用的結構成員對齊在n字節自然邊界上。如果結構體中有成員的長度大于n，則按照最大成員的長度來對齊。
• __attribute__ ((packed))： 取消結構在編譯過程中的優化對齊，按照實際占用字節數進行對齊。

將上述示例代碼的結構體更改如下(取消對齊)，再次執行，可以發現取消對齊后和我們的假設就一致了。

typedef struct __attribute__ ((__packed__))
{
char c1;
short s;
char c2;
int i;
} s;
// 再次執行：c1 -> 0, s -> 1, c2 -> 3, i -> 4


(5) Redis為什么不對齊呢？

綜上所述我們知道了對齊填充可以提高 CPU 的數據讀取效率，作為 IO 頻繁的 Redis 為什么選擇不對齊呢？

我們再次回顧 Redis6.x 中的 SDS 結構：

有個細節各位需要知道，即 SDS 的指針并不是指向 SDS 的起始位置（len位置），而是直接指向buf[]，使得 SDS 可以直接使用 C 語言string.h庫中的某些函數，做到了兼容，十分nice~。

如果不進行對齊填充，那么在獲取當前 SDS 的類型時則只需要后退一步即可flagsPointer = ((unsigned char*)s)-1；

相反，若進行對齊填充，由于 Padding 的存在，我們在不同的系統中不知道退多少才能獲得flags，并且我們也不能將 sds 的指針指向flags，這樣就無法兼容 C 語言的函數了，也不知道前進多少才能得到 buf[]。

4.3 SDS 優勢

4.3.1 O(1)時間復雜度獲取字符串長度

由于C字符串不記錄自身的長度，所以為了獲取一個字符串的長度程序必須遍歷這個字符串，直至遇到'0'為止，整個操作的時間復雜度為O(N)。而我們使用SDS封裝字符串則直接獲取len屬性值即可，時間復雜度為O(1)。

4.3.2 二進制安全

什么是二進制安全？

通俗地講，C語言中，用'0'表示字符串的結束，如果字符串本身就有'0'字符，字符串就會被截斷，即非二進制安全；若通過某種機制，保證讀寫字符串時不損害其內容，則是二進制安全。

C字符串中的字符除了末尾字符為'\0'外其他字符不能為空字符，否則會被認為是字符串結尾(即使實際上不是)。這限制了C字符串只能保存文本數據，而不能保存二進制數據。而SDS使用len屬性的值判斷字符串是否結束，所以不會受'\0'的影響。

4.3.3 杜絕緩沖區溢出

字符串的拼接操作是使用十分頻繁的，在C語言開發中使用char *strcat(char *dest,const char *src)方法將src字符串中的內容拼接到dest字符串的末尾。

由于C字符串不記錄自身的長度，所有strcat方法已經認為用戶在執行此函數時已經為dest分配了足夠多的內存，足以容納src字符串中的所有內容，而一旦這個條件不成立就會產生緩沖區溢出，會把其他數據覆蓋掉，Dangerous~。

// strcat 源碼
char * __cdecl strcat (char * dst, const char * src)
{
char * cp = dst;
while( *cp )
cp++; /* 找到 dst 的結尾 */
while( *cp++ = *src++ ) ; /* 無腦將 src 復制到 dst 中 */
return( dst ); /* 返回 dst */
}


如下圖所示為一次緩沖區溢出：

與C字符串不同，SDS 的自動擴容機制完全杜絕了發生緩沖區溢出的可能性：當SDS API需要對SDS進行修改時，API會先檢查 SDS 的空間是否滿足修改所需的要求，如果不滿足，API會自動將SDS的空間擴展至執行修改所需的大小，然后才執行實際的修改操作，所以使用 SDS 既不需要手動修改SDS的空間大小，也不會出現緩沖區溢出問題。

SDS 的sds sdscat(sds s, const char *t)方法在字符串拼接時會進行擴容相關操作。

sds sdscatsds(sds s, const sds t) {
return sdscatlen(s, t, sdslen(t));
}
/* s: 源字符串
* t: 待拼接字符串
* len: 待拼接字符串長度
*/
sds sdscatlen(sds s, const void *t, size_t len) {
// 獲取源字符串長度
size_t curlen = sdslen(s);
// SDS 分配空間（自動擴容機制）
s = sdsMakeRoomFor(s,len);
if (s == NULL) return NULL;
// 將目標字符串拷貝至源字符串末尾
memcpy(s+curlen, t, len);
// 更新 SDS 長度
sdssetlen(s, curlen+len);
// 追加結束符
s[curlen+len] = '\0';
return s;
}


自動擴容機制——sdsMakeRoomFor方法

strcatlen中調用sdsMakeRoomFor完成字符串的容量檢查及擴容操作，重點分析此方法：

/* s: 源字符串
* addlen: 新增長度
*/
sds sdsMakeRoomFor(sds s, size_t addlen) {
void *sh, *newsh;
// sdsavail: s->alloc - s->len, 獲取 SDS 的剩余長度
size_t avail = sdsavail(s);
size_t len, newlen, reqlen;
// 根據 flags 獲取 SDS 的類型 oldtype
char type, oldtype = s[-1] & SDS_TYPE_MASK;
int hdrlen;
size_t usable;
/* Return ASAP if there is enough space left. */
// 剩余空間大于等于新增空間，無需擴容，直接返回源字符串
if (avail >= addlen) return s;
// 獲取當前長度
len = sdslen(s);
//
sh = (char*)s-sdsHdrSize(oldtype);
// 新長度
reqlen = newlen = (len+addlen);
// 斷言新長度比原長度長，否則終止執行
assert(newlen > len); /* 防止數據溢出 */
// SDS_MAX_PREALLOC = 1024*1024, 即1MB
if (newlen < SDS_MAX_PREALLOC)
// 新增后長度小于 1MB ，則按新長度的兩倍擴容
newlen *= 2;
else
// 新增后長度大于 1MB ，則按新長度加上 1MB 擴容
newlen += SDS_MAX_PREALLOC;
// 重新計算 SDS 的類型
type = sdsReqType(newlen);
/* Don't use type 5: the user is appending to the string and type 5 is
* not able to remember empty space, so sdsMakeRoomFor() must be called
* at every appending operation. */
// 不使用 sdshdr5
if (type == SDS_TYPE_5) type = SDS_TYPE_8;
// 獲取新的 header 大小
hdrlen = sdsHdrSize(type);
assert(hdrlen + newlen + 1 > reqlen); /* Catch size_t overflow */
if (oldtype==type) {
// 類型沒變
// 調用 s_realloc_usable 重新分配可用內存，返回新 SDS 的頭部指針
// usable 會被設置為當前分配的大小
newsh = s_realloc_usable(sh, hdrlen+newlen+1, &usable);
if (newsh == NULL) return NULL; // 分配失敗直接返回NULL
// 獲取指向 buf 的指針
s = (char*)newsh+hdrlen;
} else {
// 類型變化導致 header 的大小也變化，需要向前移動字符串，不能使用 realloc
newsh = s_malloc_usable(hdrlen+newlen+1, &usable);
if (newsh == NULL) return NULL;
// 將原字符串copy至新空間中
memcpy((char*)newsh+hdrlen, s, len+1);
// 釋放原字符串內存
s_free(sh);
s = (char*)newsh+hdrlen;
// 更新 SDS 類型
s[-1] = type;
// 設置長度
sdssetlen(s, len);
}
// 獲取 buf 總長度(待定)
usable = usable-hdrlen-1;
if (usable > sdsTypeMaxSize(type))
// 若可用空間大于當前類型支持的最大長度則截斷
usable = sdsTypeMaxSize(type);
// 設置 buf 總長度
sdssetalloc(s, usable);
return s;
}


自動擴容機制總結：

擴容階段：

• 若 SDS 中剩余空閑空間 avail 大于新增內容的長度 addlen，則無需擴容；
• 若 SDS 中剩余空閑空間 avail 小于或等于新增內容的長度 addlen： 若新增后總長度 len+addlen < 1MB，則按新長度的兩倍擴容；若新增后總長度 len+addlen > 1MB，則按新長度加上 1MB 擴容。

內存分配階段：

• 根據擴容后的長度選擇對應的 SDS 類型： 若類型不變，則只需通過 s_realloc_usable擴大 buf 數組即可；若類型變化，則需要為整個 SDS 重新分配內存，并將原來的 SDS 內容拷貝至新位置。

自動擴容流程圖如下所示：

擴容后的 SDS 不會恰好容納下新增的字符，而是多分配了一些空間(預分配策略)，這減少了修改字符串時帶來的內存重分配次數

4.3.4 內存重分配次數優化

(1) 空間預分配策略

因為 SDS 的空間預分配策略， SDS 字符串在增長過程中不會頻繁的進行空間分配。通過這種分配策略，SDS 將連續增長N次字符串所需的內存重分配次數從必定N次降低為最多N次。

(2) 惰性空間釋放機制

空間預分配策略用于優化 SDS 增長時頻繁進行空間分配，而惰性空間釋放機制則用于優化 SDS 字符串縮短時并不立即使用內存重分配來回收縮短后多出來的空間，而僅僅更新 SDS 的len屬性，多出來的空間供將來使用。

SDS 中調用sdstrim方法來縮短字符串：

/* sdstrim 方法刪除字符串首尾中在 cset 中出現過的字符
* 比如:
* s = sdsnew("AA...AA.a.aa.aHelloWorld :::");
* s = sdstrim(s,"Aa. :");
* printf("%s\n", s);
*
* SDS 變成了 "HelloWorld"
*/
sds sdstrim(sds s, const char *cset) {
char *start, *end, *sp, *ep;
size_t len;
sp = start = s;
ep = end = s+sdslen(s)-1;
// strchr()函數用于查找給定字符串中某一個特定字符
while(sp <= end && strchr(cset, *sp)) sp++;
while(ep > sp && strchr(cset, *ep)) ep--;
len = (sp > ep) ? 0 : ((ep-sp)+1);
if (s != sp) memmove(s, sp, len);
s[len] = '\0';
// 僅僅更新了len
sdssetlen(s,len);
return s;
}


勘誤

在《Redis的設計與實現》一書中針對 sdstrim方法的講解為：刪除字符串中 cset 出現的所有字符，而不是首尾。

比如：調用sdstrim("XYXaYYbcXyY","XY")，后移除了所有的'X'和'Y'。這是錯誤❌的~

SDS 并沒有釋放多出來的5字節空間，僅僅將 len 設置成了7，剩余空間為5。如果后續字符串增長時則可以派上用場（可能不需要再分配內存）。

也許各位看官又會有疑問了，這沒真正釋放空間，是否會導致內存泄漏呢？放心，SDS為我們提供了真正釋放SDS未使用空間的方法sdsRemoveFreeSpace。

sds sdsRemoveFreeSpace(sds s) {
void *sh, *newsh;
// 獲取類型
char type, oldtype = s[-1] & SDS_TYPE_MASK;
// 獲取 header 大小
int hdrlen, oldhdrlen = sdsHdrSize(oldtype);
// 獲取原字符串長度
size_t len = sdslen(s);
// 獲取可用長度
size_t avail = sdsavail(s);
// 獲取指向頭部的指針
sh = (char*)s-oldhdrlen;
/* Return ASAP if there is no space left. */
if (avail == 0) return s;
// 查找適合這個字符串長度的最優 SDS 類型
type = sdsReqType(len);
hdrlen = sdsHdrSize(type);
/* 如果類型相同，或者至少仍然需要一個足夠大的類型，我們只需 realloc buf即可；
* 否則，說明變化很大，則手動重新分配字符串以使用不同的頭文件類型。
*/
if (oldtype==type || type > SDS_TYPE_8) {
newsh = s_realloc(sh, oldhdrlen+len+1);
if (newsh == NULL) return NULL;
s = (char*)newsh+oldhdrlen;
} else {
newsh = s_malloc(hdrlen+len+1);
if (newsh == NULL) return NULL;
memcpy((char*)newsh+hdrlen, s, len+1);
// 釋放內存
s_free(sh);
s = (char*)newsh+hdrlen;
s[-1] = type;
sdssetlen(s, len);
}
// 重新設置總長度為len
sdssetalloc(s, len);
return s;
}


4.4 SDS 最長多少？

Redis 官方給出了最大的字符串容量為 512MB。這是為什么呢？

在 Reids3.x 版本中len是使用int修飾的，這就會導致 buf 最長就是2147483647，無形中限制了字符串的最大長度。

任何細節在源碼中都能發現，在_sdsnewlen方法創建 SDS 中都會調用sdsTypeMaxSize方法獲取每種類型所能創建的最大buf長度，不難發現此方法最大的返回值為2147483647，即512MB。

static inline size_t sdsTypeMaxSize(char type) {
if (type == SDS_TYPE_5)
return (1<<5) - 1;
if (type == SDS_TYPE_8)
return (1<<8) - 1;
if (type == SDS_TYPE_16)
return (1<<16) - 1;
#if (LONG_MAX == LLONG_MAX)
if (type == SDS_TYPE_32)
return (1ll<<32) - 1; // 不管方法啥意思，最大返回2147483647。OVER~
#endif
return -1; /* this is equivalent to the max SDS_TYPE_64 or SDS_TYPE_32 */
}


此方法在 Redis3.0.0中是不存在的

4.5 部分 API 源碼解讀

創建SDS

Redis 通過sdsnewlen方法創建 SDS。在方法中會根據字符串初始化長度選擇合適的類型。

sds _sdsnewlen(const void *init, size_t initlen, int trymalloc) {
void *sh;
sds s;
// 根據初始化長度判斷 SDS 的類型
char type = sdsReqType(initlen);
// SDS_TYPE_5 強制轉換為 SDS_TYPE_8
// 這樣側面驗證了 sdshdr5 從未被使用，創建這一步就GG了 ??????u\
if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8;
// 獲取頭部大學
int hdrlen = sdsHdrSize(type);
// 指向 flags 的指針
unsigned char *fp; /* flags pointer. */
// 分配的空間
size_t usable;
// 防止溢出
assert(initlen + hdrlen + 1 > initlen); /* Catch size_t overflow */
// 分配空間
// s_trymalloc_usable: 嘗試分配內存，失敗則返回NULL
// s_malloc_usable: 分配內存或者拋異常[不友好]
sh = trymalloc?
s_trymalloc_usable(hdrlen+initlen+1, &usable) :
s_malloc_usable(hdrlen+initlen+1, &usable);
if (sh == NULL) return NULL;
if (init==SDS_NOINIT)
init = NULL;
else if (!init)
memset(sh, 0, hdrlen+initlen+1);
// s 此時指向buf
s = (char*)sh+hdrlen;
// 指向flags
fp = ((unsigned char*)s)-1;
usable = usable-hdrlen-1;
// 對不同類型的 SDS 可分配空間進行截斷
if (usable > sdsTypeMaxSize(type))
usable = sdsTypeMaxSize(type);
switch(type) {
case SDS_TYPE_5: {
*fp = type | (initlen << SDS_TYPE_BITS);
break;
}
case SDS_TYPE_8: {
SDS_HDR_VAR(8,s);
sh->len = initlen;
sh->alloc = usable;
*fp = type;
break;
}
// ... 省略
}
if (initlen && init)
memcpy(s, init, initlen);
// 末尾添加\0
s[initlen] = '\0';
return s;
}


通過sdsnewlen方法我們可以獲得以下信息：

• SDS_TYPE_5 會被強制轉換為 SDS_TYPE_8 類型；
• 創建時默認會在末尾加'\0'；
• 返回值是指向 SDS 結構中 buf 的指針；
• 返回值是char *sds類型，可以兼容部分C函數。

釋放SDS

為了優化性能，SDS 提供了不直接釋放內存，而是通過重置len達到清空 SDS 目的的方法——sdsclear。改方法僅僅將 SDS 的len歸零，而buf的空間并為真正被清空，新的數據可以復寫，而不用重新申請內存。

void sdsclear(sds s) {
sdssetlen(s, 0);// 設置len為0
s[0] = '\0';//“清空”buf
}


若真正想清空 SDS 則可以調用sdsfree方法，底層通過調用s_free釋放內存。

void sdsfree(sds s) {
if (s == NULL) return;
s_free((char*)s-sdsHdrSize(s[-1]));
}


我是敖丙，你知道的越多，你不知道的越多，感謝各位人才的：點贊、收藏和評論，我們下期見！

---

文章持續更新，關注后回復【資料】有我準備的一線大廠面試資料和簡歷模板，有大廠面試完整考點。

總結

以上是生活随笔為你收集整理的让我聊聊sds是什么(sds是什么意思)的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。