［Redis源码阅读］sds字符串实现

时间  2019-11-07
标签 redis 源码 阅读 sds 字符串 实现 栏目 Redis 繁體版
原文   原文链接

初衷

从开始工做就开始使用Redis，也有一段时间了，但都只是停留在使用阶段，没有往更深的角度探索，每次想读源码都止步在阅读书籍上，由于看完书很快又忘了，此次逼本身先读代码。由于我的以为写做须要阅读文字来加强灵感，那么写代码的，就阅读更多代码来加强灵感吧。git

redis的实现原理，在《Redis设计与实现》一书中讲得很详细了，可是想经过结合代码的形式再深刻探索，加深本身的理解，如今将本身探索的心得写在这儿。github

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

// sds结构体，使用不一样的结构体来保存不一样长度大小的字符串
typedef char *sds;

struct __attribute__ ((__packed__)) sdshdr5 {
    unsigned char flags; /* flags共8位，低三位保存类型标志，高5位保存字符串长度，小于32(2^5-1) */
    char buf[]; // 保存具体的字符串
};
struct __attribute__ ((__packed__)) sdshdr8 {
    uint8_t len; /* 字符串长度，buf已用的长度 */
    uint8_t alloc; /* 为buf分配的总长度，alloc-len就是sds结构体剩余的空间 */
    unsigned char flags; /* 低三位保存类型标志 */
    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[];
};

sds结构体从4.0开始就使用了5种header定义，节省内存的使用，可是不会用到sdshdr5，我认为是由于sdshdr5能保存的大小较少，2^5=32，所以就不使用它。redis

其余的结构体保存了len、alloc、flags以及buf四个属性。各自的含义见代码的注释。算法

sds结构体的获取

上面能够看到有5种结构体的定义，在使用的时候是经过一个宏来获取的：安全

#define SDS_HDR(T,s) ((struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T))))

"##"被称为链接符，它是一种预处理运算符， 用来把两个语言符号(Token)组合成单个语言符号。好比SDS_HDR(8, s)，根据宏定义展开是：数据结构

((struct sdshdr8 *)((s)-(sizeof(struct sdshdr8))))

而具体使用哪个结构体，sds底层是经过flags属性与SDS_TYPE_MASK作与运算得出具体的类型（具体的实现可见下面的sdslen函数），而后再根据类型去获取具体的结构体。curl

sds特性的实现

在Redis设计与实现一书中讲到，相比C字符串而言，sds的特性以下：函数

  • 常数复杂度获取字符串长度性能

  • 杜绝缓冲区溢出学习

  • 减小内存从新分配次数

  • 二进制安全

那么，它是怎么作到的呢？看代码。

常数复杂度获取字符串长度

由于sds将长度属性保存在结构体中，因此只须要读取这个属性就能获取到sds的长度，具体调用的函数时sdslen，实现以下：

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

能够看到，函数是根据类型调用SDS_HDR宏来获取具体的sds结构，而后直接返回结构体的len属性。

杜绝缓冲区溢出

对于C字符串的操做函数来讲，若是在修改字符串的时候忘了为字符串分配足够的空间，就有可能出现缓冲区溢出的状况。而sds中的API就不会出现这种状况，由于它在修改sds以前，都会判断它是否有足够的空间完成接下来的操做。

拿书中举例的sdscat函数来看，若是strcat想在原来的"Redis"字符串的基础上进行字符串拼接的操做，可是没有检查空间是否知足，就有可能会修改了"Redis"字符串以后使用到的内存，多是其余结构使用了，也有多是一段没有被使用的空间，所以有可能会出现缓冲区溢出。可是sdscat就不会，以下面代码所示：

sds sdscatlen(sds s, const void *t, size_t len) {
    size_t curlen = sdslen(s);

    s = sdsMakeRoomFor(s,len);
    if (s == NULL) return NULL;
    memcpy(s+curlen, t, len);
    sdssetlen(s, curlen+len);
    s[curlen+len] = '\0';
    return s;
}

sds sdscat(sds s, const char *t) {
    return sdscatlen(s, t, strlen(t));
}

从代码中能够看到，在执行memcpy将字符串写入sds以前会调用sdsMakeRoomFor函数去检查sds字符串s是否有足够的空间，若是没有足够空间，就为其分配足够的空间，从而杜绝了缓冲区溢出。sdsMakeRoomFor函数的实现以下：

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;

    /* 只有有足够空间就立刻返回，不然就继续执行分配空间的操做 */
    if (avail >= addlen) return s;

    len = sdslen(s);
    sh = (char*)s-sdsHdrSize(oldtype);
    newlen = (len+addlen);
    // SDS_MAX_PREALLOC == 1MB，若是修改后的长度小于1M，则分配的空间是原来的2倍，不然增长1MB的空间
    if (newlen < SDS_MAX_PREALLOC)
        newlen *= 2;
    else
        newlen += SDS_MAX_PREALLOC;

    type = sdsReqType(newlen);

    if (type == SDS_TYPE_5) type = SDS_TYPE_8;

    hdrlen = sdsHdrSize(type);
    if (oldtype==type) {
        newsh = s_realloc(sh, hdrlen+newlen+1);
        if (newsh == NULL) return NULL;
        s = (char*)newsh+hdrlen;
    } else {
        /* 新增空间后超过当前类型的长度，使用malloc，并把原字符串拷贝过去 */
        newsh = s_malloc(hdrlen+newlen+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);
    }
    sdssetalloc(s, newlen);
    return s;
}

减小内存分配操做

sds字符串的不少操做都涉及到修改字符串内容，好比sdscat拼接字符串、sdscpy拷贝字符串等等。这时候就须要内存的分配与释放，若是每次操做都分配刚恰好的大小，那么对程序的性能一定有影响，由于内存分配涉及到系统调用以及一些复杂的算法。

sds使用了空间预分配以及惰性空间释放的策略来减小内存分配操做。

空间预分配

前面提到，每次涉及到字符串的修改时，都会调用sdsMakeRoomFor检查sds字符串，若是大小不够再进行大小的从新分配。sdsMakeRoomFor函数有下面这几行判断：

// SDS_MAX_PREALLOC == 1MB，若是修改后的长度小于1M，则分配的空间是原来的2倍，不然增长1MB的空间
if (newlen < SDS_MAX_PREALLOC)
    newlen *= 2;
else
    newlen += SDS_MAX_PREALLOC;

函数判断字符串修改后的大小，若是修改后的长度小于1M，则分配给sds的空间是原来的2倍，不然增长1MB的空间。

惰性空间释放

若是操做后减小了字符串的大小，好比下面的sdstrim函数，只是在最后修改len属性，不会立刻释放多余的空间，而是继续保留多余的空间，这样在下次须要增长sds字符串的大小时，就不须要再为其分配空间了。固然，若是以后检查到sds的大小实在太大，也会调用sdsRemoveFreeSpace函数释放多余的空间。

sds sdstrim(sds s, const char *cset) {
    char *start, *end, *sp, *ep;
    size_t len;

    sp = start = s;
    ep = end = s+sdslen(s)-1;
    /* 从头部和尾部逐个字符遍历往中间靠拢，若是字符在cest中，则继续前进 */
    while(sp <= end && strchr(cset, *sp)) sp++;
    while(ep > sp && strchr(cset, *ep)) ep--;
    len = (sp > ep) ? 0 : ((ep-sp)+1); // 所有被去除了，长度就是0
    if (s != sp) memmove(s, sp, len); // 拷贝内容
    s[len] = '\0';
    sdssetlen(s,len);
    return s;
}

二进制安全

二进制安全指的是只关心二进制化的字符串，不关心具体格式。只会严格的按照二进制的数据存取，不会妄图以某种特殊格式解析数据。好比遇到'0'字符不会中止解析。

对于C字符串来讲，strlen是判断遇到'0'以前的字符数量。若是须要保存二进制的数据，就不能经过传统的C字符串来保存，由于获取不到它真实的长度。而sds字符串是经过len属性保存字符串的大小，因此它是二进制安全的。

其余小函数实现

在阅读源码的过程当中，也发现了两个我的比较感兴趣趣的函数：

  • sdsll2str（将long long类型的整型数字转成字符串）

  • sdstrim （去除头部和尾部的指定字符）

我这两个函数拉出来作了测试，在项目的redis-4.0/tests目录下。sdstrim函数的实现源码上面有列出，看看sdsll2str的实现：

int sdsll2str(char *s, long long value) {
    char *p, aux;
    unsigned long long v;
    size_t l;

    /* 经过取余数获得原字符串的逆转形式 */
    v = (value < 0) ? -value : value;
    p = s;
    do {
        *p++ = '0'+(v%10);
        v /= 10;
    } while(v);
    if (value < 0) *p++ = '-';

    /* Compute length and add null term. */
    l = p-s;
    *p = '\0';

    /* 反转字符串 */
    p--;
    while(s < p) {
        aux = *s;
        *s = *p;
        *p = aux;
        s++;
        p--;
    }
    return l;
}

函数是经过不断取余数，获得原字符串的逆转形式，接着，经过从尾部开始将字符逐个放到字符串s中，看起来像是一个反转操做，从而实现了将整型转为字符串的操做。

以为感兴趣是由于sdsll2str这个函数在以前学习C语言的时候常常能看到做为问题出现，能看到如此简洁的实现，表示眼前一亮。而在PHP开发时常用trim函数，因此想看看它们的区别。

总结

经过详细地阅读sds的源码，不只学习到sds的实现细节，还学习到了一些经常使用字符串操做函数的实现。若是只是仅仅看看数据结构的定义也能够初步了解，可是要深刻了解的话仍是须要详细的阅读具体函数的实现代码。仍是那句，写代码的，须要阅读更多代码来加强灵感。

我在github有对Redis源码更详细的注解。感兴趣的能够围观一下，给个star。Redis4.0源码注解。能够经过commit记录查看已添加的注解。

原创文章，文笔有限，才疏学浅，文中如有不正之处，万望告知。

更多精彩内容，请关注我的公众号。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程