redis源码阅读—sds_redis sdshdr5,sdshdr8

于 2024-09-07 20:17:25 发布
阅读量400 收藏 6
点赞数 4
文章标签： redis 前端 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_87020857/article/details/142001833
版权
获取常见值

在sds.h中写了一些常见方法，比如计算sds的长度（即sdshdr的len），计算sds的空闲长度（即sdshdr的可用长度alloc-已用长度len），计算sds的可用长度(即sdshdr的alloc)等等。但是大家有没有疑问，这不是一行代码搞定的事吗，为啥要抽象出方法呢？那么问题在于在上面，我们有将sdshdr分为五种类型，分别是sdshdr5，sdshdr8，sdshdr16，sdshdr32，sdshdr64。那么我们在实际使用的时候，想要区分当前是哪个类型，并取其相应字段或设置相应字段。

//计算sds对应的字符串长度，其实上取得是字符串所对应的哪种sdshdr的len值 
static inline size_t sdslen(const sds s) {
	// 柔性数组不占空间，所以倒数第二位的是flags 
    unsigned char flags = s[-1];
    //flags与上面定义的宏变量7做位运算 
    switch(flags&SDS_TYPE_MASK) {
        case SDS_TYPE_5://0 
            return SDS_TYPE_5_LEN(flags);
        case SDS_TYPE_8://1
            return SDS_HDR(8,s)->len;//取上面结构体sdshdr8的len  
        case SDS_TYPE_16://2
            return SDS_HDR(16,s)->len;
        case SDS_TYPE_32://3
            return SDS_HDR(32,s)->len;
        case SDS_TYPE_64://5
            return SDS_HDR(64,s)->len;
    }
    return 0;
}
 
//计算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;
}
 
//设置sdshdr的len 
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;
    }
}
 
//给sdshdr的len添加多少大小 
static inline void sdsinclen(sds s, size_t inc) {
    unsigned char flags = s[-1];
    switch(flags&SDS_TYPE_MASK) {
        case SDS_TYPE_5:
            {
                unsigned char *fp = ((unsigned char*)s)-1;
                unsigned char newlen = SDS_TYPE_5_LEN(flags)+inc;
                *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS);
            }
            break;
        case SDS_TYPE_8:
            SDS_HDR(8,s)->len += inc;
            break;
        case SDS_TYPE_16:
            SDS_HDR(16,s)->len += inc;
            break;
        case SDS_TYPE_32:
            SDS_HDR(32,s)->len += inc;
            break;
        case SDS_TYPE_64:
            SDS_HDR(64,s)->len += inc;
            break;
    }
}
 
//获取sdshdr的总长度 
static inline size_t sdsalloc(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)->alloc;
        case SDS_TYPE_16:
            return SDS_HDR(16,s)->alloc;
        case SDS_TYPE_32:
            return SDS_HDR(32,s)->alloc;
        case SDS_TYPE_64:
            return SDS_HDR(64,s)->alloc;
    }
    return 0;
}
 
//设置sdshdr的总长度 
static inline void sdssetalloc(sds s, size_t newlen) {
    unsigned char flags = s[-1];
    switch(flags&SDS_TYPE_MASK) {
        case SDS_TYPE_5:
            /* Nothing to do, this type has no total allocation info. */
            break;
        case SDS_TYPE_8:
            SDS_HDR(8,s)->alloc = newlen;
            break;
        case SDS_TYPE_16:
            SDS_HDR(16,s)->alloc = newlen;
            break;
        case SDS_TYPE_32:
            SDS_HDR(32,s)->alloc = newlen;
            break;
        case SDS_TYPE_64:
            SDS_HDR(64,s)->alloc = newlen;
            break;
    }
}
创建对象

我们通过sdsnew方法来创建对象，显示通过判断init是否为空来确定初始大小，接着调用方法sdsnew（这边方法名一样，但是参数不一样，其为方法的重载），先根据长度确定类型（上面有提过五种类型，不记得的可以往上翻），然后根据类型分配相应的内存资源，最后追加C语言的结尾符’\0’。

sds sdsnew(const char *init) {
    size_t initlen = (init == NULL) ? 0 : strlen(init);
    return sdsnewlen(init, initlen);
}
 
 
sds sdsnewlen(const void *init, size_t initlen) {
    void *sh;
    sds s;
    char type = sdsReqType(initlen);//根据长度确定类型 
    /*空字符串，用sdshdr8，这边是经验写法，当想构造空串是为了放入超过32长度的字符串 */
    if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8;
    int hdrlen = sdsHdrSize(type);//到下一个方法，已经把他们放在一起了
    unsigned char *fp; /* flags pointer. */
 
	//分配内存 
    sh = s_malloc(hdrlen+initlen+1);
    if (!init)
        memset(sh, 0, hdrlen+initlen+1);
    if (sh == NULL) return NULL;
    s = (char*)sh+hdrlen;
    fp = ((unsigned char*)s)-1;
    //根据不同的类型，创建不同结构体，调用SDS_HDR_VAR函数
	//为不同的结构体赋值,如已用长度len,总长度alloc 
    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 = 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);
    //最后追加'\0' 
    s[initlen] = '\0';
    return s;
}
 
 
//根据实际字符长度确定类型 
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;
#endif
    return SDS_TYPE_64;
}
删除
String类型的删除并不是直接回收内存，而是修改字符，让其为空字符，这其实是惰性释放，等待将来使用。在调用sdsempty方法时，再次调用上面的sdsnewlen方法。
 
/*修改sds字符串使其为空（零长度）。
*但是，所有现有缓冲区不会被丢弃，而是设置为可用空间
*这样，下一个append操作将不需要分配到
*当要缩短SDS保存的字符串时，程序并不立即使用内存充分配来回收缩短后多出来的字节，并等待将来使用。
void sdsclear(sds s) {
    sdssetlen(s, 0);
    s[0] = '\0';
}
sds sdsempty(void) {
    return sdsnewlen("",0);
}
添加字符（扩容）重点！！！

添加字符串，sdscat输入参数为sds和字符串t，首先调用sdsMakeRoomFor扩容方法，再追加新的字符串，最后添加上结尾符’\0’。我们来看下扩容方法里面是如何实现的？第一步先调用常见方法中的sdsavail方法，获取还剩多少空闲空间。如果空闲空间大于要添加的字符串t的长度，则直接返回，不想要扩容。如果空闲空间不够，则想要扩容。第二步判断想要扩容多大，这边有分情况，如果目前的字符串小于1M，则直接扩容双倍，如果目前的字符串大于1M，则直接添加1M。第三个判断添加字符串之后的数据类型还是否和原来的一致，如果一致，则没啥事。如果不一致，则想要新建一个sdshdr，把现有的数据都挪过去。

这样是不是有点抽象，举个例子，现在str的字符串为hello，目前是sdshdr8，总长度50，已用6，空闲44。现在想要添加长度为50的字符t，第一步想要看下是否要扩容，50明显大于44，需要扩容。第二步扩容多少，str的长度小于1M，所以扩容双倍，新的长度为50*2=100。第三步50+50所对应sdshdr类型还是sdshdr8吗？明显还是sdshdr8，所以不要数据迁移，还在原来的基础上添加t即可。

sds sdscat(sds s, const char *t) {
    return sdscatlen(s, t, strlen(t));
}
 
sds sdscatlen(sds s, const void *t, size_t len) {
	//调用sds.h里面的sdslen，即取已用长度 
    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 sdsMakeRoomFor(sds s, size_t addlen) {
    void *sh, *newsh;
    //调用sds.h，获取空闲长度alloc 
    size_t avail = sdsavail(s);
    size_t len, newlen;
    char type, oldtype = s[-1] & SDS_TYPE_MASK;
    int hdrlen;
 
   //空闲长度大于需要增加的，不需要扩容，直接返回 
    if (avail >= addlen) return s;
 
//调用sds.h里面的sdslen，即取可用长度 
    len = sdslen(s);
    
    sh = (char*)s-sdsHdrSize(oldtype);
    //len加上要添加的大小 
    newlen = (len+addlen);
    
    //#define SDS_MAX_PREALLOC (1024*1024) 
    //当新长度小于 1024*1024，直接扩容两倍 
    if (newlen < SDS_MAX_PREALLOC)
        newlen *= 2;
    else //当新长度大于 1024*1024，加2014*1024 
        newlen += SDS_MAX_PREALLOC;
 
//根据长度计算新的类型 
    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);
    //如果类型一样，直接使用原地址，长度加上就行 
    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);
        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;
}
 
//计算不同类型的结构体的大小 
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

2401_87020857
关注
Redis源码阅读——SDS
qq_33620071的博客
10-29 718
Redis源码阅读——SDS 参考Redis设计与实现 以及网上博客阅读Redis源码。 SDS相关知识点见读书笔记。 创建和销毁 为了能够对sds进行相关API的测试，因此把sds模块单独提出来。阅读Redis的Makefile发现，编译sds模块需要的源文件包括sds.c, sds.h zmalloc.c test-sds: sds.c sds.h $(REDIS_CC) s...
redis中的sds结构解析,字符串为何不用C原生?
你还有好多未完成的梦，你有什么理由停下？
06-01 497
1丶redis为什么使用sds,不适用c语言的字符串呢?
一文带你快速搞懂动态字符串SDS，面试不再懵逼(2)
最新发布
2401_85112749的博客
07-01 971
/设置sdshdr的len)s)-1;break;break;break;break;break;//给sdshdr的len添加多少大小)s)-1;break;break;break;break;break;//获取sdshdr的总长度return 0;//设置sdshdr的总长度break;break;break;break;break;
redis源码阅读—sds
qq_36581961的博客
12-26 528
文章目录sdshdr定义sds逻辑图sds优势更快的获取字符串长度杜绝缓冲区溢出减少修改字符串时带来的内存重分配次数二进制安全关键代码获取常见值创建对象添加字符（扩容）重点！！！ sdshdr定义 真实的数据并不是直接存储，也有封装，看下面的代码就知道分为五种，分别是sdshdr5，sdshdr8，sdshdr16，sdshdr32，sdshdr64。sdshdr5和另外四种的区别比较明显，sdshrd5其实对内存空间的更加节约。包括已用长度len，总长度alloc（分配的长度），标记flags，实际数据b
Redis中关于sdshdr8 结构体的理解和使用
qq_34462436的博客
01-11 901
解析 sdshdr8 #pragma pack(1) 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[]; }; 1字节对齐，sdshdr8结构体有
Redis的数据类型（三）SDS篇
fgjsd的博客
12-16 648
redis的迭代期间，sds的变化与特性
Redis系列 - Redis底层数据结构(简单动态字符串(SDS)、链表、字典、跳跃表、整数集合、压缩列表)
u011485472的博客
11-04 1176
Redis系列 - Redis基本数据类型
redis-unstable_Redis数据库源码_
09-30
以上只是Redis源码中的一部分关键知识点，深入研究源码还能了解到更多关于错误处理、内存管理、命令执行流程等方面的内容。对于想要深入了解Redis或者进行定制化开发的开发者来说，阅读和理解源码是非常有价值的。
深挖 Redis 6.0 源码—SDS.docx
06-27
Redis中的SDS（Simple Dynamic Strings，简单动态字符串）是一种核心数据结构，用于存储字符串和整数，它解决了C语言中字符串处理的二进制安全问题。在C语言中，字符串通常由字符数组和终止符'\0'组成，这使得包含'\...
Redis源码与设计剖析 -- 8.对象系统
qq_49723651的博客
07-19 533
SDS、双端链表、字典、跳表、压缩列表、整数集合、快速列表.Redis并没有直接使用这些数据结构来实现键值对数据库，而是基于这些数据结构创建了一个对象系统，这个系统包含字符串对象、列表对象、哈希对象、集合对象和有序集合对象这五种类型的对象，每种对象都用到了至少一种我们前面所介绍的数据结构.Redis可以在执行命令之前，根据对象的类型来判断一个对象是否可以执行给定的命令.可以针对不同的使用场景，为对象设置多种不同的数据结构实现，从而优化对象在不同场景下的使用效率.对象共享机制过期键自动删除。...
Redis 剖析系列：（一）String数据类型
zhm6422107的专栏
06-07 331
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
Redis源码入门-字符串sds,sdshdr
srs1995的博客
02-24 499
sds，全称Simple Dynamic Strings，是Redis自定义的一个字符串类型。 typedef char *sds; 看到这你肯定内心觉得Redis在逗你，这不就是一个字符数组么，怎么就Simple Dynamic Strings了呢 !没错，我当时也是这么觉得的，但是仔细阅读源码后发现sds并不是一个人在战斗，它还有战友sdshdr，sdshdr是个五胞胎，分别是sdshdr5，sdshdr8，sdshd16，sdshdr32，sdshd64。块头从小到大。 sdshdr 全称 Simpl
Redis源码剖析--动态字符串SDS
ZeeCoder
12-09 2214
请持续关注我的个人博客：https://zcheng.ren Redis没有使用C语言的字符串结构，而是自己设计了一个简单的动态字符串结构sds。它的特点是：可动态扩展内存、二进制安全和与传统的C语言字符串类型兼容。下面就从源码的角度来分析一下Redis中sds的实现。（sds的源码实现主要在sds.c和sds.h两个文件中）# sds数据结构定义 在sds.h文件中，我们可以找到sds的数据结构定
Redis深入浅出——字符串和SDS
热门推荐
我的博客
08-15 2万+
一、字符串 字符串的类信息定义 1.1 字符串介绍 字符串是Redis中最为常见的数据存储类型，其底层实现是简单动态字符串sds(simple dynamic string)，是可以修改的字符串。 它类似于Java中的ArrayList，它采用预分配冗余空间的方式来减少内存的频繁分配。 如图中所示，内部为当前字符串实际分配的空间 。其中capacity是最大容量，len是实际长度...
Redis源码剖析之SDS(Simple Dynamic String)
xindoo
09-26 3749
SDS(simple dynamic string)是Redis提供的字符串的封装，在redis中也是存在最广泛的数据结构，它也是很多其他数据结构的基础，所以才选择先介绍SDS。 SDS也兼容部分C字符串API(strcmp,strlen)，它如何兼容C字符串我觉得也是有个很sao的操作，等看完我这篇博客你就明白了。在开始正式内容前，我先抛几个问题(有些也是面试高频题)，带着问题去学习也是一种非常好的学习方法。 C语言中也算是支持String了，为什么Redis还要自己封装一个？ SDS中的D(dynam
Redis 入门与数据结构
跨语言，跨平台，跨应用
09-02 956
1、redis 诞生历程 08 年的时候有一个意大利西西里岛的小伙子，笔名 antirez(http://invece.org/)，创建了一个访客信息网站 LLOOGG.COM。有的时候我们需要知道网站的访问情况，比如访客的 IP、操作系统、浏览器、使用的搜索关键词、所在地区、访问的网页地址等等。在国内，有很多网站提供了这个功能，比如 CNZZ，百度统计，国外也有谷歌的 Google Analytics。我们不用自己写代码去实现这个功能，只需要在全局的 footer 里面嵌入一段 JS 代码就行了，当页面被
redis源码阅读笔记（一）：sds
qq_21815863的博客
05-15 345
redis 数据结构 sds sdshdr数据结构结构体代码struct __attribute__ ((__packed__)) sdshdr32 { uint32_t len; /* 当前字符串的长度 */ uint32_t alloc; /* 分配的空间大小，不包括头部（len alloc flags）跟结束符(null \0) */ unsigned
为了拿捏 Redis 数据结构，我画了 40 张图（完整版）
小林coding
12-01 9931
大家好，我是小林。 Redis 为什么那么快？ 除了它是内存数据库，使得所有的操作都在内存上进行之外，还有一个重要因素，它实现的数据结构，使得我们对数据进行增删查改操作时，Redis 能高效的处理。 因此，这次我们就来好好聊一下 Redis 数据结构，这个在面试中太常问了。 注意，Redis 数据结构并不是指 String（字符串）对象、List（列表）对象、Hash（哈希）对象、Set（集合）对象和 Zset（有序集合）对象，因为这些是 Redis 键值对中值的数据类型，也就是数据的保存形式，这些对象的底
Redis源码分析：从事件驱动到数据结构
这篇Redis源码日志为读者提供了一条深入理解Redis内部工作机制的路径，不仅涵盖了服务器架构的核心部分，还详细剖析了Redis如何利用高效的数据结构实现其功能。对于想要深入研究Redis源码或提升其使用技巧的开发者来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值