Redis源码学习:高性能Hash表的设计与实现

Redis的数据结构——Hash表 Redis的Hash表数据结构详解 阅读详情

哈希表(Hash)是Redis数据库的数据类型之一,理解哈希表的实现对于掌握Redis非常重要。这篇文章,从哈希冲突和哈希扩展这两个角度,来一步步讲解Redis哈希表的工作原理。

什么是哈希表?

哈希表是一种通过哈希函数将键映射到值的数据结构。简单来说,就是通过一个计算公式(哈希函数)把一个键(比如一个名字)转换成一个数组的索引,数组中的每一个元素就是一个哈希桶(也叫bucket),然后在这个索引位置存储对应的值(比如电话号码)。这样我们就能以O(1)的时间复杂度通过键快速找到对应的值。

哈希冲突

哈希冲突是什么?

当键的数量超过数组的大小,必然会出现两个不同的键通过哈希函数映射到数组的同一个位置时,就发生了哈希冲突。举个例子,如果我们把“Tom”和“Jerry”这两个名字通过同一个公式转换成同一个数组位置,这时候就会有冲突。

如何解决哈希冲突?

Redis使用链式哈希来解决这个问题。链式哈希的意思是,每个bucket不再只存一个值,而是变成一个链表的头指针。如果有冲突,新来的键值对就插到链表头中。这样,同一个位置上可以存多个键值对。

Redis中的链式哈希

在Redis使用链式哈希解决哈希冲突,每个bucket指向一个链表,源码(位于dict.h文件)如下:

// 哈希表的定义
typedef struct dictht {
	// 哈希项数组,保存指向哈希项的指针
    dictEntry **table;
    // 哈希表的大小
    unsigned long size;
    // 哈希表小的掩码,总是等于 size -1 
    unsigned long sizemask;
    // 哈希项的数量,因为有哈希冲突的存在,used可能会比size大
    unsigned long used;
} dictht;

// 哈希项的定义
typedef struct dictEntry {
    void *key;  // 键
    union {
        void *val;
        uint64_t u64;
        int64_t s64;
        double d;
    } v;  // 值
    struct dictEntry *next;  // 指向下一个条目的指针(用于链式哈希)
} dictEntry;

每个dictEntry结构包含一个键key,一个值v,以及一个指向下一个条目的指针next。

联合体v是一个四选一的类型,包含了指向实际值的指针 val,还包含了无符号的 64 位整数、有符号的 64 位整数,以及 double 类的值。这是一种节省内存的设计。当值为整数或双精度浮点数时,由于其本身就是 64 位,就可以不用指针指向了,而是可以直接存在键值对的结构体中,这样就避免了再用一个指针,从而节省了内存空间。

插入键值对时,如果发生冲突,新条目将插入到链表的头部。采用头插法的好处就是性能高,不需要遍历链表了。

dictEntry *dictAddRaw(dict *d, void *key, dictEntry **existing) {
    // 进行rehash检查
    if (dictIsRehashing(d)) _dictRehashStep(d);

    unsigned long idx = dictHashKey(d, key) & ht->sizemask;
    dictEntry *entry = ht->table[idx];
    while (entry) {
        if (dictCompareKeys(d, key, entry->key)) {
            if (existing) *existing = entry;
            return NULL;
        }
        entry = entry->next;
    }

    entry = zmalloc(sizeof(*entry));
    entry->next = ht->table[idx];
    ht->table[idx] = entry;
    ht->used++;
    dictSetKey(d, entry, key);
    return entry;
}

哈希扩展

为什么需要哈希扩展?

随着哈希表中存储的键值对越来越多,哈希冲突变得越来越频繁,哈希表的效率会降低。为了保持高效的性能,需要在恰当的扩展哈希表,也就是增加哈希表的大小。这个过程称为哈希扩展或rehash。

渐进式rehash

Redis采用渐进式rehash策略,以避免扩展过程中阻塞数据库的正常操作。也就是说,Redis不会一次性把所有数据搬到新的哈希表中,而是分多次慢慢进行,每次只处理一个bucket数据。

rehash的实现

Redis在dict结构中,定义了两个哈希表,用于 rehash 时交替保存数据。

typedef struct dict {
    dictType *type;
    void *privdata;
    dictht ht[2]; //两个Hash表,交替使用,用于rehash操作
    long rehashidx; //Hash表是否在进行rehash的标识,-1表示没有进行rehash
    int16_t pauserehash; /* If >0 rehashing is paused (<0 indicates coding error) */
} dict;

每次rehash只处理一个bucket的链表,这样就不会长时间阻塞数据库的其他操作。调用dictRehash函数,传入的参数n始终为1,这样一来,每次迁移完一个bucket,哈希表就会执行正常的增删查请求操作,这就是在代码层面实现渐进式 rehash 的方法。

以下是相关的源码片段:

void _dictRehashStep(dict *d) {
    if (d->iterators == 0) dictRehash(d, 1);
}

int dictRehash(dict *d, int n) {
    if (!dictIsRehashing(d)) return 0;

    while (n--) {
        dictEntry *de, *nextde;

		/* 如果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]);
            /* 值改完1,表示rehash结束 */
            d->rehashidx = -1;
            /* 返回0,表示ht[0]中所有元素都迁移完成 */
            return 0;
        }

		/* 当前正在迁移的桶*/
        while (d->ht[0].table[d->rehashidx] == NULL) d->rehashidx++;
	    /* 哈希表中的哈希项 */
        de = d->ht[0].table[d->rehashidx];
        while (de) {
            unsigned long h;
			/* 获得下一个哈希项 */
            nextde = de->next;
            /* 当前哈希项在ht[1]的位置 */
            h = dictHashKey(d, de->key) & d->ht[1].sizemask;
            /* 添加到ht[1]中 */
            de->next = d->ht[1].table[h];
            d->ht[1].table[h] = de;
	        /* 减少ht[0]中的哈希项 */
            d->ht[0].used--;
            /* 增加ht[1]中的哈希项*/
            d->ht[1].used++;
            /* 指向下一个哈希项 */
            de = nextde;
        }
        /* 如果当前bucket中已经没有哈希项了,将该bucket置为NULL */
        d->ht[0].table[d->rehashidx] = NULL;
        /* 将rehash加1,下一次将迁移下一个bucket中的元素 */
        d->rehashidx++;
    }

	/* 返回1,表示ht[0]中仍然有元素没有迁移 */
    return 1;
}
什么时候触发rehash

Redis中在每次的增删查中都会判断是否需要扩容,在函数_dictExpandIfNeeded中检查负载因子(LoadFactor=used/size),只要满足以下任意一个条件就会触发哈希表扩容:

  • 哈希表的LoadFactor>=1,并且服务器没有执行SAVE或REWRITEAOF等子进程
  • 哈希表的LoadFactor>5
static int _dictExpandIfNeeded(dict *d)
{
    /* Incremental rehashing already in progress. Return. */
    if (dictIsRehashing(d)) return DICT_OK;

    /* 如果哈希表为空,则进行初始化为4. */
    if (d->ht[0].size == 0) return dictExpand(d, DICT_HT_INITIAL_SIZE);
    if (!dictTypeExpandAllowed(d))
        return DICT_OK;
    if ((dict_can_resize == DICT_RESIZE_ENABLE &&
         d->ht[0].used >= d->ht[0].size) ||
        (dict_can_resize != DICT_RESIZE_FORBID &&
         d->ht[0].used / d->ht[0].size > dict_force_resize_ratio))
    {
	    /* 扩容大小为used + 1, 底层会对扩容的大小做判断,实际上找的是第一个大于等于used+1的2倍 */
        return dictExpand(d, d->ht[0].used + 1);
    }
    return DICT_OK;
}
rehash扩容大小

通过函数_dictExpand对哈希表进行扩容,每次扩容大小总是2的幂,看下内部的 _dictNextPower函数源码:

static unsigned long _dictNextPower(unsigned long size)
{
	/* 哈希表的初始大小 */
    unsigned long i = DICT_HT_INITIAL_SIZE;
	/* 如果要扩容的大小已经超过了最大值,则返回最大值加1*/
    if (size >= LONG_MAX) return LONG_MAX + 1LU;
    /* 要扩容的大小没有超过最大值 */
    while(1) {
	    /* 从DICT_HT_INITIAL_SIZE(通常是4)开始,不断将i乘以2,直到 i 大于等于size */
        if (i >= size)
            return i;
        i *= 2;
    }
}

总结

通过链式哈希,Redis有效地解决了哈希冲突的问题;通过渐进式rehash,Redis确保了哈希表扩展时的高效性和稳定性。这些机制让Redis哈希表在处理大量数据时仍然保持高效。

参考资料

Redis底层数据结构---hash表 Redis的哈希表—rehash详细讲解   Redis的性能优越,应用普遍,可以存储的键值个数大到上亿条记录,依然保持较高的效率。作为一个内存数据库,Redis内部采用了字典(哈希表)的数据结构实现了键值对的存储。随着数据量的不断增加,数据必然会产生hash碰撞,而Redis采用链地址法解决hash冲突。我们知道如果哈希表数据量达到了一个很大的量级,那么冲突的链的元素数量就会很大,这时查询效率就... 阅读详情

相关推荐

深度图解 Redis Hash(散列表)实现原理

指向下一个节点指针,当散列表数据增加,可能会出现不同的 key 得到的哈希值相等,也就是说多个 key 对应在一个哈希桶里面,这就是哈希冲突。在 rehash 期间,服务端每次处理客户端对 dict 散列表执行添加、查找、删除或者更新操作时,除了执行指定操作以外,还会检查当前 dict 是否处于 rehash 状态,是的话就把散列表。是不是很贴心,既能保证性能,又能避免内存浪费。,存放函数的结构体,定义了一些函数指针,可以通过设置自定义函数,实现 dict 的 key 和 value 存放任何类型的数据。

m0_71777195的博客 340

吃透Redis(一):数据结构篇-全局Hash表

通过源码分析Redis的全局Hash表,dictEntry源码,RedisObject源码,SDS、Hash表扩容、渐进式reHash等原理

吃透Java 3310

Redis数据库的哈希表实现原理

本文旨在深入解析Redis中哈希表(Hash Table)的实现原理,包括其数据结构设计、操作算法、性能优化策略等核心内容。我们将从基础概念出发,逐步深入到Redis特有的实现细节和优化技术。本文首先介绍Redis哈希表的基本概念和背景,然后详细解析其实现原理,包括数据结构、核心算法和数学原理。接着通过实际代码分析展示具体实现,讨论应用场景和优化策略,最后总结未来发展趋势。哈希表(Hash Table): 一种通过哈希函数将键映射到值的数据结构字典(Dict): Redis中对哈希表的抽象和封装。

2502_91592937的博客 812

【Redis】深入探索 Redis 的数据类型 —— 哈希表 Hash

在构建和优化应用程序时,数据缓存是提高性能和降低数据库负载的关键策略之一。Redis(Remote Dictionary Server)是一个高性能的内存数据库,广泛用于数据缓存和快速数据访问。其中,哈希类型(Hash)是 Redis 中的一种强大数据结构,通常用于存储对象、映射关系和键值对等数据。在本文中,我们将深入探讨Redis中的哈希类型。我们将从哈希类型的基本命令入手,逐步介绍它们的使用方法、内部编码方式以及在实际应用场景中的应用。

qq_61635026的博客 2675

因时机器人-灵巧手配置方案(Ubuntu18.04)

因时机器人-灵巧手配置方案(Ubuntu18.04)

CH_monsy的博客 3858

为什么你的Mac蓝牙总断连?深入解析硬件干扰与系统设置避坑

本文深入解析Mac蓝牙频繁断连的原因,包括硬件干扰(如WiFi同频干扰、USB设备电磁干扰)和系统设置问题,并提供详细的优化方案和诊断工具(如blueutil)使用指南,帮助用户有效解决蓝牙稳定性问题。

ik67890123的博客 683

如何实现一个性能优异的Hash表?

实际上,一个最简单的Hash表就是一个数组,数组里的每个元素是一个哈希桶(也叫做Bucket),第一个数组元素被编为哈希桶0,以此类推。当一个键值对的键经过Hash函数计算后,再对数组元素个数取模,就能得到该键值对对应的数组元素位置,也就是第几个哈希桶。如下图所示,key1经过哈希计算和哈希值取模后,就对应哈希桶1,类似的,key3和key16分别对应哈希桶7和桶4。

qq_33240556的博客 970

软件测试面试题汇总

软件测试面试题汇总 测试技术面试题 ........................................................................................................................................................................ 5 1、什么是兼容

晴天的专栏 2万+

透过Redis源码探究Hash表的实现,你学废了吗?

我们在学习 Redis 的 Hash 表的时候难免脑子里会想起其他 Hash 表的实现,然后进行一番对比。通常我们如果要设计一个 Hash 表,那么我们需要考虑这几个问题:

wdj_yyds的博客 716

拆解歌尔2718硅麦:2.75mm超小封装背后的MEMS技术解析

本文深度解析歌尔2718硅麦的2.75mm超小封装技术,探讨MEMS麦克风在微型化过程中的声学性能与结构可靠性平衡。通过ASIC芯片堆叠、纳米级应力控制等创新技术,歌尔2718在TWS耳机和智能手机中实现卓越性能,同时克服微型化带来的声学挑战。

weixin_28292761的博客 612

Altium Designer(AD24/25)PCB编辑的几种方法介绍

本文介绍了Altium Designer(AD24/25)软件中PCB编辑的四种操作方法:1)通过菜单栏"Place→Component"激活;2)点击工具栏元器件图标;3)右键快捷菜单选择;4)快捷键P+C组合操作。建议初学者先通过菜单栏和快捷菜单熟悉操作,熟练后转为工具栏和快捷键以提高效率。文章配有操作示意图,帮助用户快速掌握PCB元器件放置技巧。

fydar的博客 947

Redis源码---如何实现一个性能优异的Hash表

Redis源码---如何实现一个性能优异的Hash表

汤键的博客 803

24、无人机能耗模型与上下文质量管理的研究

本文系统介绍了无人机能耗模型与上下文质量管理的研究进展。详细阐述了Dorling、Stolaroff、Kirchstein和Tseng等经典能耗模型的原理及特点,并基于LSTM架构构建了数据驱动的能耗预测模型,实验表明其预测精度显著优于传统模型。此外,还探讨了物联网环境中的上下文质量管理问题,引入了conQeng框架,以提升上下文选择、测量和验证的效率与可靠性。研究为无人机能耗优化和物联网上下文管理提供了理论支持和技术方案。

palm99的专栏 345

透过Redis源码探究Hash表的实现!

我们在学习 Redis 的 Hash 表的时候难免脑子里会想起其他 Hash 表的实现,然后进行一番对比。通常我们如果要设计一个 Hash 表,那么我们需要考虑这几个问题: 有没有并发操作; Hash冲突如何解决; 以什么样的方式扩容。

wdj_yyds的博客 582

双重分组进位跳跃进位链

跳跃进位链

qq_62260432的博客 942

【异常】Python环境中没有安装 `openpyxl` 模块提示ModuleNotFoundError: No module named ‘openpyxl‘

是一个用于读写Excel 2010 xlsx/xlsm/xltx/xltm文件的库。只是示例版本号,你可以根据需要选择不同的版本。安装完成后,再次尝试运行你的程序,应该就不会再出现。,这表明你的Python环境中缺少。运行一个Python程序时遇到了。如果由于某些原因你无法直接使用。,你可以指定版本号来安装,这里。要解决这个问题,你需要安装。

奶爸的编程之路,也就一周冷个三天 3399

学习Redis源码路径

学习 Redis 源码并剖析其技术栈是一个深入理解分布式系统、高性能网络编程和内存管理的绝佳途径。Redis 虽然代码量不大(约 10 万行 C 代码),但设计精妙,涵盖了事件驱动、内存管理、数据结构、持久化、集群协议等多个核心系统技术。

ZachLi的博客 1187

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

Redis100篇 - Redis的哈希表为什么快 扩容和缩容机制详解

Redis哈希表高效的关键在于其精心设计的底层结构、渐进式rehash机制和负载因子控制。哈希表使用链地址法解决冲突,并通过SipHash算法保证均匀分布。当负载因子超过阈值时,Redis会触发渐进式扩容/缩容,分步迁移数据到新哈希表,避免服务中断。核心优化包括:快速索引计算(位运算替代取模)、双哈希表设计(实现平滑rehash)以及动态调整大小(2的幂次扩容)。这些特性共同确保了Redis哈希表在O(1)时间复杂度下的稳定性能。

千淘万漉虽辛苦,吹尽狂沙始到金 2万+

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

Redis Hash:高效结构化数据存储与操作

在当今大数据时代,Redis作为一款高性能的内存数据库,被广泛应用于缓存、消息队列等领域。其中,Redis的Hash类型作为一种数据结构,以其独特的优势在数据处理中扮演着重要角色。本文将围绕Redis知识点之Hash:概述展开,深入探讨其概念、特点和应用场景。在实际应用中,我们常常会遇到需要存储大量键值对的情况,如用户信息、商品信息等。传统的键值对存储方式在处理这类数据时,往往需要频繁地查询和更新,导致性能低下。而Redis的Hash类型能够将多个键值对存储在一个键下,极大地提高了数据存储和查询的效率。

我是Java程序员廖志伟,感谢朋友们的支持! 1152

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

提升 C++ 编程代码质量和学习 Redis 源码的关系

提升 C++ 编程代码质量和学习 Redis 源码是可行的,但需要结合科学的方法和明确的侧重点。Redis 虽然主要用 C 语言编写(部分模块用 C++),但其设计思想(如高性能、内存管理、并发控制)对 C++ 开发者仍有巨大价值。

ZachLi的博客 630

Java开发者必读:Redis哈希表实现与优化解析

哈希表作为基础数据结构,在Java中以HashMap形式广泛使用,其核心原理是通过哈希函数将键映射到数组索引。Redis作为高性能内存数据库,其哈希表实现采用渐进式rehash和SipHash算法等优化策略,有效解决了传统哈希表在扩容时的性能抖动问题。通过分析Redis的dict.c源码,可以发现其设计在哈希冲突处理、内存管理和并发控制等方面具有独特优势。这些优化技术对Java开发者构建高并发缓存系统、实现分布式路由等场景具有重要参考价值,特别是在处理大数据量和高性能要求的应用时,能够显著提升系统稳定性。

weixin_33326218的博客 244
上一篇: Redis源码学习:SDS设计与内存管理
下一篇: Redis源码学习:跳表(Skip List)的工作原理详解
我是DL
博客等级 码龄10年 509粉丝 93原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我是DL

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值