【Redis】基础数据结构-简单动态字符串SDS

C语言字符串

char *str = "redis"; // 可以不显式的添加\0，由编译器添加
char *str = "redis\0"; // 也可以添加\0代表字符串结束

C语言中使用char*字符数组表示字符串，‘\0’来标记一个字符串的结束，不过在使用的过程中我们不需要显式的在字符串中加入’\0’。

存在问题

1.二进制安全

C语言以’\0’标记字符串的结尾，如果一个字符串本身带有’\0’，比如一些二进制数据，那么字符串就会被截断，导致无法存储二进制数据。

2.缓冲区溢出

假设内存有两个相邻的字符串s1和s2，s1保存了字符串“Redis”，s2中保存了字符串“MongoDB”，如果不对大小进行判断，直接调用strcat(s1, “Cluster”)函数在s1字符串后面追加“Cluster“，s1的数据溢出到s2所在空间，导致s2的内容被意外的修改。

3.频繁的内存分配

因为C字符串不记录自身长度，如果对字符串进行修改，需要内存重分配扩展底层数组的空间大小，比如调用strcat函数进行拼接时，需要重新分配内存，保证数组有足够的空间，否则就会发生缓冲区溢出。

由于内存重分配涉及复杂算法，并且可能需要执行系统调用，所以是一个耗时的操作。

4.获取字符串长度复杂度为O（N）

C字符串不记录自身长度，需要遍历每个字符计算字符串长度，在高并发情况下有可能称为性能的瓶颈。

参考：黄健宏《Redis设计与实现》

Redis String

String字符串是Redis中的一种数据结构，它的语法如下：

SET key value

key和value都是字符串，一个key对应一个value，通过key可以获取到对应的value：

GET KEY

简单动态字符串

Redis的字符串没有直接使用C语言的字符数组实现，而是通过SDS（Simple Dynamic String）简单动态字符串实现的。

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

Redis为了灵活的保存不同大小的字符串节省内存空间，设计了不同的结构头sdshdr64、sdshdr32、sdshdr16、sdshdr8和sdshdr5。

虽然结构头不同，但是他们都具有相同的属性（sdshdr5除外）：

len：字符数组buf实际使用的大小，也就是字符串的长度
alloc：字符数组buf分配的空间大小
flags：标记SDS的类型：sdshdr64、sdshdr32、sdshdr16、sdshdr8和sdshdr5
buf[]：字符数组，用来存储实际的字符数据

一些优化

Redis使用了_attribute_ (( __packed__))节省内存空间，它可以告诉编译器使用紧凑的方式分配内存，不使用字节对齐的方式给变量分配内存。

关于字节对齐可参考结构体字节对齐，C语言结构体字节对齐详解。

柔性数组

在结构体定义中，可以看到最后一个buf数组是没有设置大小的，这种放在结构体中最后一个元素位置并且没有设置大小的数组称为柔性数组，它可以在程序运行过程中动态的进行内存分配。

SDS创建

（1）sds在创建的时候，buf数组初始大小为：struct结构体大小 + 字符串的长度+1, +1是为了在字符串末尾添加一个\0。

（2）在完成字符串到字符数组的拷贝之后，会在字符串末尾加一个\0，这样可以复用C语言的一些函数。

sds _sdsnewlen(const void *init, size_t initlen, int trymalloc) {
    void *sh;
    sds s;
    // 根据长度计算sds类型
    char type = sdsReqType(initlen);
    if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8;
    // 获取结构体大小
    int hdrlen = sdsHdrSize(type);
    unsigned char *fp; /* flags pointer. */
    size_t usable;

    assert(initlen + hdrlen + 1 > initlen); /* Catch size_t overflow */
    // 分配内存空间，初始大小为：struct结构体大小+字符串的长度+1,+1是为了在字符串末尾添加一个\0
    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);
    // 指向buf数组的指针
    s = (char*)sh+hdrlen;
    fp = ((unsigned char*)s)-1;
    usable = usable-hdrlen-1;
    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;
        }
        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; // 设置sds类型
            break;
        }
    }
    if (initlen && init)
        memcpy(s, init, initlen); // 将字符串拷贝到buf数组
    // 字符串末尾添加一个\0
    s[initlen] = '\0';
    return s;
}

// 获取结构体大小
static inline int sdsHdrSize(char type) {
    switch(type&SDS_TYPE_MASK) {
        case SDS_TYPE_5:
            return sizeof(struct sdshdr5);
        case SDS_TYPE_8:
            return sizeof(struct sdshdr8);
        case SDS_TYPE_16:
            return sizeof(struct sdshdr16);
        case SDS_TYPE_32:
            return sizeof(struct sdshdr32);
        case SDS_TYPE_64:
            return sizeof(struct sdshdr64);
    }
    return 0;
}

SDS扩容

（1）判断剩余可用空间是否大于需要增加的长度，如果大于说明空间足够，直接返回即可，反之计算新的长度，进行扩容；

（2）空间预分配，扩容新的长度为已经使用的长度+需要增加的长度，然后会判断是否小于SDS_MAX_PREALLOC（1M）：

如果小于，直接扩容为新长度的2倍
如果大于，扩容容量为新长度+SDS_MAX_PREALLOC的值

（3）由于扩容之后大小发生了改变，需要重新计算使用哪种SDS类型：

如果类型不需要改变，直接扩容即可
如果类型发生改变，需要重新进行内存分配，并将旧的内存释放

sds sdsMakeRoomFor(sds s, size_t addlen) {
    void *sh, *newsh;
    // 获取剩余可用空间大小
    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
    if (newlen < SDS_MAX_PREALLOC)
        // 扩容为新长度的2倍
        newlen *= 2;
    else
        // 新长度 = 新长度+SDS_MAX_PREALLOC
        newlen += SDS_MAX_PREALLOC;
    // 根据新的长度计算需要使用sds的类型
    type = sdsReqType(newlen);
    if (type == SDS_TYPE_5) type = SDS_TYPE_8;
    // 获取struct大小
    hdrlen = sdsHdrSize(type);
    assert(hdrlen + newlen + 1 > len);  /* Catch size_t overflow */
    // 如果sds类型不需要改变
    if (oldtype==type) {
        // 扩容
        newsh = s_realloc_usable(sh, hdrlen+newlen+1, &usable);
        if (newsh == NULL) return NULL;
        s = (char*)newsh+hdrlen;
    } else {
        // 如果需要改变sds类型，重新分配空间
        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);
    sdssetalloc(s, usable);
    return s;
}