《redis设计与实现》读书笔记

最新推荐文章于 2022-11-23 18:49:06 发布

bohu83

最新推荐文章于 2022-11-23 18:49:06 发布

阅读量363

点赞数

分类专栏：分布式 redis从入门到放弃文章标签： sds redis string 源码 emptr

本文链接：https://blog.csdn.net/bohu83/article/details/83862843

版权

redis从入门到放弃同时被 2 个专栏收录

44 篇文章 12 订阅

订阅专栏

分布式

38 篇文章 1 订阅

订阅专栏

一序

在看《redis设计与实现》，书中的版本毕竟是3.0的老一些了，荣有参考意义，代码以3.2版本为准。

字符串是Redis中最为常见的数据存储类型，其底层实现是简单动态字符串sds(simple dynamic string)，是可以修改的字符串。Redis 所有的数据结构都是以唯一的 key 字符串作为名称，然后通过这个唯一 key 值来获取相应的 value 数据。不同类型的数据结构的差异就在于 value 的结构不一样。但是这个key使用的结构，都是字符串类型。

书上重点介绍了sds与C语言的字符串的差别。这里只罗列下sds优点：

常数复杂度获取字符串长度。
杜绝缓冲区溢出。
减少修改字符串长度时所需分配内存重分配次数。
二进制安全。
够兼容传统C字符串。

二基础知识

2.1 字符串操作命令

set(key, value)：给数据库中名称为key的string赋予值value
get(key)：返回数据库中名称为key的string的value
getset(key, value)：给名称为key的string赋值value，并返回上一次的值，如果key不存在，则会创建一个新的key，返回nil。
mget(key1, key2,…, keyN)：返回库中多个string（它们的名称为key1，key2…）的value
setnx(key,value)：如果不存在名称为key的string，则向库中添加string，名称为key，值为value
setex(key, time, value)：向库中添加string（名称为key，值为value）同时，设定过期时间time
mset(key1, value1, key2, value2,…key N, value N)给多个string赋值，名称为key i的string赋值value i
msetnx(key1, value1, key2, value2,…key N, value N)：如果所有名称为key i的string都不存在，则向库中添加string，名称key i赋值为value i
incr(key)：名称为key的string增1操作
incrby(key, integer)：名称为key的string增加integer
decr(key)：名称为key的string减1操作
decrby(key, integer)：名称为key的string减少integer
append(key, value)：名称为key的string的值附加value
substr(key, start, end)：返回名称为key的string的value的子串

除了对字符串的基本操作之外，还有将字符串作为位图bitmap，下面是具体的操作命令。

getbit(key, offset) ：获取key中的第offset + 1位的值
setbit (key, offset, value) ：将ket的第offset+1位位设置为value
bitcount (key [, start, end])：统计key中从start到end内1的个数。
bitpos (key, bit, [start], [end)：查找到指定范围内出现的第一个bit的位置

拓展

Redis 3.2之后，为了支持bitmap(位图)，提供了bitfield指令集，它提供了三个指令，get/set/incryby，使用方法如下：

bitfield w get u4 2：表示从第3个位开始取4位，重新组成一个无符号位的数据。
bitfield w get i3 2：表示从第3个位开始取3位，重新组成一个有符号位的数据
bitfield w set u8 8 97：设置从第9位开始的8位，设置为97
bitfield w incrby u4 2 1： # 从第三个位开始，对接下来的 4 位无符号数 +1

2.2 C语言有关数据类型参考

假设你跟我一样不熟悉C语言，不然后面的计算部分可以略过。

三源码分析

字符串的实现代码在sds.c和sds.h文件中。第一眼看上去，总体来说比mysql那种少多了，都没啥打包区分下。

在介绍结果之前，先说下一开始的特点：

为啥sds是二进制安全的，它可以存储任意二进制数据，不像C语言字符串那样以‘\0’来标识字符串结束，因为传统C字符串符合ASCII编码，这种编码的操作的特点就是：遇零则止。即，当读一个字符串时，只要遇到’\0’结尾，就认为到达末尾，就忽略’\0’结尾以后的所有字符。因此，如果传统字符串保存图片，视频等二进制文件，操作文件时就被截断了。而SDS表头的buf被定义为字节数组，因为判断是否到达字符串结尾的依据则是表头的len成员，这意味着它可以存放任何二进制的数据和文本数据，包括’\0’。

为啥获取字符串长度是常数？SDS 和传统的 C 字符串获得的做法不同，传统的C字符串遍历字符串的长度，遇零则止，复杂度为O(n)。而SDS表头的len成员就保存着字符串长度，所以获得字符串长度的操作复杂度为O(1)。

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

跟书上的3.0的不太一样，看起来类型多了好多，先大概说一下含义：

len 使用的长度，不包含空终止字符

alloc：表示字符串的最大容量，不包含Header和最后的空终止字符

flags：表示header的类型。

buf[] :存放真正的数据。

#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    
#define SDS_HDR_VAR(T,s) struct sdshdr##T *sh = (void*)((s)-(sizeof(struct sdshdr##T))); // 获取header头指针
#define SDS_HDR(T,s) ((struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T))))   // 获取header头指针
#define SDS_TYPE_5_LEN(f) ((f)>>SDS_TYPE_BITS) // 获取sdshdr5的长度

上面是定义了header的操作。没太看懂怎么算的。

3.2 empstr与 raw

debug object codehole
Value at:0x7f9abb7bc100 refcount:1 encoding:embstr serializedlength:40 lru:14932997 lru_seconds_idle:2
>  set codehole abcdefghijklmnopqrstuvwxy123456789123456
OK
> debug object codehole
Value at:0x7f9abd7898b0 refcount:1 encoding:raw serializedlength:41 lru:14933009 lru_seconds_idle:4
10

一个字符的差别，存储形式 encoding 就发生了变化。一个是 embstr，一个是 row。测试数据长度提示是40，是包含结尾的空元素的，实际长度是39.注意这是在3.0版本测试的，如果是3.2版本，应该就是44了，后面会解释区别。

在了解存储格式的区别之前，首先了解下RedisObject结构体。因为：robj + SDS header + string +null-term是个整个存储结构。代码在server.h

typedef struct redisObject {
    unsigned type:4;
    unsigned encoding:4;
    unsigned lru:LRU_BITS; /* lru time (relative to server.lruclock) */
    int refcount;
    void *ptr;
} robj;

不同的对象具有不同的类型 type(4bit)，同一个类型的 type 会有不同的存储形式 encoding(4bit)。
为了记录对象的 LRU 信息，使用了 24 个 bit 的 lru 来记录 LRU 信息。
每个对象都有个引用计数 refcount，当引用计数为零时，对象就会被销毁，内存被回收。
ptr 指针将指向对象内容 (body) 的具体存储位置。
一个 RedisObject 对象头共需要占据 16 字节的存储空间。

再看一下RedisObject的10种存储格式——encoding


/* Objects encoding. Some kind of objects like Strings and Hashes can be
 * internally represented in multiple ways. The 'encoding' field of the object
 * is set to one of this fields for this object. */
#define OBJ_ENCODING_RAW 0     /* Raw representation */
#define OBJ_ENCODING_INT 1     /* Encoded as integer */
#define OBJ_ENCODING_HT 2      /* Encoded as hash table */
#define OBJ_ENCODING_ZIPMAP 3  /* Encoded as zipmap */
#define OBJ_ENCODING_LINKEDLIST 4 /* Encoded as regular linked list */
#define OBJ_ENCODING_ZIPLIST 5 /* Encoded as ziplist */
#define OBJ_ENCODING_INTSET 6  /* Encoded as intset */
#define OBJ_ENCODING_SKIPLIST 7  /* Encoded as skiplist */
#define OBJ_ENCODING_EMBSTR 8  /* Embedded sds string encoding */
#define OBJ_ENCODING_QUICKLIST 9 /* Encoded as linked list of ziplists */

而Redis 的字符串共有两种存储方式，在长度特别短时，使用 emb 形式存储 (embedded)，当长度超过 44 时，使用 raw形式存储。 (3.2之前的版本是39)

tips: robj + SDS header + string +null-term,所以版本差异就是sdshdr的不同。

3.0版本是：

struct sdshdr {
    
    // buf 中已占用空间的长度
    int len;

    // buf 中剩余可用空间的长度
    int free;

    // 数据空间
    char buf[];
};

所以string长度：64-header-null-term -sdshdr（int+int）=64-16-1-(4+4)=39 因为len,free都是int,占4个字节。也是我们上面例子验证过的。

对于3.2版本代码：sdshdr改成了sdshdr8,sdshdr16，sdshdr32，sdshdr64，里面属性也从int 变成uint8_t,uint16_t.。。。本身就是针对短字符串的embstr自然会使用最小的sdshdr8。对应就是：64-header-null-term -sdshdr（uint8_t * 2 + char）=64-16-1-（1+1+1）=44. 看看上面的类型占得长度图就理解了。

embstr 存储形式是这样一种存储形式，它将 RedisObject 对象头和 SDS 对象连续存在一起，使用 malloc 方法一次分配。而 raw 存储形式不一样，它需要两次 malloc，两个对象头在内存地址上一般是不连续的。

3.3 长度与扩容

sds.h有基础的操作：

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

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

分别是看已用长度跟可用长度。试着去理解下代码：

unsigned char flags = s[-1]。根据之前的sds结构，对于定义的sds s，把s向前移动一个字节就能获取到flag。(个人理解：声明结构体时已经取消了优化字节对齐，所以这些结构体都是程序都是连续存储的，有点类似offset 的感觉 )

那么：flags&SDS_TYPE_MASK怎么理解？

flag前面提过了就是0-4的取值。最大是4，二进制是100，也就是3位。

#define SDS_TYPE_MASK 7 //掩码3位最大：111就是7了
#define SDS_TYPE_BITS 3 //位数

&SDS_TYPE_MASK这样就能保证截取的值在7以内，再去进行switch判断。

后面就是做减法了，可用= 容量-已用

sdssetlen，sdsinclen，sdsalloc，都是类似的。再看看sds.c的代码：

创建字符串：

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 (string_size < 1ll<<32)
        return SDS_TYPE_32;
    return SDS_TYPE_64;
}

/* Create a new sds string with the content specified by the 'init' pointer
 * and 'initlen'.
 * If NULL is used for 'init' the string is initialized with zero bytes.
 *
 * The string is always null-termined (all the sds strings are, always) so
 * even if you create an sds string with:
 *
 * mystring = sdsnewlen("abc",3);
 *
 * You can print the string with printf() as there is an implicit \0 at the
 * end of the string. However the string is binary safe and can contain
 * \0 characters in the middle, as the length is stored in the sds header. */
sds sdsnewlen(const void *init, size_t initlen) {
    void *sh;
    sds s;
    char type = sdsReqType(initlen);//根据长度觉得使用哪种sdshdr
    /* Empty strings are usually created in order to append. Use type 8
     * since type 5 is not good at this.  type5在sds.h注释说不用，用8替代*/
    if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8;
    int hdrlen = sdsHdrSize(type); //获取当前sdshdr类型的大小，代码在上面，没贴
    unsigned char *fp; /* flags pointer. flag指针*/ 

    sh = s_malloc(hdrlen+initlen+1); //申请需要的内存，多的1个字节用于存放'\0'
    if (!init)
        memset(sh, 0, hdrlen+initlen+1); //初始化：第一个参数是位置，第三个参数是长度
    if (sh == NULL) return NULL;  //没有申请到足够内存则退出
    s = (char*)sh+hdrlen;     //得到柔性数组的地址
    fp = ((unsigned char*)s)-1;  //拿到flags的地址
    switch(type) {
        case SDS_TYPE_5: {
            *fp = type | (initlen << SDS_TYPE_BITS);
            break;
        }
        case SDS_TYPE_8: {
            SDS_HDR_VAR(8,s);  //根据现在的类型，去初始化sdshdr的成员信息，不包含柔性数组
            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)
        memcpy(s, init, initlen); //将数组拷贝到柔性数组当中
    s[initlen] = '\0';  //追加\0结尾
    return s;
}

追加：

/* Append the specified binary-safe string pointed by 't' of 'len' bytes to the
 * end of the specified sds string 's'.
 *
 * After the call, the passed sds string is no longer valid and all the
 * references must be substituted with the new pointer returned by the call. */
sds sdscatlen(sds s, const void *t, size_t len) {
    size_t curlen = sdslen(s); //就是获取sdshdr中的len属性
  //   按需调整空间，如果 capacity 不够容纳追加的内容，就会重新分配字节数组并复制原字符串的内容到新数组中
    s = sdsMakeRoomFor(s,len); 
    if (s == NULL) return NULL; //内存不足，扩容出错返回
    memcpy(s+curlen, t, len);  // 将需要添加的字符串拷贝到目的字符串尾部
    sdssetlen(s, curlen+len);  //设置追加后的sdshdr长度值
    s[curlen+len] = '\0';//追加以\0 结尾
    return s;
}

/* Enlarge the free space at the end of the sds string so that the caller
 * is sure that after calling this function can overwrite up to addlen
 * bytes after the end of the string, plus one more byte for nul term.
 *
 * Note: this does not change the *length* of the sds string as returned
 * by sdslen(), but only the free buffer space we have. */
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); //用sds（指向结构体尾部，字符串首部）减去结构体长度得到结构体首部指针
    newlen = (len+addlen);                  //获取追加后的长度
    if (newlen < SDS_MAX_PREALLOC)          //SDS_MAX_PREALLOC宏是1M内存的大小，如果小于1M，则在当前长度的基础上翻倍
        newlen *= 2;
    else
        newlen += SDS_MAX_PREALLOC;         //如果追加后的长度超过1M，则长度追加1M个字节

    type = sdsReqType(newlen);              //根据新的长度判断对应的sdshdr类型

    /* 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);              //获取新类型的sdshdr大小
    if (oldtype==type) {
        newsh = s_realloc(sh, hdrlen+newlen+1);     //如果新旧类型一直，则在原来的地址上重新安装长度分配空间
        if (newsh == NULL) return NULL;             //分配失败则返回
        s = (char*)newsh+hdrlen;                    //获得柔性数组的地址
    } else {
        newsh = s_malloc(hdrlen+newlen+1);          //新的类型发送变化，sdshdr不一致，所以重新分配新的内存
        if (newsh == NULL) return NULL;             //分配失败则返回
        memcpy((char*)newsh+hdrlen, s, len+1);      
        s_free(sh);                                 //释放原来的sdshdr空间
        s = (char*)newsh+hdrlen;                    //获得柔性数组的地址
        s[-1] = type;
        sdssetlen(s, len);                          //设置新sdshdr的len属性
    }
    sdssetalloc(s, newlen);                         //设置新sdshdr的alloc属性
    return s;
}

看起来真刺激，离不开找位置，计算长度之类。C语言真牛逼。通过上面的源代码可以看出，扩容策略是字符串在长度小于 SDS_MAX_PREALLOC 之前，扩容空间采用加倍策略，也就是保留 100% 的冗余空间。当长度超过 SDS_MAX_PREALLOC 之后，为了避免加倍后的冗余空间过大而导致浪费，每次扩容只会多分配 SDS_MAX_PREALLOC大小的冗余空间。
还有就是惰性空间释放用于优化SDS的字符串缩短操作。就是

/* Modify an sds string in-place to make it empty (zero length).
 * However all the existing buffer is not discarded but set as free space
 * so that next append operations will not require allocations up to the
 * number of bytes previously available. */
void sdsclear(sds s) {
    sdssetlen(s, 0);
    s[0] = '\0';
}

实现在sds.h


static inline void sdssetlen(sds s, size_t newlen) {
    unsigned char flags = s[-1];
    switch(flags&SDS_TYPE_MASK) {
        case SDS_TYPE_5:
            {
                unsigned char *fp = ((unsigned char*)s)-1;
                *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS);
            }
            break;
        case SDS_TYPE_8:
            SDS_HDR(8,s)->len = newlen;
            break;
        case SDS_TYPE_16:
            SDS_HDR(16,s)->len = newlen;
            break;
        case SDS_TYPE_32:
            SDS_HDR(32,s)->len = newlen;
            break;
        case SDS_TYPE_64:
            SDS_HDR(64,s)->len = newlen;
            break;
    }
}

当要清空一个SDS时，并不真正释放其内存，而是设置len字段为0即可，这样当之后再次使用到该SDS时，可避免重新分配内存，从而提高效率。

先看到这里，sds.c还有大半代码没看完。

参考：

https://blog.csdn.net/langzi7758521/article/details/51512215

https://blog.csdn.net/qq193423571/article/details/81637075

https://blog.csdn.net/king_qg/article/details/83116760

bohu83

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
《redis设计与实现》读书笔记

一序在看《redis设计与实现》，书中的版本毕竟是3.0的老一些了，荣有参考意义，代码以3.2版本为准。字符串是Redis中最为常见的数据存储类型，其底层实现是简单动态字符串sds(simple dynamic string)，是可以修改的字符串。Redis 所有的数据结构都是以唯一的 key 字符串作为名称，然后通过这个唯一 key 值来获取相应的 value 数据。不同类...
复制链接

扫一扫