【Redis】字典
Redis 字典
基本语法
字典是Redis中的一种数据结构,底层使用哈希表实现,一个哈希表中可以存储多个键值对,它的语法如下,其中KEY为键,field和value为值(也是一个键值对):
HSET key field value
根据Key和field获取value:
HGET key field
哈希表
数据结构
dictht
dictht是哈希表的数据结构定义:
- table:哈希表数组,数组中的元素是dictEntry类型的
- size:哈希表数组的大小
- sizemask:哈希表大小掩码,一般等于size-1
- used:已有节点的数量(存储键值对的数量)
typedef struct dictht {
dictEntry **table;
unsigned long size;
unsigned long sizemask;
unsigned long used;
} dictht;
dictEntry
dictEntry是哈希表节点的结构定义:
- key:键值对中的键
- v:键值对中的值
- next:由于会出现哈希冲突,所以next是指向下一个节点的指针
typedef struct dictEntry {
void *key; // 键
union {
void *val;
uint64_t u64;
int64_t s64;
double d;
} v; // 值
struct dictEntry *next; // 指向下一个节点的指针
} dictEntry;
dict
dict是Redis中字典的结构定义:
- type:指向dictType的指针
- privdata
- ht[2]:一个dictht类型的数组,数组大小为2,保存了两个哈希表,rehash时使用
- rehashidx:记录了当前rehash的进度
- pauserehash:rehash暂停标记,大于0表示没有进行rehash
typedef struct dict {
dictType *type; //
void *privdata; // 私有数据
dictht ht[2]; // 保存了两个哈希表
long rehashidx; // rehash的进度标记
int16_t pauserehash;
} dict;
typedef struct dictType {
uint64_t (*hashFunction)(const void *key);
void *(*keyDup)(void *privdata, const void *key);
void *(*valDup)(void *privdata, const void *obj);
int (*keyCompare)(void *privdata, const void *key1, const void *key2);
void (*keyDestructor)(void *privdata, void *key);
void (*valDestructor)(void *privdata, void *obj);
int (*expandAllowed)(size_t moreMem, double usedRatio);
} dictType;
哈希冲突
一个键值对放入哈希表的时候,会根据key的值,计算一个hash值,然后根据hash值与哈希表大小掩码做与运算得到一个索引值,索引值决定元素放入哪个哈希桶中(落入哈希表数组哪个索引位置处)。
// 计算hash值
hash = dictHashKey(d,key)
// 计算索引
idx = hash & d->ht[table].sizemask;
在进行哈希计算的时候,不可避免会出现哈希冲突,出现哈希冲突的时候,Redis采用链式哈希解决冲突,也就是落入同一个桶中的元素,使用链表将这些冲突的元素链起来(dictEntry中的next指针)。
rehash
由于Redis采用链式哈希解决冲突,那么在冲突频繁的场景下,链表会变得越来越长,这种情况下查找效率是比较低下的,需要遍历链表对比KEY的值来获取数据,为了处理效率低下的问题,需要对哈希表进行扩容,扩容的过程称为rehash。
在dict结构替中ht保存了两个哈希表,ht[0]用于数据正常的增删改查,ht[1]用于rehash:
(1)正常情况下,所有的增删改查操作都在ht[0]中进行;
(2)需要进行rehash时,会使用ht[1]建立新的哈希表,并将ht[0]中的数据迁移到ht[1]中;
(3)迁移完成后,ht[0]的空间被释放,然后将ht[1]地址赋给ht[0],ht[1]的大小被设为0,ht[0]重新接收正常的请求,回到了第(1)步的状态;
rehash的触发条件
/* 判断是否需要扩容 */
static int _dictExpandIfNeeded(dict *d)
{
/* 如果已经处于rehash状态中直接返回 */
if (dictIsRehashing(d)) return DICT_OK;
/* 如果ht[0]的大小为0,意味着哈希表为空,此时做初始化操作 */
if (d->ht[0].size == 0) return dictExpand(d, DICT_HT_INITIAL_SIZE);
/*如果已经存储的节点数量大于或等于哈希表数组的大小,并且跨域扩容或者(节点数量/哈希表数组大小)大于一个比例,同时根据字典的类型判断是否允许分配内存*/
if (d->ht[0].used >= d->ht[0].size &&
(dict_can_resize ||
d->ht[0].used/d->ht[0].size > dict_force_resize_ratio) &&
dictTypeExpandAllowed(d))
{
// 进行扩容
return dictExpand(d, d->ht[0].used + 1);
}
return DICT_OK;
}
/* 由于扩容需要分配内存,这里检查字典类型分配是否被允许*/
static int dictTypeExpandAllowed(dict *d) {
if (d->type->expandAllowed == NULL) return 1;
return d->type->expandAllowed(
_dictNextPower(d->ht[0].used + 1) * sizeof(dictEntry*),
(double)d->ht[0].used / d->ht[0].size);
}
d->ht[0].used/d->ht[0].size : 节点数量与哈希表数组大小的比例,称作负载因子。
dict_force_resize_ratio 的默认值是 5。
- ht[0]的大小为0,此时哈希表是空的,相当于对哈希表做一个初始化的操作。
- 如果哈希表中存储的节点数量大于或者等于哈希表数组的大小,并且哈希表可以扩容或者负载因子大于dict_force_resize_ratio(默认值为5),根据字典的类型判断允许分配内存,满足这三个条件开始扩容。
dict_can_resize
dict_can_resize用来判断哈希表是否可以扩容,有两种状态,值分别为1和0,1代表可以扩容,0代表禁用扩容:
void dictEnableResize(void) {
dict_can_resize = 1;
}
void dictDisableResize(void) {
dict_can_resize = 0;
}
updateDictResizePolicy中对dict_can_resize的状态进行了控制,当前没有RDB子进程并且也没有AOF子进程时设置dict_can_resize状态为可扩容:
void updateDictResizePolicy(void) {
// 没有RDB子进程并且也没有AOF子进程
if (server.rdb_child_pid == -1 && server.aof_child_pid == -1)
dictEnableResize(); // 启用扩容
else
dictDisableResize(); // 禁用扩容
}
扩容大小
从代码中可以看到,扩容后哈希表数组的大小为已经存储的节点数量+1:
// 进行扩容
return dictExpand(d, d->ht[0].used + 1);
一些旧版本中扩容后的大小为已存储节点数量的2倍:
dictExpand(d, d->ht[0].used*2);
渐进式hash
当哈希表存储节点内容比较多时,需要将原来的节点一个一个拷贝到新的哈希表中,此时Redis主线程无法执行其他请求,造成阻塞,影响性能,为了解决这个问题,引入了渐进式hash。
渐进式hash并不会一次把旧节点全部拷贝到新的哈希表中,而是分多次渐进式的完成拷贝,其中rehashidx记录了迁移进度,每一次迁移的过程中会更新rehashidx的值,下一次进行数据迁移的时候,从rehashidx的位置开始迁移,在dictRehash中可以看到迁移的处理:
- 方法传入了一个参数n,代表本次需要迁移几个哈希桶
- 根据需要迁移哈希桶的数量,循环处理每一个哈希桶:
- 如果当前哈希桶中为空,继续下一个桶的处理rehashidx++
- 如果当前哈希桶不为空,将当前桶中的所有节点迁移到新的哈希表中,然后更新rehashidx的值继续处理下一个桶
- 如果已经处理够了n个桶,或者哈希表的所有数据已经迁移完毕,则结束迁移。
int dictRehash(dict *d, int n) {
int empty_visits = n*10; /* Max number of empty buckets to visit. */
if (!dictIsRehashing(d)) return 0;
// 循环处理每一个哈希桶,n为需要迁移哈希桶的数量
while(n-- && d->ht[0].used != 0) {
dictEntry *de, *nextde;
assert(d->ht[0].size > (unsigned long)d->rehashidx);
// 如果当前哈希桶没有存储数据
while(d->ht[0].table[d->rehashidx] == NULL) {
// rehashidx的值是哈希表数组的某个索引值(指向了某个哈希桶),意味着当前迁移到数组的哪个索引位置处
d->rehashidx++; // 继续下一个桶
if (--empty_visits == 0) return 1;
}
de = d->ht[0].table[d->rehashidx];
// 如果当前的哈希桶中存储着数据,将哈希桶存储的所有数据迁移到新的哈希表中
while(de) {
uint64_t h;
nextde = de->next;
/* Get the index in the new hash table */
h = dictHashKey(d, de->key) & d->ht[1].sizemask;
de->next = d->ht[1].table[h];
d->ht[1].table[h] = de;
d->ht[0].used--;
d->ht[1].used++;
de = nextde;
}
d->ht[0].table[d->rehashidx] = NULL;
// rehashidx,继续迁移下一个哈希桶
d->rehashidx++;
}
/* 判断ht[0]的节点是否迁移完成 */
if (d->ht[0].used == 0) {
// 释放ht[0]的空间
zfree(d->ht[0].table);
// 将ht[0]指向ht[1]
d->ht[0] = d->ht[1];
// 重置ht[1]的大小为0
_dictReset(&d->ht[1]);
// 设置rehashidx,-1代表rehash结束
d->rehashidx = -1;
return 0;
}
/* More to rehash... */
return 1;
}
_dictRehashStep
_dictRehashStep中可以看到调用dictRehash时,每次迁移哈希桶的数量为1:
static void _dictRehashStep(dict *d) {
if (d->pauserehash == 0) dictRehash(d,1);
}
总结
Redis字典底层使用哈希表实现。
键值对放入哈希表的时候,会根据key的值,计算hash值,出现哈希冲突的时候,Redis采用链式哈希解决冲突,使用链表将这些冲突的元素链起来。
由于Redis采用链式哈希解决冲突,那么在冲突频繁的场景下,链表会变得越来越长,这种情况下查找效率是比较低下的,需要遍历链表对比KEY的值来获取数据,为了处理效率低下的问题,需要对哈希表进行扩容,扩容的过程称为rehash。
当哈希表存储节点内容比较多时,进行rehas的时候主线程无法执行其他请求,造成阻塞,影响性能,所以采用了渐进式hash,渐进式hash并不会一次把旧节点全部拷贝到新的哈希表中,而是分多次渐进式的完成拷贝。
参考
黄健宏《Redis设计与实现》
Redis版本:redis-6.2.5
【Redis】字典的更多相关文章
- redis 字典
redis 字典 前言 借鉴了 黄健宏 的 <<Redis 设计与实现>> 一书, 对 redis 源码进行学习 欢迎大家给予意见, 互相沟通学习 概述 字典是一种用于存储键值 ...
- Redis 字典的实现
[Redis 字典的实现] 注意 dict 类型使用了两个指针,分别指向两个哈希表. 其中, 0 号哈希表(ht[0])是字典主要使用的哈希表, 而 1 号哈希表(ht[1])则只有在程序对 0 号哈 ...
- 阿里面试官:HashMap 熟悉吧?好的,那就来聊聊 Redis 字典吧!
最近,小黑哥的一个朋友出去面试,回来跟小黑哥抱怨,面试官不按套路出牌,直接打乱了他的节奏. 事情是这样的,前面面试问了几个 Java 的相关问题,我朋友回答还不错,接下来面试官就问了一句:看来 Jav ...
- Redis 字典结构细谈
Redis 字典底层基于哈希表实现. 一.哈希表结构 1.dictht: typedef struct dictht { dictEntry **table; //哈希表数组,存储具体的键值对元素,对 ...
- REDIS 字典数据结构
对于REDIS来讲 其实就是一个字典结构,key ---->value 就是一个典型的字典结构 [当然 对于vaule来讲的话,有不同的内存组织结构 这是后话] 试想一个这样的存储场景: ...
- redis字典的底层实现hashTable
Redis的字典使用哈希表作为底层实现.一个哈希表里面可以有多个哈希表节点,而每个哈希表节点就保存了字典中的一个键值对 哈希表的数据结构为 table属性是一个数组,数组中的每个元素都是指向dictE ...
- 《闲扯Redis七》Redis字典结构的底层实现
一.前言 上节<闲扯Redis六>Redis五种数据类型之Hash型 中说到 Hash(哈希对象)的底层实现有: 1.ziplist 编码的哈希对象使用压缩列表作为底层实现 2.hasht ...
- 《闲扯Redis八》Redis字典的哈希表执行Rehash过程分析
一.前言 随着操作的不断执行, 哈希表保存的键值对会逐渐地增多或者减少, 为了让哈希表的负载因子(load factor)维持在一个合理的范围之内, 当哈希表保存的键值对数量太多或者太少时, 程序需要 ...
- redis字典
字典作为一种保存键值对的数据结构,在redis中使用十分广泛,redis作为数据库本身底层就是通过字典实现的,对redis的增删改查实际上也是构建在字典之上. 一.字典的结构
- redis字典快速映射+hash釜底抽薪+渐进式rehash | redis为什么那么快
前言 相信你一定使用过新华字典吧!小时候不会读的字都是通过字典去查找的.在Redis中也存在相同功能叫做字典又称为符号表!是一种保存键值对的抽象数据结构 本篇仍然定位在[redis前传]系列中,因为本 ...
随机推荐
- Vmware虚拟机三种网络模式详解(转载)
原文来自http://note.youdao.com/share/web/file.html?id=236896997b6ffbaa8e0d92eacd13abbf&type=note 由于l ...
- 帝国CMS 给简介字段添加一键排版按钮
帝国CMS后台->管理数据表->选择数据表>打开smalltext字段输入表单替换html代码 添加如下代码: <script> function format() { ...
- Django中间件、csrf跨站请求、csrf装饰器、基于django中间件学习编程思想
django中间件 中间件介绍 什么是中间件? 官方的说法:中间件是一个用来处理Django的请求和响应的框架级别的钩子.它是一个轻量.低级别的插件系统,用于在全局范围内改变Django的输入和输出. ...
- [源码解析] TensorFlow 分布式 DistributedStrategy 之基础篇
[源码解析] TensorFlow 分布式 DistributedStrategy 之基础篇 目录 [源码解析] TensorFlow 分布式 DistributedStrategy 之基础篇 1. ...
- js 递归求1/2+1/4+1/6+....1/n的和,和1/1+1/3+1/5+.....+1/n的和
function fun1(n) { if (n == 2) { return 1 / 2; } if (n == 1) { ...
- Codeforces Round #133 (Div. 2), A.【据图推公式】 B.【思维+简单dfs】
Problem - 216A - Codeforces Problem - B - Codeforces A Tiling with Hexagons 题意: 给出a b c ,求里面有多少个六边形 ...
- 倒计时第3天!Google Summer of Code报名即将截止!(Casbin社区还有空缺名额)
Google Summer of Code 介绍 Google Summer of Code ( GSoC ,即 Google 编程之夏)是 Google (谷歌)组织并提供经费,面对全球在读学生的在 ...
- HMS Core 6.4.0版本发布公告
支持转化事件回传至华为应用市场商业推广,便捷归因,实时调优: 卸载分析新增卸载前路径分析,深度剖析卸载根因. 查看详情 新增关键帧能力,通过关键帧点可实现图片.文字等位置移动.旋转等动态效果,比如文字 ...
- Java基础语法Day_08(继承、抽象)
第1节 继承 day09_01_继承的概述 day09_02_继承的格式 day09_03_继承中成员变量的访问特点 day09_04_区分子类方法中重名的三种变量 day09_05_继承中成员方法的 ...
- HashSet与TreeSet的区别
HashSet元素唯一,无序,依靠hashcode(),toString()实现元素的唯一性 TreeSet元素唯一,有序,依靠bTo实现比较,即继承Comparable类并重写compareTo(O ...