Redis系列——对象分析

最新推荐文章于 2024-10-11 09:07:53 发布
最新推荐文章于 2024-10-11 09:07:53 发布
阅读量141 收藏
点赞数
分类专栏： redis技术梳理 文章标签： redis nosql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46734067/article/details/115068952
版权
本文深入探讨了Redis中的对象结构，包括RedisObject、字符串、列表、哈希、集合和有序集合的实现。针对不同数据量，Redis使用了多种编码方式如ziplist、intset、hashtable、linkedlist和skiplist，以优化内存使用和性能。文章还介绍了对象的引用计数和LRU机制，展示了如何创建、管理和转换这些对象。
摘要由CSDN通过智能技术生成

前言

在知道了Redis底层所用的数据结构之后
https://blog.csdn.net/weixin_46734067/article/details/114974101
我们来分析Redis如何用这些数据结构来搭建对象
文章主要结构如下

  1. 整体上介绍RedisObject，介绍对象类型及其编码
  2. 字符串对象
  3. 列表对象
  4. hash对象
  5. 集合对象
  6. 有序集合对象
  7. 引用计数
  8. LRU

Redis对象

我们直接看定义

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;

如何创建一个对象？

/*
 * 创建一个新 robj 对象
 */
robj *createObject(int type, void *ptr) {

    robj *o = zmalloc(sizeof(*o));

    o->type = type;
    o->encoding = REDIS_ENCODING_RAW;
    o->ptr = ptr;
    o->refcount = 1;

    /* Set the LRU to the current lruclock (minutes resolution). */
    o->lru = LRU_CLOCK();
    return o;
}

type表示当前的redisObject是哪种类型的对象
共有5种对象类型，可以看到redis内部对其做了相应的编码

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

可以用TYPE命令查看键对应值的对象类型
在这里插入图片描述

encoding表示底层采用了哪种数据结构来实现对象

/* 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. */
/* 对象编码
 * 有的对象比如字符串和字典在内部可以用不同的方式表示
 * encoding属性用来设定对象底层数据结构 */
#define REDIS_ENCODING_RAW 0     /* Raw representation */
#define REDIS_ENCODING_INT 1     /* Encoded as integer */
#define REDIS_ENCODING_HT 2      /* Encoded as hash table */
#define REDIS_ENCODING_ZIPMAP 3  /* Encoded as zipmap */
#define REDIS_ENCODING_LINKEDLIST 4 /* Encoded as regular linked list */
#define REDIS_ENCODING_ZIPLIST 5 /* Encoded as ziplist */
#define REDIS_ENCODING_INTSET 6  /* Encoded as intset */
#define REDIS_ENCODING_SKIPLIST 7  /* Encoded as skiplist */
#define REDIS_ENCODING_EMBSTR 8  /* Embedded sds string encoding */

可以用OBJECT ENCODING命令来查看底层的数据结构
在这里插入图片描述
在不同的情景下，对象底层的数据结构会不同，这样当数据量不同的时候，可以选择最佳的数据结构，从而优化性能。

接下来我们详细的说明每一种对象

字符串对象

源码目录
object.c 创建对象的方法
t_string.c 命令对应的具体实现方法

如何创建一个StringObject？

#define REDIS_ENCODING_EMBSTR_SIZE_LIMIT 39
robj *createStringObject(char *ptr, size_t len) {
    if (len <= REDIS_ENCODING_EMBSTR_SIZE_LIMIT)
        return createEmbeddedStringObject(ptr,len);
    else
        return createRawStringObject(ptr,len);
}

可以看到createEmbeddedStringObject，对应的编码就是

#define REDIS_ENCODING_EMBSTR 8  /* Embedded sds string encoding */

// 创建一个 REDIS_ENCODING_EMBSTR 编码的字符对象
// 这个字符串对象中的 sds 会和字符串对象的 redisObject 结构一起分配
// 因此这个字符也是不可修改的
robj *createEmbeddedStringObject(char *ptr, size_t len) {
	// 一起分配了obj和sds的内存
    robj *o = zmalloc(sizeof(robj)+sizeof(struct sdshdr)+len+1);
    struct sdshdr *sh = (void*)(o+1);
    
	// 设置对象类型
    o->type = REDIS_STRING;
    // 设置底层数据结构类型
    o->encoding = REDIS_ENCODING_EMBSTR;
    o->ptr = sh+1;
    o->refcount = 1;
    o->lru = LRU_CLOCK();

    sh->len = len;
    sh->free = 0;
    if (ptr) {
        memcpy(sh->buf,ptr,len);
        sh->buf[len] = '\0';
    } else {
        memset(sh->buf,0,len+1);
    }
    return o;
}

createRawStringObject，对应编码就是

#define REDIS_ENCODING_RAW 0     /* Raw representation */

对应函数为

// 创建一个 REDIS_ENCODING_RAW 编码的字符对象
// 对象的指针指向一个 sds 结构
robj *createRawStringObject(char *ptr, size_t len) {
    return createObject(REDIS_STRING,sdsnewlen(ptr,len));
}

传递参数REDIS_STRING，sdsnewlen(ptr,len)
这个分配内存的函数

/*
 * 根据给定的初始化字符串 init 和字符串长度 initlen
 * 创建一个新的 sds
 *
 * 参数
 *  init ：初始化字符串指针
 *  initlen ：初始化字符串的长度
 *
 * 返回值
 *  sds ：创建成功返回 sdshdr 相对应的 sds
 *        创建失败返回 NULL
 *
 * 复杂度
 *  T = O(N)
 */
sds sdsnewlen(const void *init, size_t initlen) {

    struct sdshdr *sh;

    // 根据是否有初始化内容，选择适当的内存分配方式
    // T = O(N)
    if (init) {
        // zmalloc 不初始化所分配的内存
        sh = zmalloc(sizeof(struct sdshdr)+initlen+1);
    } else {
        // zcalloc 将分配的内存全部初始化为 0
        sh = zcalloc(sizeof(struct sdshdr)+initlen+1);
    }

    // 内存分配失败，返回
    if (sh == NULL) return NULL;

    // 设置初始化长度
    sh->len = initlen;
    // 新 sds 不预留任何空间
    sh->free = 0;
    // 如果有指定初始化内容，将它们复制到 sdshdr 的 buf 中
    // T = O(N)
    if (initlen && init)
        memcpy(sh->buf, init, initlen);
    // 以 \0 结尾
    sh->buf[initlen] = '\0';

    // 返回 buf 部分，而不是整个 sdshdr
    return (char*)sh->buf;
}

这个函数返回创建的SDS指针，然后再创建一个redisObject将ptr指针指向这个SDS。

两者区别：
RAW 不连续地址 先后创建SDS和redisObject
EMBSTR 一口气分配连续地址

也可以传入整数，创建字符串对象

robj *createStringObjectFromLongLong(long long value) {

    robj *o;

    // value 的大小符合 REDIS 共享整数的范围
    if (value >= 0 && value < REDIS_SHARED_INTEGERS) {
        incrRefCount(shared.integers[value]);
        o = shared.integers[value];

    // 不符合共享范围，创建一个新的整数对象
    } else {
        // 值可以用 long 类型保存，
        // 创建一个 REDIS_ENCODING_INT 编码的字符串对象
        if (value >= LONG_MIN && value <= LONG_MAX) {
            o = createObject(REDIS_STRING, NULL);
            o->encoding = REDIS_ENCODING_INT;
            o->ptr = (void*)((long)value);

        // 值不能用 long 类型保存（long long 类型），将值转换为字符串，
        // 并创建一个 REDIS_ENCODING_RAW 的字符串对象来保存值
        } else {
            o = createObject(REDIS_STRING,sdsfromlonglong(value));
        }
    }

    return o;
}

// 在sds.c中定义函数
// 根据输入的 long long 值 value ，创建一个 SDS
sds sdsfromlonglong(long long value) {
    char buf[SDS_LLSTR_SIZE];
    int len = sdsll2str(buf,value);

    return sdsnewlen(buf,len);
}

redis把常用的对象提前创建好，作为共享对象，减少创建对象耗时

// 通过复用来减少内存碎片，以及减少操作耗时的共享对象
struct sharedObjectsStruct {
    robj *crlf, *ok, *err, *emptybulk, *czero, *cone, *cnegone, *pong, *space,
    *colon, *nullbulk, *nullmultibulk, *queued,
    *emptymultibulk, *wrongtypeerr, *nokeyerr, *syntaxerr, *sameobjecterr,
    *outofrangeerr, *noscripterr, *loadingerr, *slowscripterr, *bgsaveerr,
    *masterdownerr, *roslaveerr, *execaborterr, *noautherr, *noreplicaserr,
    *busykeyerr, *oomerr, *plus, *messagebulk, *pmessagebulk, *subscribebulk,
    *unsubscribebulk, *psubscribebulk, *punsubscribebulk, *del, *rpop, *lpop,
    *lpush, *emptyscan, *minstring, *maxstring,
    *select[REDIS_SHARED_SELECT_CMDS],
    *integers[REDIS_SHARED_INTEGERS],
    *mbulkhdr[REDIS_SHARED_BULKHDR_LEN], /* "*<value>\r\n" */
    *bulkhdr[REDIS_SHARED_BULKHDR_LEN];  /* "$<value>\r\n" */
};

可以看到前一万个整数，redis都是提前创建好的。

#define REDIS_SHARED_INTEGERS 10000

列表对象

列表可以由LINKEDLIST 编码和ZIPLIST 编码

/*
 * 创建一个 LINKEDLIST 编码的列表对象
 */
robj *createListObject(void) {

    list *l = listCreate();

    robj *o = createObject(REDIS_LIST,l);

    listSetFreeMethod(l,decrRefCountVoid);

    o->encoding = REDIS_ENCODING_LINKEDLIST;

    return o;
}

/*
 * 创建一个 ZIPLIST 编码的列表对象
 */
robj *createZiplistObject(void) {

    unsigned char *zl = ziplistNew();

    robj *o = createObject(REDIS_LIST,zl);

    o->encoding = REDIS_ENCODING_ZIPLIST;

    return o;
}

当列表中数据量较少时，用ZIPLIST，随着数据量增多，使用双端链表LINKEDLIST
那么如何插入数据呢？

/* 
 * 将给定元素添加到列表的表头或表尾。
 *
 * 参数 where 决定了新元素添加的位置：
 *
 *  - REDIS_HEAD 将新元素添加到表头
 *
 *  - REDIS_TAIL 将新元素添加到表尾
 *
 */
void listTypePush(robj *subject, robj *value, int where) {

    /* Check if we need to convert the ziplist */
    listTypeTryConversion(subject,value);

    if (subject->encoding == REDIS_ENCODING_ZIPLIST &&
        ziplistLen(subject->ptr) >= server.list_max_ziplist_entries)
            listTypeConvert(subject,REDIS_ENCODING_LINKEDLIST);

    // ZIPLIST
    if (subject->encoding == REDIS_ENCODING_ZIPLIST) {
        int pos = (where == REDIS_HEAD) ? ZIPLIST_HEAD : ZIPLIST_TAIL;
        // 取出对象的值，因为 ZIPLIST 只能保存字符串或整数
        value = getDecodedObject(value);
        subject->ptr = ziplistPush(subject->ptr,value->ptr,sdslen(value->ptr),pos);
        decrRefCount(value);


    // 双端链表
    } else if (subject->encoding == REDIS_ENCODING_LINKEDLIST) {
        if (where == REDIS_HEAD) {
            listAddNodeHead(subject->ptr,value);
        } else {
            listAddNodeTail(subject->ptr,value);
        }
        incrRefCount(value);

    // 未知编码
    } else {
        redisPanic("Unknown list encoding");
    }
}

可以看到每次插入数据之前需要判断是否进行转化
如何判断又如何转换呢？

/* 
 * 对输入值 value 进行检查，看是否需要将 subject 从 ziplist 转换为双端链表，
 * 以便保存值 value 。
 *
 * 函数只对 REDIS_ENCODING_RAW 编码的 value 进行检查，
 * 因为整数编码的值不可能超长。
 */
void listTypeTryConversion(robj *subject, robj *value) {

    // 确保 subject 为 ZIPLIST 编码
    if (subject->encoding != REDIS_ENCODING_ZIPLIST) return;

    if (sdsEncodedObject(value) &&
        // 看字符串是否过长
        sdslen(value->ptr) > server.list_max_ziplist_value)
            // 将编码转换为双端链表
            listTypeConvert(subject,REDIS_ENCODING_LINKEDLIST);
}

具体是如何转化的？

/*
 * 将列表的底层编码从 ziplist 转换成双端链表
 */
void listTypeConvert(robj *subject, int enc) {

    listTypeIterator *li;

    listTypeEntry entry;

    redisAssertWithInfo(NULL,subject,subject->type == REDIS_LIST);

    // 转换成双端链表
    if (enc == REDIS_ENCODING_LINKEDLIST) {

        list *l = listCreate();

        listSetFreeMethod(l,decrRefCountVoid);

        /* listTypeGet returns a robj with incremented refcount */
        // 遍历原来的链表
        li = listTypeInitIterator(subject,0,REDIS_TAIL);
        while (listTypeNext(li,&entry)) listAddNodeTail(l,listTypeGet(&entry));
        listTypeReleaseIterator(li);

        // 更新编码
        subject->encoding = REDIS_ENCODING_LINKEDLIST;

        // 释放原来的 ziplist
        zfree(subject->ptr);

        // 更新对象值指针
        subject->ptr = l;

    } else {
        redisPanic("Unsupported list conversion");
    }
}

hash对象

创建一个hash对象时，底层编码为ZIPLIST
当存储的元素数量超过server.hash_max_ziplist_value时，则转化为HASHTABLE

/*
 * 创建一个 ZIPLIST 编码的哈希对象
 */
robj *createHashObject(void) {

    unsigned char *zl = ziplistNew();

    robj *o = createObject(REDIS_HASH, zl);

    o->encoding = REDIS_ENCODING_ZIPLIST;

    return o;
}

如果对象长度超过hash_max_ziplist_value，那么就转化为hashtable

void hashTypeTryConversion(robj *o, robj **argv, int start, int end) {
    int i;

    // 如果对象不是 ziplist 编码，那么直接返回
    if (o->encoding != REDIS_ENCODING_ZIPLIST) return;

    // 检查所有输入对象，看它们的字符串值是否超过了指定长度
    for (i = start; i <= end; i++) {
        if (sdsEncodedObject(argv[i]) &&
            sdslen(argv[i]->ptr) > server.hash_max_ziplist_value)
        {
            // 将对象的编码转换成 REDIS_ENCODING_HT
            hashTypeConvert(o, REDIS_ENCODING_HT);
            break;
        }
    }
}

两者如何转化的呢？

/*
 * 将一个 ziplist 编码的哈希对象 o 转换成其他编码
 * enc是要转化的目标底层编码数据结构
 */
void hashTypeConvertZiplist(robj *o, int enc) {
    redisAssert(o->encoding == REDIS_ENCODING_ZIPLIST);

    // 目前编码方式已经是ZIPLIST，自然不需要改变
    if (enc == REDIS_ENCODING_ZIPLIST) {
        /* Nothing to do... */

    // 转换成 HT（HASHTABLE） 编码
    } else if (enc == REDIS_ENCODING_HT) {

        hashTypeIterator *hi;
        dict *dict;
        int ret;

        // 创建哈希迭代器
        hi = hashTypeInitIterator(o);

        // 创建空白的新字典
        dict = dictCreate(&hashDictType, NULL);

        // 遍历整个 ziplist
        while (hashTypeNext(hi) != REDIS_ERR) {
            robj *field, *value;

            // 取出 ziplist 里的键
            field = hashTypeCurrentObject(hi, REDIS_HASH_KEY);
            field = tryObjectEncoding(field);

            // 取出 ziplist 里的值
            value = hashTypeCurrentObject(hi, REDIS_HASH_VALUE);
            value = tryObjectEncoding(value);

            // 将键值对添加到字典
            ret = dictAdd(dict, field, value);
            if (ret != DICT_OK) {
                redisLogHexDump(REDIS_WARNING,"ziplist with dup elements dump",
                    o->ptr,ziplistBlobLen(o->ptr));
                redisAssert(ret == DICT_OK);
            }
        }

        // 释放 ziplist 的迭代器
        hashTypeReleaseIterator(hi);

        // 释放对象原来的 ziplist
        zfree(o->ptr);

        // 更新哈希的编码和值对象
        o->encoding = REDIS_ENCODING_HT;
        o->ptr = dict;

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

那么如何添加一个k->v键值对呢？
对于不同的编码方式，采用不同的插入方式。

/* 
 * 将给定的 field-value 对添加到 hash 中，
 * 如果 field 已经存在，那么删除旧的值，并关联新值。
 *
 * 这个函数负责对 field 和 value 参数进行引用计数自增。
 * 返回结果：
 * 返回 0 表示元素已经存在，这次函数调用执行的是更新操作。
 * 返回 1 则表示函数执行的是新添加操作。
 * 
 */
int hashTypeSet(robj *o, robj *field, robj *value) {
    int update = 0;

    // 添加到 ziplist
    if (o->encoding == REDIS_ENCODING_ZIPLIST) {
        unsigned char *zl, *fptr, *vptr;

        // 解码成字符串或者数字
        field = getDecodedObject(field);
        value = getDecodedObject(value);

        // 遍历整个 ziplist ，尝试查找并更新 field （如果它已经存在的话）
        zl = o->ptr;
        fptr = ziplistIndex(zl, ZIPLIST_HEAD);
        if (fptr != NULL) {
            // 定位到域 field
            fptr = ziplistFind(fptr, field->ptr, sdslen(field->ptr), 1);
            if (fptr != NULL) {
                /* Grab pointer to the value (fptr points to the field) */
                // 定位到域的值
                vptr = ziplistNext(zl, fptr);
                redisAssert(vptr != NULL);

                // 标识这次操作为更新操作
                update = 1;

                /* Delete value */
                // 删除旧的键值对
                zl = ziplistDelete(zl, &vptr);

                /* Insert new value */
                // 添加新的键值对
                zl = ziplistInsert(zl, vptr, value->ptr, sdslen(value->ptr));
            }
        }

        // 如果这不是更新操作，那么这就是一个添加操作
        if (!update) {
            /* Push new field/value pair onto the tail of the ziplist */
            // 插入压缩链表末尾
            zl = ziplistPush(zl, field->ptr, sdslen(field->ptr), ZIPLIST_TAIL);
            zl = ziplistPush(zl, value->ptr, sdslen(value->ptr), ZIPLIST_TAIL);
        }
        
        // 更新对象指针
        o->ptr = zl;

        // 释放临时对象
        decrRefCount(field);
        decrRefCount(value);

        /* Check if the ziplist needs to be converted to a hash table */
        // 检查在添加操作完成之后，是否需要将 ZIPLIST 编码转换成 HT 编码
        if (hashTypeLength(o) > server.hash_max_ziplist_entries)
            hashTypeConvert(o, REDIS_ENCODING_HT);

    // 添加到字典
    } else if (o->encoding == REDIS_ENCODING_HT) {

        // 添加或替换键值对到字典
        // 添加返回 1 ，替换返回 0
        if (dictReplace(o->ptr, field, value)) { /* Insert */
            incrRefCount(field);
        } else { /* Update */
            update = 1;
        }

        incrRefCount(value);
    } else {
        redisPanic("Unknown hash encoding");
    }

    // 更新/添加指示变量
    return update;
}

只讲解几个命令，其余指令同样也在在t_hash.c文件中，与添加操作类似。

集合对象

集合对象底层数据结构可以是
REDIS_ENCODING_HT 或者 REDIS_ENCODING_INTSET

/*
 * 创建一个 HT 编码的集合对象
 */
robj *createSetObject(void) {

    dict *d = dictCreate(&setDictType,NULL);

    robj *o = createObject(REDIS_SET,d);

    o->encoding = REDIS_ENCODING_HT;

    return o;
}

/*
 * 创建一个 INTSET 编码的集合对象
 */
robj *createIntsetObject(void) {

    intset *is = intsetNew();

    robj *o = createObject(REDIS_SET,is);

    o->encoding = REDIS_ENCODING_INTSET;

    return o;
}

当输入的值可以被编码为整数时，用INTSET编码

robj *setTypeCreate(robj *value) {

    if (isObjectRepresentableAsLongLong(value,NULL) == REDIS_OK)
        return createIntsetObject();

    return createSetObject();
}

如何添加新元素
就算集合中全都可以被编码为整数，但是集合的元素个数>server.set_max_intset_entries
也会编码为hashtable从而加快查询效率

/*
 * 添加成功返回 1 ，如果元素已经存在，返回 0 。
 */
int setTypeAdd(robj *subject, robj *value) {
    long long llval;

    // 判断底层数据结构
    if (subject->encoding == REDIS_ENCODING_HT) {
        // 将 value 作为键， NULL 作为值，将元素添加到字典中
        if (dictAdd(subject->ptr,value,NULL) == DICT_OK) {
            incrRefCount(value);
            return 1;
        }

    // intset
    } else if (subject->encoding == REDIS_ENCODING_INTSET) {
        
        // 如果对象的值可以编码为整数的话，那么将对象的值添加到 intset 中
        if (isObjectRepresentableAsLongLong(value,&llval) == REDIS_OK) {
            uint8_t success = 0;
            subject->ptr = intsetAdd(subject->ptr,llval,&success);
            if (success) {
                // 添加成功
                // 检查集合在添加新元素之后是否需要转换为字典
                if (intsetLen(subject->ptr) > server.set_max_intset_entries)
                    setTypeConvert(subject,REDIS_ENCODING_HT);
                return 1;
            }

        // 如果对象的值不能编码为整数，那么将集合从 intset 编码转换为 HT 编码
        // 然后再执行添加操作
        } else {
            // 转化为HT
            setTypeConvert(subject,REDIS_ENCODING_HT);

            // 添加HT时，将当前的value作为键值，键对应的值为NULL
            // 添加value -> NULL键值对
            redisAssertWithInfo(NULL,value,dictAdd(subject->ptr,value,NULL) == DICT_OK);
            incrRefCount(value);
            return 1;
        }

    // 未知编码
    } else {
        redisPanic("Unknown set encoding");
    }

    // 添加失败，元素已经存在
    return 0;
}

有序集合

有两种底层数据结构实现有序集合

  1. 底层为ZIPLIST
  2. 底层为ZSET结构。ZSET结构由一个跳表和一个字典组成

我们先看ZIPLIST作为底层，相对比较简单

ZIPLIST为底层的有序集合

/*
 * 创建一个 ZIPLIST 编码的有序集合
 */
robj *createZsetZiplistObject(void) {

    unsigned char *zl = ziplistNew();

    robj *o = createObject(REDIS_ZSET,zl);

    o->encoding = REDIS_ENCODING_ZIPLIST;

    return o;
}

创建了一个ZIPLIST，然后又创建了一个对象指向它。
比如我们使用以下的命令创建一个有序列表
ZADD runoobkey 1 redis
ZADD runoobkey 2 mongodb
ZADD runoobkey 3 mysql

每当调用ZADD命令时，系统底层调用t_zset.c中的zaddGenericCommand函数
下面节选了函数的关键一部分

创建的过程

// 取出有序集合对象
    zobj = lookupKeyWrite(c->db,key);
    if (zobj == NULL) {
        // 有序集合不存在，创建新有序集合
        if (server.zset_max_ziplist_entries == 0 ||
            server.zset_max_ziplist_value < sdslen(c->argv[3]->ptr))
        {
            zobj = createZsetObject();
        } else {
            zobj = createZsetZiplistObject();
        }
        // 关联对象到数据库
        dbAdd(c->db,key,zobj);
    } else {
        // 对象存在，检查类型
        if (zobj->type != REDIS_ZSET) {
            addReply(c,shared.wrongtypeerr);
            goto cleanup;
        }
    }

当底层编码为ZIPLIST时，添加操作如下

// 有序集合为 ziplist 编码
        if (zobj->encoding == REDIS_ENCODING_ZIPLIST) {
            unsigned char *eptr;

            /* Prefer non-encoded element when dealing with ziplists. */
            // 查找成员
            ele = c->argv[3+j*2];
            if ((eptr = zzlFind(zobj->ptr,ele,&curscore)) != NULL) {

                // 成员已存在

                // ZINCRYBY 命令时使用
                if (incr) {
                    score += curscore;
                    if (isnan(score)) {
                        addReplyError(c,nanerr);
                        goto cleanup;
                    }
                }

                /* Remove and re-insert when score changed. */
                // 执行 ZINCRYBY 命令时，
                // 或者用户通过 ZADD 修改成员的分值时执行
                if (score != curscore) {
                    // 删除已有元素
                    zobj->ptr = zzlDelete(zobj->ptr,eptr);
                    // 重新插入元素
                    zobj->ptr = zzlInsert(zobj->ptr,ele,score);
                    // 计数器
                    server.dirty++;
                    updated++;
                }
            } else {
                /* Optimize: check if the element is too large or the list
                 * becomes too long *before* executing zzlInsert. */
                // 元素不存在，直接添加
                zobj->ptr = zzlInsert(zobj->ptr,ele,score);

                // 查看元素的数量，
                // 看是否需要将 ZIPLIST 编码转换为有序集合
                if (zzlLength(zobj->ptr) > server.zset_max_ziplist_entries)
                    zsetConvert(zobj,REDIS_ENCODING_SKIPLIST);

                // 查看新添加元素的长度
                // 看是否需要将 ZIPLIST 编码转换为有序集合
                if (sdslen(ele->ptr) > server.zset_max_ziplist_value)
                    zsetConvert(zobj,REDIS_ENCODING_SKIPLIST);

                server.dirty++;
                added++;
            }

        // 有序集合为 SKIPLIST 编码
        }

对ziplist编码的有序集合，添加操作，插入到第一个分值大于当前值的节点之前

/* Insert (element,score) pair in ziplist. 
 *
 * 将 ele 成员和它的分值 score 添加到 ziplist 里面
 *
 * ziplist 里的各个节点按 score 值从小到大排列
 */
unsigned char *zzlInsert(unsigned char *zl, robj *ele, double score) {

    // 指向 ziplist 第一个节点（也即是有序集的 member 域）
    unsigned char *eptr = ziplistIndex(zl,0), *sptr;
    double s;

    // 解码值
    ele = getDecodedObject(ele);

    // 遍历整个 ziplist
    while (eptr != NULL) {

        // 取出分值
        sptr = ziplistNext(zl,eptr);
        redisAssertWithInfo(NULL,ele,sptr != NULL);
        s = zzlGetScore(sptr);

        if (s > score) {
            // 遇到第一个 score 值比输入 score 大的节点
            // 将新节点插入在这个节点的前面，
            // 让节点在 ziplist 里根据 score 从小到大排列
            zl = zzlInsertAt(zl,eptr,ele,score);
            break;
        } else if (s == score) {
            /* Ensure lexicographical ordering for elements. */
            // 如果输入 score 和节点的 score 相同
            // 那么根据 member 的字符串位置来决定新节点的插入位置
            if (zzlCompareElements(eptr,ele->ptr,sdslen(ele->ptr)) > 0) {
                zl = zzlInsertAt(zl,eptr,ele,score);
                break;
            }
        }

        /* Move to next element. */
        // 输入 score 比节点的 score 值要大
        // 移动到下一个节点
        eptr = ziplistNext(zl,sptr);
    }

    /* Push on tail of list when it was not yet inserted. */
    if (eptr == NULL)
        zl = zzlInsertAt(zl,NULL,ele,score);

    decrRefCount(ele);
    return zl;
}

ZSET结构为底层的有序集合

对于底层是跳表和字典组成的有序集合会比较复杂，我们详细的讲解。

/*
 * 创建一个 zset编码的有序集合
 */
robj *createZsetObject(void) {

    zset *zs = zmalloc(sizeof(*zs));

    robj *o;

    zs->dict = dictCreate(&zsetDictType,NULL);
    zs->zsl = zslCreate();

    o = createObject(REDIS_ZSET,zs);

    o->encoding = REDIS_ENCODING_SKIPLIST;

    return o;
}

创建了一个REDIS_ENCODING_SKIPLIST编码的底层结构为zset的有序集合

/*
 * 有序集合
 */
typedef struct zset {

    // 字典，键为成员，值为分值
    // 用于支持 O(1) 复杂度的按成员取分值操作
    dict *dict;

    // 跳跃表，按分值排序成员
    // 用于支持平均复杂度为 O(log N) 的按分值定位成员操作
    // 以及范围操作
    zskiplist *zsl;

} zset;

对于底层是zset的有序集合的添加操作

...

// 有序集合为 SKIPLIST 编码
else if (zobj->encoding == REDIS_ENCODING_SKIPLIST) {
            zset *zs = zobj->ptr;
            zskiplistNode *znode;
            dictEntry *de;

            // 编码对象
            ele = c->argv[3+j*2] = tryObjectEncoding(c->argv[3+j*2]);

            // 查看成员是否存在
            de = dictFind(zs->dict,ele);
            if (de != NULL) {

                // 成员存在

                // 取出成员
                curobj = dictGetKey(de);
                // 取出分值
                curscore = *(double*)dictGetVal(de);

                // ZINCRYBY 时执行
                if (incr) {
                    score += curscore;
                    if (isnan(score)) {
                        addReplyError(c,nanerr);
                        /* Don't need to check if the sorted set is empty
                         * because we know it has at least one element. */
                        goto cleanup;
                    }
                }
                
                // 执行 ZINCRYBY 命令时，
                // 或者用户通过 ZADD 修改成员的分值时执行
                if (score != curscore) {
                    // 删除原有元素
                    redisAssertWithInfo(c,curobj,zslDelete(zs->zsl,curscore,curobj));

                    // 重新插入元素
                    znode = zslInsert(zs->zsl,score,curobj);
                    incrRefCount(curobj); /* Re-inserted in skiplist. */

                    // 更新字典的分值指针
                    dictGetVal(de) = &znode->score; /* Update score ptr. */

                    server.dirty++;
                    updated++;
                }
            } else {

                // 元素不存在，直接添加到跳跃表
                znode = zslInsert(zs->zsl,score,ele);
                incrRefCount(ele); /* Inserted in skiplist. */

                // 将元素关联到字典
                redisAssertWithInfo(c,NULL,dictAdd(zs->dict,ele,&znode->score) == DICT_OK);
                incrRefCount(ele); /* Added to dictionary. */

                server.dirty++;
                added++;
            }
        }

有序集合的成员都是字符串，分值都是浮点数。
虽然有两个数据结构，一个是跳跃表，一个是字典。
但是其底层指针所指向的分值和成员都是同一个数据空间。

引用计数

在之前redisObject结构体中，我们看到过refcount。
当对象被创建时，refcount初始化为1。
每当有程序使用时refcount+1
每当一个程序结束使用时refcount-1
当refcount为1时，再次调用decrRefCount()时，就会回收内存。

/*
 * 为对象的引用计数减一
 *
 * 当对象的引用计数降为 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--;
    }
}

拿上文以ZSET为底层数据结构的有序集合为例。
将对象添加跳表时 refcount + 1
将对象添加字典时 refcount + 1
所以当对象加入时 refcount 一共 + 2。

有一个例外的特例就是我们上文提到的共享变量其refcount恒等于 INT_MAX

LRU

LRU 属性记录了对象最后一次被访问的时间
空转时长就是当前时间减去LRU记录的时间，也表示已有这么长的时间该对象没有被使用过。
当数据库内存超过限制时，根据配置策略的不同，会考虑到空转时长这一属性。

cggggw
关注
专栏目录
Redis——Redis Cluster集群原理
庄小焱
03-14 4630
摘要 我们平时习惯于使用 Rabbitmq 和 Kafka 作为消息队列中间件，来给应用程序之间增加异步消息传递功能。这两个中间件都是专业的消息队列中间件，特性之多超出了大多数人的理解能力。使用过 Rabbitmq 的同学知道它使用起来有多复杂，发消息之前要创建 Exchange，再创建 Queue，还要将 Queue 和 Exchange 通过某种规则绑定起来，发消息的时候要指定 routingkey，还要控制头部信息。消费者在消费消息之前也要进行上面一系列的繁琐过程。但是绝大多数情况下，虽然我们的消息
Redis对象详解
weixin_45563088的博客
03-19 2468
文章目录五种基本数据类型Redis对象的组成字符串对象SDS不同编码的区别int编码embstr 和 rawRedis如何选择编码列表对象linkedlist编码ziplist编码压缩列表内存连续压缩列表的构成压缩列表节点的构成哈希对象ziplist编码hashtable编码字典Rehash集合对象有序集合对象ziplist实现skiplist实现为什么还要使用字典？skiplist小结 五种基本数据类型 Redis支持五种基本数据类型：String，Hash，List，Set，Zset / Sorted
Redis教程：数据对象分析（一）
destiny的专栏
02-21 300
1、 五种基本数据对象 图1 redis数据对象 2、 数据结构对象分析 Redis中的每个对象都由一个redisObject结构表示，该结构中保存数据相关的三个属性分别是：type、encoding、ptr。 redis.h typedef struct redisObject { //类型 unsigned type:4; unsigned n...
redis-5大对象之---存储基础结构
八角塘塘主的博客
12-15 2757
第一节：字符串-SDS：字符串数组字符串结构： 优势： 1、空间预分配： free < 1M，则翻一倍，free=len free > 1M，则free=1M 2、惰性释放 sdsclear:释放内容，但是内存不释放 sdsfree:释放空间和内容 3、还能存图片 二进制安全，以二进制来读写第二节：链表-list 第三节：字典-HashMap-哈希表建立了索引的数组和链表
redis代码结构之三类型库-list
阿罗
01-19 1896
redis代码结构之三类型库-list  1. REDIS_LIST(t_list.c) 该类型的命令包括：lpush,rpush,lpop,rpop等等。这里我们只介绍lpush命令，它相应的命令回调函数为void lpushCommand(redisClient *c) { pushGenericCommand(c,REDIS_HEAD);}我们直接看pushGenericCommand
redis大对象相关
wenxi2367的博客
03-12 1480
什么对象是大对象?如何查询大对象？
Redis实战——Redisson分布式锁
qq_59212867的博客
12-11 6148
Redis实战——Redisson分布式锁的使用及原其理
Redis系列——底层数据结构分析
weixin_46734067的博客
03-18 206
前言 redis作为k->v的数据库，广泛的使用在缓存中。我每次用redis时就直接调用api或者spring中封装好的对象，从来没有深入研究过内部结构。这也导致有时候面试被问到了，或者自己在调用的时候一知半解，出了问题不知道怎么去排查。 最近在看好多redis的技术书籍以及相关博客，也同时写一系列的redis文章，便于自己梳理脉络，也方便新手入门。 由于本人技术水平限制，错误在所难免，若有发现请及时留言，谢谢。 简单动态字符串SDS redis用c语言编写。在c语言中字符串用以\0结尾的数组。但是r
Redis内存——内存消耗(内存都去哪了？)
yufaxingxing的博客
05-20 609
最新：Redis内存——三个重要的缓冲区 最新：Redis内存——内存消耗(内存都去哪了？) 最新：Redis持久化——如何选择合适的持久化方式 最新：Redis持久化——AOF日志 更多文章... Reids作为一个基于内存的数据库，内存是否能够高效合理的利用至关重要！从价格上来讲，我们从某宝或某东上可以看到内存条的价格要比普通的机械硬盘贵上十几倍，就算是是固态硬盘也要贵上不少，从性能上来说，...
Redis——Redis线程模型原理
庄小焱
12-30 1284
Redis 作为缓存系统的事实标准，它的底层原理值得开发者去深入学习，Redis 自 2009 年发布第一版之后，其单线程网络模型的选择在社区中从未停止过讨论。如今到网络上搜索redis线程模型原理文章。都存在很多的误导大家的学习，同时没有深入对redis的线程模型的原理和redis到底使用的是单线程还是使用的多线的原因解释不清楚，今天博文博文将详细的介绍redis3.5的单线模型和redis6.0的多线程模型的原理。
Redis——DelayedQueue原理与应用
庄小焱
03-15 2444
摘要 主要介绍的是的线程的IO模型的原理 Redis 是个单线程程序！ 这点必须铭记。也许你会怀疑高并发的 Redis 中间件怎么可能是单线程。很抱歉，它就是单线程，你的怀疑暴露了你基础知识的不足。莫要瞧不起单线程，除了 Redis 之外， Node.js 也是单线程， Nginx 也是单线程，但是它们都是服务器高性能的典范。 Redis 单线程为什么还能这么快？ 因为它所有的数据都在内存中，所有的运算都是内存级别的运算。正因为 Redis 是单线程，所以要小心使用 Redis 指令，对于那些时
Redis源码学习简记（七）object原理与个人理解
菜鸟的学习之路
04-11 742
        object是redis中的封装系统。其把string，list，set，zset与hash封装成一个统一的对象，命名为robj。该数据结构中，存储了类型，编码，引用次数，数据与LRU替换算法的一些数据。具体先看看这个数据结构的定义，在server.h中定义。 //redis属于key-value 数据库 //nosql数据库，这种映射关系使用dict用来维护 //而dict实...
Redis源码阅读笔记-对象及其类型和编码
weixin_34342578的博客
09-22 128
2019独角兽企业重金招聘Python工程师标准>>> ...
redis原理-对象以及命令解析与执行
webrtc
02-17 7278
redis原理-对象以及命令解析与执行 一、  redis对象 适用场景： redis是使用对象来存放数据的，基于前面的几种数据结构创建对象。 原理解释： redis对象类型有下面5种：    /*Object types */ #define REDIS_STRING 0  #define REDIS_LIST 1 #define REDIS_SET 2 #define R
Redis list 类型
m0_74099572的博客
10-07 688
列表类型 list 相当于 数组或者顺序表list内部的编码方式更接近于 双端队列 ，支持头插 头删 尾插 尾删。需要注意的是，Redis的下标支持负数下标。 比如数组大小为5，那么要访问下标为 -2 的值可以理解为访问 5 - 2 = 3Redis中的数据是有序的，但是注意这里的有序不是指排序数组中的升序或者降序，而是指数据的顺序很关键。比如把元素位置调换之后，得到的新的list与原来的list是不等价的。同样的一个词在不同的上下文中，它的意义可能是不一样的。比如同步这个词在 线程之间和IO之间的意义就不
SpringBoot日常：redission的接入使用和源码解析
qq_32590535的博客
10-08 1158
Redisson 是一个在 Redis 的基础上实现的 Java 驻内存数据网格客户端（In-Memory Data Grid）。它不仅提供了一系列的 redis 常用数据结构命令服务，还提供了许多分布式服务，例如分布式锁、分布式对象、分布式集合、分布式远程服务、分布式调度任务服务等等。本文会介绍如何将redission集成到springboot和如何使用 Redisson 操作 Redis 中的字符串、哈希、列表、集合、有序集合，以及布隆过滤器和分布式锁等功能，并解析源码中其最大亮点的看门狗机制。
滚雪球学Redis[1.3讲]：Redis的安装与配置
**My Coding Family**
10-09 709
在前几期文章中，我们探讨了什么是 Redis以及Redis 的基本架构，从宏观上理解了 Redis 是一个高性能的内存数据库，并学习了其客户端-服务器模型、单线程与多线程设计、内存存储与持久化机制等关键概念。这些知识为我们打下了理论基础。然而，理论与实践结合，才能真正掌握 Redis。本期，我们将深入探讨 Redis 的安装与配置过程，包括在多种操作系统上的安装方法、Redis 配置文件的重要选项以及安装过程中常见的错误与解决方案。这些内容将帮助你顺利地在本地或生产环境中部署和配置 Redis。
重学SpringBoot3-集成Redis（十二）之点赞功能实现
最新发布
CoderJia的学习之路
10-11 2439
在现代的应用中，点赞功能是一个非常常见的需求，尤其在社交媒体、博客等平台上。Redis 作为一个高性能的键值存储系统，由于其读写速度快、支持丰富的数据结构，因此非常适合用来实现实时的点赞功能。本文将介绍如何结合 Spring Boot 3 和 Redis 来实现一个高效的点赞功能。
《Redis实战》——KS著
7. 性能优化：探讨如何监控和分析Redis的性能，以及如何通过调整配置、优化数据结构或使用缓存策略来提升性能。 8. Redis与其他系统的集成：如何将Redis与其他应用（如Web应用、消息队列等）集成，实现缓存、队列、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值