揭秘Redis哈希表底层实现

已于 2024-08-23 13:45:31 修改
阅读量515 收藏 4
点赞数 6
分类专栏： 精通Redis 文章标签： 后端 redis
于 2024-08-23 13:44:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/newbietao/article/details/141463862
版权

前言

本文是 《Redis 数据结构》合集的第四篇文章，建议大家从第一篇文章开始阅读这样效果更好：

  1. 揭秘Redis对象底层实现

  2. 揭秘Redis字符串底层实现

  3. 揭秘Redis列表底层实现

  4. 揭秘Redis哈希表底层实现

  5. 揭秘Redis集合底层实现

  6. 机密Redis有序列表底层实现

哈希对象

哈希对象的编码可以是 ziplist 或者 hashtable 。

ziplist 编码

ziplist 编码的哈希对象使用压缩列表作为底层实现， 每当有新的键值对要加入到哈希对象时， 程序会先将保存了键的压缩列表节点推入到压缩列表表尾， 然后再将保存了值的压缩列表节点推入到压缩列表表尾， 因此：

  1. 保存了同一键值对的两个节点总是紧挨在一起， 保存键的节点在前， 保存值的节点在后；
  2. 先添加到哈希对象中的键值对会被放在压缩列表的表头方向， 而后来添加到哈希对象中的键值对会被放在压缩列表的表尾方向。
redis> HSET profile name "Tom"
(integer) 1
redis> HSET profile age 25
(integer) 1
redis> HSET profile career "Programmer"
(integer) 1

ziplist 编码的 hash 对象的内存布局如下：

ziplist 编码hash对象

在《揭秘Redis列表底层实现》中介绍过压缩列表，与列表对象中的压缩列表不同的是哈希对象的压缩列表是按 k->v->k-v 的方式连续的排列子压缩列表中：

压缩列表内存布局

hashtable 编码

hashtable 编码的哈希对象使用字典作为底层实现， 哈希对象中的每个键值对都使用一个字典键值对来保存：
字典的每个键都是一个字符串对象， 对象中保存了键值对的键；
字典的每个值都是一个字符串对象， 对象中保存了键值对的值。

hashtable 编码的哈希对象

编码转换

当哈希对象可以同时满足以下两个条件时， 哈希对象使用 ziplist 编码：

  1. 哈希对象保存的所有键值对的键和值的字符串长度都小于 64 字节；
  2. 哈希对象保存的键值对数量小于 512 个；

不能满足这两个条件的哈希对象需要使用 hashtable 编码。

# 哈希对象只包含一个键和值都不超过 64 个字节的键值对
redis> HSET blah greeting "hello world"
(integer) 1
redis> OBJECT ENCODING blah
"ziplist"
# 向哈希对象添加一个新的键值对，值的长度为 68 字节
redis> HSET blah story "many string ... many string ... many string ... many string ... many"
(integer) 1
# 编码已改变
redis> OBJECT ENCODING blah
"hashtable"

字典

字典在 Redis 中的应用相当广泛， 比如 Redis 的数据库就是使用字典来作为底层实现的， 对数据库的增、删、查、改操作也是构建在对字典的操作之上的。

除了用来表示数据库之外， 字典还是哈希键的底层实现之一： 当一个哈希键包含的键值对比较多， 又或者键值对中的元素都是比较长的字符串时， Redis 就会使用字典作为哈希键的底层实现。

在字典中， 一个键（key）可以和一个值（value）进行关联（或者说将键映射为值）， 这些关联的键和值就被称为键值对。

字典中的每个键都是独一无二的， 程序可以在字典中根据键查找与之关联的值， 或者通过键来更新值， 又或者根据键来删除整个键值对， 等等。

字典结构

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

type 属性和 privdata 属性是针对不同类型的键值对， 为创建多态字典而设置的。每个 dictType 结构保存了一簇用于操作特定类型键值对的函数， Redis 会为用途不同的字典设置不同的类型特定函数。

typedef struct dictType {
    // 计算哈希值的函数
    unsigned int (*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);
} dictType;
  • ht 属性是一个包含两个项的数组， 数组中的每个项都是一个 dictht 哈希表， 一般情况下， 字典只使用 ht[0] 哈希表， ht[1] 哈希表只会在对 ht[0] 哈希表进行 rehash 时使用。
  • 除了 ht[1] 之外， 另一个和 rehash 有关的属性就是 rehashidx ： 它记录了 rehash 目前的进度， 如果目前没有在进行 rehash ， 那么它的值为 -1 。

哈希表结构

typedef struct dictht {
    // 哈希表数组
    dictEntry **table;
    // 哈希表大小
    unsigned long size;
    // 哈希表大小掩码，用于计算索引值
    // 总是等于 size - 1
    unsigned long sizemask;
    // 该哈希表已有节点的数量
    unsigned long used;
} dictht;
  • table 属性是一个数组， 数组中的每个元素都是一个指向 dict.h/dictEntry 结构的指针， 每个 dictEntry 结构保存着一个键值对。
  • size 属性记录了哈希表的大小， 也即是 table 数组的大小， 而 used 属性则记录了哈希表目前已有节点（键值对）的数量。
  • sizemask 属性的值总是等于 size - 1 ， 这个属性和哈希值一起决定一个键应该被放到 table 数组的哪个索引上面。

哈希表节点结构

typedef struct dictEntry {
    // 键
    void *key;
    // 值
    union {
        void *val;
        uint64_t u64;
        int64_t s64;
    } v;
    // 指向下个哈希表节点，形成链表
    struct dictEntry *next;
} dictEntry;
  • key 属性保存着键值对中的键。
  • v 属性则保存着键值对中的值， 其中键值对的值可以是一个指针， 或者是一个 uint64_t 整数， 又或者是一个 int64_t 整数。
  • next 属性是指向另一个哈希表节点的指针， 这个指针可以将多个哈希值相同的键值对连接在一次， 以此来解决键冲突（collision）的问题。

普通状态下（没有进行 rehash）的字典：

哈希算法

计算索引

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

# 使用字典设置的哈希函数，计算键 key 的哈希值
hash = dict->type->hashFunction(key);

# 使用哈希表的 sizemask 属性和哈希值，计算出索引值
# 根据情况不同， ht[x] 可以是 ht[0] 或者 ht[1]
index = hash & dict->ht[x].sizemask;

哈希冲突

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

Redis 的哈希表使用链地址法（separate chaining）来解决键冲突： 每个哈希表节点都有一个 next 指针， 多个哈希表节点可以用 next 指针构成一个单向链表， 被分配到同一个索引上的多个节点可以用这个单向链表连接起来， 这就解决了键冲突的问题。

使用链表解决冲突

因为 dictEntry 节点组成的链表没有指向链表表尾的指针， 所以为了速度考虑， 程序总是将新节点添加到链表的表头位置（复杂度为 O(1)）， 排在其他已有节点的前面。

rehash

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

负载因子

# 负载因子 = 哈希表已保存节点数量 / 哈希表大小
load_factor = ht[0].used / ht[0].size

扩容与缩容

扩容条件

当以下条件中的任意一个被满足时， 程序会自动开始对哈希表执行扩展操作：

  • 服务器目前没有在执行 BGSAVE 命令或者 BGREWRITEAOF 命令， 并且哈希表的负载因子大于等于 1 ；
  • 服务器目前正在执行 BGSAVE 命令或者 BGREWRITEAOF 命令， 并且哈希表的负载因子大于等于 5 ；

执行 BGSAVE 命令或 BGREWRITEAOF 命令的过程中， Redis 需要创建当前服务器进程的子进程， 而大多数操作系统都采用写时复制（copy-on-write）技术来优化子进程的使用效率， 所以在子进程存在期间， 服务器会提高执行扩展操作所需的负载因子， 从而尽可能地避免在子进程存在期间进行哈希表扩展操作， 这可以避免不必要的内存写入操作， 最大限度地节约内存。

缩容条件

当哈希表的负载因子小于 0.1 时， 程序自动开始对哈希表执行收缩操作。

rehash过程

  1. 以及 ht[0] 当前包含的键值对数量 （也即是 ht[0].used 属性的值）：
    1. 如果执行的是扩展操作， 那么 ht[1] 的大小为第一个大于等于 ht[0].used * 2 的 2^n （2 的 n 次方幂）；
    2. 如果执行的是收缩操作， 那么 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] 里面， 但是， 这个 rehash 动作并不是一次性、集中式地完成的， 而是分多次、渐进式地完成的。

渐进式 rehash过程

以下是哈希表渐进式 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 的过程中， 字典会同时使用 ht[0] 和 ht[1] 两个哈希表， 所以在渐进式 rehash 进行期间， 字典的删除（delete）、查找（find）、更新（update）等操作会在两个哈希表上进行： 比如说， 要在字典里面查找一个键的话， 程序会先在 ht[0] 里面进行查找， 如果没找到的话， 就会继续到 ht[1] 里面进行查找， 诸如此类。

另外， 在渐进式 rehash 执行期间， 新添加到字典的键值对一律会被保存到 ht[1] 里面， 而 ht[0] 则不再进行任何添加操作： 这一措施保证了 ht[0] 包含的键值对数量会只减不增， 并随着 rehash 操作的执行而最终变成空表。

哈希对象源码

新建字典

/*
 * 创建一个新的字典
 * T = O(1)
 */
dict *dictCreate(dictType *type, void *privDataPtr)
{
    dict *d = zmalloc(sizeof(*d));
    _dictInit(d,type,privDataPtr);
    return d;
}

/*
 * 初始化哈希表
 * T = O(1)
 */
int _dictInit(dict *d, dictType *type, void *privDataPtr)
{
    // 初始化两个哈希表的各项属性值
    // 但暂时还不分配内存给哈希表数组
    _dictReset(&d->ht[0]);
    _dictReset(&d->ht[1]);

    // 设置类型特定函数
    d->type = type;
    // 设置私有数据
    d->privdata = privDataPtr;
    // 设置哈希表 rehash 状态
    d->rehashidx = -1;
    // 设置字典的安全迭代器数量
    d->iterators = 0;

    return DICT_OK;
}

/*
 * 重置（或初始化）给定哈希表的各项属性值
 * p.s. 上面的英文注释已经过期
 * T = O(1)
 */
static void _dictReset(dictht *ht)
{
    ht->table = NULL;
    ht->size = 0;
    ht->sizemask = 0;
    ht->used = 0;
}

新建hash表

/*
 * 根据需要，初始化字典（的哈希表），或者对字典（的现有哈希表）进行扩展
 *
 * T = O(N)
 */
static int _dictExpandIfNeeded(dict *d)
{
    /* Incremental rehashing already in progress. Return. */
    // 渐进式 rehash 已经在进行了，直接返回
    if (dictIsRehashing(d)) return DICT_OK;

    /* If the hash table is empty expand it to the initial size. */
    // 如果字典（的 0 号哈希表）为空，那么创建并返回初始化大小的 0 号哈希表
    // T = O(1)
    if (d->ht[0].size == 0) return dictExpand(d, DICT_HT_INITIAL_SIZE);

    /* If we reached the 1:1 ratio, and we are allowed to resize the hash
     * table (global setting) or we should avoid it but the ratio between
     * elements/buckets is over the "safe" threshold, we resize doubling
     * the number of buckets. */
    // 一下两个条件之一为真时，对字典进行扩展
    // 1）字典已使用节点数和字典大小之间的比率接近 1：1
    //    并且 dict_can_resize 为真
    // 2）已使用节点数和字典大小之间的比率超过 dict_force_resize_ratio
    if (d->ht[0].used >= d->ht[0].size &&
        (dict_can_resize ||
         d->ht[0].used/d->ht[0].size > dict_force_resize_ratio))
    {
        // 新哈希表的大小至少是目前已使用节点数的两倍
        // T = O(N)
        return dictExpand(d, d->ht[0].used*2);
    }

    return DICT_OK;
}

rehash

/* Performs N steps of incremental rehashing. Returns 1 if there are still
 *
 * 执行 N 步渐进式 rehash 。
 *
 * 返回 1 表示仍有键需要从 0 号哈希表移动到 1 号哈希表，
 * 返回 0 则表示所有键都已经迁移完毕。
 *
 * Note that a rehashing step consists in moving a bucket (that may have more
 * than one key as we use chaining) from the old to the new hash table.
 *
 * 注意，每步 rehash 都是以一个哈希表索引（桶）作为单位的，
 * 一个桶里可能会有多个节点，
 * 被 rehash 的桶里的所有节点都会被移动到新哈希表。
 *
 * T = O(N)
 */
int dictRehash(dict *d, int n) {

    // 只可以在 rehash 进行中时执行
    if (!dictIsRehashing(d)) return 0;

    // 进行 N 步迁移
    // T = O(N)
    while(n--) {
        dictEntry *de, *nextde;

        /* Check if we already rehashed the whole table... */
        // 如果 0 号哈希表为空，那么表示 rehash 执行完毕
        // T = O(1)
        if (d->ht[0].used == 0) {
            // 释放 0 号哈希表
            zfree(d->ht[0].table);
            // 将原来的 1 号哈希表设置为新的 0 号哈希表
            d->ht[0] = d->ht[1];
            // 重置旧的 1 号哈希表
            _dictReset(&d->ht[1]);
            // 关闭 rehash 标识
            d->rehashidx = -1;
            // 返回 0 ，向调用者表示 rehash 已经完成
            return 0;
        }

        /* Note that rehashidx can't overflow as we are sure there are more
         * elements because ht[0].used != 0 */
        // 确保 rehashidx 没有越界
        assert(d->ht[0].size > (unsigned)d->rehashidx);

        // 略过数组中为空的索引，找到下一个非空索引
        while(d->ht[0].table[d->rehashidx] == NULL) d->rehashidx++;

        // 指向该索引的链表表头节点
        de = d->ht[0].table[d->rehashidx];
        /* Move all the keys in this bucket from the old to the new hash HT */
        // 将链表中的所有节点迁移到新哈希表
        // T = O(1)
        while(de) {
            unsigned int 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;
        // 更新 rehash 索引
        d->rehashidx++;
    }

    return 1;
}

尝试将键插入到字典中

/*
 * 尝试将键插入到字典中
 *
 * 如果键已经在字典存在，那么返回 NULL
 *
 * 如果键不存在，那么程序创建新的哈希节点，
 * 将节点和键关联，并插入到字典，然后返回节点本身。
 *
 * T = O(N)
 */
dictEntry *dictAddRaw(dict *d, void *key)
{
    int index;
    dictEntry *entry;
    dictht *ht;

    // 如果条件允许的话，进行单步 rehash
    // T = O(1)
    if (dictIsRehashing(d)) _dictRehashStep(d);

    /* Get the index of the new element, or -1 if
     * the element already exists. */
    // 计算键在哈希表中的索引值
    // 如果值为 -1 ，那么表示键已经存在
    // T = O(N)
    if ((index = _dictKeyIndex(d, key)) == -1)
        return NULL;

    // T = O(1)
    /* Allocate the memory and store the new entry */
    // 如果字典正在 rehash ，那么将新键添加到 1 号哈希表
    // 否则，将新键添加到 0 号哈希表
    ht = dictIsRehashing(d) ? &d->ht[1] : &d->ht[0];
    // 为新节点分配空间
    entry = zmalloc(sizeof(*entry));
    // 将新节点插入到链表表头
    entry->next = ht->table[index];
    ht->table[index] = entry;
    // 更新哈希表已使用节点数量
    ht->used++;

    /* Set the hash entry fields. */
    // 设置新节点的键
    // T = O(1)
    dictSetKey(d, entry, key);

    return entry;
}
简单的土拨鼠
关注
  • 6
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
揭秘Redis底层：如何构建高性能内存数据库？
孤芳不自赏
04-21 683
大家好呀！小米在这里！今天要跟大家聊聊阿里巴巴面试题中备受关注的话题：Redis底层结构！Redis作为一款高性能的内存数据库，其底层设计承载着重要使命。让我们一起探索SDS数组、跳跃表、字典dict等核心结构，揭开Redis底层的神秘面纱吧！
redis面试题之底层实现.zip
04-18
在面试中，对Redis的底层实现深入理解是衡量候选人技术能力的重要标准。下面我们将详细探讨Redis的几个核心知识点。 1. 数据结构： Redis提供了多种数据结构，如字符串(String)、哈希(Hash)、列表(List)、集合(Set...
Redis数据结构与底层实现揭秘
码到三十五
01-24 1494
Redis通过精巧的数据结构和编码方式，实现了高性能的数据存储和操作。其底层实现不仅考虑了内存的使用效率，还充分考虑了数据操作的性能。这使得Redis能够在处理大量数据和并发请求时，依然保持出色的性能表现。对于开发者而言，理解Redis的数据结构和底层实现，有助于更好地使用和优化Redis，从而提升应用的整体性能。
揭秘Redis对象底层实现
newbietao的博客
08-15 676
Redis 会在初始化服务器时， 创建一万个字符串对象， 这些对象包含了从 0 到 9999 的所有整数值， 当服务器需要用到值为 0 到 9999 的字符串对象时， 服务器就会使用这些共享对象， 而不是新创建对象。Redis 使用对象来表示数据库中的键和值， 每次当我们在 Redis 的数据库中新创建一个键值对时， 我们至少会创建两个对象， 一个对象用作键值对的键（键对象）， 另一个对象用作键值对的值（值对象）。
Redis String 类型底层揭秘
擅长后端研发
02-27 1366
Redis 的 string 是个 “万金油” ，这么评价它不为过. 它可以保存int,float 甚至二进制也可以保存。对于key，value 这样的单值，查询以及插入都是O(1)时间复杂度。满脑子都是它的优点，真的就那么好吗？如果不了解它的底层结构，会有很多坑的，下面让我们细细说来。有这样一个需求，我们要开发一个图片存储系统，要求这个系统能快速地记录图片ID和图片在存储系统中保存的ID（图片存储对象ID）。同时还更够根据图片ID快速查询图片存储对象ID。
揭秘Redis列表底层实现
newbietao的博客
08-16 815
介绍了 Redis 数据结构中的列表对象，包括其编码方式、ziplist 和 linkedlist 两种实现方式，以及相关的 API 源码。
【Redis技术进阶之路】「底层源码解析」揭秘高效存储模型与数据结构底层实现（字典）
世界上并没有完美的程序，但是我们并不因此而沮丧，因为写程序就是一个不断追求完美的过程。
06-20 1092
随着数据需求的迅猛增长，持久化和数据查询技术的重要性日益凸显。关系型数据库已不再是唯一选择，数据的处理方式正变得日益多样化。在众多新兴的解决方案与工具中，Redis凭借其独特的优势脱颖而出。
揭秘Redis的“隐藏武器”：跳跃表的原理与应用
sinner小屋
08-07 714
跳跃表（SkipList）是一种有序数据结构，它在不同的层级上维护了多个指针，这些指针指向数据结构的节点。通过这些多级索引，跳跃表可以实现快速的数据插入、删除和查找操作。跳跃表在每一层级的索引中，数据节点以有序的方式排列，这样在查找时可以从最高层级快速定位到目标数据的大致位置，然后逐级下降，直到找到目标节点。跳跃表是Redis能够高效处理有序集合的关键数据结构。它为Redis提供了快速的数据插入、删除和查找操作，这对于实现实时排行榜、有序消息队列等应用至关重要。
追求性能极致 - Redis：Bitmap实现亿万级数据计算
smart_an的专栏
04-26 595
我们在第一篇深刻理解高性能Redis的本质动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODING_SKIPLIST)哈希表(REDIS_HASH)整数集合(REDIS_ENCODING_INTSET)
redis stream持久化_一文深度揭秘Redis的磁盘持久化机制
weixin_42355400的博客
12-24 295
前言Redis 是内存数据库，数据都是存储在内存中，为了避免进程退出导致数据的永久丢失，需要定期将 Redis 中的数据以数据或命令的形式从内存保存到本地磁盘。当下次 Redis 重启时，利用持久化文件进行数据恢复。Redis 提供了 RDB 和 AOF 两种持久化机制，前者将当前的数据保存到磁盘，后者则是将每次执行的写命令保存到磁盘(类似于 MySQL 的 Binlog)。本文将详细介绍 RDB...
Redis 哈希(Hash)
12-16
Redis哈希(Hash)是Redis数据结构中的一种，它是一个字符串类型的字段(field)与值(value)的映射表。这个特性使得哈希非常适合用来存储和操作复杂的数据对象，如用户资料、配置信息等，其中每个字段代表一个属性，对应...
哈希表哈希表哈希表.zip
05-29
哈希表广泛应用于数据库系统、编译器的符号表、缓存系统（如Redis）、字符串查找算法（如Rabin-Karp字符串匹配算法）等领域。在实际应用中，为了提高性能，哈希表通常会预先设定一个较大的容量，并在负载因子（已...
redis哈希类型_动力节点Java学院整理
09-09
主要介绍了redis哈希类型的常用方法及原理浅析，感兴趣的朋友一起看看吧
redis哈希和集合_动力节点Java学院整理
09-09
在Redis中，哈希（Hash）和集合（Set）是两种重要的数据结构，它们各自有独特的特性和用途。 **哈希（Hash）** 哈希是一种将键（Key）映射到值（Value）的数据结构，特别适合存储对象。在Redis中，哈希是由字符串...
aspose-words中插入附件及遇到的问题
ZT的专栏
08-19 414
前端使用tinymce编辑一段内容，后端使用aspose-words将html转为word，并将html中的附件转换为word中的附件。使用正则表达式找出需要替换的附件位置，然后再使用aspose-words替换为附件。使用2.3K大小的ico，操作成功并正常显示。aspose-words版本：21.1。
开发一个免费的图表网站 Free Charts
柠檬说葡萄你好酸
08-22 233
最近在使用图表网站时，发现许多都需要收费，因此萌生了自己做一个免费图表网站的想法。经过两三周的努力，完成了一个图表网站。除了vue，其他的技术都是第一次用，现学现卖。不仅给自己做一个，也准备给大家做一个！
【人工智能】使用NLP进行语音到文本的转换和主题的提取项目实践及案例分析一
weixin_51306394的博客
08-19 1278
本项目旨在构建一个完整的语音到文本转换系统，并进一步从转换后的文本中提取主题。这涉及到自然语言处理（NLP）的多个关键技术，包括语音识别（ASR, Automatic Speech Recognition）、文本处理、以及主题建模
Java CORS：跨越资源边界，探索跨域资源共享的无限可能
最新发布
qq_44771627的博客
08-22 607
随着前端技术的飞速发展，越来越多的应用程序开始使用多种不同的后端服务。这些服务往往部署在不同的域上，这就引发了**跨域访问**的问题。CORS作为一种解决跨域问题的有效机制，对于现代Web开发至关重要。本文将详细介绍如何在Java环境中配置和使用CORS，帮助你轻松应对跨域访问带来的挑战。
redis 哈希散列 实现原理
11-15
Redis中的哈希散列是通过哈希算法将键映射到哈希表中的桶(bucket)或槽(slot)中的。Redis集群中内置了16384个哈希槽，当需要在Redis集群中放置一个key-value时，Redis先对key使用crc16算法算出一个结果，然后把结果对16384取模，这样每个key都会对应一个编号在0-16383之间的哈希槽，Redis会根据节点数量大致均等的将哈希槽映射到不同的节点。这样，每个节点就负责一部分哈希槽，每个哈希槽也只会被分配到一个节点上，从而实现了分布式存储和负载均衡。 除了一致性哈希算法，Redis还支持其他的哈希算法，如MurmurHash2、MurmurHash64A等。这些哈希算法都有自己的特点和适用场景，可以根据实际情况进行选择。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值