写在前面
以下内容是基于Redis 6.2.6 版本整理总结
一、对象
前面几篇文章，我们介绍了Redis用到的主要的数据结构，如：sds、list、dict、ziplist、skiplist、inset等。
但是，Redis并没有直接使用这些数据结构来实现key-value数据库，而是基于这些数据结构构建了一个对象系统。包括字符串对象、列表对象、哈希对象、集合对象和有序集合对象五种类型的对象。每种对象都使用了至少一种前面提到的数据结构。
通过对对象的区分，Redis可以在执行命令前判断该对象是否能够执行该条命令。为对象设置不同的数据结构实现，只要是为了提高效率。
二、对象的类型及编码
Redis使用对象来表示数据中的key和value，每当我们在Redis数据库中创建一个新的键值对时，至少会创建两个对象，一个作用域key，另一个作用于value。
举个栗子：set msg “hello world” 表示分别创建了一个字符串对象保存“msg”，另一个字符串对象保存“hello world”:
redisObject 结构体
Redis中的每个对象由 redisObject 结构体来描述，对象的类型、编码、内存回收、共享对象都需要redisObject的支持，redisObject 结构体定义如下：
#define LRU_BITS 24
typedef struct redisObject {
unsigned type:4; // 类型
unsigned encoding:4; // 编码
unsigned lru:LRU_BITS; /* LRU time (relative to global lru_clock) or
* LFU data (least significant 8 bits frequency
* and most significant 16 bits access time). */
int refcount;
void *ptr;
} robj;
下面我们来看看每个字段的含义:
（1）type： 占4个比特位，表示对象的类型，有五种类型。当我们执行type命令时，便是通过type字段获取对象的类型。
/* The actual Redis Object */
#define OBJ_STRING 0 /* String object. */
#define OBJ_LIST 1 /* List object. */
#define OBJ_SET 2 /* Set object. */
#define OBJ_ZSET 3 /* Sorted set object. */
#define OBJ_HASH 4 /* Hash object. */
type命令使用示例：
（2）encoding： 占4个比特位，表示对象使用哪种编码，redis会根据不同的场景使用不同的编码，大大提高了redis的灵活性和效率。
字符串对象不同编码类型示例：
（3）lru： 占 24 个比特位，记录该对象最后一次被访问的时间。千万别以为这只能在LRU淘汰策略中才用，LFU也是复用的个字段。当使用LRU时，它保存的上次读写的24位unix时间戳(秒级)；使用LFU时，24位会被分为两个部分，16位的分钟级时间戳和8位特殊计数器，这里就不展开了，详细可以注意我后续的文章。
（4）refcount： 对象的引用计数，类似于shared_ptr 智能指针的引用计数，当refcount为0时，释放该对象。
（5）ptr: 指向对象具体的底层实现的数据结构。
三、不同对象编码规则
四、对象在源码中的使用
4.1 字符串对象
4.1.1字符串对象创建
// code location： src/object.c
#define OBJ_ENCODING_EMBSTR_SIZE_LIMIT 44
// 创建 strintg 对象
robj *createStringObject(const char *ptr, size_t len) {
// 如果待保存的字符串的长度小于等于44，使用 embstr 编码
if (len <= OBJ_ENCODING_EMBSTR_SIZE_LIMIT)
return createEmbeddedStringObject(ptr,len);
else // 否则使用 raw 编码
return createRawStringObject(ptr,len);
}
robj *createEmbeddedStringObject(const char *ptr, size_t len) {
// 申请 robj + sdshdr + data + 1 的空间
robj *o = zmalloc(sizeof(robj)+sizeof(struct sdshdr8)+len+1);
struct sdshdr8 *sh = (void*)(o+1);
o->type = OBJ_STRING; // 设置类型
o->encoding = OBJ_ENCODING_EMBSTR; // 设置编码
o->ptr = sh+1;
o->refcount = 1;
if (server.maxmemory_policy & MAXMEMORY_FLAG_LFU) {
o->lru = (LFUGetTimeInMinutes()<<8) | LFU_INIT_VAL;
} else {
o->lru = LRU_CLOCK();
}
sh->len = len;
sh->alloc = len;
sh->flags = SDS_TYPE_8;
if (ptr == SDS_NOINIT)
sh->buf[len] = '\0';
else if (ptr) {
memcpy(sh->buf,ptr,len);
sh->buf[len] = '\0';
} else {
memset(sh->buf,0,len+1);
}
return o;
}
从 createEmbeddedStringObject 函数可以看到，该对象是robj和sds的结合体，将sds直接放入到robj里，这也是嵌入式编码embstr的由来。
为什么要限制44字节呢？因为robj结构体占16个字节，sdshdr结构体占3个字节，最后结尾的‘\0’占一个字节，限制44个字节，就能保证64个字节里能放下所有内容（16+3+1+44 = 64）。
4.1.2 字符串对象编码
Redis将节省内存做到了极致，它的作者对字符串对象又做了特殊的编码处理，以进一步达到节省空间的目的。编码处理过程及代码注释如下：
/* Try to encode a string object in order to save space */
robj *tryObjectEncoding(robj *o) {
long value;
sds s = o->ptr;
size_t len;
/* Make sure this is a string object, the only type we encode
* in this function. Other types use encoded memory efficient
* representations but are handled by the commands implementing
* the type. */
// 这里只对string对象进行编码，其他类型的编码都有对应的具体实现处理
serverAssertWithInfo(NULL,o,o->type == OBJ_STRING);
/* We try some specialized encoding only for objects that are
* RAW or EMBSTR encoded, in other words objects that are still
* in represented by an actually array of chars. */
// 非sds string对象，直接返回原对象
if (!sdsEncodedObject(o)) return o;
/* It's not safe to encode shared objects: shared objects can be shared
* everywhere in the "object space" of Redis and may end in places where
* they are not handled. We handle them only as values in the keyspace. */
// 如果该对象由其他对象共享，不能编码，如果编码可能影响到其他对象的使用
if (o->refcount > 1) return o;
/* Check if we can represent this string as a long integer.
* Note that we are sure that a string larger than 20 chars is not
* representable as a 32 nor 64 bit integer. */
// 检查能否把一个字符串表示为长整型数，长度要小于等于20
len = sdslen(s);
if (len <= 20 && string2l(s,len,&value)) {
/* This object is encodable as a long. Try to use a shared object.
* Note that we avoid using shared integers when maxmemory is used
* because every object needs to have a private LRU field for the LRU
* algorithm to work well. */
// 如果可以被编码为long型，且编码后的值小于OBJ_SHARED_INTEGERS(10000)，且未配
// 置LRU替换淘汰策略, 就使用这个数的共享对象，相当于所有小于10000的数都是用的同一个robj
if ((server.maxmemory == 0 ||
!(server.maxmemory_policy & MAXMEMORY_FLAG_NO_SHARED_INTEGERS)) &&
value >= 0 &&
value < OBJ_SHARED_INTEGERS)
{
decrRefCount(o);
incrRefCount(shared.integers[value]);
return shared.integers[value];
} else {
if (o->encoding == OBJ_ENCODING_RAW) {
sdsfree(o->ptr);
o->encoding = OBJ_ENCODING_INT;
o->ptr = (void*) value;
return o;
} else if (o->encoding == OBJ_ENCODING_EMBSTR) {
decrRefCount(o);
return createStringObjectFromLongLongForValue(value);
}
}
}
// 不能转为long的字符串
/* If the string is small and is still RAW encoded,
* try the EMBSTR encoding which is more efficient.
* In this representation the object and the SDS string are allocated
* in the same chunk of memory to save space and cache misses. */
// 如果字符串的长度太小，小于等于44
if (len <= OBJ_ENCODING_EMBSTR_SIZE_LIMIT) {
robj *emb;
// 如果当前编码是embstr，直接返回原对象，否则转为embstr编码，返回
if (o->encoding == OBJ_ENCODING_EMBSTR) return o;
emb = createEmbeddedStringObject(s,sdslen(s));
decrRefCount(o);
return emb;
}
/* We can't encode the object...
*
* Do the last try, and at least optimize the SDS string inside
* the string object to require little space, in case there
* is more than 10% of free space at the end of the SDS string.
*
* We do that only for relatively large strings as this branch
* is only entered if the length of the string is greater than
* OBJ_ENCODING_EMBSTR_SIZE_LIMIT. */
// 如果前面编码没有成功，这里做最后一步，当编码类型为raw，且它的sds可用空间超过10%，
// 尝试释放调这部分内存
trimStringObjectIfNeeded(o);
/* Return the original object. */
// 返回原对象
return o;
}
4.1.3 字符串对象解码
有编码就有解码，实际上只需要那些可以转为整型类型的字符串传进行解码，解码代码及注释如下：
robj *getDecodedObject(robj *o) {
robj *dec;
// 如果编码是 embstr 和 raw ，只是把引用计数加一，然后返回原对象
if (sdsEncodedObject(o)) {
incrRefCount(o);
return o;
}
// 如果编码是 int 进行解码，返回新的对象
if (o->type == OBJ_STRING && o->encoding == OBJ_ENCODING_INT) {
char buf[32];
ll2string(buf,32,(long)o->ptr);
dec = createStringObject(buf,strlen(buf));
return dec;
} else {
serverPanic("Unknown encoding type");
}
}
4.2 redis对象引用计数及自动清理
void incrRefCount(robj *o) {
if (o->refcount < OBJ_FIRST_SPECIAL_REFCOUNT) {
o->refcount++; // 引用计数加一
} else {
if (o->refcount == OBJ_SHARED_REFCOUNT) {
/* Nothing to do: this refcount is immutable. */
} else if (o->refcount == OBJ_STATIC_REFCOUNT) {
serverPanic("You tried to retain an object allocated in the stack");
}
}
}
// 减少引用计数
void decrRefCount(robj *o) {
// 释放空间
if (o->refcount == 1) {
switch(o->type) {
case OBJ_STRING: freeStringObject(o); break;
case OBJ_LIST: freeListObject(o); break;
case OBJ_SET: freeSetObject(o); break;
case OBJ_ZSET: freeZsetObject(o); break;
case OBJ_HASH: freeHashObject(o); break;
case OBJ_MODULE: freeModuleObject(o); break;
case OBJ_STREAM: freeStreamObject(o); break;
default: serverPanic("Unknown object type"); break;
}
zfree(o);
} else {
if (o->refcount <= 0) serverPanic("decrRefCount against refcount <= 0");
if (o->refcount != OBJ_SHARED_REFCOUNT) o->refcount--; // 计数减一
}
}
五、总结
- redis对象为所有类型的value提供了统一的封装
- 为对象的淘汰策略保存相关信息
- 实现引用计数及内存自动释放功能
