#define OBJ_ZSET 3 /* Sorted set object. */
#define OBJ_HASH 4 /* Hash object. */
/* The "module" object type is a special one that signals that the object
-
is one directly managed by a Redis module. In this case the value points
-
to a moduleValue struct, which contains the object value (which is only
-
handled by the module itself) and the RedisModuleType struct which lists
-
function pointers in order to serialize, deserialize, AOF-rewrite and
-
free the object.
-
Inside the RDB file, module types are encoded as OBJ_MODULE followed
-
by a 64 bit module type ID, which has a 54 bits module-specific signature
-
in order to dispatch the loading to the right module, plus a 10 bits
-
encoding version. */
#define OBJ_MODULE 5 /* Module object. 自定义消息类型*/
#define OBJ_STREAM 6 /* Stream object. 消息流*/
/* 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 OBJ_ENCODING_RAW 0 /* Raw representation 简单动态字符串*/
#define OBJ_ENCODING_INT 1 /* Encoded as integer 整数*/
#define OBJ_ENCODING_HT 2 /* Encoded as hash table 字典*/
#define OBJ_ENCODING_ZIPMAP 3 /* Encoded as zipmap 未使用*/
#define OBJ_ENCODING_LINKEDLIST 4 /* No longer used: old list encoding. 不再使用*/
#define OBJ_ENCODING_ZIPLIST 5 /* Encoded as ziplist 压缩列表*/
#define OBJ_ENCODING_INTSET 6 /* Encoded as intset 整数集合*/
#define OBJ_ENCODING_SKIPLIST 7 /* Encoded as skiplist 跳表*/
#define OBJ_ENCODING_EMBSTR 8 /* Embedded sds string encoding 简单动态字符串*/
#define OBJ_ENCODING_QUICKLIST 9 /* Encoded as linked list of ziplists 快速链表*/
#define OBJ_ENCODING_STREAM 10 /* Encoded as a radix tree of listpacks 流*/
对象的整个周期中，编码不是一成不变的。也是为了节约嘛。比如上面可以看到有个整数集合，当集合中所有元素都可以用整数表示时，底层数据结构采用整数集合。看：
int setTypeAdd(robj *subject, sds value) {
long long llval;
if (subject->encoding == OBJ_ENCODING_HT) {
dict *ht = subject->ptr;
dictEntry *de = dictAddRaw(ht,value,NULL);
if (de) {
dictSetKey(ht,de,sdsdup(value));
dictSetVal(ht,de,NULL);
return 1;
}
}
else if (subject->encoding == OBJ_ENCODING_INTSET) {
if (isSdsRepresentableAsLongLong(value,&llval) == C_OK) {
uint8_t success = 0;
subject->ptr = intsetAdd(subject->ptr,llval,&success);
if (success) {
/* Convert to regular set when the intset contains
- too many entries. */
if (intsetLen(subject->ptr) > server.set_max_intset_entries)
setTypeConvert(subject,OBJ_ENCODING_HT);
return 1;
}
}
else {
/* Failed to get integer from object, convert to regular set. */
setTypeConvert(subject,OBJ_ENCODING_HT);
/* The set was an intset and this value is not integer
- encodable, so dictAdd should always work. */
serverAssert(dictAdd(subject->ptr,sdsdup(value),NULL) == DICT_OK);
return 1;
}
}
else {
serverPanic("Unknown set encoding");
}
return 0;
}
当执行sadd命令向集合中添加元素时，redis会校验待添加的元素是否可以解析为整数。如果解析失败，则会将集合存储结构转换为字典。
对象在不同情况下会采用不同的方式存储，那同时采用多种数据结构存储呢？也是会的。我们来看一下例子：
有序字典zset
typedef struct zset {
dict *dict;
zskiplist *zsl;
} zset;
目前看来是：字典单个检索快，跳表批量检索稳。
那有个疑问了：这里就不艰苦朴素，勤俭持家了？
这里面存的是指针副本，不是数据副本哈。该花的地方还是得花啊，勤俭持家不等于抠抠搜搜嘛。
我们再看robj。
1）当robj存储的数据可以用long类型表示时，数据直接存储在ptr字段。
2）refcount用于实现对象的共享，实现思想比较经典了，具体可以看一下智能指针。
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--;
}
}
3）lru，缓存淘汰策略（不一定就是LRU哈，不要被事物的表面现象所迷惑，也有可能是LFU，在配置文件中设定）
redis获取时间是以一秒为周期执行系统调用获取精确时间，存储在server.lfu_decay_time中，不是实时获取的。
4）LFUDecrAndReturn，这个函数虽然我看不太懂，但是思想还是很不错的。
其返回计数值，实现了计数值随时间衰减的过程。不然越老的数据一般情况下访问次数越大，即使该对象可能很长时间没有访问了、
/* If the object decrement time is reached decrement the LFU counter but
-
do not update LFU fields of the object, we update the access time
-
and counter in an explicit way when the object is really accessed.
-
And we will times halve the counter according to the times of
-
elapsed time than server.lfu_decay_time.
-
Return the object frequency counter.
-
This function is used in order to scan the dataset for the best object
-
to fit: as we check for the candidate, we incrementally decrement the
-
counter of the scanned objects if needed. */
unsigned long LFUDecrAndReturn(robj *o) {
unsigned long ldt = o->lru >> 8;
unsigned long counter = o->lru & 255;
unsigned long num_periods = server.lfu_decay_time ? LFUTimeElapsed(ldt) / server.lfu_decay_time : 0;
if (num_periods)
counter = (num_periods > counter) ? 0 : counter - num_periods;
return counter;
}
