redisObject 以及 对抽象的理解

最新推荐文章于 2024-07-07 09:36:42 发布
最新推荐文章于 2024-07-07 09:36:42 发布
阅读量454 收藏
点赞数
分类专栏： redis源码学习&实践 文章标签： redis c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a158372582/article/details/106712261
版权

redisObject 以及对抽象的理解

给新观众老爷的开场

大家好，我是弟弟！
最近读了一遍 黄健宏大佬的 <<Redis 设计与实现>>，对Redis 3.0版本有了一些认识
该书作者有一版添加了注释的 redis 3.0源码
👉官方redis的github传送门。
👉黄健宏大佬添加了注释的 redis 3.0源码传送门

网上说Redis代码写得很好，为了加深印象和学习redis大佬的代码写作艺术，了解工作中使用的redis 命令背后的源码逻辑，便有了写博客记录学习redis源码过程的想法。

redisObject

看过前几期的观众老爷，都会常常见到一个叫 robj 的结构体
比如在k/v空间中查询k/v, key是robj类型的指针，返回的value 也是robj类型的指针👇

/*
 * 从数据库 db 中取出键 key 的值（对象）
 *
 * 如果 key 的值存在，那么返回该值；否则，返回 NULL 。
 */
robj *lookupKey(redisDb *db, robj *key)
{
    // 查找键空间
    dictEntry *de = dictFind(db->dict, key->ptr);
    // 节点存在
    if (de)
    {
        // 取出值
        robj *val = dictGetVal(de);
		...
        // 返回值
        return val;
    }
    // 节点不存在
    return NULL;
}

redis的k/v空间里不是有好多种类型的数据结构吗？
如果说key都是字符串可以用一个类型来表示，
那链表，集合，有序集合，hash表呢？
我们是不是应该对不同的数据结构都写一套 存取k/v的逻辑呢？

显然是只写一套是最简单省事的哈 🐶

如果每种数据结构都来一套对应的 存取k/v逻辑，
不仅增加了开发量，而且引入了非常多的冗余逻辑，
不仅不方便人阅读，而且系统的混乱程度也会升高，
做新功能扩展一类的开发，代码会越写越屎💩

抽象出 redisObject 的好处，拿存取k/v来举例

  1. 抽象层面相同逻辑的代码一套就够了。 比如存取k/v的代码

    针对不同数据结构来一套特定的crud代码，这个是没办法避免的事情。

    但是对于 k/v 在redis中的存取操作，这是可以抽象出一套代码的，
    因为不同数据类型的对象都可以用一个指针来指向他们，
    对于k/v的存取最需要关心的是 key的指针是哪个，value的指针是哪个，
    k/v 的指针指向的结构类型是什么(类型变量，只是一个数字)，编码方式是什么。
    而对于 k/v指针指向的具体结构到底长啥样，对于存取k/v的指针这个操作来说 实际上是不关心的。
    谁要读 就 根据读出来的 指针、类型字段和实现方式 自己解析就好了。🙃️

  2. 代码逻辑精简，清晰明了
    便于开发者自己阅读，也便于后来的其他开发者阅读，赏心悦目。

  3. 降低系统混乱程度(墒减)，系统各个部分都简单明了时，系统会比较健壮，容易扩展
    因为简单嘛，所以相对复杂来说不容易出错，就比较健壮。

    是否在工作中有这样一种体验？ 修了一个bug，结果多了好几个bug😂
    这种问题一部分是因为系统太混乱，对于修改造成的影响，人在短时间之内没办法快速评估/发现所有被影响的地方。只有等上线、搞出一口大锅之后才发现原来没改对😂

    人脑有智慧，但接受/处理/输出 信息的速度，相比于电脑来说差太远了。
    金字塔原理一书中提到 人大概同一时间接收超过7个信息时，就不太能记全所有信息了。
    如果系统太过复杂，谨慎修bug😂

  4. 因结构简单带来了 可以组合/嵌套出复杂结构的能力。
    这种能力要是不通过抽象获得，无脑写代码将是一场噩梦。

    一个hash表里，可以存放各种类型的value, 甚至可以hash表里嵌套一个hash表。
    没错redis的哈希数据结构就是放在全局的k/v字典里的，这个全局k/v字典实际上就是一个hash表

  5. 对象引用计数，方便对象的复用与销毁，节省空间

  6. 记录对象的访问信息，以便于内存不足时进行内存淘汰

redisObject的结构定义

redisObject一共有5个字段

  1. 指向实际对象的指针
  2. 实际对象的数据结构类型
  3. 实际对象在一个具体数据结构类型下的编码类型
  4. 引用计数
  5. lru字段

结构定义如下👇

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;

redisObject 涵盖的数据类型有哪些

在redis3.0里redisObject一共有5中数据类型

/* Object types */
// 对象类型
#define REDIS_STRING 0
#define REDIS_LIST 1
#define REDIS_SET 2
#define REDIS_ZSET 3
#define REDIS_HASH 4

在较新一些的redis6.0里，redisObject一共有7种类型。

每一种数据类型，在redis内部都有2种及以上的 编码方式，也可以理解为实现方式。
为什么要这么搞呢？

主要是考虑到redis作为一个内存数据库，在key对应的value比较小时，使用更节省内存的方式存储。
当key对应的value元素个数或单个元素过大时，会转换成更为通用的实现方式。

在之前学习各个数据结构时，会经常发现这样的情况，再创建各个数据类型时，默认会先以节省内存的编码方式创建，当满足一定条件时，会转换为更为通用的编码方式。

所有的编码类型如下👇

/* Objects encoding. Some kind of objects like Strings and Hashes can be
 * internally represented in multiple ways. The 'encoding' field of the object
 * is set to one of this fields for this object. */
// 对象编码
#define REDIS_ENCODING_RAW 0        （REDIS_STRING）
#define REDIS_ENCODING_INT 1        （REDIS_STRING）
#define REDIS_ENCODING_HT 2         （REDIS_SET，REDIS_HASH）
#define REDIS_ENCODING_ZIPMAP 3     /* Encoded as zipmap */
#define REDIS_ENCODING_LINKEDLIST 4 （REDIS_LIST）
#define REDIS_ENCODING_ZIPLIST 5    （REDIS_LIST，REDIS_HASH,REDIS_ZSET）
#define REDIS_ENCODING_INTSET 6     （REDIS_SET）
#define REDIS_ENCODING_SKIPLIST 7   （REDIS_ZSET）
#define REDIS_ENCODING_EMBSTR 8     （REDIS_STRING）

数据结构类型判断

前面说，当从redis的db中存取k/v时，使用了redisObject结构，没有关心value的具体结构。
那么当value从redis的db中取出来后，再做相应逻辑之前还是要判断一下value的数据结构类型，
否则是会有问题的。

比如hget 命令对应的 hgetCommand命令，通过key从db中取出value后，判断了value是否是hash对象
源码逻辑如下👇

void hgetCommand(redisClient *c) {
    robj *o;

    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk)) == NULL ||
        checkType(c,o,REDIS_HASH)) return;

    // 取出并返回域的值
    addHashFieldToReply(c, o, c->argv[2]);
}
/*
 * 检查对象 o 的类型是否和 type 相同：
 *
 *  - 相同返回 0 
 *
 *  - 不相同返回 1 ，并向客户端回复一个错误
 */
int checkType(redisClient *c, robj *o, int type) {

    if (o->type != type) {
        addReply(c,shared.wrongtypeerr);
        return 1;
    }

    return 0;
}
/*
 * 为执行读取操作而从数据库中查找返回 key 的值。
 *
 * 如果 key 存在，那么返回 key 的值对象。
 *
 * 如果 key 不存在，那么向客户端发送 reply 参数中的信息，并返回 NULL 。
 */
robj *lookupKeyReadOrReply(redisClient *c, robj *key, robj *reply) {

    // 查找
    robj *o = lookupKeyRead(c->db, key);

    // 决定是否发送信息
    if (!o) addReply(c,reply);

    return o;
}

实际上这个 用key在redis的db中取value并判断类型的操作，在各种数据类型上都是有的

比如 取string

void getCommand(redisClient *c) {
    getGenericCommand(c);
}
int getGenericCommand(redisClient *c) {
    robj *o;
    // 尝试从数据库中取出键 c->argv[1] 对应的值对象
    // 如果键不存在时，向客户端发送回复信息，并返回 NULL
    if ((o = lookupKeyReadOrReply(c, c->argv[1], shared.nullbulk)) == NULL) {
        return REDIS_OK;
    }
    // 值对象存在，检查它的类型
    if (o->type != REDIS_STRING) {
        // 类型错误
        addReply(c, shared.wrongtypeerr);
        return REDIS_ERR;
    }
    ...
 }

取list

void lindexCommand(redisClient *c) {

    robj *o = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk);

    if (o == NULL || checkType(c,o,REDIS_LIST)) return;
    ...
}

其余类型…省略

将公有逻辑抽象出来，只写一套代码。不同的实现方式的具体逻辑再写不同的代码。
似乎还不错🤔

对象引用计数

C语言是没有GC的，自己申请的内存还得自己释放。

比如B函数通过A函数得到了一个robj*类型的变量C ，B函数用完之后理所应当的要释放掉C。
但此时问题就来了，这个C别人有没有在用呢？如果只是B自己在用那释放掉就释放了。
如果有别人在用，这个C还不能马上释放。

redis作者搞了一个简单的对象引用计数，来解决内存复用与销毁的问题。

  1. 谁要"拷贝"这个redisObject，引用计数就+1
  2. 谁用完了这个redisObject，引用计数就-1
    引用计数为0时，free掉redisObject占用的内存空间

举个源码例子
比如判断hash表中的key是否与输入的key相等
因为字符串类型底层有多种不同的实现方式，在比较的时候需要统一的一种形式。
getDecodedObject 会返回给定 robj的 REDIS_ENCODING_RAW 编码形式。

  1. 如果robj 的编码就是 REDIS_ENCODING_RAW 那么可以复用该内存，仅增加引用计数即可
  2. 否则，创建一个新的 REDIS_ENCODING_RAW编码的robj 字符串，引用计数初始为1
  3. 比对完之后对 getDecodedObject 返回的结构体 减1个引用计数，若引用计数减为0，则释放该结构体

非字符串类型的robj会崩溃

int dictEncObjKeyCompare(void *privdata, const void *key1,
        const void *key2)
{
    robj *o1 = (robj*) key1, *o2 = (robj*) key2;
    int cmp;

    if (o1->encoding == REDIS_ENCODING_INT &&
        o2->encoding == REDIS_ENCODING_INT)
            return o1->ptr == o2->ptr;

    o1 = getDecodedObject(o1);
    o2 = getDecodedObject(o2);
    cmp = dictSdsKeyCompare(privdata,o1->ptr,o2->ptr);
    decrRefCount(o1);
    decrRefCount(o2);
    return cmp;
}


/* Get a decoded version of an encoded object (returned as a new object).
 *
 * 以新对象的形式，返回一个输入对象的解码版本（RAW 编码）。
 *
 * If the object is already raw-encoded just increment the ref count. 
 *
 * 如果对象已经是 RAW 编码的，那么对输入对象的引用计数增一，
 * 然后返回输入对象。
 */
robj *getDecodedObject(robj *o) {
    robj *dec;

    if (sdsEncodedObject(o)) {
        incrRefCount(o);
        return o;
    }

    // 解码对象，将对象的值从整数转换为字符串
    if (o->type == REDIS_STRING && o->encoding == REDIS_ENCODING_INT) {
        char buf[32];

        ll2string(buf,32,(long)o->ptr);
        dec = createStringObject(buf,strlen(buf));
        return dec;

    } else {
        redisPanic("Unknown encoding type");
    }
}

/*
 * 为对象的引用计数增一
 */
void incrRefCount(robj *o) {
    o->refcount++;
}
/*
 * 为对象的引用计数减一
 *
 * 当对象的引用计数降为 0 时，释放对象。
 */
void decrRefCount(robj *o) {

    if (o->refcount <= 0) redisPanic("decrRefCount against refcount <= 0");

    // 释放对象
    if (o->refcount == 1) {
        switch(o->type) {
        case REDIS_STRING: freeStringObject(o); break;
        case REDIS_LIST: freeListObject(o); break;
        case REDIS_SET: freeSetObject(o); break;
        case REDIS_ZSET: freeZsetObject(o); break;
        case REDIS_HASH: freeHashObject(o); break;
        default: redisPanic("Unknown object type"); break;
        }
        zfree(o);

    // 减少计数
    } else {
        o->refcount--;
    }
}

lru字段 与 内存淘汰

redisObject中的lru字段记录了k/v被访问的 时间 or 频率 相关信息。
这个lru字段 只占了24位空间

在内存不足时作为参考数据，根据淘汰策略进行数据淘汰，以释放空间。
这个redis的内存淘汰策略有多种方式，可以单独写一篇博客了，在这里先不细说了。🐶

小结

  1. 写代码的时候最先想到的就是具体如何实现，这个想法并没有什么问题。
    但这是局部视角，并不完整，缺少站在系统整体层面的思考。
    所写的代码模块，在整个系统中是一个什么定位，与系统中其他模块有什么关系。
    所写代码模块本身是否有更好的组织方式。
    系统层面的整体思考 跟 具体功能如何实现 一样重要。(跑题了🐶)

往期博客回顾

  1. redis服务器的部分启动过程
  2. GET命令背后的源码逻辑
  3. redis的基础数据结构之 sds
  4. redis的基础数据结构之 list
  5. redis的基础数据结构 之 ziplist
  6. redis 基础数据结构之 hash表
  7. redis不稳定字典的遍历
  8. redis 基础数据结构 之 集合
  9. redis 基础数据结构 之 有序集合
a158372582
关注
专栏目录
Redis学习(7)——对象（redisObject）
H1517043456的博客
04-08 698
一，Redis对象概述 我们知道Redis中使用了，简单动态字符串，双端链表，跳跃表，字典，压缩列表，整数集合，快速列表等数据结构，但是对于Redis，它并没用直接使用这些数据结构来实现键值对数据库，而是以它们为基础创建了一个对象系统。 这个对象系统包括了字符串对象、列表对象、哈希对象、集合对象和有序集合对象，这五个类型的对象。这些对象的实现都是基于上述的数据结构实现的。基于五个不同对象的键值...
.net抽象缓存工厂redis、httpruntime
01-19
本文将深入探讨.NET中抽象缓存工厂如何与Redis和HttpRuntime结合使用，以及如何在实际项目中应用这些概念。我们将通过提供的代码示例来理解整个流程。 首先，我们关注的是"ICache.cs"，这是一个接口文件，它定义了...
07 Redis-对象的类型与编码
qq_29869663的博客
05-27 172
前言 Redis用的主要数据结构有简单动态字符串、双端链表、字典、压缩列表、跳跃表、整数集合等。但是Redis并没有直接使用这些数据结构来实现键值对数据库，而是基于这些数据结构构建了一个对象系统，这个系统包含字符串对象、列表对象、哈希对象、集合对象和有序集合对象五种类型的对象，每种对象用到至少一种前面的数据结构。 通过这五种不同类型的对象，Redis可以在执行命令之前，根据对象的类型来判断一个对象是否可以执行给定的命令。同时，我们可以针对不同的使用场景，为对象设置不同的数据结构，从而优化对象在不同场.
Redis源码剖析和注释（八）--- 对象系统(redisObject)
men_wen的博客
04-20 7117
Redis 对象系统1. 介绍redis中基于双端链表、简单动态字符串(sds)、字典、跳跃表、整数集合、压缩列表、快速列表等等数据结构实现了一个对象系统，并且实现了5种不同的对象，每种对象都使用了至少一种前面的数据结构，优化对象在不同场合下的使用效率。 双端链表源码剖析和注释 简单动态字符串(SDS)源码剖析和注释 字典结构源码剖析和注释 跳跃表源码剖析和注释 整数集合源码剖析和注释 压缩列表源码
Redis 对象
sanmao123456_的博客
07-07 185
0、对象 Redis 没有直接使用基本数据结构来实现键值对数据库，而是基于这些数据结构创建了一个对象系统： 字符串对象 列表对象 哈希对象 集合对象 有序集合对象 使用对象的优点： 可以在执行命令前，根据对象的类型来判断一个对象是否可以执行给定的命令。 可以针对不同的使用场景，为对象设置多种不同的数据结构实现，从而优化效率。 Redis 的对象系统实现了基于引用计数技术的内存回收机制。 Redis 的对象系统实现了基于引用计数技术的对象共享机制，这一机制可以在适当的条件下，通过让多个数据库共享同一个对
Redis对象redisObject
Mr_moving
04-29 765
一，Redis对象概述 我们知道Redis中使用了，简单动态字符串，双端链表，跳跃表，字典，压缩列表，整数集合，快速列表等数据结构，但是对于Redis，它并没用直接使用这些数据结构来实现键值对数据库，而是以它们为基础创建了一个对象系统。 这个对象系统包括了字符串对象、列表对象、哈希对象、集合对象和有序集合对象，这五个类型的对象。这些对象的实现都是基于上述的数据结构实现的。基于五个不同对...
Redis源码剖析：RedisObject与数据结构
RedisObject包含了数据类型、编码方式以及指向实际数据的指针，这使得Redis能够灵活地存储和操作不同类型的值，如字符串、列表、哈希表、集合和有序集合。 RedisObject结构体主要包括以下几个字段： 1. `type`：...
SpringDataRedis对Redis的数据类型的常用操作API的使用代码举例.zip
03-23
在Java开发中，Spring Data Redis是一个非常重要的库，它提供了对Redis数据存储的高级抽象和便捷操作。这个压缩包文件“SpringDataRedis对Redis的数据类型的常用操作API的使用代码举例.zip”显然包含了关于如何利用...
SpringBoot集成Redis快速入门Demo
04-05
在本文中，我们将深入探讨如何使用SpringBoot集成Redis进行快速入门。这个Demo旨在展示如何配置...随着对Spring Data Redis和RedisTemplate的深入理解和实践，可以进一步优化数据访问和存储策略，以满足项目的需求。
spring + redis集群
10-11
首先，Spring Data Redis是Spring框架的一个模块，它简化了Redis的数据访问，提供了高度抽象的API，使得开发人员可以轻松地进行键值存储操作。Spring Data Redis支持多种Redis操作，包括字符串、哈希、列表、集合和...
Redis数据结构之RedisObject
chengxuyuan_2012的专栏
04-22 913
Redis是一种高性能的开源内存数据存储系统，它支持多种不同类型的键值对。这些键值对的实现是基于一系列底层的数据结构。Redis底层数据结构包括字符串、双端链表、字典、压缩列表、整数集合等，但是Redis为了加快读写速度，并没有直接使用这些数据结构，而是在此基础上又包装了一层称之为RedisObject，RedisObject 有五种对象：字符串（String）、列表（List）、集合（Set）、有序集合（Sorted Set）和哈希（Hash）。
Redis数据类型之redisObject
小麦大大博客
08-29 7178
1、Redis中的object 为了便于操作，Redis定义了redisObjec结构体来表示string、hash、list、set、zset五种数据类型。redisObject定义在redis.h文件中： typedef struct redisObject { unsigned type:4; unsigned encoding:4; ...
redis底层数据结构之redisObject
qq_48669591的博客
08-08 370
redis底层数据结构之redisObject
【Redis】RedisObject 对象
石臻臻的杂货铺(szzdzhp001)
03-21 4481
在前面介绍各个底层数据结构时有提到， Redis 的每一种数据类型，比如字符串、列表、有序集， 它们都拥有不只一种底层实现（Redis 内部称之为编码，encoding）， 这说明， 每当对某种数据类型的键进行操作时， 程序都必须根据键所采取的编码， 进行不同的操作。 Redis 构建了自己的类型系统， 这个系统的主要功能包括： redisObject 对象。 基于 redisObject ...
Redis对象机制 (Redis Object)
yjh6688的博客
06-18 426
什么是Redis的对象机制以及Redis Oject到底是什么？这里有入门讲解。
Redis对象系统
weixin_57023347的博客
11-29 1048
在Redis中有许多数据结构，比如：简单动态字符串(SDS)，双端链表，字典，压缩列表，整数集合等。Redis并没有直接使用这些数据结构来实现键值对数据库，而是基于这些数据结构创建了一个对象系统。这个系统中包含字符串对象，列表对象，哈希对象，集合对象和有序集合对象这物种类型的对象。通过这五种不同类型的对象，Redis可以在执行命令前，根据对象的类型来判断一个对象是否可以执行给定的命令。使用对象的另一个好处时，我们可以针对不同的使用场景，为对象设置多种不同的数据结构实现，从而优化对象在不同场景下的使用效率。
【Redis实现系列】RedisObject实现
菜鸡也有大佬梦
11-11 373
RedisObject Redis使用对象来表示数据库中的键和值，每次当我们在Redis的数据库中新创建一个键值对时，我们至少会创建两个对象，一个对象用作键值对的键（键对象），另一个对象用作键值对的值（值对象）。 Redis 数据库中的每个键值对的键和值都是一个对象 redisObject。 typedef struct redisObject { // 类型（共有 5 种：string、list、hash、set、zset） unsigned type:4; // 编码（共有
redisObject详解
TABE_的博客
03-26 2550
这里写目录标题Redis的两层数据结构简介Redis数据结构的内部实现redisObject结构体redisObject的作用 Redis的两层数据结构简介 redis的性能高的原因之一是它每种数据结构都是经过专门设计的，并都有一种或多种数据结构来支持，依赖这些灵活的数据结构，来提升读取和写入的性能。如果要了解redis的数据结构，可以从两个不同的层面来讨论它： 第一个层面，是从使用者的角度，这一层面也是Redis暴露给外部的调用接口，比如：string，list，hash，set，sorted set。
Redis数据结构解析-RedisObject
最新发布
时间如瑾 代码如诗
07-07 1197
RedisObject 是 Redis 中表示数据对象的结构体，它是 Redis 数据库中的基本数据类型的抽象。在 Redis 中，所有的数据都被存储为 RedisObject 类型的对象。// 数据类型，如字符串、列表、哈希等// 编码方式，如 int、raw、hashtable 等// Least Recently Used，用于记录对象最近被访问的时间// 引用计数，用于自动内存管理void *ptr;// 指向实际存储数据的指针} robj;type。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值