Redis复习-底层数据结构

动态字符串

我们都知道Redis中保存的Kev是字符串，vale往往是字符串或者字符串的集合。可见字符串是Redis中最常用的一种数据结构。
不过Redis没有直接使用C语言中的字符串，因为C语言字符串存在很多问题：
1.获取字符串长度的需要通过运算(循环数组直到'/0')
2.非二进制安全（不能存储'/0'）
3.不可修改

// c语言，声明字符串
char* s = "hello"
// 本质是字符数组： {'h', 'e', 'l', 'l', 'o', '\0'}

Redis构建了一种新的字符串结构，称为简单动态字符串（SimpleDynamicString），简称SDS。
当我们在底层执行set name xxx，redis底层会生成两个sds，一个"name"，一个"xxx"

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

uint8_t类型的长度为八个二进制位的整数，最大可表示255，也就是说数组最多可分配255字节（char一个字节）

例如，一个包含字符串“name”的sds结构如下：

SDS之所以叫做动态字符串，是因为它具备动态扩容的能力，例如一个内容为“hi”的SDS：

假如我们要给SDS追加一段字符串“，Amy”，这里首先会申请新内存空间：
1.如果新字符串小于1M，则新空间为扩展后字符串长度的两倍+1;
2.如果新字符串大于1M，则新空间为扩展后字符串长度+1M+1。称为内存预分配。

sds的优点

IntSet

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

typedef struct intset {
  uint32_t encoding; /* 编码方式，支持存放16位、32位、64位整数*/
  uint32_t length; /* 元素个数 */
  int8_t contents[]; /* 整数数组，保存集合数据*/
} intset;

其中的encoding包含三种模式，表示存储的整数大小不同：

/* Note that these encodings are ordered, so:
 * INTSET_ENC_INT16 < INTSET_ENC_INT32 < INTSET_ENC_INT64. */
#define INTSET_ENC_INT16 (sizeof(int16_t)) /* 2字节整数，范围类似java的short*/
#define INTSET_ENC_INT32 (sizeof(int32_t)) /* 4字节整数，范围类似java的int */
#define INTSET_ENC_INT64 (sizeof(int64_t)) /* 8字节整数，范围类似java的long */

为了方便查找，Redis会将intset中所有的整数按照升序依次保存在contents数组中，结构如图：

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

IntSet升级

现在，假设有一个intset，元素为{5,10，20}，采用的编码是INTSET_ENC_INT16，则每个整数占2字节：
我们向该其中添加一个数字：50000，这个数字超出了int16_t的范围，intset会自动升级编码方式到合适的大小。
以当前案例来说流程如下：
1.升级编码为INTSET_ENC_INT32，每个整数占4字节，并按照新的编码方式及元素个数扩容数组
2.倒序依次将数组中的元素拷贝到扩容后的正确位置
扩容过程：



更改后的头信息：

intset新增源码：

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 = 0; //如果找到了，则无需插入，直接结束并返回失败
​      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;
}

intset升级源码：

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可以看做是特殊的整数数组，具备一些特点：
1.Redis会确保Intset中的元素唯一、有序
2.具备类型升级机制，可以节省内存空间
3.底层采用二分查找方式来查询（用在确保set的元素唯一）

dict

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

哈希表（DictHashTable）

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

哈希节点（DictEntry）

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）

字典(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;

整体结构：

Dict的渐进式rehash

Dict扩容

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

相关源码：

static int _dictExpandIfNeeded(dict *d){
  // 如果正在rehash，则返回ok
  if (dictIsRehashing(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 &&
​    (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;
}

Dict收缩

Dict除了扩容以外，每次删除元素时，也会对负载因子做检查，当LoadFactor < 0.1 时，会做哈希表收缩：

相关源码：

// 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 || dictIsRehashing(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);
}

rehash过程

不管是扩容还是收缩，必定会创建新的哈希表，导致哈希表的size和sizemask变化，而key的查询与sizemask有关。因此必须对哈希表中的每一个key重新计算索引，插入新的哈希表，这个过程称为rehash。过程是这样的：
1.计算新hash表的realeSize，值取决于当前要做的是扩容还是收缩：
2.如果是扩容，则新size为第一个大于等于dict.ht[0].used + 1的2^n
3.如果是收缩，则新size为第一个大于等于dict.ht[0].used的2^n （不得小于4）
4.按照新的realeSize申请内存空间，创建dictht，并赋值给dict.ht[1]
5.设置dict.rehashidx = 0，标示开始rehash
6.将dict.ht[0]中的每一个dictEntry都rehash到dict.ht[1]
7.将dict.ht[1]赋值给dict.ht[0]，给dict.ht[1]初始化为空哈希表，释放原来的dict.ht[0]的内存

整体流程：

Dict的rehash并不是一次性完成的。试想一下，如果Dict中包含数百万的entry，要在一次rehash完成，极有可能导致主线程阻塞。因此Dict的rehash是分多次、渐进式的完成，因此称为渐进式rehash。流程如下：
1.计算新hash表的size，值取决于当前要做的是扩容还是收缩：
2.如果是扩容，则新size为第一个大于等于dict.ht[0].used + 1的2^n
3.如果是收缩，则新size为第一个大于等于dict.ht[0].used的2^n （不得小于4）
4.按照新的size申请内存空间，创建dictht，并赋值给dict.ht[1]
5.设置dict.rehashidx = 0，标示开始rehash
6.每次执行新增、查询、修改、删除操作时，都检查一下dict.rehashidx是否大于-1，如果是则将dict.ht[0].table[rehashidx]的entry链表rehash到dict.ht[1]，并且将rehashidx++。直至dict.ht[0]的所有数据都rehash到dict.ht[1]
7.将dict.ht[1]赋值给dict.ht[0]，给dict.ht[1]初始化为空哈希表，释放原来的dict.ht[0]的内存
8.将rehashidx赋值为-1，代表rehash结束
9.在rehash过程中，新增操作，则直接写入ht[1]，查询、修改和删除则会在dict.ht[0]和dict.ht[1]依次查找并执行。这样可以确保ht[0]的数据只减不增，随着rehash最终为空

总结

Dict的结构：
1.类似java的HashTable，底层是数组加链表来解决哈希冲突
2.Dict包含两个哈希表，ht[0]平常用，ht[1]用来rehash
Dict的伸缩：
1.当LoadFactor大于5或者LoadFactor大于1并且没有子进程任务时，Dict扩容
2.当LoadFactor小于0.1时，Dict收缩
3.扩容大小为第一个大于等于used + 1的2^n
4.收缩大小为第一个大于等于used 的2^n
5.Dict采用渐进式rehash，每次访问Dict时执行一次rehash
6.rehash时ht[0]只减不增，新增操作只在ht[1]执行，其它操作在两个哈希表

ziplist

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

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

previous_entry_length：前一节点的长度，占1个或5个字节。
-如果前一节点的长度小于254字节，则采用1个字节来保存这个长度值
-如果前一节点的长度大于254字节，则采用5个字节来保存这个长度值，第一个字节为0xfe，后四个字节才是真实长度数据
encoding：编码属性，记录content的数据类型（字符串还是整数）以及长度，占用1个、2个或5个字节
contents：负责保存节点的数据，可以是字符串或整数

Encoding编码

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

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

整数：如果encoding是以“11”开始，则证明content是整数，且encoding固定只占用1个字节

例如，一个ZipList中包含两个整数值：“2”和“5”

ZipList的连锁更新问题

ZipList的每个Entry都包含previous_entry_length来记录上一个节点的大小，长度是1个或5个字节：
如果前一节点的长度小于254字节，则采用1个字节来保存这个长度值
如果前一节点的长度大于等于254字节，则采用5个字节来保存这个长度值，第一个字节为0xfe，后四个字节才是真实长度数据
现在，假设我们有N个连续的、长度为250~253字节之间的entry，因此entry的previous_entry_length属性用1个字节即可表示，如图所示：

新插入一个entry，长度大于等于254，后面节点使用5个字节保存该长度值，以此类推，后面也都改为5个字节。

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

总结

ZipList特性：
1.压缩列表的可以看做一种连续内存空间的"双向链表"
2.列表的节点之间不是通过指针连接，而是记录上一节点和本节点长度来寻址，内存占用较低
3.如果列表数据过多，导致链表过长，可能影响查询性能
4.增或删较大数据时有可能发生连续更新问题(出现概率较小，还未解决)

quicklist

问题1：ZipList虽然节省内存，但申请内存必须是连续空间，如果内存占用较多，申请内存效率很低。怎么办？
为了缓解这个问题，我们必须限制ZipList的长度和entry大小。
问题2：但是我们要存储大量数据，超出了ZipList最佳的上限该怎么办？
我们可以创建多个ZipList来分片存储数据。
问题3：数据拆分后比较分散，不方便管理和查找，这多个ZipList如何建立联系？
Redis在3.2版本引入了新的数据结构QuickList，它是一个双端链表，只不过链表中的每个节点都是一个ZipList。

为了避免QuickList中的每个ZipList中entry过多，Redis提供了一个配置项：list-max-ziplist-size来限制。
如果值为正，则代表ZipList的允许的entry个数的最大值
如果值为负，则代表ZipList的最大内存大小，分5种情况：
-1：每个ZipList的内存占用不能超过4kb
-2：每个ZipList的内存占用不能超过8kb
-3：每个ZipList的内存占用不能超过16kb
-4：每个ZipList的内存占用不能超过32kb
-5：每个ZipList的内存占用不能超过64kb
其默认值为 -2：

除了控制ZipList的大小，QuickList还可以对节点的ZipList做压缩。通过配置项list-compress-depth来控制。因为链表一般都是从首尾访问较多，所以首尾是不压缩的。这个参数是控制首尾不压缩的节点个数：
0：特殊值，代表不压缩
1：标示QuickList的首尾各有1个节点不压缩，中间节点压缩
2：标示QuickList的首尾各有2个节点不压缩，中间节点压缩
以此类推

默认值：0

QuickList源码：

typedef struct quicklist {
  // 头节点指针
  quicklistNode *head;
  // 尾节点指针
  quicklistNode *tail;
  // 所有ziplist的entry的数量
  unsigned long count;   
  // ziplists总数量
  unsigned long len;
  // ziplist的entry上限，默认值 -2 
  int fill : QL_FILL_BITS;   
   // 首尾不压缩的节点数量
  unsigned int compress : QL_COMP_BITS;
  // 内存重分配时的书签数量及数组，一般用不到
  unsigned int bookmark_count: QL_BM_BITS;
  quicklistBookmark bookmarks[];
} quicklist;

QuickListNode源码：

typedef struct quicklistNode {
  // 前一个节点指针
  struct quicklistNode *prev;
  // 下一个节点指针
  struct quicklistNode *next;
  // 当前节点的ZipList指针
  unsigned char *zl;
  // 当前节点的ZipList的字节大小
  unsigned int sz;
  // 当前节点的ZipList的entry个数
  unsigned int count : 16;  
  // 编码方式：1，ZipList; 2，lzf压缩模式
  unsigned int encoding : 2;
  // 数据容器类型（预留）：1，其它；2，ZipList
  unsigned int container : 2;
  // 是否被解压缩。1：则说明被解压了，将来要重新压缩
  unsigned int recompress : 1;
  unsigned int attempted_compress : 1; //测试用
  unsigned int extra : 10; /*预留字段*/
} quicklistNode;

整体结构：

总结

QuickList的特点：
•是一个节点为ZipList的双端链表
•节点采用ZipList，解决了传统链表的内存占用问题（使用同样内存的指针，可以存储的节点数据更多）
•控制了ZipList大小，解决连续内存空间申请效率问题
•中间节点可以压缩，进一步节省了内存

skiplist

SkipList（跳表）首先是链表，但与传统链表相比有几点差异：
1.元素按照升序排列存储
2.节点可能包含多个指针，指针跨度不同。

zskiplist源码：

// t_zset.c

typedef struct zskiplist {
  // 头尾节点指针
  struct zskiplistNode *header, *tail;
  // 节点数量
  unsigned long length;
  // 最大的索引层级，默认是1
  int level;
} zskiplist;

zskiplistNode源码：

// t_zset.c

typedef struct zskiplistNode {
  sds ele; // 节点存储的值
  double score;// 节点分数，排序、查找用
  struct zskiplistNode *backward; // 前一个节点指针
  struct zskiplistLevel {
​    struct zskiplistNode *forward; // 下一个节点指针
​    unsigned long span; // 索引跨度
  } level[]; // 多级索引数组
} zskiplistNode;

整体结构：

链表指针backward是降序指向，多级的索引指针forward是升序指向

总结

SkipList的特点：
1.跳跃表是一个双向链表，每个节点都包含score和ele值
2.节点按照score值排序，score值一样则按照ele字典排序
3.每个节点都可以包含多层指针，层数是1到32之间的随机数
4.不同层指针到下一个节点的跨度不同，层级越高，跨度越大
5.增删改查效率与红黑树基本一致，实现却更简单

RedisObject

Redis中的任意数据类型的键和值都会被封装为一个RedisObject，也叫做Redis对象，源码如下：

当有很多数据时，不推荐使用String，因为一个RedisObject头部就要占用16字节，很多了占用内存就会很多。

Redis的编码方式

Redis中会根据存储的数据类型不同，选择不同的编码方式，共包含11种不同类型：

五种数据结构

Redis中会根据存储的数据类型不同，选择不同的编码方式。每种数据类型的使用的编码方式如下：

posted @   Helix_node  阅读(3)  评论(0)  编辑  收藏  举报
相关博文：
·  Redis复习-五种数据类型
·  Redis复习-通信协议、内存回收
·  Redis原理篇
·  Redis原理（一）： 数据结构
·  Redis 高级篇 Part 1
阅读排行：
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 单元测试从入门到精通
· 上周热点回顾（3.3-3.9）
· winform 绘制太阳，地球，月球 运作规律
点击右上角即可分享
微信分享提示