Redis【2】- SDS源码分析

1 简介&基础用法

Redis 中用得最多的就是字符串，在 C 语言中其实可以直接使用 char* 字符数组来实现字符串，也有很多可以直接使用得函数。但是 Redis 并没有使用 C 语言原生的字符串，而是自己实现了一个  SDS（简单动态字符串，Simple Dynamic String） 。
Redis 的 SDS 兼容了 C 语言的字符串范例的用法，
下面是 Redis 中 string 范例最常用的用法：

1. 本地:0>set hello world
2. OK
3. 本地:0>get hello
4. world
5. 本地:0>type hello
6. string
7. 本地:0>strlen hello
8. 5

复制代码

2 为什么 Redis 自实现字符串？

2.1 存储二进制的限制

C 语言的 char* 是以 \0 作为竣事字符串的标识，假如需要存储的数据中自己就含有 \0 ，那就没有办法精确表现，而像图像这种数据，一般存储下来都是二进制格式的，所以 Redis 不能直接使用 char*。
下面是 C 语言的 \0 对字符串长度判断的影响：

1. #include "stdio.h"  
2. #include "string.h"  
3.   
4. int main(void) {  
5.     char *a = "hello\0Wolrd";  
6.     char *b = "helloWolrd\0";  
7.     printf("字符串的长度：%lu\n",  
8.            strlen(a)  
9.     );    printf("字符串的长度：%lu\n",  
10.            strlen(b)  
11.     );}

复制代码

输出结果则会不一样，\0 后面的数据会被截断：

1. 字符串的长度：5
2. 字符串的长度：10

复制代码

在 SDS 结构中却能保证二进制安全，因为 SDS 生存了 len 属性，这就可以不实用 \0 这个标识来判断字符串是否竣事。
2.2 操作效率问题

2.2.1 空间效率

2.2.1.1 预分配内存

原生的 C 语言字符串，在添加的时候，可能会因为可用空间不敷，无法添加，而 Redis 追加字符串的时候，使用了预分配的策略，假如内存不敷，先进行内存拓展，再追加，有用淘汰修改字符串带来的内存重新分配的次数。
类似于 Java 中的 ArrayList，采取预分配，内部真实的容量一般都是大于实际的字符串的长度的，当字符串的长度小于 1MB 的时候，假如内存不敷，扩容都是更加如今的空间；假如字符串的长度已经凌驾了 1MB，扩容的时候也只会多扩 1MB 的空间，但是最大的字符串的长度是 512MB。
2.2.1.2 惰性空间开释

惰性空间开释用于优化 SDS 的字符串收缩操作，当 SDS 的 API 需要收缩字符串生存的字符串的时候，程序并不会立纵然用内存重新分配来回收缩多出来的字节，而是使用 free 属性将这些字节的数量记载下来，并等候将来使用。
固然 SDS 也提供了 SDS 显式调用，真正的开释未使用的空间。
2.2.2 操作效率

原生的 C 语言在获取字符的长度的时候，底层实际是遍历，时间复杂度是 O(n) ，String 作为 Redis 用得最多的数据范例，获取字符串的长度是比力频仍的操作，肯定不能这么干，那就用一个变量把 String 的长度存储起来，获取的时候时间复杂度是 O(1)。
2.2.3 兼容性较好

Redis 固然使用了 \0 来结尾，但是 sds 字符串的末端还是会依照 c 语言的惯例，所以可以重用一部分  的函数。好比对比的函数 strcasecmp ，可以用来对比 SDS 生存的字符串是否和另外一个字符串是否相同。

1. strcasecmp(sds->buf,"hello world");

复制代码

3 源码解读

3.1 简单指针介绍

数组的指针操作：

1. #include <stdio.h>
2. int main() {
3.     printf("Hello, World!\n");
4.     char t[] = {'a','b','c','d'};
5.     char* s = t+1; // 指针前进一位
6.     char  bb = s[0];
7.     char  cc = s[1];
8.     char  dd = s[2];
9.     char  flag = s[-1]; // 指针后退一位等价于  char  flag = *(s - 1);  或者  char  *flag = s - 1;   printf("%c %c %c %c", *flag, bb, cc ,dd);
10.     printf("%c %c %c %c", flag, bb, cc ,dd);
11.     return 0;
12. }

复制代码

最终输出结果：

1. Hello, World!
2. a b c d

复制代码

3.1.1 sdshdr 巧妙的结构筹划

SDS 的相关代码主要在下面两个文件：

• sds. h：头文件
  
• sds. c：源文件
  

SDS 定义在 sds. h 中，为了兼容 C 风格的字符串，给 char 取了个别名叫 sds :

1. typedef char *sds;

复制代码

《Redis 筹划与实现》中，表明的是 Redis 3.0 的代码，提到 sds 的实现结构 sdshdr 是这样的：

1. struct sdshdr {
2.     // 记录buf数组已使用字节的数量
3.     // 等于SDS所保存字符串的长度
4.     int len;
5.    
6.     // 记录buf数组中未使用的字节数
7.     int free;
8.    
9.     // 字节数组，用于保存字符串
10.     char buf[];
11. };

复制代码

但是实际上 7.0 版本已经是长这样：

• 
  
  • Sdshdr5 从未被使用，我们只是直接访问标志字节。
    
  
  

• 然而，这里文档标识 sdshdr5 的结构。
  
• 
  
  • 结构定义使用了__attribute__ ((packed))声明为非内存对齐, 紧凑排列情势（取消编译阶段的内存优化对齐功能）
    
  
  
• 
  
  • 假如定义了一个 sds *s, 可以非常方便的使用 s[-1] 获取到 flags 地点，避免了在上层调用各种范例判断。
    
  
  

1. struct __attribute__ ((__packed__)) sdshdr5 {
2.     unsigned char flags; /* 低 3 位存储类型，高 5 位存储字符串长度 */
3.     char buf[];
4. };
5. struct __attribute__ ((__packed__)) sdshdr8 {
6.     uint8_t len; /* 已使用 */
7.     uint8_t alloc; /* 总分配的，不包括头部和空的终止符*/
8.     unsigned char flags; /* 低 3 位存储类型，高 5 位预留，还没使用 */
9.     char buf[];
10. };
11. struct __attribute__ ((__packed__)) sdshdr16 {
12.     uint16_t len;  /* 已使用 */
13.     uint16_t alloc; /* 总分配的，不包括头部和空的终止符*/
14.     unsigned char flags;  /* 低 3 位存储类型，高 5 位预留，还没使用 */
15.     char buf[];
16. };
17. struct __attribute__ ((__packed__)) sdshdr32 {
18.     uint32_t len; /* 已使用 */
19.     uint32_t alloc; /* 总分配的，不包括头部和空的终止符*/
20.     unsigned char flags;  /* 低 3 位存储类型，高 5 位预留，还没使用 */
21.     char buf[];
22. };
23. struct __attribute__ ((__packed__)) sdshdr64 {
24.     uint64_t len; /* used */
25.     uint64_t alloc; /* 总分配的，不包括头部和空的终止符*/
26.     unsigned char flags;  /* 低 3 位存储类型，高 5 位预留，还没使用 */
27.     char buf[];
28. };
30. // 类型定义一共占用了 0，1，2，3，4 五个数字，也就是三位就可以标识，  
31. // 那么我们可以使用 flags&SDS_TYPE_MASK 来获取动态字符串对应的字符串类型
33. #define SDS_TYPE_5  0  
34. #define SDS_TYPE_8  1  
35. #define SDS_TYPE_16 2  
36. #define SDS_TYPE_32 3  
37. #define SDS_TYPE_64 4  
38. #define SDS_TYPE_MASK 7  
39. #define SDS_TYPE_BITS 3  
40. #define SDS_HDR_VAR(T,s) struct sdshdr##T *sh = (void*)((s)-(sizeof(struct sdshdr##T)));  
41. #define SDS_HDR(T,s) ((struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T))))  
42. #define SDS_TYPE_5_LEN(f) ((f)>>SDS_TYPE_BITS)

复制代码

上面定义了 4 种结构体，**Redis 根据差异的字符串的长度，来选择符合的结构体，每个结构体有对应数据部分和头部。
范例一共有这些：

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

复制代码

用二进制表现，只需要 3 位即可，这也是为什么上面的结构体 sdshdr5  里面的 flags 字段注释里写的：前三位表现范例，后 5 位用于表现字符串长度。

1.     unsigned char flags; /* 3 lsb of type, and 5 msb of string length */  

复制代码

而其他的 sds 结构体范例，因为长度太长了，存不下，所以后 5 位暂时没有作用，而是另外使用属性存储字符串的长度。

1.     uint8_t len; /* used */  
2.     uint8_t alloc; /* excluding the header and null terminator */  

复制代码

3.2 3.2  attribute 的作用是什么？

__attribute__ ((packed)) 的作用就是告诉编译器取消结构在编译过程中的优化对齐, 按照实际占用字节数进行对齐，是 GCC 特有的语法。这个功能是跟操作体系没关系，跟编译器有关，gcc 编译器不是紧凑模式的。
attribute__关键字主要是用来在函数或数据声明中设置其属性。给函数赋给属性的主要目的在于让编译器进行优化。函数声明中的__attribute((noreturn))，就是告诉编译器这个函数不会返回给调用者，以便编译器在优化时去掉不须要的函数返回代码。
__attribute__书写特征是：__attribute__前后都有两个下划线，而且后面会紧跟一对括弧，括弧里面是相应的__attribute__参数，其语法格式为：

1. __attribute__ ((attribute-list))

复制代码

下面是实行的一些代码，实行环境为 Mac：

1. #include "stdio.h"  
2.   
3. struct One{ char ch; int a;} one;  
4. struct __attribute__ ((__packed__)) Tow{ char ch; int a;} tow;  
5.   
6. int main(void) {  
7.     printf("int 的内存大小：%lu\n",  
8.            sizeof(int)  
9.     );    printf("新结构体one的大小（不压缩）：%lu\n",  
10.            sizeof(one)  
11.     );    printf("新结构体tow的大小（压缩）：%lu\n",  
12.            sizeof(tow)  
13.     );}

复制代码

运行结果：

1. int 的内存大小：4
2. 新结构体one的大小（不压缩）：8
3. 新结构体tow的大小（压缩）：5

复制代码

编译器压缩优化（内存不对齐）后，确实体积从 8 酿成了 5，缩小了不少，别看这小小的变化，其实在巨大的数量眼前，就是很大的空间优化。
3.3 宏操作

redis 基于前面 sds 筹划，定义了一些十分巧妙的宏操作：
3.3.1 通过 sds 获取差异范例 sdshdr 变量

1. /*  
2. * 宏操作  
3. * SDS_HDR_VAR(8,s);  
4. * 下面是对应宏定义翻译的产物  
5. * struct sdshdr8 *sh = (void*)((s)-(sizeof(struct sdshdr##T)));  
6. * 可以根据指向 buf 的sds变量s得到 sdshdr8 的指针,sh 是创建出来的变量  
7. */  
8. #define SDS_HDR_VAR(T,s) struct sdshdr##T *sh = (void*)((s)-(sizeof(struct sdshdr##T)));
10. /**  
11. * 和上面类似  
12. * 根据指向buf的sds变量s得到sdshdr的指针，只不过这里是获取的是指针地址  
13. */  
14. #define SDS_HDR(T,s) ((struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T))))

复制代码

3.3.2 获取 sdshdr5 字符串范例的长度

1. /**  
2. * 该函数就是获取sdshdr5字符串类型的长度，由于根本不使用sdshdr5类型，所以需要直接返回空，  
3. * 而flags成员使用最低三位有效位来表示类型，所以让f代表的flags的值右移三位即可  
4. */  
5. #define SDS_TYPE_5_LEN(f) ((f)>>SDS_TYPE_BITS)

复制代码

3.3.3 通过 sds 获取 len 的值

1. /**  
2. * 使用到了取消编译阶段的内存优化对齐功能，直接使用s[-1]获取到flags成员的值，  
3. * 然后根据flags&&SDS_TYPE_MASK来获取到动态字符串对应的类型进而获取动态字符串的长度。  
4. * SDS_TYPE_5_LEN 比较特殊一点，因为结构有点不一样  
5. */  
6. static inline size_t sdslen(const sds s) {  
7. unsigned char flags = s[-1];  
8. switch(flags&SDS_TYPE_MASK) {  
9. case SDS_TYPE_5:  
10. return SDS_TYPE_5_LEN(flags);  
11. case SDS_TYPE_8:  
12. return SDS_HDR(8,s)->len;  
13. case SDS_TYPE_16:  
14. return SDS_HDR(16,s)->len;  
15. case SDS_TYPE_32:  
16. return SDS_HDR(32,s)->len;  
17. case SDS_TYPE_64:  
18. return SDS_HDR(64,s)->len;  
19. }  
20. return 0;  
21. }

复制代码

3.4 创建新字符串

创建新的字符串一般是通报初始化的长度：

1. sds sdsnewlen(const void *init, size_t initlen) {  
2.         // 内部封装的函数，最后一个参数是是否尝试分配
3.     return _sdsnewlen(init, initlen, 0);  
4. }

复制代码

下面我们看具体的函数实现：
创建的返回的是指针，指向的是结构体中 buf 开始的位置，

1. sds _sdsnewlen(const void *init, size_t initlen, int trymalloc) {  
2.         // sh 指向sds分配开始的地方
3.     void *sh;
4.     // s 也是指针，指向 buf 开始的位置  
5.     sds s;
6.     // 不同长度返回不同的类型sds
7.     char type = sdsReqType(initlen);  
8.     /* Empty strings are usually created in order to append. Use type 8  
9.      * since type 5 is not good at this. */
10.     // 空字符串经常被创建出来之后，就会执行append操作，所以用type 8替换掉它，type 5 太短了。
11.     if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8;  
12.     // 获取整个struct的长度
13.     int hdrlen = sdsHdrSize(type);
14.     // flag 指针，标识sds 是哪一个类型的  
15.     unsigned char *fp; /* flags pointer. */
16.     // 可用大小  
17.     size_t usable;  
18.     // 防止溢出
19.     assert(initlen + hdrlen + 1 > initlen); /* Catch size_t overflow */
20.     // 分配内存,其中s_trymalloc_usable是调整内存,s_malloc_usable是新分配内存,是两种内存分配的方式,通过参数trymalloc控制（+1 是为了处理 \0）
21.     sh = trymalloc?  
22.         s_trymalloc_usable(hdrlen+initlen+1, &usable) :  
23.         s_malloc_usable(hdrlen+initlen+1, &usable);  
24.     // 分配不成功，提前结束
25.     if (sh == NULL) return NULL;
26.     // 如果需要完全为空的字符串，直接返回null  
27.     if (init==SDS_NOINIT)  
28.         init = NULL;  
29.     else if (!init)
30.         memset(sh, 0, hdrlen+initlen+1);  // 初始化
31.     // s 指向数组 buf 的位置（从结构体往后加上hdrlen就是buf数组开头的位置）
32.     s = (char*)sh+hdrlen;
33.     // buf数组的位置-1，就是flags字段的位置  
34.     fp = ((unsigned char*)s)-1;
35.     // 可用空间减去hdrlen（已用空间），再减1（‘\0‘）  
36.     usable = usable-hdrlen-1;
37.     // 如果可用空间大于当前结构体中alloc字段的大小,就使用alloc的最大值  
38.     if (usable > sdsTypeMaxSize(type))  
39.         usable = sdsTypeMaxSize(type);
40.     // 初始化不同类型的数组，字符串长度，可用大小和类型  
41.     switch(type) {  
42.         case SDS_TYPE_5: {  
43.             *fp = type | (initlen << SDS_TYPE_BITS);  
44.             break;  
45.         }        
46.         case SDS_TYPE_8: {  
47.             SDS_HDR_VAR(8,s);  
48.             sh->len = initlen;  
49.             sh->alloc = usable;  
50.             *fp = type;  
51.             break;  
52.         }        
53.         case SDS_TYPE_16: {  
54.             SDS_HDR_VAR(16,s);  
55.             sh->len = initlen;  
56.             sh->alloc = usable;  
57.             *fp = type;  
58.             break;  
59.         }        
60.         case SDS_TYPE_32: {  
61.             SDS_HDR_VAR(32,s);  
62.             sh->len = initlen;  
63.             sh->alloc = usable;  
64.             *fp = type;  
65.             break;  
66.         }        
67.         case SDS_TYPE_64: {  
68.             SDS_HDR_VAR(64,s);  
69.             sh->len = initlen;  
70.             sh->alloc = usable;  
71.             *fp = type;  
72.             break;  
73.         }
74.         }
75.         if (initlen && init)  
76.         memcpy(s, init, initlen);  
77.     s[initlen] = '\0';  
78.     return s;  
79. }

复制代码

3.5 获取可用空间

SDS 和我平常所用到的 C 语言的原生字符串有差异，因为从获取可用空间的盘算方法来看，并未考虑到字符串需要以 \0 结尾，结构体自己带有长度的成员 len，不需要 \0 来做字符串结尾的判断，而且不使用 \0  作为结尾有很多利益, 分配的减去使用的即可。

1. static inline size_t sdsavail(const sds s) {
2.     unsigned char flags = s[-1];
3.     switch(flags&SDS_TYPE_MASK) {
4.         case SDS_TYPE_5: {
5.             return 0;
6.         }
7.         case SDS_TYPE_8: {
8.             SDS_HDR_VAR(8,s);
9.             return sh->alloc - sh->len;
10.         }
11.         case SDS_TYPE_16: {
12.             SDS_HDR_VAR(16,s);
13.             return sh->alloc - sh->len;
14.         }
15.         case SDS_TYPE_32: {
16.             SDS_HDR_VAR(32,s);
17.             return sh->alloc - sh->len;
18.         }
19.         case SDS_TYPE_64: {
20.             SDS_HDR_VAR(64,s);
21.             return sh->alloc - sh->len;
22.         }
23.     }
24.     return 0;
25. }

复制代码

3.6 设置 & 增加 sds 的长度

1. // 设置 sds 的长度
2. static inline void sdssetlen(sds s, size_t newlen) {
3.     unsigned char flags = s[-1];
4.     switch(flags&SDS_TYPE_MASK) {
5.         case SDS_TYPE_5:
6.             {
7.                 unsigned char *fp = ((unsigned char*)s)-1;
8.                 *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS);
9.             }
10.             break;
11.         case SDS_TYPE_8:
12.             SDS_HDR(8,s)->len = newlen;
13.             break;
14.         case SDS_TYPE_16:
15.             SDS_HDR(16,s)->len = newlen;
16.             break;
17.         case SDS_TYPE_32:
18.             SDS_HDR(32,s)->len = newlen;
19.             break;
20.         case SDS_TYPE_64:
21.             SDS_HDR(64,s)->len = newlen;
22.             break;
23.     }
24. }
26. // 增加 sds 的长度
27. static inline void sdsinclen(sds s, size_t inc) {
28.     unsigned char flags = s[-1];
29.     switch(flags&SDS_TYPE_MASK) {
30.         case SDS_TYPE_5:
31.             {
32.                 unsigned char *fp = ((unsigned char*)s)-1;
33.                 unsigned char newlen = SDS_TYPE_5_LEN(flags)+inc;
34.                 *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS);
35.             }
36.             break;
37.         case SDS_TYPE_8:
38.             SDS_HDR(8,s)->len += inc;
39.             break;
40.         case SDS_TYPE_16:
41.             SDS_HDR(16,s)->len += inc;
42.             break;
43.         case SDS_TYPE_32:
44.             SDS_HDR(32,s)->len += inc;
45.             break;
46.         case SDS_TYPE_64:
47.             SDS_HDR(64,s)->len += inc;
48.             break;
49.     }
50. }

复制代码

3.7 设置 & 获取已分配空间大小

1. /* sdsalloc() = sdsavail() + sdslen() */
2. // 获取 sds 已经分配的空间的大小
3. static inline size_t sdsalloc(const sds s) {
4.     unsigned char flags = s[-1];
5.     switch(flags&SDS_TYPE_MASK) {
6.         case SDS_TYPE_5:
7.             return SDS_TYPE_5_LEN(flags);
8.         case SDS_TYPE_8:
9.             return SDS_HDR(8,s)->alloc;
10.         case SDS_TYPE_16:
11.             return SDS_HDR(16,s)->alloc;
12.         case SDS_TYPE_32:
13.             return SDS_HDR(32,s)->alloc;
14.         case SDS_TYPE_64:
15.             return SDS_HDR(64,s)->alloc;
16.     }
17.     return 0;
18. }
20. // 设置 sds 已经分配的空间的大小
21. static inline void sdssetalloc(sds s, size_t newlen) {
22.     unsigned char flags = s[-1];
23.     switch(flags&SDS_TYPE_MASK) {
24.         case SDS_TYPE_5:
25.             /* Nothing to do, this type has no total allocation info. */
26.             break;
27.         case SDS_TYPE_8:
28.             SDS_HDR(8,s)->alloc = newlen;
29.             break;
30.         case SDS_TYPE_16:
31.             SDS_HDR(16,s)->alloc = newlen;
32.             break;
33.         case SDS_TYPE_32:
34.             SDS_HDR(32,s)->alloc = newlen;
35.             break;
36.         case SDS_TYPE_64:
37.             SDS_HDR(64,s)->alloc = newlen;
38.             break;
39.     }
40. }

复制代码

3.8 扩大 sds 空间

1. /**
2. * 扩大sds字符串末尾的空闲空间，以便调用者确信在调用此函数后可以覆盖到字符串末尾 addlen字节，再加上null term的一个字节。
3. * 如果已经有足够的空闲空间，这个函数返回时不做任何操作，如果没有足够的空闲空间，它将分配缺失的部分，甚至更多:
4. * 当greedy为1时，放大比需要的更多，以避免将来在增量增长时需要重新分配。
5. * 当greedy为0时，将其放大到足够大以便为addlen腾出空间。
6. * 注意:这不会改变sdslen()返回的sds字符串的长度，而只会改变我们拥有的空闲缓冲区空间。
7. */
8. // 扩大sds空间
9. sds _sdsMakeRoomFor(sds s, size_t addlen, int greedy) {
10.     void *sh, *newsh;
11.     // 获取剩余可用的空间
12.     size_t avail = sdsavail(s);
13.     size_t len, newlen, reqlen;
14.     // 获取sds 具体数据类型
15.     char type, oldtype = s[-1] & SDS_TYPE_MASK;
16.     int hdrlen;
17.     size_t usable;
19.     /* Return ASAP if there is enough space left. */
20.     // 可用空间足够直接返回
21.     if (avail >= addlen) return s;
23.     // 已用字符长度
24.     len = sdslen(s);
26.     // sh 回溯到sds起始位置
27.     sh = (char*)s-sdsHdrSize(oldtype);
29.     // newlen 为最小需要的长度
30.     reqlen = newlen = (len+addlen);
31.     assert(newlen > len);   /* Catch size_t overflow */
32.     // 在newlen小于SDS_MAX_PREALLOC(1M)，对newlen进行翻倍，在newlen大于SDS_MAX_PREALLOC的情况下，让newlen加上SDS_MAX_PREALLOC。
33.     if (greedy == 1) {
34.         if (newlen < SDS_MAX_PREALLOC) // 小于1Kb 预分配2倍长度 = newlen + newlen
35.             newlen *= 2;
36.         else
37.             newlen += SDS_MAX_PREALLOC; // 多余1Mb 预分配 = newlen + 1Mb
38.     }
40.     // 获取新长度的类型
41.     type = sdsReqType(newlen);
43.     /* Don't use type 5: the user is appending to the string and type 5 is
44.      * not able to remember empty space, so sdsMakeRoomFor() must be called
45.      * at every appending operation. */
46.     if (type == SDS_TYPE_5) type = SDS_TYPE_8;
48.     // 新类型头部长度
49.     hdrlen = sdsHdrSize(type);
50.     // 校验是否溢出
51.     assert(hdrlen + newlen + 1 > reqlen);  /* Catch size_t overflow */
52.     if (oldtype==type) {
53.         /**
54.          * 本质上是 使用 zrealloc_usable函数，指针ptr必须为指向堆内存空间的指针，即由malloc函数、calloc函数或realloc函数分配空间的指针。
55.          * realloc函数将指针p指向的内存块的大小改变为n字节。
56.          * 1.如果n小于或等于p之前指向的空间大小，那么。保持原有状态不变。
57.          * 2.如果n大于原来p之前指向的空间大小，那么，系统将重新为p从堆上分配一块大小为n的内存空间，同时，将原来指向空间的内容依次复制到新的内存空间上，p之前指向的空间被释放。
58.          * relloc函数分配的空间也是未初始化的。
59.          */
60.         newsh = s_realloc_usable(sh, hdrlen+newlen+1, &usable);
61.         // 申请空间失败
62.         if (newsh == NULL) return NULL;
63.         // s指向新sds结构的buf开始位置
64.         s = (char*)newsh+hdrlen;
65.     } else {
66.         /* Since the header size changes, need to move the string forward,
67.          * and can't use realloc */
68.         // 数据结构发生变更，协议头部变更，需要从堆上重新申请数据空间
69.         newsh = s_malloc_usable(hdrlen+newlen+1, &usable);
70.         if (newsh == NULL) return NULL;
71.         // 系统copy，越过头部结构长度，复制s的有效数据集合
72.         memcpy((char*)newsh+hdrlen, s, len+1);
73.         // 释放旧空间
74.         s_free(sh);
75.         // s执行新的空间，buf起始位置
76.         s = (char*)newsh+hdrlen;
77.         // flag 赋值 头部的第三个有效字段
78.         s[-1] = type;
79.         // 更新有效数据长度
80.         sdssetlen(s, len);
81.     }
82.     // 实际可用数据空间
83.     usable = usable-hdrlen-1;
84.     if (usable > sdsTypeMaxSize(type))
85.         usable = sdsTypeMaxSize(type);
86.     // 更新分配的空间值
87.     sdssetalloc(s, usable);
88.     return s;
89. }

复制代码

3.9 开释多余空间

1. /* 对sds中多余的空间进行释放  
2. * 重新分配sds字符串，使其末尾没有空闲空间。所包含的字符串保持不变，  
3. * 但下一个连接操作将需要重新分配。  
4. * 调用之后，传递的sds字符串不再有效，所有引用必须用调用返回的新指针替换。  
5. */
6. sds sdsRemoveFreeSpace(sds s, int would_regrow) {  
7.         return sdsResize(s, sdslen(s), would_regrow);  
8. }

复制代码

1. /**
2. * 调整分配的大小，这可以使分配更大或更小，如果大小小于当前使用的len，数据将被截断。
3. * 当将d_regrow参数设置为1时，它会阻止使用SDS_TYPE_5，这是在sds可能再次更改时所需要的。
4. * 无论实际分配大小如何，sdsAlloc大小都将被设置为请求的大小，这样做是为了避免在调用者检测到它有多余的空间时重复调用该函数
5. */
6. sds sdsResize(sds s, size_t size, int would_regrow) {
7.     void *sh, *newsh;
8.     char type, oldtype = s[-1] & SDS_TYPE_MASK;
9.     int hdrlen, oldhdrlen = sdsHdrSize(oldtype);
10.     size_t len = sdslen(s);
11.     sh = (char*)s-oldhdrlen;
13.     /* Return ASAP if the size is already good. */
14.     if (sdsalloc(s) == size) return s;
16.     /* Truncate len if needed. */
17.     if (size < len) len = size;
19.     /* Check what would be the minimum SDS header that is just good enough to
20.      * fit this string. */
21.     type = sdsReqType(size);
22.     if (would_regrow) {
23.         /* Don't use type 5, it is not good for strings that are expected to grow back. */
24.         if (type == SDS_TYPE_5) type = SDS_TYPE_8;
25.     }
26.     hdrlen = sdsHdrSize(type);
28.     /* If the type is the same, or can hold the size in it with low overhead
29.      * (larger than SDS_TYPE_8), we just realloc(), letting the allocator
30.      * to do the copy only if really needed. Otherwise if the change is
31.      * huge, we manually reallocate the string to use the different header
32.      * type. */
33.     int use_realloc = (oldtype==type || (type < oldtype && type > SDS_TYPE_8));
34.     size_t newlen = use_realloc ? oldhdrlen+size+1 : hdrlen+size+1;
35.     int alloc_already_optimal = 0;
36.     #if defined(USE_JEMALLOC)
37.         /* je_nallocx returns the expected allocation size for the newlen.
38.          * We aim to avoid calling realloc() when using Jemalloc if there is no
39.          * change in the allocation size, as it incurs a cost even if the
40.          * allocation size stays the same. */
41.         alloc_already_optimal = (je_nallocx(newlen, 0) == zmalloc_size(sh));
42.     #endif
44.     if (use_realloc && !alloc_already_optimal) {
45.         newsh = s_realloc(sh, newlen);
46.         if (newsh == NULL) return NULL;
47.         s = (char*)newsh+oldhdrlen;
48.     } else if (!alloc_already_optimal) {
49.         newsh = s_malloc(newlen);
50.         if (newsh == NULL) return NULL;
51.         memcpy((char*)newsh+hdrlen, s, len);
52.         s_free(sh);
53.         s = (char*)newsh+hdrlen;
54.         s[-1] = type;
55.     }
56.     s[len] = 0;
57.     sdssetlen(s, len);
58.     sdssetalloc(s, size);
59.     return s;
60. }

复制代码

3.10 拼接字符串

将一个字符串拼接到原 sds 后面：

1. sds sdscatlen(sds s, const void *t, size_t len) {
2.     // 现在长度
3.     size_t curlen = sdslen(s);
4.     // 扩容
5.     s = sdsMakeRoomFor(s,len);
6.     if (s == NULL) return NULL;
7.     // 复制
8.     memcpy(s+curlen, t, len);
9.     // 设置长度
10.     sdssetlen(s, curlen+len);
11.     // 结尾'\0'
12.     s[curlen+len] = '\0';
13.     return s;
14. }

复制代码

3.11 拷贝

1. sds sdscpylen(sds s, const char *t, size_t len) {
2.     // 长度不够需要扩容
3.     if (sdsalloc(s) < len) {
4.         s = sdsMakeRoomFor(s,len-sdslen(s));
5.         if (s == NULL) return NULL;
6.     }
7.     // 复制
8.     memcpy(s, t, len);
9.     // 末尾 '\0'
10.     s[len] = '\0';
11.     // 设置长度
12.     sdssetlen(s, len);
13.     return s;
14. }

复制代码

4 SDS 的优点

• 
  
  • 获取字符串的时间效率为 O (1)
    
  
  
• 
  
  • 杜绝缓冲区的溢出，复制或者追加字符串之前，会对空间进行检查与拓展，而且预分配一些容量，淘汰分片内存的次数。
    
  
  
• 
  
  • 可以存储二进制数据，含有 \0 则在读取时不会被截断。
    
  
  
• 
  
  • 可以复用一部分 c 原生字符串的函数。
    
  
  

作者： 秦怀，个人站点 秦怀杂货店，纵使迟钝，驰而不息。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。