Redis底层数据结构的实现原理

最新推荐文章于 2024-08-16 19:29:55 发布
最新推荐文章于 2024-08-16 19:29:55 发布
阅读量749 收藏 1
点赞数 2
分类专栏： Redis 文章标签： redis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44324174/article/details/110010125
版权

文章目录

1、String——SDS

我们都知道redis是用C语言来写的，C语言中的字符串是用字符数组来实现的，但是redis为什么不用C语言中的String，而要自己定义一个动态字符串来存储呢？

C语言中存储String

char str[]=“redis”;  
C语言在读取时是以“\0”为结束符作为标志的，

但是redis在存储数据的时候万一存储的是“re\0dis”，在读取的时候就会导致数据的丢失，所以为了保证数据的安全性，我们需要在原来的基础上加一些参数，这就有了SDS。

SDS结构

struct sdshdr{
    int len;    //buf数组已使用的字节，即SDS保存的字符串长度：保证数据安全
    int free;   //未使用的字节长度：减少内存重新分配的次数
    char buf[]; //保存字符串的字节数组
}

SDS的扩容过程

如果要保存redis这几个字符，其SDS的结构就是:
len=5;
free=0;
char buf[]="redis";当想要在要redis的基础上再拼接一个“123”该怎么操作。
当SDS API需要对SDS进行修改时，API会先检查SDS的空间是否满足修改所需的要求，如果不满足的话，API会自动
将SDS的空间扩展至执行修改所需的大小，然后才执行实际的修改操作。
len=5;
addlen=3;
(len+addlen)*2=16  （当存储的数据达到1M的时候，扩容不再是2倍，而是每次多扩容1M）
创建一个长度为16的字符数组，把数据迁移过去，把123拼接到后面，此时：
len=8;
free=8;
char buf[]="redis123";
这样做的好处就是下次再次进行拼接的时候，可能就不需要再进行内存分配。

C字符串和SDS之间的区别

C字符串SDS
获取字符串长度的时间复杂度为O（n）获取字符串长度的时间复杂度为O（1）
API是不安全的，会造成缓冲区溢出API安全，不会造成缓冲区溢出
修改字符串长度N次必然需要执行N次内存分配修改字符串长度N次最多需要执行N次内存分配
只能保存文本数据可以保存文本或二进制数据

2、list

2.1 链表

当一个列表键包含了数量比较多的元素，又或者列表中包含的元素都是比较长的字符串时，Redis就会使用链表作为列表键的底层实现。

每个链表节点使用一个listNode结构来表示：

typedef struct listNode{
    //前置节点
    struct listNode *prev;
    //后置节点
    struct listNode *next;
    //节点的值
    void *value;
}listNode;

虽然仅仅使用多个listNode结构就可以组成链表，但使用addlist.h/list来持有链表的话，操作起来会更方便：

typedef struct list{
    //表头节点
    listNode *head;
    //表尾节点
    listNode *tail;
    //链表所包含的节点数量
    unsigned long len;
    //节点值复制函数
    void *(*dup)(void *ptr);
    //节点值释放函数
    void (*free)(void *ptr);
    //节点值对比函数
    int (*match)(void *ptr,void *key);
}list;

Redis的链表实现的特性可以总结如下：

  • 双端：链表节点带有prev和next指针，获取某个节点的前置节点和后置节点的复杂度都是O（1）。
  • 无环：表头节点的prev指针和表尾节点的next指针都指向NULL，对链表的访问以NULL为终点。
  • 带表头指针和表尾指针：通过list结构的head指针和tail指针，程序获取链表的表头节点和表尾节点的复杂度为O（1）。
  • 带链表长度计数器：list结构中的len属性可以快速获取链表长度。
  • 多态：链表节点使用void *指针来保存节点值，并且可以通过list结构的dup、free、match三个属性为节点值设置类型特定函数，所以链表可以用于保存各种不同类型的值。

2.2 压缩列表

当一个列表键只包含少量列表项，并且每个列表项要么就是小整数值，要么就是长度比较短的字符串，那么redis就会使用压缩列表来做列表键的底层实现。

redis>RPUSH lst 1 3 5 10086 "hello" "world"
redis>OBJECT ENCODING lst
“ziplist”

压缩列表时Redis为了节约内存而开发的，是由一系列特殊编码的连续内存块组成的顺序型数据结构，一个压缩列表可以包含任意多个节点，每个节点可以保存一个字节数组或者一个整数值。

之所以说这种存储结构节省内存，是相较于数组的存储思路而言的，我们知道数组要求每个元素的大小相同，如果我们要存储不同长度的字符串，那我们就需要用最大长度的字符串大小作为元素的大小（假设是20个字节）。存储小于20个字节长度的字符串的时候，便会浪费部分存储空间。

数组的优势占用一片连续的空间可以很好的利用CPU缓存访问数据，如果我们想要保留这种优势，又想节省空间我们可以对数组进行压缩，但是在遍历的时候由于不知道每个元素的大小是多少，因此无法计算出下一个节点的具体位置，这个时候就需要给每个节点增加一个属性，表示当前结点元素的大小（也就是后面说的content），这就是简单的压缩列表。

压缩列表的构成

在这里插入图片描述

属性类型长度用途
zlbytesuint32_t4字节记录整个压缩列表占用的内存字节数，在对压缩列表进行内存重分配或者计算zlend的位置时使用
zltailuint32_t4字节记录压缩列表尾节点距离起始地址有多少字节，通过这个偏移量，程序无须遍历整个压缩列表就可以确定表尾节点的地址
zllenuint16_t2字节记录了压缩列表包含的节点数量，当这个属性的值小于UINT16_MAX（65535）时，这个属性的值就是压缩列表包含节点的数量；当这个值等于UINT16_MAX时，节点的真实数量需要遍历整个压缩列表才能计算得出
entryX列表节点不定压缩列表包含的各个节点，节点的长度由节点保存的内容决定
zlenduint8_t1字节特殊值0xFF（十进制255），用于标记压缩列表的末端

压缩列表节点的构成

每个压缩列表节点可以保存一个字节数组或者一个整数值，其中，字节数组可以是：

  • 长度小于等于63（2^6-1）字节的字节数组；
  • 长度小于等于16383（2^14-1）字节的字节数组；
  • 长度小于等于4294967295（2^32-1）字节的字节数组；

而整数值则可以是以下六种长度的其中一种：

  • 4位长，介于0至12之间的无符号整数；
  • 1字节长的有符号整数；
  • 3字节长的有符号整数；
  • int16_t 类型整数；
  • int32_t 类型整数；
  • int64_t 类型整数；

每个压缩列表节点都由previous_entry_length、encoding、content三个部分组成。

1、pervious_entry_length

pervious_entry_length属性是以字节为单位，记录了压缩列表中前一个节点的长度，pervious_entry_length属性的长度可以是1字节或者5字节。

  • 如果前一节点的长度小于254字节，那么pervious_entry_length属性的长度为1字节。
  • 如果前一节点的长度大于等于254字节，那么pervious_entry_length属性的长度为5字节。

因为节点的pervious_entry_length属性记录了前一个节点的长度，并且是顺序存储，所以程序可以通过指针运算，根据当前节点的起始地址计算出前一个节点的起始地址。

压缩列表的从头到尾向表头遍历操作就是使用这一原理实现的，只要我们拥有了一个指向某个节点起始地址的指针，那么通过这个指针以及这个节点的pervious_entry_length属性，程序就可以一直向前一个节点回溯，最终到达压缩列表的表头节点。

2、encoding

节点的encoding属性记录了节点的content属性所保存数据的类型以及长度。

  • 一字节、两字节、五字节长，值的最高位为00、01、10的是字节数组编码，这种编码表示节点的content属性保存着字节数组，数组的长度由编码除去最高两位之后的其他位记录。
编码编码长度content属性保存的值
00bbbbbb1字节长度小于等于63字节的字节数组
01bbbbbb bbbbbbbb2字节长度小于等于16383字节的字节数组
10bbbbbb bbbbbbbb bbbbbbbb bbbbbbbb bbbbbbbb5字节长度小于等于4294967295字节的字节数组
  • 一字节长，值的最高位以11开头的是整数编码，这种编码表示节点的content属性保存着整数值，整数值的类型和长度由编码除去最高两位之后的其他位记录。

3、content
节点的content属性负责保存节点的值，节点值可以是一个字节数组或者整数，值的类型和长度由节点的encoding属性决定。

previous_entry_lengthencodingcontent
…00001011“hello world”
  • 编码的最高两位00表示节点保存的是一个字节数组；
  • 编码的后六位001011记录字节数组的长度11；
  • content属性保存着节点的值“hello world”；

3、hash

3.1 字典

字典：又称为符号表。关联数组或映射，是一种用于保存键值对的抽象数据结构。

当一个哈希键包含的键值对比较多，又或者键值对中的元素都是比较长的字符串时，Redis就会使用字典作为哈希键的底层实现。

Redis的字典使用哈希表作为底层实现，一个哈希表里面可以有多个哈希表节点，而每个哈希表节点就保存了字典中的一个键值对。

哈希表结构

typedef struct dictht{
     //哈希表数组
     dichEntry **table;
     //哈希表大小
     unsigned long size;
     //哈希表大小掩码，用于计算索引值
     unsigned long sizemask;
     //该哈希表已有节点的数量
     unsigned long used；
}dictht;

哈希表节点，每个dictEntry结构都保存着一个键值对。

typedef struct dictEntry{
      //键
      void *key;
      //值
      union{
           void *val;
           unit64_tu64;
           int64_ts64;
      }v;
      //指向下个哈希表节点，形成链表
      struct dictEntry *next;
}dictEntry;

key属性保存着键值对中的键，而v属性则保存着键值对中的值，其中键值对的值可以是一个指针，或者是一个unit64_t整数，又或者是一个int64_t整数。

next属性是指向另一个哈希表节点的指针，这个指针可以将多个哈希值相同的键值对连接在一起，以此来解决键冲突的问题。

字典结构

typedef struct dict{
    //类型特定函数
    dictType *type;
    //私有数据
    void *privdata;
    //哈希表
    dictht ht[2];
    //rehash索引 当rehash不在进行时，值为1
    int trehashidx;
}dict;

type属性和privdata属性是针对不同类型的键值对，为创建多态字典而设置的：

  • type属性是一个指向dictType结构的指针，每个dictType结构保存了一簇用于操作特定类型键值对的函数，Redis会为用途不同的字典上设置不同的类型特定函数。
  • 而privdata属性则保存了需要传给哪些类型特定函数的可选参数。
typedef struct dictType{
    //计算哈希值的函数
    unsigned int (*hashFunction)(const void *key)
    //复制键的函数
    void *(*keyDup)(void *privdata,const void *obj);
    //复制值的函数
    void *(*valDup)(void *privdata,const void *obj);
    //对比键的函数
    int (*keyCompare)(void *privadta,const void *key1,const void (key2);
    //销毁键的函数
    void (*keyDestructor)(void *privdata,void *key);
    //销毁值的函数
    void (*valDestruvtor)(void *privdata,void *obj);
}dictType;
  • ht属性是一个包含两个项的数组，数组中的每个项都是一个dictht哈希表，一般情况下，字典只使用ht[0]哈希表，h[1]哈希表只会在对h[0]哈希表进行rehash时使用。
  • 除了ht[1]之外，另一个和rehash有关的属性就是rehashidx，它记录了rehash目前的进度，如果目前没有在进行rehash，那么它的值为-1；

普通状态下（没有进行rehash）的字典。
在这里插入图片描述
哈希算法

当要将一个新的键值对添加到字典里面时，程序需要先根据键值对的键计算出哈希值和索引值，然后再根据索引值，将包含新键值对的哈希表节点放到哈希表数组的指定索引上面。

Redis计算哈希值和索引值的方法：

# 使用字典设置的哈希函数，计算键key的哈希值
hash=dict->type->hashFunction(key);
# 使用哈希表的sizemask属性和哈希值，计算出索引值
# 根据情况不同，ht[x]可以是ht[0]或者ht[1]
index=hash&dict->ht[x].sizemask;

当字典被用作数据库的底层实现，或者哈希键的底层实现时，Redis使用MurmurHash2算法来计算键的哈希值。

解决键冲突

当有两个或者以上数量的键被分配到了哈希表数组的同一个索引上面时，我们称这些键发生了冲突。

Redis的哈希表使用链地址方来解决键冲突，每个哈希表节点都有一个next指针，多个哈希表节点可以用next指针构成一个单向链表，因为dictEntry节点组成的链表没有指向链表表尾的指针，所以为了速度考虑，程序总是将新节点添加到链表的表头位置（复杂度为O（1）），排在其他已有节点的前面。

rehash

随着操作的不断进行，哈希表保存的键值对会逐渐的增多或者减少，为了让哈希表的负载因子维持在一个合理的范围之内，当哈希表保存的键值对数量太多或者太少时，程序需要对哈希表的大小进行相应的扩展或者收缩。

扩展和收缩哈希表的工作可以通过执行rehash（重新散列）操作来完成，Redis对字典的哈希表执行rehash的步骤如下：

1、为字典的ht[1]哈希表分配空间，这个哈希表的空间大小取决于要执行的操作，以及ht[0]当前包含的键值对数量（也就是ht[0].uesd属性的值）。

  • 扩展操作： ht[1]的大小为第一个大于等于ht[0].used*2的2^n（2的n次方幂）。
  • 收缩操作：ht[1]的大小为第一个大于等于ht[0].used的2^n。

2、将保存在ht[0]中的所有键值对rehash到ht[1]上面：rehash指的是重新计算键的哈希值和索引值，然后将键值对放置到ht[1]哈希表的指定位置上。

3、当ht[0]包含的所有键值对都迁移到了ht[1]之后（ht[0]变为空表），释放ht[0]，将ht[1]设置为ht[0]，并在ht[1]新创建一个空白哈希表，为下一次rehash做准备。

渐进式rehash

扩展或收缩哈希表都需要将ht[0]里面的所有键值对rehash到ht[1]里面1，但是，这个rehash动作并不是一次性的、集中式的完成的，而是分多次、渐进式地完成的。

这样做的原因在于，如果ht[0]里只保存着四个键值对，那么服务器就可以在瞬间就将这些键值对全部rehash到ht[1]，但是，如果哈希表里保存的键值对数量不是四个，而是四百万甚至更多，那么要一次性将这些键值对全部rehash到ht[1]的话，庞大的计算量可能会导致服务器在一段时间内停止服务。

因此，为了避免rehash对服务器性能造成影响，服务器不是一次性将ht[0]里面的所有键值对全部rehash到ht[1]，而是分多次、渐进式地将ht[0]里面的键值对慢慢地rehash到ht[1]。

以下式哈希表渐进式rehash的步骤：

1、为ht[1]分配空间，让字典同时持有ht[0]和ht[1]两个哈希表。

2、在字典中维持一个索引计数器变量rehashidx，并将它的值设置为0，表示rehash工作正式开始。

3、在rehash进行期间，==每次对字典执行添加、删除、查找或者更新操作时，程序出了指定的操作以外，还会顺带将ht[0]哈希表在rehashidx索引还是那个的所有键值对rehash至ht[1]，==当rehash工作完成之后，程序将rehashidx属性的值增一。

4、随着字典操作的不断执行，最终在某个时间点上，ht[0]的所有键值对都会被rehash至ht[1]，这时程序将rehashidx的属性的值设为-1，表示rehash操作已完成。

渐进式rehash的好处在于它采取分而治之的方式，将rehash键值对所需的计算工作均摊到对字典的每个添加、删除、查找和更新操作还是那个，从而避免了集中式rehash而带来的庞大计算量。

3.2 压缩列表

当一个哈希键只包含少量键值对，并且每个键值对的键和值要么就是小整数值，要么就是长度比较短的字符串，那么Redis就会使用压缩列表来做哈希键的底层实现。

redis>HMSET profile "name" "Jack" "age" 28 "job" "Programmer"
O**加粗样式**K
redis>OBJECT ENCODING profile
"ziplist"

上面list中有关于压缩列表的详细解释。

4、set

4.1 整数集合

整数集合是集合键的底层实现之一，当一个集合只包含整数值元素，并且这个歌集合的元素数量不多时，Redis就会使用整数集合作为集合键的底层实现。

整数集合的实现

整数集合是Redis用于保存整数值的集合抽象数据结构，它可以保存类型为int16_t、int32_t、int64_t的整数值，并且保证集合中不会出现重复元素。

每个intset.h/inset结构表示一个整数集合：

typedef stuct intset{
     //编码方式
     uint32_t encoding;
     //集合包含的元素数量
     uint32_t length;
     //保存元素的数组
     int8_t contents[];
}intset;

contents数组是整数集合的底层实现：整数集合的每个元素都是contents数组的一个数组项，各个项在数组中按值的大小从小到大又粗地排列，并且数组中不包含任何重复项。

length属性记录了整数集合包含的元素数量，也即是contents数组的长度。

虽然intset结构将contents属性声明为int8_t类型的数组，但实际上contents数组并不保存任何int8_t类型的值，contents数组的真正类型取决于encoding属性的值：

  • encoding属性的值为INTSET_ENC_INT16，那么contents就是一个int16_t类型的数组（最小值为-32768，最大值为32767）。
  • ncoding属性的值为INTSET_ENC_INT32，那么contents就是一个int32_t类型的数组（最小值为-2^31，最大值为 2^31-1）。
  • ncoding属性的值为INTSET_ENC_INT64，那么contents就是一个int64_t类型的数组（最小值为-2^63，最大值为 2^63-1）。

升级

每当我们要将一个新元素添加到整数集合里面，并且新元素的类型比整数集合现有所有元素得到类型都要长时，整数集合要先进行升级，然后才能将新元素添加到整数集合里面。

升级整数集合并添加新元素共分为三步进行：

  • 1、根据新元素的类型，扩展整数集合底层数组的空间大小，并为新元素分配空间。
  • 2、将底层数组现有的所有元素都转换成与新数组相同的类型，并将类型转换后的元素放置到正确的位上，而且在放置元素的过程，需要继续维持底层数组的有序性质不变。
  • 3、将新元素添加到底层数组里面。

因为每次向整数集合添加新元素都可能会引起升级，而每次升级都需要对底层数组中已有的所有元素进行类型转换，所以向整数集合添加新元素的时间复杂度都是O（N）。

因为引发升级的新元素的长度总是比整数集合现有的元素长度都大，所以这个新元素的值要么就大于所有现有元素要么小于所有现有元素。

  • 新元素小于所有现有元素：新元素会被放置在底层数组的最开头（索引为0）。
  • 新元素大于所有现有元素：新元素会被放置在底层数组的最末尾（索引length-1）。

升级的好处

1、提升灵活性

整数集合可以通过自动升级底层数组来适应新元素，所以我们可以随意地将int16_t、int32_t或者int64_t类型的整数添加到集合中，而不必担心出现类型错误，这种做法非常灵活。

2、节约内存

如果一个数组要同时保存int16_t、int32_t、int64_t三种类型的值，最简单的做法就是直接使用int64_t类型的数组作为整数集合的底层实现，不过这样一来，就是添加到集合中的元素都是int16_t类型，数组都需要使用int64_t类型的空间去保存它们，从而出现浪费内存的情况。

而整数集合现在的做法既可以让集合能同时保存三种不同类型的值，又可以确保升级操作只会在有需要的时候进行，这可以尽量节省内存。

整数集合不支持降级操作。

5、Zset

5.1 跳跃表

Redi使用跳跃表作为有序集合键的底层实现之一，如果一个有序集合包含的元素数量的比较多，又或者有序集合中元素的成员是比较长的字符串时Redis就会使用跳跃表来作为有序集合键的底层实现。

跳跃表（skiplist）是一种有序数据结构，它通过在每个节点中维持多个指向其他节点的指针，从而达到快速访问节点的目的。

Redis中的跳跃表由zskiplistNode和zskiplist两个结构定义，其中zskiplistNode结构用于标识跳跃表节点，而zskiplist结构用于保存跳跃表节点的相关信息。

zskiplist

header:指向跳跃表的表头节点。
tail:指向跳跃表的表尾节点。
level:记录目前跳跃表内，层数最大的那个节点的层数（表头节点的层数不计算在内）。
length:记录跳跃表的长度，也即是，跳跃表目前包含节点的数量。

zskiplistNode

typedef struct zskiplistNode{
       //层
       struct zskiplistLevel{
            //前进指针
            struct zskiplistNode *forward;
            //跨度
            unsigned int span;
       }level[];
      //后退指针
      struct zskilistNode *backward;
      //分值
      double score;
      //成员对象
      robj *obj;
}zskiplistNode;

层：

跳跃表节点的level数组可以包含多个元素，每个元素都包含一个指向其他节点的指针，程序可以通过这些层来加快访问其他节点的速度，一般来说，层的数量越多，访问其他节点的速度就越快。
每次创建一个新跳跃表节点的时候，程序都根据幂次定律（越大的数出现的概率越小）随机生成一个介于1和32之间的值作为level数组的大小，这个大小就是层的高度。

redis中随机层数的算法：

#define ZSKIPLIST_MAXLEVEL 32;
#define ZSKIPLIST_P 0.25
int zslRandomLevel(void) {
    int level = 1;
    //random() 返回一个[0...1)的随机数
    while ((random()&0xFFFF) < (ZSKIPLIST_P * 0xFFFF))
        level += 1;
    return (level<ZSKIPLIST_MAXLEVEL) ? level : ZSKIPLIST_MAXLEVEL;
}

根据上面计算层数的算法，可以看出，产生越高的节点数，概率越低：

  • 节点层数至少为1，而大于1的节点层数，满足一个概率分布。p=0.25
  • 节点层数恰好等于1的概率为1-p；
  • 节点层数大于等于2的概率为p，而节点层数恰好等于2的概率为p(1-p)；
  • 节点层数大于等于3的概率为p^2，而节点层数恰好等于2的概率为p*p(1-p)；

当skiplist中有n个节点的时候，

  • 第一层链表固有n个节点；
  • 第二层链表平均有n*p个节点；
  • 第三层链表平均有n*p^2个节点；
  • …
  • 第i层链表平均有n*p^(i-1)个节点；

本来想算一个时间复杂度的，但是算到这不会算了，以后算出来了再写吧

插入元素过程
在这里插入图片描述查找元素过程
在这里插入图片描述

查找元素46：
1、在L4层与55对比，发现小了，退回到第三层
2、在L3层与21比对，发信大了，继续与55比，发现小了，退回到第二层
3、在L2层与37比较，发现小了，与55对比，发现小了，退回到第一层。
4、在L1层与46对比，查找成功。

锦鱼不忘旧时晨
关注
专栏目录
Redis——Redis数据结构底层原理
庄小焱
03-31 3648
本博文主要介绍Redis数据结构底层原理。帮助大家更好的学习和理解Redis数据结构。Redis发展到现在已经有 9 种数据类型了，其中最基础、最常用的数据类型有 5 种，它们分别是：字符串类型、列表类型、哈希表类型、集合类型、有序集合类型，而在这 5 种数据类型中最常用的是字符串类型。这五种数据结构的底层实现丰富。
Redis的五种对象类型及其底层实现
热门推荐
聚沙成塔 积水成渊
04-01 4万+
Redis对象类型简介 Redis是一种key/value型数据库，其中，每个key和value都是使用对象表示的。比如，我们执行以下代码： redis>SET message "hello redis" 其中的key是message，是一个包含了字符串"message"的对象。而value是一个包含了"hello redis"的对象。 Redis共有五种对象的类型，分别是：
Redis底层原理
最新发布
kwb18293575696的博客
08-16 1311
单节点Redis的并发能力是有上限的，要进一步提高Redis的并发能力，就需要搭建主从集群，实现读写分离。
Redis 底层数据结构的实现原理是什么？
yygr的博客
02-10 1722
https://www.zhihu.com/question/484626962 Redis面试中经常被问到，Redis效率为什么这么快，很多同学往往回答：① Redis基于内存操作；② Redis是单线程的，采用了IO多路复用技术；除了它是内存数据库，使得所有的操作都在内存上进行之外，还有一个重要因素，它实现的数据结构，使得我们对数据进行增删查改操作时，Redis 能高效的处理。今天来聊下redis的底层数据结构简单动态字符串(Simple dynamic string,SDS)C语言字符串使用长度为n+
Redis的五种数据结构的底层实现原理
张维鹏的博客
01-31 3万+
Redis的五种数据结构的底层实现原理： 1、String底层实现方式：动态字符串sds 或者 long； 2、Hash底层实现方式：压缩列表ziplist 或者 字典dict； 3、List在Redis3.2之前的底层实现方式：压缩列表ziplist 或者 双向循环链表linkedlist； 4、List在Redis3.2及之后的底层实现方式：quicklist 5、Set底层实现方式：有序整数集合intset 或者 字典dict 6、Sorted set底层实现方式：压缩列表ziplist 或者zset
图解Redis底层数据结构实现原理
Seky_fei的博客
06-26 8600
待更新中
Redis底层数据结构实现原理
10-07
Redis底层的数据结构实现原理是通过组合不同的基础数据结构来实现更高层的数据结构。每种数据结构都经过专门设计，以提升读取和写入的性能。...更多关于Redis底层数据结构实现原理的详细信息，可以参考引用中的链接。
Redis数据结构底层原理详细分析
HuangJianShanの游离世界
06-03 1991
Redis的对象、简单动态字符串、链表、字典、跳跃表、整数集合、压缩列表的存储机制 首先内存和硬盘的比较 内存直接由CPU控制，也就是CPU内部集成的内存控制器，所以说内存是直接与CPU对接，享受与CPU通信的最优带宽，然而硬盘则是通过桥接芯片(在主板上)与CPU相连，所以说速度比较慢。两者相比内存比硬盘到底有多快？通常的说法是：内存访问速度是纳秒级（10的-9次方），硬盘的访问速度是微秒级（10的-3次方）。找到一个稍微科学点的测试数据，如下图 1.顺序访问：这种情况下，内存访问速度仅仅是.
Redis底层数据结构
m0_56111848的博客
04-25 1296
Redis数据结构 一、基本数据结构 常见数据结构：String（字符串）、List（列表）、Hash（哈希）、Set（集合）和 Sorted Set（有序集合） ​ String 类型的底层实现只有一种数据结构，也就是简单动态字符串。而 List、Hash、Set 和 Sorted Set 这四种数据类型，都有两种底层实现结构。通常情况下，我们会把这四种类型称为集合类型，它们的特点是一个键对应了一个集合的数据。 ​ 压缩列表和跳表我们平时接触得可能不多，但它们也是 Redis 重要的数据结构，需要重
redis底层数据模型与数据结构
08-12
### Redis 底层数据模型与数据结构解析 #### 一、`redisObject` 结构解析 Redis 中存储数据的基本单元是 `redisObject` 结构，它定义了 Redis 对象的各种属性，包括类型、编码方式、LRU/LFU 计算等。 **1.1 `...
Redis 底层的数据结构实现原理
莫言zero的博客
04-10 632
Redis内存模型 数据 作为数据库，数据是最主要部分; 这部分占用的内存会统计在used_memory中。 Redis使用键值对存储数据，其中的值（对象）包括5种类型，字符串、列表、哈希、集合、有序集合。 这五种类型是Redis对外提供，实际上，在Redis内部，每种类型都有2种或更多的内部编码实现。 进程 Redis主进程本身运行肯定需要占用内存，如代码、常量池等；这部分数据大约几M，在大多数生产环境中与Redis数据占用的内存相比可以忽略。 这部分数据不是jemalloc分配，因此不会统计在us
redis的底层数据结构和五大数据类型底层实现原理
shaolong1013的博客
08-30 299
底层数据结构：https://www.cnblogs.com/ysocean/p/9080942.html 五大数据类型底层实现原理：https://www.cnblogs.com/ysocean/p/9102811.html
redis的5种数据结构及其底层实现原理
zhongzhh8的博客
10-21 3万+
redis中的数据结构 Redis支持五种数据类型：string（字符串），hash（哈希），list（列表），set（无序集合）及zset(有序集合)。 在秒杀项目里，我用过redis的Set和Hash结构： String：一个 key 对应一个字符串，string是Redis 最基本的数据类型。（字节的abase框架只实现了redis的string数据结构，导致我们如果想要存储复杂的数据结构的时候，只能转成json格式的字符串来存储） list：一个 key 对应一个字符串列表，底层使用双向链表实现
Redis底层原理实现
Hai-Yang-code的博客
09-15 6754
简单动态字符串 Redis 是用 C 语言写的，但是对于Redis的字符串，却不是 C 语言中的字符串（即以空字符’\0’结尾的字符数组），它是自己构建了一种名为 简单动态字符串（simple dynamic string,SDS）的抽象类型，并将 SDS 作为 Redis的默认字符串表示。 SDS 定义： struct sdshdr{ //记录buf数组中已使用字节的数量 //等于 SDS 保存字符串的长度 int len; //记录 buf 数组中未使用字节的数量
redis 底层原理实现
qq_43019193的博客
05-08 2万+
1.Redis 数据类型 Redis支持五种数据类型：string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)。 2.简单动态字符串 c字符串是以空字符结尾的字符串，redis中使用sds（Simple Dynamic String, 简单动态字符串）代替c字符串，sds定义： 区别如下： 3.字典 Redis数据库使用字典来作为底...
Redis 数据结构的实现
weixin_34245169的博客
03-07 74
   Redis 数据结构的实现         先看个对照关系：   Redis数据结构 实现一 实现二 string 整数（如果value能够表示为整数） 字符串 hash 压缩列表（只包含少量键值对， 并且每个键值对的键和值要么就是小整数值， 要么就是长度比较短的字符串） 字典 list 压缩列表（只包含少量列表项， 并且每个列表项要么就是小整数值， 要么就是长度比较短的字...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值