Redis的字符串是如何实现的

前言

字符串在日常开发中应用得比较普遍，对于redis来说，键值对中的键是字符串，值也是字符串。比如在redis中写入一条客户信息记录姓名、性别、爱好等。

在redis这种内存数据库中，由于字符串被广泛的应用，在设计字符串时基于以下几点来设计：
1.支持丰富高效的字符串操作，比如追加、拷贝、比较等操作
2.能保存二进制数据
3.能尽可能的节省内存开销

可能会有人问了，既然c语言库提供了char*这样的字符数组来字符串操作。比如strcmp,strcat。感觉完全可以考虑直接使用c库提供的啊。c库字符串运用是很普遍，但是也不是没有问题的。它需要频繁的创建和检查空间，这在实际项目中其实很花时间的。所以，redis设计了简单字符串（sds，simple data )来表示字符串。同原来的c语言相比提升了字符串的操作效率，而且还支持二进制格式。下面我们就来介绍下redis的字符串是如何实现的。

为什么不用char*

先来看看char*字符数组的结构，其实很简单就是开辟一块连续的内存空间来依次存放每一个字符，最后一个字符是”\0″表示字符串结束。c库中的字符串操作函数就是通过检查”\0″来判断字符串结束。比如strlen函数就是遍历字符数组中的每一个字符并计数，直到遇到”\0″结束计数，然后返回计数结果。下面我们通过一个代码来看看”\0″结束字符对字符串长度的影响。

这段代码的执行结果如下：

表示a1的字符长度是2个字符。这是因为在he后面有了”\0″，所以字符串以”\0″表示结束，这就会产生一个问题，如果字符串内部本身就有”\0″,那么数据就会被”\0″截断，而这就不能保存任意二进制数据了。

传统设计操作复杂度高

除了上面提到的不能保存任意二进制数据以外，操作复杂度也挺大。比如c语言中用得比较普遍的strlen函数，它要遍历字符数组中的每一个字符才能得到字符串长度。所以，时间复杂度是o(n)。另外再说一个常用函数strcat，它同strlen函数一样先遍历字符串才能得到目标字符串的末尾，而且它把源字符串追加到目标字符串末尾的时，还得确认目标字符串是否具有足够的空间。所以在调用的时候，开发人员还要人为保证目标字符串有足够的可用空间，不然就需要动态地申请空间。这样不仅时间复杂度高，操作复杂度也高了。

sds的设计

redis在设计的时候还是尽量保证复用c标准的字符串操作函数的。redis在保留了使用字符数组来保存实际数据基础上，专门设计了一种sds数据结构。
首先，sds结构里面包含了一个字符数组buf[],同时sds结构里面还包含了三个元数据。分别是字符数组现有长度len，分配给字符数组的空间长度alloc以及sds类型flags。其中len和alloc这两个元数据定义了不同类型的sds。sds定义代码如下所示：

typedef char *sds;

/* 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; /* used */
    uint8_t alloc; /* excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    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[];
};

用个图来表示一下

代码中定义了一个别名

typedef char *sds;

所以sds本质还是字符数组，只是在字符数组基础上增加了额外的元数据，redis在使用字符数组时直接使用sds这个别名。

sds的高效操作

创建sds

redis调用sdsnewlen函数创建sds。我们以sedsnewlen举例，代码如下：

hisds sdsnewlen(const void *init, size_t initlen) {
   //指向sds结构的指针
    void *sh;
    //sds类型变量,就是char*的别名
    sds s;
    //根据大小获取sds的类型
    char type = hi_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;
    int hdrlen = sdshdrsize(type);
    unsigned char *fp; /* flags pointer. */

     //为新创建的sds结构分配内存
    sh = s_malloc(hdrlen+initlen+1);
    if (sh == null) return null;
    if (!init)
        memset(sh, 0, hdrlen+initlen+1);
    
    //指向sds结构体中的buf数组,sh指向sds结构的起始位置，hdrlen表示元数据的长度    
    s = (char*)sh+hdrlen;
    fp = ((unsigned char*)s)-1;
    //根据类型初始化len,alloc
    switch(type) {
        case sds_type_5: {
            *fp = type | (initlen << hi_sds_type_bits);
            break;
        }
        case sds_type_8: {
            sds_hdr_var(8,s);
            sh->len = initlen;
            sh->alloc = initlen;
            *fp = type;
            break;
        }
        case sds_type_16: {
            sds_hdr_var(16,s);
            sh->len = initlen;
            sh->alloc = initlen;
            *fp = type;
            break;
        }
        case sds_type_32: {
            sds_hdr_var(32,s);
            sh->len = initlen;
            sh->alloc = initlen;
            *fp = type;
            break;
        }
        case sds_type_64: {
            sds_hdr_var(64,s);
            sh->len = initlen;
            sh->alloc = initlen;
            *fp = type;
            break;
        }
    }
    if (initlen && init)
    //将字符串拷贝给sds变量s
        memcpy(s, init, initlen);
     //字符串变量末尾添加"hisds sdsnewlen(const void *init, size_t initlen) {
//指向sds结构的指针
void *sh;
//sds类型变量,就是char*的别名
sds s;
//根据大小获取sds的类型
char type = hi_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;
int hdrlen = sdshdrsize(type);
unsigned char *fp; /* flags pointer. */
//为新创建的sds结构分配内存
sh = s_malloc(hdrlen+initlen+1);
if (sh == null) return null;
if (!init)
memset(sh, 0, hdrlen+initlen+1);
//指向sds结构体中的buf数组,sh指向sds结构的起始位置，hdrlen表示元数据的长度    
s = (char*)sh+hdrlen;
fp = ((unsigned char*)s)-1;
//根据类型初始化len,alloc
switch(type) {
case sds_type_5: {
*fp = type | (initlen << hi_sds_type_bits);
break;
}
case sds_type_8: {
sds_hdr_var(8,s);
sh->len = initlen;
sh->alloc = initlen;
*fp = type;
break;
}
case sds_type_16: {
sds_hdr_var(16,s);
sh->len = initlen;
sh->alloc = initlen;
*fp = type;
break;
}
case sds_type_32: {
sds_hdr_var(32,s);
sh->len = initlen;
sh->alloc = initlen;
*fp = type;
break;
}
case sds_type_64: {
sds_hdr_var(64,s);
sh->len = initlen;
sh->alloc = initlen;
*fp = type;
break;
}
}
if (initlen && init)
//将字符串拷贝给sds变量s
memcpy(s, init, initlen);
//字符串变量末尾添加"\0"表示字符串结束  
s[initlen] = '\0';
return s;
}"表示字符串结束  
    s[initlen] = 'hisds sdsnewlen(const void *init, size_t initlen) {
//指向sds结构的指针
void *sh;
//sds类型变量,就是char*的别名
sds s;
//根据大小获取sds的类型
char type = hi_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;
int hdrlen = sdshdrsize(type);
unsigned char *fp; /* flags pointer. */
//为新创建的sds结构分配内存
sh = s_malloc(hdrlen+initlen+1);
if (sh == null) return null;
if (!init)
memset(sh, 0, hdrlen+initlen+1);
//指向sds结构体中的buf数组,sh指向sds结构的起始位置，hdrlen表示元数据的长度    
s = (char*)sh+hdrlen;
fp = ((unsigned char*)s)-1;
//根据类型初始化len,alloc
switch(type) {
case sds_type_5: {
*fp = type | (initlen << hi_sds_type_bits);
break;
}
case sds_type_8: {
sds_hdr_var(8,s);
sh->len = initlen;
sh->alloc = initlen;
*fp = type;
break;
}
case sds_type_16: {
sds_hdr_var(16,s);
sh->len = initlen;
sh->alloc = initlen;
*fp = type;
break;
}
case sds_type_32: {
sds_hdr_var(32,s);
sh->len = initlen;
sh->alloc = initlen;
*fp = type;
break;
}
case sds_type_64: {
sds_hdr_var(64,s);
sh->len = initlen;
sh->alloc = initlen;
*fp = type;
break;
}
}
if (initlen && init)
//将字符串拷贝给sds变量s
memcpy(s, init, initlen);
//字符串变量末尾添加"\0"表示字符串结束  
s[initlen] = '\0';
return s;
}';
    return s;
}

该函数主要执行过程如下：
1.根据初始化长度获取sds类型。如果初始化长度initlen为0，一般被认为是要执行append操作，设置sds类型为sds_type_8
2.为新创建的sds结构分配内存，内存空间为元数据长度+buf长度+字符串最后的结束符”\0″。
3.根据sds类型去初始化元数据len和alloc
4.将字符串拷贝给sds

字符数组拼接

由于sds结构中记录了占用的空间和被分配的空间，所以它比传统c语言的字符串效率更高。下面我们通过redis的字符串追加函数sdscatlen来看一看。代码如下：

sds sdscatlen(sds s, const void *t, size_t len) {
//获取目标字符串的长度 
 size_t curlen = sdslen(s);
//根据追加长度和目标字符串长度判断是否需要增加新的空间
  s = sdsmakeroomfor(s,len);
  if (s == null) return null;
  //将源字符串t中len长度的数据拷贝到目标字符串尾部
  memcpy(s+curlen, t, len);
  //设置目标字符串的最新长度
  sdssetlen(s, curlen+len);
  //拷贝完成后，在字符串结尾加上"sds sdscatlen(sds s, const void *t, size_t len) {
//获取目标字符串的长度 
size_t curlen = sdslen(s);
//根据追加长度和目标字符串长度判断是否需要增加新的空间
s = sdsmakeroomfor(s,len);
if (s == null) return null;
//将源字符串t中len长度的数据拷贝到目标字符串尾部
memcpy(s+curlen, t, len);
//设置目标字符串的最新长度
sdssetlen(s, curlen+len);
//拷贝完成后，在字符串结尾加上"\0"
s[curlen+len] = '\0';
return s;
}
"
  s[curlen+len] = 'sds sdscatlen(sds s, const void *t, size_t len) {
//获取目标字符串的长度 
size_t curlen = sdslen(s);
//根据追加长度和目标字符串长度判断是否需要增加新的空间
s = sdsmakeroomfor(s,len);
if (s == null) return null;
//将源字符串t中len长度的数据拷贝到目标字符串尾部
memcpy(s+curlen, t, len);
//设置目标字符串的最新长度
sdssetlen(s, curlen+len);
//拷贝完成后，在字符串结尾加上"\0"
s[curlen+len] = '\0';
return s;
}
';
  return s;
}

这个函数有三个参数分别是目标字符串s,源字符串t和要追加的长度len。这个代码执行过程如下：
1.首先获取目标字符串的长度，然后调用sdsmakeroomfor函数判断是否要给目标字符串添加新的空间，这样就可以保证目标字符串有足够的空间追加字符串
2.在保证了有足够空间可以追加字符串后，将源字符串中指定长度len的数据追加到目标字符串
3.设置目标字符串的最新长度

长度获取

代码中，函数sdslen记录了字符数组的使用长度，不用同c库一样遍历字符串了，这样可以大大降低了操作使用字符串的开销。该函数的代码如下所示：

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;
}

这样时间复杂度直接降到了o(1)。这个函数有一个骚操作，通过s[-1]获取到flags，然后调用sds_hdr宏函数。我们来看下这个宏函数定义

#define sds_hdr(t,s) ((struct sdshdr##t *)((s)-(sizeof(struct sdshdr##t))))

其中##用来将两个token连接为一个token，所以加上参数将在预编译阶段将被替换如下

sds_hdr(8,s);
((struct sdshdr8 *)((s)-(sizeof(struct sdshdr8))))

字符数组地址减去结构体的大小，就能获取到结构体的首地址，然后直接访问len属性。

预分配内存空间

此外，在代码中还使用了sdsmakeroomfor函数，它在拼接字符串之前会检查是否需要扩容，如果需要扩容则会预分配空间。这一设计的好处就是避免了开发中忘记给目标字符串扩容而导致操作失败。比如strcpy(char* dst, const char* dst),如果src长度大于了dst的长度，又没有做检查就会遭成内存溢出。代码如下所示：

sds sdsmakeroomfor(sds s, size_t addlen) {
    void *sh, *newsh;
    //获取sds目前可用的空间
    size_t avail = sdsavail(s);
    size_t len, newlen;
    char type, oldtype = s[-1] & sds_type_mask;
    int hdrlen;
    size_t usable;

    //空余空间足够，无需扩展
    if (avail >= addlen) return s;

    len = sdslen(s);
    sh = (char*)s-sdshdrsize(oldtype);
    newlen = (len+addlen);
    assert(newlen > len);   /* catch size_t overflow */
    //如果新的字符数组长度小于sds_max_prealloc
    //分配2倍所需长度
    if (newlen < sds_max_prealloc)
        newlen *= 2;
    //否则分配新长度加上sds_max_prealloc的长度
    else
        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. */
    if (type == sds_type_5) type = sds_type_8;

    hdrlen = sdshdrsize(type);
    assert(hdrlen + newlen + 1 > len);  /* catch size_t overflow */
    if (oldtype==type) {
        newsh = s_realloc_usable(sh, hdrlen+newlen+1, &usable);
        if (newsh == null) return null;
        s = (char*)newsh+hdrlen;
    } else {
        / /如果头部大小发生变化只需要将字符数组向前移，不使用realloc
        newsh = s_malloc_usable(hdrlen+newlen+1, &usable);
        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);
    }
    usable = usable-hdrlen-1;
    if (usable > sdstypemaxsize(type))
        usable = sdstypemaxsize(type);
     //更新sds容量  
    sdssetalloc(s, usable);
    return s;
}

其中sds_max_prealloc的长度为1024*1024

#define sds_max_prealloc (1024*1024)

节省内存的设计

前面讲sds结构的时候提到过它有一个元数据flag，表示字符串类型。sds一共有5中类型，它们分别是sdshdr5,sdshdr8,sdshdr16,sdshdr32和sdshdr64。这五种的主要区别是它们字符数组的现有长度len和分配空间alloc的不同。
那么我们就以sdshdr16为例，它的定义如下

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[];
};

我们可以看到现有长度len和已分配空间alloc都是uint16_t类型，uint16_t是16位无符号整型，会占用2个字节。当字符串类型是sdshdr16的时候它包含的字符数组长度最大为2^16-1字节。而对于其它三种sdshdr8,sdshdr32和sdshdr64，以此类推它们的类型就分别是uin8_t，uin32_t和uint64_t，len和alloc这两个元数据占用的空间分别是1字节、4字节和8字节。
实际上，设计不同的结构头的目的是为了灵活保存不同大小的字符串，从而有效地节省内存空间。在保存不同大小的字符串时，结构头占用的内存空间也不一样，这样一来保存小字符串时，占用的空间也会比较小。
除了设计不同类型的结构头以外，redis还使用编译优化来节省内存空间。比如上面sdshdr16的代码中就有__attribute__ ((packed))，它的目的是告诉编译器采用紧凑的方式分配内存，默认情况下编译器会按照16字节的对齐方式给变量分配内存。也就是说一个变量没有到16个字节，编译器也会给它分配16个字节。
我们来举个例子

#include <string.h>
#include <iostream>

using namespace std;

typedef struct mystruct
{
 char  a;
 int b;   
} mystruct;


int
main()
{
    cout << sizeof(mystruct) << endl;
    
    return 0;
}

虽然char占用1个字节，int占用4个字节，但是打印出来是8，这样多出来的3个字节白白浪费掉了。现在我们运用__attribute__ ((packed))属性定义结构体，就可以实际占用多少字节，编译器就分配多少空间。我们把刚才代码修改一下加上这个属性。代码如下

#include <string.h>
#include <iostream>

using namespace std;

typedef struct mystruct
{
 char  a;
 int b;   
} __attribute__ ((__packed__))mystruct;


int
main()
{
    cout << sizeof(mystruct) << endl;
    
    return 0;
}

运行这段代码，结果就变为5了，表示编译器用了紧凑型的内存分配。在开发过程中，为了节省内存开销就可以考虑把__attribute__ ((packed))这个属性运用起来。

到此这篇关于redis的字符串是如何实现的的文章就介绍到这了,更多相关redis字符串实现内容请搜索www.887551.com以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.887551.com！