Redis数据结构——动态字符串、Dict、ZipList

已于 2023-05-12 20:05:12 修改
阅读量767 收藏
点赞数 1
分类专栏： Redis 笔记 后端 文章标签： redis 数据结构 数据库
于 2023-05-12 19:55:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TiankkTT/article/details/130649100
版权
后端 同时被 3 个专栏收录
21 篇文章 0 订阅
订阅专栏
笔记
20 篇文章 0 订阅
订阅专栏
Redis
4 篇文章 0 订阅
订阅专栏

一、Redis数据结构-动态字符串

我们都知道Redis中保存的Key是字符串，value往往是字符串或者字符串的集合。可见字符串是Redis中最常用的一种数据结构。

不过Redis没有直接使用C语言中的字符串，因为C语言字符串存在很多问题：

  • 获取字符串长度的需要通过运算。
  • 非二进制安全。
  • 不可修改。

Redis构建了一种新的字符串结构，称为简单动态字符串（Simple Dynamic String），简称SDS。
例如，我们执行命令：

在这里插入图片描述

那么Redis将在底层创建两个SDS，其中一个是包含“name”的SDS，另一个是包含“KEKE”的SDS。

Redis是C语言实现的，其中SDS是一个结构体，源码如下：

在这里插入图片描述

例如，一个包含字符串“name”的sds结构如下：
在这里插入图片描述

SDS之所以叫做动态字符串，是因为它具备动态扩容的能力，例如一个内容为“hi”的SDS：
在这里插入图片描述

假如我们要给SDS追加一段字符串“,Amy”，这里首先会申请新内存空间：

如果新字符串小于1M，则新空间为扩展后字符串长度的两倍+1；

如果新字符串大于1M，则新空间为扩展后字符串长度+1M+1。称为内存预分配。
在这里插入图片描述

优点：

  • 获取字符串长度的时间复杂度为O(1)。
  • 支持动态扩容。
  • 减少内存分配次数。
  • 二进制安全。

Redis数据结构-intset

IntSet是Redis中set集合的一种实现方式，基于整数数组来实现，并且具备长度可变、有序等特征。
结构如下：

在这里插入图片描述

其中的encoding包含三种模式，表示存储的整数大小不同：
在这里插入图片描述

在这里插入图片描述

现在，数组中每个数字都在int16_t的范围内，因此采用的编码方式是INTSET_ENC_INT16，每部分占用的字节大小为：
encoding：4字节
length：4字节
contents：2字节 * 3 = 6字节

我们向该其中添加一个数字：50000，这个数字超出了int16_t的范围，intset会自动升级编码方式到合适的大小。
以当前案例来说流程如下：

  • 升级编码为INTSET_ENC_INT32, 每个整数占4字节，并按照新的编码方式及元素个数扩容数组。
  • 倒序依次将数组中的元素拷贝到扩容后的正确位置。
  • 将待添加的元素放入数组末尾。
  • 最后，将inset的encoding属性改为INTSET_ENC_INT32，将length属性改为4。

在这里插入图片描述

源码如下：

intset *intsetAdd(intset *is, int64_t value, uint8_t *success){
	uint8_t valenc = _intsetValueEncoding(value);//获取当前值编码
    uint32_t pos;//要插入的位置
	if (success) *success = 1;
    //判断编码是不是超过了当前intset的编码
    if (valenc > intrev32ifbe(is->encoding)){//超出编码，需要升级
    	return intsetUpgradeAndAdd(is,value);
    } else {
    //在当前intset中查找值与value—样的元素的角标pos
        if (intsetSearch(is,value,&pos)) {
          if (success)*success = O;//如果找到了，则无需插入，直接结束并返回失败return is;
    }
    //数组扩容
    is = intsetResize(is,intrev32ifbe(is->length)+1);
    //移动数组中pos之后的元素到pos+1，给新元素腾出空间
    if (pos < intrev32ifbe(is->length)) intsetMoveTail(is,pos,pos+1);
    }
    //插入新元素
    _intsetSet(is,pos,value);/重置元素长度
    is->length = intrev32ifbe(intrev32ifbe(is->length)+ 1);
    return is;
}

static intset *intsetUpgradeAndAdd(intset *is, int64_t value){//获取当前intset编码
    uint8_t curenc = intrev32ifbe(is->encoding);//获取新编码
    uint8_t newenc = _intsetValueEncoding(value);//获取元素个数
    int length = intrev32ifbe(is->length);
    //判断新元素是大于0还是小于0，小于0插入队首、大于0插入队尾
    int prepend = value < 0 ? 1 : 0;
    //重置编码为新编码
    is->encoding = intrev32ifbe(newenc);
    //重置数组大小
    is = intsetResize(is,intrev32ifbe(is->length)+1);
    //倒序遍历，逐个搬运元素到新的位置,_intsetGetEncoded按照旧编码方式查找旧元素
    while(length--) // _intsetSet按照新编码方式插入新元素
    	intsetSet(is,length+prepend, _intsetGetEncoded(is,length,curenc));
    //插入新元素，prepend决定是队首还是队尾
    if (prepend)
    	_intsetSet(is,0,value);
    else
    	_intsetSet(is,intrev32ifbe(is->length),value);
    //修改数组长度
    is- >length = intrev32ifbe(intrev32ifbe(is->length)+ 1);
    return is;
}

小总结：

Intset可以看做是特殊的整数数组，具备一些特点：

  • Redis会确保Intset中的元素唯一、有序。
  • 具备类型升级机制，可以节省内存空间。
  • 底层采用二分查找方式来查询。

二、 Redis数据结构-Dict

我们知道Redis是一个键值型（Key-Value Pair）的数据库，我们可以根据键实现快速的增删改查。而键与值的映射关系正是通过Dict来实现的。
Dict由三部分组成，分别是：哈希表（DictHashTable）、哈希节点（DictEntry）、字典（Dict）。

typedef struct dictht {
    // entry数组
	//数组中保存的是指向entry的指针
    dictEntry **table;
	//哈希表大小
	unsigned long size;
	//哈希表大小的掩码，总等于size - 1
    unsigned long sizemask;
	// entry个数
	unsigned long used;
} dictht;


typedef struct dictEntry {
    void *key;//键
	union {
		void *val;
        uint64_t u64;
        int64_t s64;
        double d;
    } v;//值
	//下一个Entry的指针
    struct dictEntry *next;
} dictEntry;

当我们向Dict添加键值对时，Redis首先根据key计算出hash值（h），然后利用 h & sizemask来计算元素应该存储到数组中的哪个索引位置。我们存储k1=v1，假设k1的哈希值h =1，则1&3 =1，因此k1=v1要存储到数组角标1位置。
在这里插入图片描述

Dict由三部分组成，分别是：哈希表（DictHashTable）、哈希节点（DictEntry）、字典（Dict）。

typedef struct dict {
    dictType *type; // dict类型，内置不同的hash函数
    void *privdata;//私有数据，在做特殊hash运算时用
    dictht ht[2];//一个Dict包含两个哈希表，其中一个是当前数据，另一个一般是空,rehash时使用
    long rehashidx; // rehash的进度，-1表示未进行
    int16_t pauserehash; // rehash是否暂停，1则暂停，0则继续
} dict;

typedef struct dictht {// entry数组
    //数组中保存的是指向entry的指针
    dictEntry **table;
    //哈希表大小
    unsigned long size;
    //哈希表大小的掩码，总等于size - 1
    unsigned long sizemask;
    // entry个数
    unsigned long used;
}dictht;

typedef struct dictEntry {
    void *key;//键
		union {
			void *val;
            uint64_t u64;
            int64_t s64;
            double d;
        } v;//值
	//下一个Entry的指针
    struct dictEntry *next;
}dictEntry;

typedef struct dict {
    dictType *type; // dict类型，内置不同的hash函数
    void *privdata;//私有数据，在做特殊hash运算时用
    dictht ht[2];//一个Dict包含两个哈希表，其中一个是当前数据，另一个一般是空，rehash时使用
    long rehashidx; // rehash的进度，-1表示未进行
    int16_t pauserehash; // rehash是否暂停，1则暂停，O则继续
} dict;

Dict的扩容

Dict中的HashTable就是数组结合单向链表的实现，当集合中元素较多时，必然导致哈希冲突增多，链表过长，则查询效率会大大降低。
Dict在每次新增键值对时都会检查负载因子（LoadFactor = used/size） ，满足以下两种情况时会触发哈希表扩容：
哈希表的 LoadFactor >= 1，并且服务器没有执行 BGSAVE 或者 BGREWRITEAOF 等后台进程；
哈希表的 LoadFactor > 5 ；

static int dictExpandlfNeeded(dict*d){
    //如果正在rehash，则返回ok
    if (dictlsRehashing(d)) return DICT_OK;
    //如果哈希表为空，则初始化哈希表为默认大小:4
    if (d->ht[0].size == 0) return dictExpand(d, DICT_HT_INITIAL_SIZE);
    //当负载因子(used/size)达到1以上，并且当前没有进行bgrewrite等子进程操作
    //或者负载因子超过5，则进行dictExpand ，也就是扩容
    if (d->ht[0].used >= d->ht[0].size &i&
    (dict_can_resize || d->ht[0].used/d->ht[0].size > dict_force_resize_ratio){
    //扩容大小为used + 1，底层会对扩容大小做判断，实际上找的是第一个大于等于used+1的2^n
        return dictExpand(d, d->ht[0].used + 1);
    }
    return DICT_OK;
}

// t_hash.c # hashTypeDeleted()
//……
if (dictDelete((dict*)o->ptr, field) == C_OK){
    deleted = 1;
	//删除成功后，检查是否需要重置Dict大小，如果需要则调用dictResize重置
    /*Always check if the dictionary needs a resize after a delete.*/
	if (htNeedsResize(o->ptr)) dictResize(o->ptr);
}
……

// server.c文件
int htNeedsResize(dict *dict) {
    long long size, used;
    //哈希表大小
    size = dictSlots(dict);
    // entry数量
    used = dictSize(dict);
    // size > 4(哈希表初识大小)并且负载因子低于0.1
    return (size > DICT_HT_INITIAL_SIZE && (used*100/size <HASHTABLE_MIN_FILL));
}
        
int dictResize(dict *d){
    unsigned long minimal;
    //如果正在做bgsave或bgrewriteof或rehash，则返回错误
    if (!dict_can_resize |l dictlsRehashing(d))
        return DICT_ERR;
    //获取used，也就是entry个数
    minimal = d->ht[0].used;//如果used小于4，则重置为4
    if (minimal < DICT_HT_INITIAL_SIZE)
        minimal = DICT_HT_INITIAL_SIZE;
    //重置大小为minimal，其实是第一个大于等于minimal的2^n
    return dictExpand(d, minimal);
}

Dict的rehash

不管是扩容还是收缩，必定会创建新的哈希表，导致哈希表的size和sizemask变化，而key的查询与sizemask有关。因此必须对哈希表中的每一个key重新计算索引，插入新的哈希表，这个过程称为rehash。过程是这样的：

  • 计算新hash表的realeSize，值取决于当前要做的是扩容还是收缩：

    • 如果是扩容，则新size为第一个大于等于dict.ht[0].used + 1的2^n。
    • 如果是收缩，则新size为第一个大于等于dict.ht[0].used的2^n （不得小于4）。

  • 按照新的realeSize申请内存空间，创建dictht，并赋值给dict.ht[1]。

  • 设置dict.rehashidx = 0，标示开始rehash。

  • 将dict.ht[0]中的每一个dictEntry都rehash到dict.ht[1]。

  • 将dict.ht[1]赋值给dict.ht[0]，给dict.ht[1]初始化为空哈希表，释放原来的dict.ht[0]的内存。

  • 将rehashidx赋值为-1，代表rehash结束。

  • 在rehash过程中，新增操作，则直接写入ht[1]，查询、修改和删除则会在dict.ht[0]和dict.ht[1]依次查找并执行。这样可以确保ht[0]的数据只减不增，随着rehash最终为空。

整个过程可以描述成：

小总结：

Dict的结构：

  • 类似java的HashTable，底层是数组加链表来解决哈希冲突。
  • Dict包含两个哈希表，ht[0]平常用，ht[1]用来rehash。

Dict的伸缩：

  • 当LoadFactor大于5或者LoadFactor大于1并且没有子进程任务时，Dict扩容。
  • 当LoadFactor小于0.1时，Dict收缩。
  • 扩容大小为第一个大于等于used + 1的2^n。
  • 收缩大小为第一个大于等于used 的2^n。
  • Dict采用渐进式rehash，每次访问Dict时执行一次rehash。
  • rehash时ht[0]只减不增，新增操作只在ht[1]执行，其它操作在两个哈希表。

三、 Redis数据结构-ZipList

ZipList 是一种特殊的“双端链表” ，由一系列特殊编码的连续内存块组成。可以在任意一端进行压入/弹出操作, 并且该操作的时间复杂度为 O(1)。

属性类型长度用途
zlbytesuint32_t4 字节记录整个压缩列表占用的内存字节数
zltailuint32_t4 字节记录压缩列表表尾节点距离压缩列表的起始地址有多少字节，通过这个偏移量，可以确定表尾节点的地址。
zllenuint16_t2 字节记录了压缩列表包含的节点数量。 最大值为UINT16_MAX （65534），如果超过这个值，此处会记录为65535，但节点的真实数量需要遍历整个压缩列表才能计算得出。
entry列表节点不定压缩列表包含的各个节点，节点的长度由节点保存的内容决定。
zlenduint8_t1 字节特殊值 0xFF （十进制 255 ），用于标记压缩列表的末端。

ZipListEntry

ZipList 中的Entry并不像普通链表那样记录前后节点的指针，因为记录两个指针要占用16个字节，浪费内存。而是采用了下面的结构：

  • previous_entry_length：前一节点的长度，占1个或5个字节。

    • 如果前一节点的长度小于254字节，则采用1个字节来保存这个长度值。
    • 如果前一节点的长度大于254字节，则采用5个字节来保存这个长度值，第一个字节为0xfe，后四个字节才是真实长度数据。

  • encoding：编码属性，记录content的数据类型（字符串还是整数）以及长度，占用1个、2个或5个字节。

  • contents：负责保存节点的数据，可以是字符串或整数。

ZipList中所有存储长度的数值均采用小端字节序，即低位字节在前，高位字节在后。例如：数值0x1234，采用小端字节序后实际存储值为：0x3412。

Encoding编码

ZipListEntry中的encoding编码分为字符串和整数两种：
字符串：如果encoding是以“00”、“01”或者“10”开头，则证明content是字符串。

编码编码长度字符串大小
|00pppppp|1 bytes<= 63 bytes
|01pppppp|qqqqqqqq|2 bytes<= 16383 bytes
|10000000|qqqqqqqq|rrrrrrrr|ssssssss|tttttttt|5 bytes<= 4294967295 bytes

例如，我们要保存字符串：“ab”和 “bc”。

ZipListEntry中的encoding编码分为字符串和整数两种：

  • 整数：如果encoding是以“11”开始，则证明content是整数，且encoding固定只占用1个字节。
编码编码长度整数类型
110000001int16_t（2 bytes）
110100001int32_t（4 bytes）
111000001int64_t（8 bytes）
11110000124位有符整数(3 bytes)
1111111018位有符整数(1 bytes)
1111xxxx1直接在xxxx位置保存数值，范围从0001~1101，减1后结果为实际值

Redis数据结构-ZipList的连锁更新问题

ZipList的每个Entry都包含previous_entry_length来记录上一个节点的大小，长度是1个或5个字节：

  • 如果前一节点的长度小于254字节，则采用1个字节来保存这个长度值。
  • 如果前一节点的长度大于等于254字节，则采用5个字节来保存这个长度值，第一个字节为0xfe，后四个字节才是真实长度数据。

现在，假设我们有N个连续的、长度为250~253字节之间的entry，因此entry的previous_entry_length属性用1个字节即可表示，如图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r3EpMeDL-1683891939936)(.\原理篇.assets\1653986217182.png)]

ZipList这种特殊情况下产生的连续多次空间扩展操作称之为连锁更新（Cascade Update）。新增、删除都可能导致连锁更新的发生。

小总结：

ZipList特性：

  • 压缩列表的可以看做一种连续内存空间的"双向链表"。
  • 列表的节点之间不是通过指针连接，而是记录上一节点和本节点长度来寻址，内存占用较低。
  • 如果列表数据过多，导致链表过长，可能影响查询性能。
  • 增或删较大数据时有可能发生连续更新问题。
逐渐呆滞
关注
专栏目录
Redis——Redis数据结构底层原理
庄小焱
03-31 3727
本博文主要介绍Redis数据结构底层原理。帮助大家更好的学习和理解Redis数据结构。Redis发展到现在已经有 9 种数据类型了，其中最基础、最常用的数据类型有 5 种，它们分别是：字符串类型、列表类型、哈希表类型、集合类型、有序集合类型，而在这 5 种数据类型中最常用的是字符串类型。这五种数据结构的底层实现丰富。
Redis原理篇——数据结构
xiaowanziddd的博客
06-29 371
一.动态字符串SDS 我们都知道Redis中保存的Key是字符串，value往往是字符串或者字符串集合。可见字符串时Redis中最常用的一种数据结构。 不过Redis没有直接使用c语言中的字符串，因为c语言字符串存在很多问题：SDS之所以叫做动态字符串，是因为它具备动态扩容的能力，例如一个内容为“hi”的SDS: 加入我们要给SDS追加一段字符串“,Amy”,这里首先会申请新内存空间：IntSet是Redis中set集合的一种实现方式，基于整数数组来实现，并且具备长度可变，有序等特征。 结构如下： 为了
[读书笔记: Redis设计与实现] 第2-5章 2简单动态字符串SDS，3链表，4字典，
学习与分享同在!
09-11 242
第一部分 数据结构与对象 第2章 简单动态字符串SDS 简易结构： struct sdsstr{ int len; //记录字符串长度 int free; //记录数组剩余看见大学 char buf[]; //存储字符串的字节数组 } 1. 相比与C字符串（底层维护一个N+1长度的字节数组），SDS更有优势： 1.获取字符串长度简单 复杂度O(1), 而C字符串需要遍历数组统计长度，复杂度O(n) 2.避免了缓冲区溢出（SDS的空间分配策略避免了缓冲区溢出）
redis之动态字符串
qq_38571892的博客
03-29 616
众所周知，redis以高性能著称。毫无疑问，redis的高性能一定要有一些自己设计的特殊、易用且安全的数据结构作为支撑，来满足不同场景下的存储需求。下面我们就对redis常使用的几种数据结构进行详解，从中大家可以看到redis是如何使用这些数据结构，选择这些数据而不使用市面已存在的类似数据结构的原因以及这些数据结构是如何保证redis的高性能的。 简单动态字符窜 我们知道redis没有使用C语音传统的字符窜表示（以空字符结尾的字符数组，在我所有文章中统一称为C字符串）,而是自己构建了一种名为**简单动态字符
Redis篇（Redis原理 - 数据结构）（持续更新迭代）
最新发布
wlcass zhengge blog
10-02 1521
我们知道 Redis 是一个键值型（ Key-Value Pair ）的数据库，我们可以根据键实现快速的增删改查。而键与值的映射关系正是通过 Dict 来实现的。Dict 由三部分组成，分别是：哈希表（ DictHashTable ）、哈希节点（ DictEntry ）、字典（ Dict ）当我们向 Dict 添加键值对时，Redis 首先根据 key 计算出 hash 值（ h ），然后利用 h & sizemask 来计算元素应该存储到数组中的哪个索引位置。
Redis中的动态字符串
qq_36763031的博客
06-23 315
Redis-sds
redis-动态字符串
qq_36436040的博客
12-03 822
第二章 简单动态字符串（simple dynamic string,SDS） SDS:redis的默认字符串 C字符串：字符串字面量（无须对字符串值进行修改的地方） 字符串的键值底层都是由SDS实现 SDS使用地方：字符串，AOF缓冲区（持久化机机制AOF）,输入缓冲区（客户端状态） SDS的定义 struct sdshdr{ //记录buf中已使用字节的数量 //等于SDS所保存字符串的长度 int len; //记录buf中未使用字节的数量 int free; //字节数组，用于保存字符串 char b
Redis动态字符串
我的博客
12-05 528
Q: 什么是 SDS A:SDS 是 Redis 在实现过程中使用的一种「动态字符串」。由于 Redis 的代码基本都是通过 C 语言来实现的，所以 SDS 在最底层还是依赖于char buf[]来存储数据。SDS 对象的数据结构大致如下图所示 可以看出，SDS 结构体成员中有三个属性：len，free，buf。其中 len 标识一个 SDS 对象管理的字符串有效字符是多少个，而 free 则代表这个 SDS 在不扩充空间的前提下还可以存储多少个有效字符，buf 则是一个char[]类型的指针，它指
Redis数据结构——五种数据类型
xiaowanziddd的博客
06-30 679
String是Redis中常见的数据存储类型：Redis的List类型可以从首、尾操作列表中的元素： 哪一个数据结构能满足上述特征？Redis的List结构类似一个双端链表，可以从首、尾操作列表中的元素：Set是Redis中的单例集合，满足下列特点： 可以看出当插入一个非整数值的时候，编码就会由IntSet转换为HT格式 底层源码： Zset也就是SortedSet,其中每一个元素都需要指定一个score值和member值：Hash结构与Redis中的Zset非常类似： 两者的区别在于是否需要排序，因
redis基础篇——redis常用的数据类型
石灰聪的博客
11-26 533
数据模型 Redis的存储我们叫做key-value存储，或者叫做字典结构。key的最大长度限制是512M，值的限制不同，有的是用长度限制的，有的是用个数限制的。Redis是KV的数据库，Key-Value我们一般会用什么数据结构来存储它？哈希表。Redis的最外层确实是通过hashtable实现的，在Redis里面，这个哈希表怎么实现呢？我们看一下C语言的源码每个键值对都是一个dictEntry，通过指针指向key的存储结构和value的存储结构，而且next存储了指向下一个键值对的指针。 typede
Redis设计与实现——数据结构与对象
等一杯咖啡的博客
06-30 862
前言 Redis是一个KV数据库，常用于实现缓存，因为基于内存实现，所以速度极快。最近阅读《Redis设计与实现》一书，整理几篇文章，本文介绍Redis数据结构相关内容。 I. 数据结构 我们通常说的Redis支持的数据类型有五种，包括字符串、哈希、列表、集合、有序集合，其实这只是存储的数据类型，底层用于存储数据的数据结构并不是这些，而是动态字符串(SDS)、链表、字典(哈希表)、跳跃表、整数集合...
redis--简单动态字符串
云端做梦
08-01 628
简单动态字符串 Redis没有直接使用C语言传统的字符串表示，而是构建了一种名为简单动态字符串（simple dynamic string,SDS）的抽象类型，将SDS用作Redis的默认字符串表示。 在Redis里边，C字符串只会作为字符串面量用在一些无需对字符串的值进行修改的地方。 文章目录简单动态字符串1、SDS的定义2、SDS与C字符串的区别2.1、获取字符串长度2.2、杜绝缓冲区溢出2....
【Redis面试题】Redis的字符串是怎么实现的？
weixin_33829657的博客
04-07 897
年前本人在找工作面试时在Redis相关问题上可栽了跟头。在面试前按常规套路准备了一下，比如 Redis 的常用5种数据结构，Redis持久化策略，Redis实现分布式锁，简单发布订阅等等都准备了，当时不知天高地厚以为十拿九稳了，可是万万没想到我终究还是在Redis的被问的第一个问题上翻船了～～ 面试官 ：看你简历上写了熟悉常用数据结构，都有哪些说说 本人 ：常用有5种，string,list...
Redis--简单动态字符串（SDS）
daylight_1的专栏
04-18 1070
1.简介 Redis没有适用传统农的C语言的字符串表示(以空字符结尾的字符数组)，而是自己设计了一个名为简单动态字符串(SDS)的的抽象类型。 在Redis中，C字符串只会作为字符串字面量，用在一些无须对字符串值进行修改的地方，比如打印日志。 在Redis中，包含字符串的键值对在底层都是由SDS实现的。 2.SDS的定义 结构定义如下： struct sdshdr{ //记录buf数组中已使用字节的数量，等于SDS所保存字符串的长度 int len; //记录buf数组中未使用字节的数量
Redis数据结构-动态字符串
admin3335的博客
10-18 842
Redis数据结构-动态字符串
redis数据结构之动态字符串（SDS）
eyes++的博客
05-20 524
我们都知道Redis中保存的Key是字符串，value往往是字符串或者字符串的集合。可见字符串是Redis中最常用的一种数据结构。
Redis简单动态字符串(SDS)
lishuangzhi的博客
01-21 693
Redis只会使用C字符串作为字面量。大多数情况下，redis使用SDS作为字符串表示 SDS (simple dynamic string) struct sdshdr { int len; //记录buf数组中已使用字节的数量，等于SDS所保存字符串的长度 int free; //记录buf数组中未使用字节的数量 char buf[]; //字节数组，用于保存字符串 }; C字符串和SDS之间的比较，也是为什么使用SDS的原因： 直接通过字段获取字符串长度，提高了效率 C字
Redis之简单动态字符串
YinXin的博客
04-28 735
SDS的介绍Redis中字符串并没有使用C语言传统的字符串，而是构建了一种名为简单动态字符串（SDS），SDS是Redis的默认字符串标识。 Redis里面的C语言字符串用在一些无需对字符串值进行修改的地方，例如打印日志redisLog（REDIS_WARNING,"redis is now ready to exit"）; 当Redis需要的是可以被修改的字符串值时，使用SDS来表示字符串值re
redis：简单动态字符串（SDS）
u013407461的博客
02-21 955
redis简单动态字符串
Redis中sds：动态字符串的实现与应用
Redis中的动态字符串学习教程深入探讨了名为sds（短字符串动态字符串）的数据结构在数据库系统中的关键作用。sds在Redis中有两大主要用途： 1. **实现字符串对象（StringObject）**： Redis作为键值对数据库，其...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值