[Redis]数据结构与对象

最新推荐文章于 2022-12-02 17:27:55 发布
最新推荐文章于 2022-12-02 17:27:55 发布
阅读量335 收藏 2
点赞数 1
分类专栏： Redis 学习总结 文章标签： redis 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013161278/article/details/113116331
版权

[Redis]数据结构与对象


源码基于redis-3.0

1. 简单动态字符串

简介

简单动态字符串，即SDS（Simple Dynamic String），它是Redis中实现底层字符串相关数据结构的基础，它在C语言的字符串基础上进行抽象构建。

数据结构

在这里插入图片描述
在源码中，sds.h/sdshdr 表示一个最基本的SDS的组成，如下

struct sdshdr {
    // 记录buf数组中已使用字节的数量
    // 等于SDS所保存字符串的长度
    int len;
    // 记录buf数组中未使用字节的数量
    int free;
    // 字节数组，用于保存字符串
    char buf[];
};

char buf[] 这里使用的是柔性数组，好处如下：

  • 倘若使用指针即char *buf，分配内存需要量两个步骤：一次分配结构体，一次分配char *buf，在释放内存的时候也需要释放两次内存：一次为char *buf，一次为结构体内存。而用长度为 0 的字符数组可以将分配和释放内存的次数都降低为 1 次，从而简化内存管理
  • 长度为 0 的数组即char buf[]不占用内存，节省内存空间
// char buf[] 的情况
struct sdshdr s;
printf("%d",sizeof(s));
// 8
// char *buf 的情况
struct sdshdr s;
printf("%d",sizeof(s));
// 12
  • 便于SDS统计len、size，时间复杂度为O(1)
// 返回sdshdr.len
static inline size_t sdslen(const sds s) {
    struct sdshdr *sh = (void*)(s-(sizeof(struct sdshdr)));
    return sh->len;
}
// 返回sdshdr.free
static inline size_t sdsavail(const sds s) {
    struct sdshdr *sh = (void*)(s-(sizeof(struct sdshdr)));
    return sh->free;
}

特点

SDS兼容一部分C语言函数

SDS遵循C字符串以空字符结尾的惯例，保存空字符的1字节空间不计算在SDS的len属性里面，并且为空字符分配额外的1字节空间，以及添加空字符到字符串末尾等操作，都是由SDS函数自动完成的，所以这个空字符对于SDS的使用者来说是完全透明的。遵循空字符结尾这一惯例的好处是，SDS可以直接重用一部分C字符串函数库里面的函数。

SDS属性len的作用

  • C语言中没有记录字符长度自身信息，字符串长度需要从头到尾遍历，时间复杂度是O(n)，Redis中增加len属性来记录字符串长度，时间复杂度降低为O(1)，记录操作有SDS内部提供实现。
  • 由于记录了字符串长度，也在一些字符串操作过程中避免了内存溢出问题

SDS减少了字符串变更时内存空间重分配

字符串的变更会频繁调用系统底层方法来进行内存空间变更，SDS通过未使用空间实现了空间预分配和惰性释放两种优化策略，避免了内存空间频繁变更带来的性能消耗。

预占空间

在这里插入图片描述

预占空间策略是，当已使用空间（len）小于1MB时，预占空间大小为已使用空间同等大小的空间进行预占；当已使用空间（len）大于等于1MB时，预占空间大小恒为1MB。通过这种预分配策略，SDS将连续增长N次字符串所需的内存重分配次数从必定N次降低为最多N次。

已使用空间分配判断条件分配未使用空间占用总空间
5B是否大于等于1MB5B5B(len) + 5B(free) + 1B(预占)
2MB是否大于等于1MB1MB2MB(len) + 1MB(free) + 1B(预占)
惰性释放

在这里插入图片描述
惰性空间释放用于优化SDS的字符串缩短操作：当SDS的API需要缩短SDS保存的字符串时，程序并不立即使用内存重分配来回收缩短后多出来的字节，而是使用属性free将这些字节的数量记录起来，并等待将来使用。

总结，无论是提前预分配空间还是惰性释放空间，必然会占用更多的额外空间，这里可以理解是以空间换时间的思想。

SDS保证文本二进制安全

在这里插入图片描述
所谓 二进制安全是一种主要用于字符串操作函数相关的计算机编程术语。一个二进制安全功能（函数），其本质上将操作输入作为原始的、无任何特殊格式意义的数据流。对于每个字符都公平对待，不特殊处理某一个字符。说白了，就是程序不会对其中的数据做任何限制、过滤、或者假设，数据在写入时是什么样的，它被读取时就是什么样。

Redis通过buf数组存储字符，读取数组长度是通过len属性，而不是C语言那样通过’\0’ 字符，因此对于特殊字符解析不会出现问题，是二进制安全的。

2. 链表

简介

链表提供了高效的节点重排能力，以及顺序性的节点访问方式，并且可以通过增删节点来灵活地调整链表的长度。C语言并没有内置这种数据结构，Redis提供了双端链表的实现。

数据结构

在这里插入图片描述
在源码中，adlist.h/listNode 表示一个最基本的链表的组成，如下

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

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

特点

  • 双端 链表节点带有prev和next指针，获取某个节点的前置节点和后置节点的时间复杂度是O(1)
  • 无环 表头节点的prev指针和表尾节点的next指针都指向null，对链表的访问以NULL为终点
  • 带表头指针和表尾指针 通过list结构的head指针和tail指针获取链表的表头节点和表尾节点，时间复杂度是O(1)
  • 带链表长度计数器 使用list结构的len属性来对list持有的链表节点进行计数，获取链表长度的时间复杂度是O(1)
  • 多态 支持保存不同类型的值

使用场景

List列表键、发布&订阅、监视器、慢查询

3. 字典

简介

字典，是用来保存键值对（Kev-Value）类型数据的抽象数据结构。C语言并没有内置上线这种数据结构，Redis提供了实现支持。字典中的每个键（Key）都是独一无二的，程序可以在字典中根据键查找与之关联的值，或者通过键来更新值，又或者根据键来删除整个键值对，等等

数据结构

在这里插入图片描述
Redis字典所使用的哈希表由dict.h/dictht结构定义

/*
 * 字典
 */
typedef struct dict {
    // 类型特定函数
    dictType *type;
    // 私有数据
    void *privdata;
    // 哈希表
    dictht ht[2];
    // rehash索引; 当rehash 不在进行时，值为-1
    in rehashidx; 
} dict;
  • type 支持多态存储特定数据类型
  • privdata 保存需要传给那些类型特定函数的可选参数
  • ht 字典持有两个哈希表dictht，ht[0]用来存储数据，ht[1]在rehash时使用
  • rehashindx 标记当前是否正在进行rehash，值为-1时没有进行rehash
/*
 * 哈希表
 *
 * 每个字典都使用两个哈希表，从而实现渐进式 rehash 。
 */
typedef struct dictht {
    // 哈希表数组
    dictEntry **table;
    // 哈希表大小
    unsigned long size;
    // 哈希表大小掩码，用于计算索引值
    // 总是等于size-1
    unsigned long sizemask;
    // 该哈希表已有节点的数量
    unsigned long used;
} dictht;
  • table 持有一个**dictEntry **组成的数组，存储的是字典数据的节点数据，即Key-Value数据
  • size 数组大小
  • sizemask 索引值，总是size-1
  • used 已使用**dictEntry **节点数量
/*
 * 哈希表节点
 */
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 指向下一个节点的指针

底层原理

哈希值计算

  1. 使用字典设置的哈希函数，计算键key的哈希值，Redis使用MurmurHash2算法来计算哈希值，这种算法的优点在于，即使输入的键是有规律的，算法仍能给出一个很好的随机分布性，并且算法的计算速度也非常快

hash = dict->type->hashFunction(key);

  1. 使用哈希表的sizemask属性和哈希值进行取模计算，计算出索引值来确定哈希槽位置。根据情况不同，ht[x]可以是ht[0]或者ht[1]

index = hash & dict->ht[x].sizemask;

哈希碰撞

在这里插入图片描述
当哈希表节点dictEntry产生碰撞时，通过next来串联指向下一个节点，通过链地址方法解决哈希节点碰撞进行存储，碰撞的节点会采用头插法插入到单链表的头部，排在其他节点前面，因为该操作不需要遍历链表时间复杂度为O(1)

rehash

重新散列步骤如下，以扩容为例

扩容前

在这里插入图片描述

开辟空间

在这里插入图片描述
为字典的ht[1]哈希表分配空间，这个哈希表的空间大小取决于要执行的操作，以及ht[0]当前包含的键值对数量（也即是ht[0].used属性的值）。如上图，扩容操作，size要大于等于ht[0].used2的第一个2的n次方即42=8，正好是2的3次方，因此ht[1]的size设置为8

操作ht[1]大小
扩容第一个满足大于等于ht[0].used * 2的2n
缩容第一个满足大于等于ht[0].used 的2n
拷贝对象

在这里插入图片描述
将保存在ht[0]中的所有键值对rehash到ht[1]上面：rehash指的是重新计算键的哈希值和索引值，然后将键值对放置到ht[1]哈希表的指定位置上

变更指针

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

rehash触发条件

如下是扩容方法的源码：

// 指示字典是否启用 rehash 的标识
static int dict_can_resize = 1;
// 强制 rehash 的比率
static unsigned int dict_force_resize_ratio = 5;

/*
 Expand the hash table if needed */
/*
 * 根据需要，初始化字典（的哈希表），或者对字典（的现有哈希表）进行扩展
 *
 * 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

服务器环境负载因子（ht[0].used / ht[0].size）是否可控
没有在执行BGSAVE命令或者BGREWRITEAOF命令>=1负载因子满足必然触发rehash
正在执行BGSAVE命令或者BGREWRITEAOF命令>=5dict_can_resize 可控制开关

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

这里个人理解是Redis会根据情况调整dict_can_resize来决定是否开启提高负载因子比例进行rehash

渐进式rehash

扩容、缩容都遵循渐进式处理方式，以下是扩容渐进式rehash步骤：

  1. 为ht[1]分配空间，让字典同时持有ht[0]和ht[1]两个哈希表。
  2. 在字典中维持一个索引计数器变量rehashidx，并将它的值设置为0，表示rehash工作正式开始。
  3. 在rehash进行期间，每次对字典执行添加、删除、查找或者更新操作时，程序除了执行指定的操作以外，还会顺带将ht[0]哈希表在rehashidx索引上的所有键值对rehash到ht[1]，当rehash工作完成之后，程序将rehashidx属性的值增一。添加数据只会在ht[1]添加，不会再重复添加到旧容器，查询逻辑会先在ht[0]查找没有的话再到ht[1]中查找。
  4. 随着字典操作的不断执行，最终在某个时间点上，ht[0]的所有键值对都会被rehash至ht[1]，这时程序将rehashidx属性的值设为-1，表示rehash操作已完成。

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

使用场景

哈希键

4. 跳跃表

简介

跳跃表（skiplist） 是一种有序数据结构，它通过在每个节点中维持多个指向其他节点的指针，从而达到快速访问节点的目的。支持平均O（logN）、最坏O（N）复杂度的节点查找，还可以通过顺序性操作来批量处理节点。跳跃表的效率可以和平衡树相媲美，并且因为跳跃表的实现比平衡树要来得更为简单，所以有不少程序都使用跳跃表来代替平衡树。

数据结构

在这里插入图片描述
Redis的跳跃表由redis.h/zskiplistNode和redis.h/zskiplist两个结构定义，其中zskiplistNode结构用于表示跳跃表节点，而zskiplist结构则用于保存跳跃表节点的相关信息

/* ZSETs use a specialized version of Skiplists */
/*
 * 跳跃表节点
 */
typedef struct zskiplistNode {
    // 成员对象
    robj *obj;
    // 分值
    double score;
    // 后退指针
    struct zskiplistNode *backward;
    // 层
    struct zskiplistLevel {
        // 前进指针
        struct zskiplistNode *forward;
        // 跨度
        unsigned int span;
    } level[];
} zskiplistNode;
  • obj 成员对象。每个节点的成员对象是唯一的。
  • score 分值。跳跃表中的所有节点都按分值从小到大来排序，分值相同时按照成员对象obj在字典序中的大小来进行排序，成员对象较小的节点会排在前面
  • backward 后退指针，指向zskiplistNode节点
  • level 层，由zskiplistLevel组成的数组。程序可以通过这些层来加快访问其他节点的速度，一般来说，层的数量越多，访问其他节点的速度就越快。每个跳跃表节点的层高都是1~32之间的随机数
    • forward指向zskiplistNode节点的前进指针，提供遍历跳跃表的能力
    • span跨度。通过跨度来标记当前节点在跳跃表中的排名rank。两个节点之间的跨度越大，它们相距得就越远。指向NULL的所有前进指针的跨度都为0，因为它们没有连向任何节点。
/*
 * 跳跃表
 */
typedef struct zskiplist {
    // 表头节点和表尾节点
    struct zskiplistNode *header, *tail;
    // 表中节点的数量
    unsigned long length;
    // 表中层数最大的节点的层数
    int level;
} zskiplist;
  • header 代表跳跃表最头部的zskiplistNode的头节点
  • tail 代表跳跃表最尾部的zskiplistNode的尾节点
  • length 跳跃表中节点总数量（不包含表头节点）
  • level 跳跃表中的总层数（不包含表头节点中的层数）

底层原理

在这里插入图片描述
Redis中的跳跃表，简单说就是在链表基础上增加了多级索引加快数据查找速度，另外增加了backward提供逆序查找，是空间换时间的思想。

在这里插入图片描述
如上图红色虚线为节点遍历路径，通过span跨度为1的level层进行节点边路，由forward路由到下一节点，直到遇到forward等于null，说明已是末位节点。

使用场景

有序集合键

5. 整数集合

简介

当一个集合只包含整数值元素，并且这个集合的元素数量不多时，Redis就会使用整数集合作为集合键的底层实现，它是存储有序、不重复的整数集。

数据结构

在这里插入图片描述
在Redis中，intset.h/intset结构表示一个整数集合

typedef struct intset {
    // 编码方式
    uint32_t encoding;
    // 集合包含的元素数量
    uint32_t length;
    // 保存元素的数组
    int8_t contents[];
} intset;
  • encoding 编码方式。根据存储数据类型决定编码方式支持最小格式存储的编码方式
  • length 数组的数量
  • contents 保存元素的数组。contents数组并不保存任何int8_t类型的值，contents数组的真正类型取决于encoding属性的值。元素会按照从小到大的顺序进行存储
encoding编码最小值最大值
INTSET_ENC_INT16-3276832767
INTSET_ENC_INT32-21474836482147483647
INTSET_ENC_INT64-92233720368547758089223372036854775807

编码升级

使用能满足元素数据类型长度最小的编码方式，在无法满足时进行编码格式升级；不支持降级操作。

升级过程：

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

编码升级优点：

  1. 统一编码存放避免类型错误
  2. 节省内存

使用场景

集合键

6. 压缩列表

简介

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

数据结构

压缩列表

在这里插入图片描述
Redis的压缩列表是由ziplist.c结构体组成

  • zlbytes 是一个无符号4byte整数，保存着 ziplist 使用的内存数量。
    通过 zlbytes，程序可以直接对 ziplist 的内存大小进行调整，无须为了计算 ziplist 的内存大小而遍历整个列表。
  • zltail 压缩列表 最后一个 entry 距离起始地址的偏移量，占4byte。
    这个偏移量使得对表尾的pop操作可以在无须遍历整个列表的情况下进行。
  • zllen 压缩列表的节点entry数目，占2byte。
    当压缩列表的元素数目超过 2^16 - 2 的时候，zllen 会设置为2^16-1 ,当程序查询到值为2^16-1，就需要遍历整个压缩列表才能获取到元素数目。所以 zllen 并不能替代 zltail。
  • entry 压缩列表存储数据的节点，可以为字节数组或者整数。
  • zlend 压缩列表的结尾，占1byte，恒为 0xFF，即255。

数据结构特点：

  1. 内部表现为数据紧凑排列的一块连续内存数组。
  2. 可以模拟双向链表结构，以O（1）时间复杂度入队和出队
  3. 新增删除操作涉及内存重新分配或释放，加大了操作的复杂性
  4. 读写操作涉及复杂的指针移动，最坏时间复杂度为O（n2）
  5. 适合存储小对象和长度有限的数据

节点信息

/*
 * 保存 ziplist 节点信息的结构
 */
typedef struct zlentry {
    // prevrawlen ：前置节点的长度
    // prevrawlensize ：编码 prevrawlen 所需的字节大小
    unsigned int prevrawlensize, prevrawlen;
    // len ：当前节点值的长度
    // lensize ：编码 len 所需的字节大小
    unsigned int lensize, len;
    // 当前节点 header 的大小
    // 等于 prevrawlensize + lensize
    unsigned int headersize;
    // 当前节点值所使用的编码类型
    unsigned char encoding;
    // 指向当前节点的指针
    unsigned char *p;
} zlentry;
  • prevrawlensize 前置节点的长度
  • prevrawlen 编码前置节点所需的字节大小
  • len 当前节点值的长度
  • lensize 编码当前节点所需的字节大小
  • headersize 当前节点header的大小，等于 prevrawlensize + lensize
  • encoding 当前节点值所使用的编码类型。支持3种字节数组、6种整数
数据类型长度
字节数组length <= 63（2 6–1）
字节数组length <= 16383（2 14–1）
字节数组length <= 4294967295（2 32–1）
整数4位长，介于0至12之间的无符号整数
整数1字节长的有符号整数
整数3字节长的有符号整数
整数int16_t类型整数
整数int32_t类型整数
整数int64_t类型整数
  • *p 指向当前节点的指针。配合zltail进行使用可以快速定位尾部节点位置

这里例举说明下：
在这里插入图片描述

  • zlbytes 是210，代表整个压缩列表占用210字节
  • zltail 尾部entry节点偏移量是179，通过指针p加上偏移量179可以找到尾结点
  • zllen 是5，代表当前有5个entry节点
  • entry 当前有5个entry节点
  • zlend 恒为 0xFF，即255。

连锁更新

在这里插入图片描述
由于每个entry都维护了前置节点的字节大小，当前置节点字节大小变化会引起当前节点属性变更，Redis 将这种在特殊情况下产生的连续多次空间扩展操作称之为连锁更新（cascade update）

前置节点长度维护前置节点属性占用空间
<254byte1byte
>=254byte5byte
影响

连锁更新在最坏情况下需要对压缩列表执行 N 次空间重分配操作， 而每次空间重分配的最坏复杂度为 O(N) ， 所以连锁更新的最坏复杂度为 O(N^2) 。

触发条件

压缩列表里要恰好有多个连续的、长度介于 250 字节至 253 字节之间的节点， 连锁更新才有可能被引发。

综上，触发连锁更新的概率很低，即使触发如果满足触发条件的节点数量不多也不会对性能产生太大影响

使用场景

列表键（少量、小整数值、短字符串）、哈希键（少量、小整数值、短字符串）

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

7. 对象

简介

Redis 使用对象来表示数据库中的键和值， 每次当我们在 Redis 的数据库中新创建一个键值对时， 我们至少会创建两个对象， 一个对象用作键值对的键（键对象）， 另一个对象用作键值对的值（值对象）。

数据结构

在这里插入图片描述
Redis 中的每个对象都由一个redisObject 结构表示

typedef struct redisObject {
    // 类型
    unsigned type:4;
    // 编码
    unsigned encoding:4;
    // 对象最后一次被访问的时间
    unsigned lru:REDIS_LRU_BITS; /* lru time (relative to server.lruclock) */
    // 引用计数
    int refcount;
    // 指向实际值的指针
    void *ptr;
} robj;
  • type 类型。对于 Redis 数据库保存的键值对来说， 键总是一个字符串对象， 而值则可以是字符串对象、列表对象、哈希对象、集合对象、有序集合对象的其中一种
类型常量对象的名称TYPE 命令的输出
REDIS_STRING字符串对象“string”
REDIS_LIST列表对象“list”
REDIS_HASH哈希对象“hash”
REDIS_SET集合对象“set”
REDIS_ZSET有序集合对象“zset”
  • encoding 类型。对象所使用的编码， 也即是说这个对象使用了什么数据结构作为对象的底层实现
编码常量编码所对应的底层数据结构
REDIS_ENCODING_INTlong 类型的整数
REDIS_ENCODING_EMBSTRembstr 编码的简单动态字符串
REDIS_ENCODING_RAW简单动态字符串
REDIS_ENCODING_HT字典
REDIS_ENCODING_LINKEDLIST双端链表
REDIS_ENCODING_ZIPLIST压缩列表
REDIS_ENCODING_INTSET整数集合
REDIS_ENCODING_SKIPLIST跳跃表和字典

不同类型对象具体底层实现的数据结构也不同， Redis 可以根据不同的使用场景来为一个对象设置不同的编码， 从而优化对象在某一场景下的效率，如下
在这里插入图片描述

类型编码对象OBJECT ENCODING命令输出
REDIS_STRINGREDIS_ENCODING_INT使用整数值实现的字符串对象“int”
REDIS_STRINGREDIS_ENCODING_EMBSTR使用 embstr 编码的简单动态字符串实现的字符串对象“embstr”
REDIS_STRINGREDIS_ENCODING_RAW使用简单动态字符串实现的字符串对象“raw”
REDIS_LISTREDIS_ENCODING_ZIPLIST使用压缩列表实现的列表对象“ziplist”
REDIS_LISTREDIS_ENCODING_LINKEDLIST使用双端链表实现的列表对象“linkedlist”
REDIS_HASHREDIS_ENCODING_ZIPLIST使用压缩列表实现的哈希对象“ziplist”
REDIS_HASHREDIS_ENCODING_HT使用字典实现的哈希对象“hashtable”
REDIS_SETREDIS_ENCODING_INTSET使用整数集合实现的集合对象“intset”
REDIS_SETREDIS_ENCODING_HT使用字典实现的集合对象“hashtable”
REDIS_ZSETREDIS_ENCODING_ZIPLIST使用压缩列表实现的有序集合对象“ziplist”
REDIS_ZSETREDIS_ENCODING_SKIPLIST使用跳跃表和字典实现的有序集合对象“skiplist”
  • refcount 引用计数。 因为C语言没有内存自动回收机制，Redis通过引用计数（Reference Counting）实现了内存回收机制。当引用计数为0时，对象所占用的内存会被回收。
对象使用状态引用计数
新建对象初始化时+1
被新引用时+1
不再被引用时-1

在这里插入图片描述
如上图，refcount 引用计数为5，此时说明被5个指针引用，此时对象进行共享，极大的减少了内存空间占用

Redis只提供了0~9999整数共享对象池，而没有提供其他数据类型的

  • lru 对象最后一次被访问的时间。通过OBJECT IDLETIME [KEY]命令进行查看对象的空闲时间，当使用GET、SET等命令会激活对象，lru会被重置为0。该属性会在内存回收算法在volatile-lru或allkeys-lru时发挥作用
  • *ptr 指向底层实现数据结构的指针

对象类型

字符串对象

值类型限定条件编码方式底层数据结构
整数-intint
字符串 或 浮点数>32rawsds
字符串 或 浮点数<=32embstrsds

raw与embstr的区别：

  • embstr创建字符串对象只需一次内存分配，而raw需要两次
  • embstr释放对象内存只需一次，而raw需要两次
  • embstr使用的是一段连续的内存空间，比raw能更好的利用缓存带来的优势

浮点数值 会被转换成字符串对象进行保存和使用
编码转换 当存储值发生变化，编码格式和底层数据结构会发生变化
嵌套对象 字符串对象是最基础的对象类型，既可以存储数值也可以存储字符串，因此它也是构成其他复杂对象类型的基石，是五种数据对象中唯一一个可以被嵌套使用的对象类型，也就是说其他复杂数据对象如哈希对象、列表对象等会将字符串对象作为组成元素之一进行构建自身复杂对象类型

以embstr编码格式、string类型对象为例的字符串对象，ptr指向了sds数据结构，如下：
在这里插入图片描述

列表对象

值类型限定条件编码方式底层数据结构
-同时满足：
所有字符串元素长度(list-max-ziplist-value控制) < 64字节
元素数量(list-max-ziplist-entries控制) < 512个		linkedlistlinkedlist
-不满足以上任意条件ziplistziplist
双端链表实现

在这里插入图片描述
双端列表中listNode节点中value使用了字符串对象进行了构建

压缩列表实现

在这里插入图片描述

哈希对象

值类型限定条件编码方式底层数据结构
-同时满足：
所有键值对的Key和Value长度(hash-max-ziplist-value控制) < 64字节
元素数量(hash-max-ziplist-entries控制) < 512个		ziplistziplist
-不满足以上任意条件hashtablehashtable
压缩列表实现

在这里插入图片描述

  • 使用压缩列表进行哈希对象实现，键值对都是成对存储在一起
  • 总是从尾部节点插入，Key在前，Value在后
哈希表实现

在这里插入图片描述

集合对象

值类型限定条件编码方式底层数据结构
整数值同时满足：
所有元素都是整数值
元素数量(set-max-intset-entries控制) < 512个		intsetintset
-不满足以上任意条件hashtablehashtable
整数集合实现

在这里插入图片描述

哈希表实现

在这里插入图片描述
使用哈希表作为底层数据结构时，通过dictEntry中key有值进行存储，value为空

有序集合

值类型限定条件编码方式底层数据结构
-同时满足：
所有元素长度(zset-max-ziplist-value控制)<64
元素数量(zset-max-ziplist-entries控制) < 128个		ziplistziplist
-不满足以上任意条件skiplistskiplist
压缩列表实现

在这里插入图片描述

  • 使用压缩列表进行有序集合对象实现，元素和分值都是成对存储在一起
  • 总是从尾部节点插入，元素在前，分值在后
跳跃表实现

在这里插入图片描述
跳跃表实现通过zset结构进行实现，同时包含一个字典(dict)和一个跳跃表(skiplist)

/*
 * 有序集合
 */
typedef struct zset {
    // 字典，键为成员，值为分值
    // 用于支持 O(1) 复杂度的按成员取分值操作
    dict *dict;
    // 跳跃表，按分值排序成员
    // 用于支持平均复杂度为 O(log N) 的按分值定位成员操作
    // 以及范围操作
    zskiplist *zsl;
} zset;
  • dict 字典。键为成员，值为分值。用于支持O(1)复杂度的按成员取分值操作
  • zsl 跳跃表。按分值排序成员。用于支持O(log N)的按分值定位成员操作以及范围操作

为什么有序集合要同时使用字典和跳跃表实现？

  • 使用字典会保留O(1)复杂度查找，但是分值是无序存放的，无法支持排序和范围操作
  • 使用跳跃表会保留分值顺序，支持排序和范围操作，但是O(log N)复杂度查找

综上，为了发挥各自优势，采用冗余两种数据结构才进行存储，且字典和跳跃表会共享元素成员和分值，因此不会造成对象重复，减少内存空间占用

参考

美团针对Redis Rehash机制的探索和实践 https://www.cnblogs.com/meituantech/p/9376472.html
http://www.voidcn.com/article/p-pmiobrfc-bnw.html
https://blog.csdn.net/luoyanjiewade/article/details/88229820
https://www.cnblogs.com/hunternet/p/11248192.html 跳跃表
https://www.bilibili.com/read/cv9019236 压缩列表
《Redis设计与实现》
http://redisbook.com/
https://github.com/huangz1990/redis-3.0-annotated

大摩羯先生
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Redis数据结构与对象总结
04-24
Redis数据结构与对象总结 数据结构与对象 简单动态字符串 SDS简介 SDS与C字符串的区别 常数复杂度获取字符串长度 O(n) O(1) 杜绝缓冲区溢出 修改字符串长度时内存重分配 空间预分配:对字符串进行增长操作时...
01-VIP-Redis核心数据结构与核心原理1
08-03
Redis是一款高性能的键值存储系统，它以其丰富的数据结构、高效的数据操作以及强大的持久化机制在现代互联网架构中扮演着重要角色。本篇文章主要探讨Redis的核心数据结构和核心原理，以及如何利用IO多路复用技术处理...
数据模型-数据结构-压缩列表
qq_44587855的博客
12-28 258
压缩列表（ziplist）是列表键和哈希键的底层实现之一。当一个列表键只包含少量列表项，并且每个列表项要么就是小整数值，要么就是长度比较短的字符串，那么Redis就会使用压缩列表来做列表键的底层实现。 总结： 压缩列表是为列表键和哈希键服务的，那么压缩列表数据结构就要支持相关操作： 支持的数据类型 列表数据类型 例如，执行以下命令将创建一个压缩列表实现的列表键： 列表键里面包含的都是1、3、5、10086这样的小整数值，以及"hello"、"world"这样的短字符串。 哈希数据类型 当一个哈希键只包含少
Redis底层数据结构——压缩列表
红橙呀
12-16 352
压缩列表是什么 Redis 中的压缩列表是由一系列特殊编码的连续内存块组成的顺序型数据结构。列表中每个节点可以存储一个字节数组或者一个整数值。 它的存在主要是为了节约内存。 压缩列表应用场景 压缩列表在 Redis 中主要作为了 List 列表和 Hash 哈希两种数据结构的底层实现之一。 在 List 列表中，要是列表中的存储元素数量少且每个元素是小的整数值或者长度较短的字符串，那么列表将使用压缩列表结构作为底层实现。 在 Hash 哈希中，要是哈希中的存储键值对数量少且每个键值对的键和值是小的整数值或者
Redis系列(八)底层数据结构之紧凑列表
呼延十
01-20 297
前言 定义 总结 参考文章 联系我 前言 Redis 已经是大家耳熟能详的东西了，日常工作也都在使用，面试中也是高频的会涉及到，那么我们对它究竟了解有多深刻呢？ 我读了几本 Redis 相关的书籍，尝试去了解它的具体实现，将一些底层的数据结构及实现原理记录下来。 本文将介绍 Redis 中底层的 listpack（紧凑列表） 的实现方法。 它是 Redis 的 Stream 用到的数据结构之一...
深入解读Redis之数据类型解析-ZipList
m0_46428737的博客
11-04 283
ZipList，压缩列表，可以任意包含多个节点。
Redis中的压缩列表
universe_ant的博客
04-15 5543
Redis中的压缩列表  压缩列表(ziplist)是列表键和哈希键的底层实现之一。当一个列表键只包含少量列表项，并且每个列表项要么就是小整数值，要么就是长度比较短的字符串，那么Redis就会使用压缩列表来做列表键的底层实现。  例如，执行以下命令将创建一个压缩列表实现的列表键：127.0.0.1:6379> RPUSH 1st 1 3 5 10086 "hello" "world" (intege
Redis数据结构与对象
wait2023的博客
04-04 797
最近复习Redis过程中整理总结的思维导图，均参考《Redis设计与实现》 redis底层的数据结构有：简单动态字符串，双端链表，字典，跳跃表，整数集合，压缩列表 我们在使用命令操作时，并不是直接操作的这些数据结构，而是操作的redis利用这些数据结构实现的redis对象，也就是我们常说的string，list，hash，set，zset ...
【Redis-02】面试题之Redis数据结构与对象-RedisObject（上篇）
qq_35850405的博客
12-02 1627
Redis数据结构与对象，RedisObject对象，简单动态字符串sds，字典dict，压缩列表ziplist，跳跃表skiplist，整数集合intset，快速列表quicklist，面试题
万字总结 ！！redis数据结构与对象
ytsydmx的博客
10-08 2575
文章目录前言1 简单字符串1.2 sds与c字符串的区别1.2.1 常数复杂度获取字符串长度1.2.2 杜绝缓冲区溢出1.2.3 减少内存重分配现象1.2.4 二进制安全1.3 总结2 链表3 字典3.2 哈希算法3.3 解决键冲突3.4 rehash3.5哈希表的扩展与收缩3.6 渐进式rehash4 跳跃表4.1 跳跃表的实现4.2 跳跃表节点4.3 重点5 整数集合5.1 整数集合的实现5.2 升级5.3 降级5.4 重点6压缩列表6.1 压缩列表的构成6.2 压缩列表节点的构成6.2.1 previ
Redis 数据结构1
08-03
7. Redis 对象和数据结构：Redis 提供的列表、哈希、集合和有序集合等对象，根据数据规模和特性，可能使用不同的底层实现，如ziplist适用于小数据量场景，而大列表可能使用链表或跳跃表，哈希可能用字典，有序集合...
详解redis数据结构之sds
01-19
详解redis数据结构之sds  字符串在redis中使用非常广泛，在redis中，所有的数据都保存在字典（Map）中，而字典的键就是字符串类型，并且对于很大一部分字典值数据也是又字符串组成的。以下是sds的具体存储结构： ...
十五分钟介绍-Redis数据结构.pdf
最新发布
09-05
以下是对Redis数据结构的详细介绍： 1. 字符串(String) 字符串是最基础的数据类型，可以存储任意二进制数据，最长可达1GB。你可以通过`SET`命令设置键值，`GET`命令获取键值。此外，Redis还提供了原子递增`INCR`、...
哈夫曼树
大摩羯先生
12-31 7338
哈夫曼树（霍夫曼树，Huffman Tree）概念、基本思想、数据结构，代码实现
CountDownLatch原理剖析
大摩羯先生
12-28 7198
CountDownLatch知识总结
哈夫曼编码（Huffman Coding）
大摩羯先生
01-05 6592
霍夫曼编码、哈夫曼编码、编码压缩、不等长编码、等长编码
ThreadLocal原理剖析
大摩羯先生
11-16 3593
ThreadLocal知识汇总，从源码核心方法分析入手，剖析哈希算法、黄金分割数核心算法，分析探测式清理、启发式清理两种内存清理方式，也分析了ThreadLocal的缺点、场景问题汇总、最后给出实战应用场景。
【学习总结】H2数据库
大摩羯先生
11-23 2931
H2数据库配置、简介、特性、连接方式、控制台、数据库操作
对Excel导入和导出的整理与学习
大摩羯先生
07-25 2533
一提到Excel的导入和导出，我们大多数人第一反应就是POI，对我而言也是。最近正好赶上做Excel导入和导出的功能，但是这次不一样的是数据量比过去增长了不少，过去业务量是百千条记录，现在变成了上万甚至十几万条记录，于是传统的POI出现了OOM、响应时间长的问题，导入导出EXCEL的响应时间长直接影响着用户的体验，OOM则会严重影响系统的正常使用更甚则服务停滞。于是，我针对EXC...
使用redis数据结构
09-03
- *1* [redis数据结构及用法汇总](https://blog.csdn.net/qq_42671928/article/details/123677676)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

大摩羯先生

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

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

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

打赏作者

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

抵扣说明：

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

余额充值