写在前面

以下内容是基于Redis 6.2.6 版本整理总结

Redis数据结构

Redis是以k-v形式存储的内存数据库，其中key和value都是以对象（object）的形式进行存储。对象分为：string、list、hash、set和zet五种对象，这五种对象的底层实现依赖于自己实现的一些数据结构，如：sds、quicklist、ziplist、hashtable、skiplist等。注意：key只能是string对象。

今天我们就来学习，Redis的sds（简单动态字符串）。

一、SDS（Simple Dynamic String，简单动态字符串）

Redis没有使用C语言传统的字符串表示方式（以’\0’结尾的字符数组），而是自己实现了sds的抽象类型，Redis默认使用sds作为字符串的表示。

set msg "hello, world"

其中，key为保存字符串“msg”的sds，value为保存字符串“hello，world”的sds。
除了用来保存字符串的值外，sds还被用作buffer（缓冲区），比如：AOF持久化模块中的AOF缓冲区，及客户端的输入缓冲区等。

1.1 SDS的定义

每个src/sds.h/sdshdr结构表示一个sds对象。sdshdrxx会根据字符串的实际长度，选取合适的结构，最大化节省内存空间。获取字符串长度时间复杂度O(1)。

attribute ((packed)) : 告诉编译器，不要因为内存对齐而在结构体中填充字节，以保证内存的紧凑，这样sds - 1就可以得到flags字段，进而能够得到其头部类型。如果填充了字节，则就不能得到flags字段。

/* Note: sdshdr5 is never used, we just access the flags byte directly.* However is here to document the layout of type 5 SDS strings. */
struct __attribute__ ((__packed__)) sdshdr5 {unsigned char flags; /* 3 lsb of type, and 5 msb of string length */char buf[];
};
struct __attribute__ ((__packed__)) sdshdr8 {uint8_t len; // 已经使用的字节数uint8_t alloc; // 实际可以存储的字节最大长度，不包括SDS头部和结尾的空字符unsigned char flags; // flags中的低3个bit决定使用哪种结构存储字符串，高5bit未使用char buf[]; // 柔性数组，用来保存实际的字符串
};
struct __attribute__ ((__packed__)) sdshdr16 {uint16_t len; /* used */uint16_t alloc; /* excluding the header and null terminator */unsigned char flags; /* 3 lsb of type, 5 unused bits */char buf[];
};
struct __attribute__ ((__packed__)) sdshdr32 {uint32_t len; /* used */uint32_t alloc; /* excluding the header and null terminator */unsigned char flags; /* 3 lsb of type, 5 unused bits */char buf[];
};
struct __attribute__ ((__packed__)) sdshdr64 {uint64_t len; /* used */uint64_t alloc; /* excluding the header and null terminator */unsigned char flags; /* 3 lsb of type, 5 unused bits */char buf[];
};

1.2 空间预分配

用来优化SDS的字符串增长操作：当SDS的API对一个SDS进行修改，并且需要对SDS进行空间扩展的时候，程序不仅会为SDS分配修改所必须要的空间，还会为SDS分配额外的未使用空间。通过空间预分配策略，Redis可以减少连续执行字符串增长操作所需的内存重分配次数。

1.3 惰性空间释放

用来优化SDS字符串缩短操作：当SDS的API对一个SDS进行缩短时，程序并不立即回收多出来的字节，而是通过alloc和len的差值，将这些字节数量保存起来，等待将来使用。

1.4 二进制安全

C语言的字符串中的字符必须符合某种编码（如：ASCII），并且除了字符串末尾的空字符，其他位置不能包含空字符，否则，会出现数据被截断的情况，比如：

如果使用C字符串所用的函数来识别，只能读取到“hello”，后面的“world”会被忽略，这个限制使得C字符串只能保存文本数据，而不能保存图片、视频、压缩文件等二进制数据。

SDS的API都会以二进制的方式来处理SDS存放在buf数组里的数据，Redis使用这个数组保存的是一系列二进制数据，而不是保存字符。SDS使用len属性的值判断字符串是否结束，而不是空字符，即SDS是二进制安全的。

二、SDS 源码分析

2.1 头部信息

Redis 使用以下宏定义来标识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
#define SDS_TYPE_MASK 7
#define SDS_TYPE_BITS 3// 通过字符串的大小返回SDS的类型
static inline char sdsReqType(size_t string_size) {if (string_size < 1<<5)return SDS_TYPE_5;if (string_size < 1<<8)return SDS_TYPE_8;if (string_size < 1<<16)return SDS_TYPE_16;
#if (LONG_MAX == LLONG_MAX)if (string_size < 1ll<<32)return SDS_TYPE_32;return SDS_TYPE_64;
#elsereturn SDS_TYPE_32;
#endif
}

2.2 SDS 操作

SDS的头部和buf是一段连续的内存空间，所以，当我们得到一个SDS的对象s时，可以通过s[-1]得到flags字段，再减去sdshdr的大小就能找到该对象的起始地址。

2.2.1 一些宏定义

// 返回sds对象的起始地址
#define SDS_HDR_VAR(T,s) struct sdshdr##T *sh = (void*)((s)-(sizeof(struct sdshdr##T)));#define SDS_HDR(T,s) ((struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T))))

2.2.2 获取当前sds对象buf中存储的字符串长度

说明，s[-1]往后偏移一个字节，拿到flags的值，再通过和SDS_TYPE_MASK掩码“与”操作，得到头部的类型，再通过对应类型宏定义返回的头部指针的len属性获取字符串的长度。

static inline size_t sdslen(const sds s) {unsigned char flags = s[-1];switch(flags&SDS_TYPE_MASK) {case SDS_TYPE_5:return SDS_TYPE_5_LEN(flags);case SDS_TYPE_8:return SDS_HDR(8,s)->len;case SDS_TYPE_16:return SDS_HDR(16,s)->len;case SDS_TYPE_32:return SDS_HDR(32,s)->len;case SDS_TYPE_64:return SDS_HDR(64,s)->len;}return 0;
}

2.2.3 获取当前sds对象剩余可用空间大小

同上，通过头的指针的alloc-len 得到可用空间的大小。

static inline size_t sdsavail(const sds s) {unsigned char flags = s[-1];switch(flags&SDS_TYPE_MASK) {case SDS_TYPE_5: {return 0;}case SDS_TYPE_8: {SDS_HDR_VAR(8,s);return sh->alloc - sh->len;}case SDS_TYPE_16: {SDS_HDR_VAR(16,s);return sh->alloc - sh->len;}case SDS_TYPE_32: {SDS_HDR_VAR(32,s);return sh->alloc - sh->len;}case SDS_TYPE_64: {SDS_HDR_VAR(64,s);return sh->alloc - sh->len;}}return 0;
}

2.2.4 使用一个字符串初始化SDS对象

Redis 6.2.6 新增了 sdstrynewlen() 函数，和 sdsnewlen() 函数的区别在于 调用_sdsnewlen()函数的第三个参数，是否开启 trymalloc。如果开始了trymalloc，若分配函数返回NULL，不会走系统设置的zmalloc_default_oom异常处理函数，该函数直接会使程序退出。

// src/sds.c
// sds mystring = sdsnewlen("abc",3);sds sdsnewlen(const void *init, size_t initlen) {return _sdsnewlen(init, initlen, 0);
}sds sdstrynewlen(const void *init, size_t initlen) {return _sdsnewlen(init, initlen, 1);
}sds _sdsnewlen(const void *init, size_t initlen, int trymalloc) {void *sh;sds s;// 根据字符串的长度选择合适的sdshdr头部char type = sdsReqType(initlen);/* Empty strings are usually created in order to append. Use type 8* since type 5 is not good at this. */if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8;// 根据type获取头部大小int hdrlen = sdsHdrSize(type);unsigned char *fp; /* flags pointer. */size_t usable;assert(initlen + hdrlen + 1 > initlen); /* Catch size_t overflow */// 是否开启trymalloc，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从sds起始地址偏移hdrlen大小，指向buf的首地址   s = (char*)sh+hdrlen;// s往后偏移一个字节，指向flags  fp = ((unsigned char*)s)-1;// usable: 实际分配的长度// hdrlen: 头部大小// 1: 结尾要保存'\0'的一个字节usable = usable-hdrlen-1;  // 计算实际buf可用的空间// 如果 usable 大于该 type 对应的最大长度，修正 usableif (usable > sdsTypeMaxSize(type))usable = sdsTypeMaxSize(type);// 填充头部各个属性字段，如：len alloc flagsswitch(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;}case SDS_TYPE_16: {SDS_HDR_VAR(16,s);sh->len = initlen;sh->alloc = usable;*fp = type;break;}case SDS_TYPE_32: {SDS_HDR_VAR(32,s);sh->len = initlen;sh->alloc = usable;*fp = type;break;}case SDS_TYPE_64: {SDS_HDR_VAR(64,s);sh->len = initlen;sh->alloc = usable;*fp = type;break;}}// 将要保存的字符串拷贝到sds对象对应的buf中if (initlen && init)memcpy(s, init, initlen);// 结尾添加 '\0'    s[initlen] = '\0';// 将该sds对象返回出去return s;
}

2.2.5 空间预分配

Redis使用sdsMakeRoomFor(s, addlen)函数来为sds对象预分配addlen大小的空间。

sds sdsMakeRoomFor(sds s, size_t addlen) {void *sh, *newsh;// 获取该sds对象当前可用空间大小size_t avail = sdsavail(s);size_t len, newlen, reqlen;// oldtype 保存该sds预分配前的typechar 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;// 获取该sds对象已使用字节数len = sdslen(s);// 获取指向该sds对象起始地址的指针sh = (char*)s-sdsHdrSize(oldtype);// 空间不够：则新分配的字节数 = old字节数 + 预分配的字节数reqlen = newlen = (len+addlen);assert(newlen > len);   /* Catch size_t overflow */// 如果预分配的字节数在1M以内，每次翻倍newlen*2 ；如果大于等于1M，每次空间新增加1Mif (newlen < SDS_MAX_PREALLOC)newlen *= 2;elsenewlen += SDS_MAX_PREALLOC;// 根据新的字节长度计算此时的typetype = 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. */if (type == SDS_TYPE_5) type = SDS_TYPE_8;// 计算此时的头部大小hdrlen = sdsHdrSize(type);assert(hdrlen + newlen + 1 > reqlen);  /* Catch size_t overflow */// 如果扩展后的type和之前一样if (oldtype==type) {newsh = s_realloc_usable(sh, hdrlen+newlen+1, &usable);if (newsh == NULL) return NULL;s = (char*)newsh+hdrlen;} else {/* Since the header size changes, need to move the string forward,* and can't use realloc */// 因为头部大小不一致，之前的属性字段不能重复使用newsh = s_malloc_usable(hdrlen+newlen+1, &usable);if (newsh == NULL) return NULL;// 拷贝目标字符串memcpy((char*)newsh+hdrlen, s, len+1);// 释放旧的sds对象s_free(sh);// s 指向 bufs = (char*)newsh+hdrlen;s[-1] = type;  // type赋值sdssetlen(s, len); // 设置新sds对象的len属性，len还是原来字符串的长度，只是预分配了空间}usable = usable-hdrlen-1;if (usable > sdsTypeMaxSize(type))usable = sdsTypeMaxSize(type);sdssetalloc(s, usable);  // 设置新sds对象的alloc属性return s;
}