chapter8 对象

    Redis并没有直接使用这些数据结构来实现键值对数据库,而是基于这些数据结构创建了一个对象系统,这个系统包含字符串对象、列表对象、哈希对象、集合对象和有序集合对象这五种类型的对象,使用对象的一个好处是,我们可以针对不同的使用场景,为对象设置多种不同的数据结构实现,从而优化对象在不同场景下的使用效率。

    除此之外,Redis的对象还实现了基于引用计数技术的内存回收机制,当程序不再使用某个对象的时候,这个对象所占用的内存就会被自动释放;另外,Redis还通过引用计数技术实现了对象共享机制,这一机制可以在适当的条件下,通过让多个数据库键共享同一个对象来节约内存。

    最后,Redis的对象带有访问时间记录信息,该信息可以用于计算数据库键的空转时长,在服务器启用了maxmemory功能的情况下,空转时长较大的那些键可能会优先被服务器删除。

8.1 对象的类型和编码

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

8.1.1 类型

    对于Redis数据库保存的键值对来说,键总是一个字符串对象,而值则可以是字符串对象、列表对象、哈希对象、集合对象或者有序集合对象的其中一种。

127.0.0.1:6379> set msg "hello world"
OK
127.0.0.1:6379> type msg
string
127.0.0.1:6379> rpush numbers 1 3 5
(integer) 3
127.0.0.1:6379> type numbers
list
127.0.0.1:6379> hmset profile name Tom age 25 career Programmer
OK
127.0.0.1:6379> type profile
hash
127.0.0.1:6379> zadd price 8.5 apple 5.0 banana 6.0 cherry
(integer) 3
127.0.0.1:6379> type price
zset
127.0.0.1:6379> sadd fruits apple banana cherry
(integer) 3
127.0.0.1:6379> type fruits
set

8.1.2 编码和底层实现

    对象的ptr指针指向对象的的底层实现数据结构,而这些数据结构由对象的encoding属性决定。

    使用OBJECT ENCODING命令可以查看一个数据库键的值对象的编码:

127.0.0.1:6379> set msg "hello world"
OK
127.0.0.1:6379> object encoding msg
"embstr"
127.0.0.1:6379> set story "long long long long long long ago ..."
OK
127.0.0.1:6379> object encoding story
"embstr"
127.0.0.1:6379> sadd numbers 1 3 5
(integer) 3
127.0.0.1:6379> object encoding numbers
"intset"
127.0.0.1:6379> sadd numbers "seven"
(integer) 1
127.0.0.1:6379> object encoding numbers
"hashtable"

    Redis可以根据不同的使用场景来为一个对象设置不同的编码,从而优化对象在某一场景下的效率。

    举个例子,在列表对象包含的元素比较少时,Redis使用压缩列表对象的底层实现:

• 因为压缩列表比双端列表更节约内存,并且在元素数量较少时,在内存中以连续块方式保存的压缩列表比起双端链表更快被载入到缓存中
• 随着列表对象包含的元素越来越多,使用压缩列表来保存元素的优势逐渐消失时,对象就会将底层实现从压缩列表转向功能更强、也更适合保存大量元素的双端链表上面。

8.2 字符串对象

    字符串对象的编码可以是int、raw或者embstr。

    如果一个字符串对象保存的是整数值,并且这个整数值可以用long类型来表示,那么字符串对象会将整数值保存在字符串对象结构的ptr属性里面(讲void*转换成long),并将字符串对象的编码设置为int。

    举个例子,如果我们执行以下set命令,那么服务器将创建一个如图8-1所示的int编码的字符串对象作为number键的值:

redis> set number 10086
Ok
redis> object encoding number
"int"

    如果字符串对象保存的是一个字符串值,并且这个字符串值的长度大于39字节,那么字符串对象将使用一个简单动态字符串(SDS)来保存这个字符串值,并将对象的编码设置为raw。

    举个例子,如果我们执行以下命令,那么服务器将创建一个如图8-2所示的raw编码的字符串对象作为story键的值:

redis> set story "Long,long,long,long ago there lived a kong ..."
OK

redis> strlen story
(integer) 43

redis> object encoding story
"raw"

    如果字符串对象保存的是一个字符串值,并且这个字符串值的长度小于等于39字节,那么字符串对象将使用embstr编码的方式来保存这个字符串值。

    使用embstr编码的字符串对象来保存短字符串值有以下好处:

• embstr编码将创建字符串对象所需的内存分配次数从raw编码的两次降低为1次
• 释放embstr编码的字符串对象只需要调用一次内存释放函数,而释放raw编码的字符串对象需要调用两次内存释放函数。
• 因为embstr编码的字符串对象的所有数据都保存在一块连续的内存里面,所以这种编码的字符串对象比起raw编码的字符串对象能够更好的利用缓存带来的优势。

redis> set msg "hello"
OK

redis> object encoding msg
"embstr"

    最后要说的是,可以用long double类型表示的浮点数在Redis中也是作为字符串值来保存的。如果我们要保存一个浮点数到字符串对象里面,那么程序会先将这个浮点数转换成字符串值,然后保存转换得到的字符串值。

127.0.0.1:6379> set pi 3.14
OK
127.0.0.1:6379> object encoding pi
"embstr"

    在有需要的时候,程序会将保存在字符串对象里面的字符串值转换为浮点数值.

127.0.0.1:6379> incrbyfloat pi 2.0
"5.14"
127.0.0.1:6379> object encoding pi
"embstr"

8.2.1 编码的转换

    int编码的字符串对象和embstr编码的字符串对象在条件满足的情况下,会被转换为raw编码的字符串对象。

127.0.0.1:6379> set number 10086
OK
127.0.0.1:6379> object encoding number
"int"
127.0.0.1:6379> append number " is a good number!"
(integer) 23
127.0.0.1:6379> get number
"10086 is a good number!"
127.0.0.1:6379> object encoding number
"raw"

127.0.0.1:6379> set msg "hello world"
OK
127.0.0.1:6379> object encoding msg
"embstr"
127.0.0.1:6379> append msg " again!"
(integer) 18
127.0.0.1:6379> object encoding msg
"raw"

8.2.2 字符串命令的实现

8.3 列表对象

    列表对象的编码可以是ziplist或者linkedlist。

    ziplist编码的列表对象使用压缩列表作为底层实现,每个压缩列表节点(entry)保存了一个列表元素.举个例子,如果我们执行以下rpush命令,那么服务器将创建一个列表对象作为numbers键的值:

127.0.0.1:6379> rpush numbers 1 "three 5" 5
(integer) 3

    如果numbers键的值对象使用的是ziplist编码,这个值对象将会是图8-5所展示的样子。

    另一方面,linkedlist编码的列表对象使用双端链表作为底层实现,每个双端链表节点(node)都保存了一个字符串对象,而每个字符串对象都保存了一个列表元素。

    如果前面所说的numbers键创建的列表对象使用的不是ziplist编码,而是linkedlist编码,那么numbers键的值对象将是图8-6所示的样子。

8.3.1 编码转换

    当列表对象可以同时满足以下两个条件时,列表对象使用ziplist编码:

• 列表对象保存的所有字符串元素的长度都小于64字节;
• 列表对象保存的元素数量小于512个;不能满足这两个条件的列表对象需要使用linkedlist编码。

    对于使用ziplist编码的列表对象来说,当使用ziplist编码所需要的两个条件任意一个不能被满足时,对象的编码转换操作就会被执行。

127.0.0.1:6379> rpush blah "hello" "world" "again"
(integer) 3
127.0.0.1:6379> object encoding blah
"quicklist"
127.0.0.1:6379> rpush blah "wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww"
(integer) 4
127.0.0.1:6379> object encoding blah
"quicklist"

8.3.2 列表命令的实现

8.4 哈希对象

    哈希对象的编码可以是ziplist或者hashtable。

    ziplist编码的哈希对象使用压缩列表作为底层实现,每当有新的键值对要加入到哈希对象时,程序会先将保存了键的压缩列表节点推入到压缩列表表尾,然后再将保存了值的压缩列表节点推入到压缩列表表尾,因此:

• 保存了同一键值对的两个节点总是紧挨在一起,保存键的节点在前,保存值的节点在后;
• 先添加到哈希对象中的键值对会被放在压缩列表的表头方向,而后来添加到哈希对象中的键值对会被放在压缩列表的表尾方向。

127.0.0.1:6379> hset profile name "Tom"
(integer) 1
127.0.0.1:6379> hset profile age 25
(integer) 1
127.0.0.1:6379> hset profile career "Programmer"
(integer) 1

    另一方面,hashtable编码的哈希对象使用字典作为底层实现,哈希对象的每个键值对都使用一个字典键值对来保存:

• 字典的每个键都是一个字符串对象,对象中保存了键值对的键;
• 字典的每个值都是一个字符串对象,对象中保存了键值对的值。

8.4.1 编码转换

    当哈希对象可以同时满足以下两个条件时,哈希对象使用ziplist编码:

• 哈希对象保存的所有键值对的键和值的字符串长度都小于64字节;
• 哈希对象保存的键值对数量小于512个;不能满足这两个条件的哈希对象需要使用hashtable编码。

    对于使用ziplist编码的列表对象来说,当使用ziplist编码所需的两个条件的任意一个不能被满足时,对象的编码操作会被执行。

# 哈希对象只包含一个键和值都不超过64个字节的键值对
127.0.0.1:6379> hset book name "Mastering C++ in 21 days"
(integer) 1
127.0.0.1:6379> object encoding book
"ziplist"
# 向哈希对象添加一个新的键值对,键的长度为66字节
127.0.0.1:6379> hset book long_long_long_long_long_long_long_long_long_long_long_description "content"
(integer) 1
# 编码已改变
127.0.0.1:6379> object encoding book
"hashtable"

# 哈希对象只包含一个键和值都不超过64个字节的键值对
127.0.0.1:6379> hset blah greeting "hello world"
(integer) 1
127.0.0.1:6379> object encoding blah
"ziplist"
# 向哈希对象添加一个新的键值对,值的长度为68字节 
127.0.0.1:6379> hset blah story "many string ... many string ... many string ... many string ... many"
(integer) 1
# 编码已改变
127.0.0.1:6379> object encoding blah
"hashtable"

8.4.2 哈希命令的实现

8.5 集合对象

    集合对象的编码可以是intset或者hashtable。

    intset编码的集合对象使用整数集合作为底层实现,集合对象包含的所有元素都被保存在整数集合里面。

    举个例子,以下代码将创建一个如图8-12所示的intset编码集合对象:

127.0.0.1:6379> sadd numbers 1 3 5
(integer) 3

     另一方面,hashtable编码的集合对象使用字典作为底层实现,字典的每个键都是一个字符串对象,每个字符串对象包含了一个集合元素,而字典的值则全部被设置为NULL。

    举个例子,以下代码将创建一个如图8-13所示的hashtable编码集合对象:

127.0.0.1:6379> sadd fruits "apple" "banana" "cherry"
(integer) 3

8.5.1 编码的转换

    当集合对象可以同时满足以下两个条件时,对象使用intset编码:

• 集合对象保存的所有元素都是整数值
• 集合对象保存的元素数量不超过512个。

不能满足这两个条件的集合对象需要使用hashtable编码。

127.0.0.1:6379> sadd numbers 1 3 5
(integer) 3
127.0.0.1:6379> object encoding numbers
"intset"
127.0.0.1:6379> sadd numbers "seven"
(integer) 1
127.0.0.1:6379> object encoding numbers
"hashtable"
# 创建一个包含512个整数元素的集合对象
127.0.0.1:6379> EVAL "for i=1, 512 do redis.call('SADD',KEYS[1],i) end" 1 integers
(nil)
127.0.0.1:6379> scard integers
(integer) 512
127.0.0.1:6379> object encoding integers
"intset"
127.0.0.1:6379> sadd integers 10086
(integer) 1
127.0.0.1:6379> scard integers
(integer) 513
127.0.0.1:6379> object encoding integers
"hashtable"

8.5.2 集合命令的实现

8.6 有序集合对象

    有序集合的编码可以是ziplist或者skiplist。

    ziplist编码的有序集合对象使用压缩列表作为底层实现,每个集合元素使用两个紧挨在一起的压缩列表节点来保存,第一个节点保存元素的成员(member),而第二个元素则保存元素的分值(score)。

    压缩列表内的集合元素按分值从小到大进行排序,分值较小的元素被放置在靠近表头的位置,而分值较大的元素则被放置在靠近表尾的位置。

    举个例子,如果我们执行以下zadd命令,那么服务器将创建一个有序集合对象作为price键的值:

127.0.0.1:6379> zadd price 8.5 apple 5.0 banana 6.0 cherry
(integer) 3

    skiplist编码的有序集合对象使用zset结构作为底层实现,一个zset结构同时包含一个字典和一个跳跃表:

typedef struct zset{
  zskiplist *zsl;
  dict *dict;
}zset;

    zset结构中的zsl跳跃表按分值从小到大保存了所有集合元素,每个跳跃表节点都保存了一个集合元素:跳跃表节点的object属性保存了元素的成员,而跳跃表节点的score属性则保存了元素的分值。

    除此之外,zset结构中的dict字典为有序集合创建了一个从成员到分值的映射,字典中的每个键值对都保存了一个集合元素:字典的键保存了元素的成员,而字典的值则保存了元素的分值。

    zset结构同时使用跳跃表和字典来保存有序集合元素,但这两种数据结构都会通过指针来共享相同元素的成员和分值,所以同时使用跳跃表和字典来保存集合元素不会产生任何重复成员或者分值,也不会因此浪费额外的内存。

    举个例子,如果前面price键创建的不是ziplist编码的有序集合对象,而是skiplist编码的有序集合对象,那么这个有序集合对象将会是图8-16所示的样子,而对象所使用的zset结构将会是图8-17所示的样子。

8.6.1 编码的转换

    当有序集合对象可以同时满足以下两个条件时,对象使用ziplist编码:

• 有序集合保存的元素数量小于128个;
• 有序集合保存的所有元素成员的长度都小于64字节;

    不能满足以上两个条件的有序集合对象将使用skiplist编码。

127.0.0.1:6379> eval "for i=1,128 do redis.call('zadd',KEYS[1],i,i) end" 1 numbers
(nil)
127.0.0.1:6379> zcard numbers
(integer) 128
127.0.0.1:6379> object encoding numbers
"ziplist"
127.0.0.1:6379> zadd numbers 3.14 pi
(integer) 1
127.0.0.1:6379> zcard numbers
(integer) 129
127.0.0.1:6379> object encoding numbers
"skiplist"

    以下代码则展示了有序集合对象因为元素的成员过长而引发编码转换的情况:

127.0.0.1:6379> zadd blah 1.0 www
(integer) 1
127.0.0.1:6379> object encoding blah
"ziplist"
127.0.0.1:6379> zadd blah 2.0 ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
(integer) 1
127.0.0.1:6379> object encoding blah
"ziplist"
127.0.0.1:6379> zadd blah 2.0 ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
(integer) 1
127.0.0.1:6379> object encoding blah
"skiplist"

8.6.2 有序集合命令的实现

8.9 类型检查与命令多态

    Redis中用于操作键的命令基本上可以分为两种类型。

    其中一种命令可以对任何类型的键执行,比如说del,expire,rename,type,object命令等。

127.0.0.1:6379> set msg "hello"
OK
127.0.0.1:6379> rpush numbers 1 2 3
(integer) 3
127.0.0.1:6379> sadd fruits apple banana cherry
(integer) 3
127.0.0.1:6379> del msg
(integer) 1
127.0.0.1:6379> del numbers
(integer) 1
127.0.0.1:6379> del fruits
(integer) 1

    而另一种命令只能对特定类型的键执行,比如:

• set,get,append,strlen等命令只能对字符串键执行;
• hdel,hset,hget,hlen等命令只能对哈希键执行;
• rpush,lpop,linsert,llen等命令只能对列表键执行;
• sadd,spop,sinter,scard等命令只能对集合键执行;
• zadd,zcard,zrank,zscore等命令只能对有序集合键执行;

127.0.0.1:6379> set msg "hello world"
OK
127.0.0.1:6379> get msg
"hello world"
127.0.0.1:6379> append msg " again!"
(integer) 18
127.0.0.1:6379> get msg
"hello world again!"
127.0.0.1:6379> llen msg
(error) WRONGTYPE Operation against a key holding the wrong kind of value

8.7.1 类型检查的实现

    类型检查是通过redisObject结构的type属性来实现的:

• 在执行一个类型特定命令之前,服务器会先检查输入数据库键的值对象是否为执行命令所需的类型,如果是的话,服务器就对键执行指定的命令;
• 否则,服务器将拒绝执行命令,并向客户端返回一个类型错误。

    举个例子,对于LLEN命令来说:

• 在执行LLEN命令之前,服务器会先检查输入数据库键的值对象是否为列表类型,也即是检查值对象redisObject结构type属性的值是否为REDIS_LIST,如果是的话,服务器就对键执行LLEN命令;
• 否则的话,服务器就拒绝执行命令并向客户端返回一个类型错误。

8.7.2 多态命令的实现

8.8 内存回收

    因为C语言并不具备自动内存回收功能,所以Redis在自己的对象系统中构建了一个引用计数(reference counting)技术实现的内存回收机制,通过这一机制,程序可以通过跟踪对象的引用计数信息,在适当的时候自动释放对象并进行内存回收。

    每个对象的引用计数信息有redisObject结构的refcount属性记录:

typedef struct redisObject{
  // ...
  // 引用计数
  int refcount;
  //...
}robj;

    对象的引用计数信息会随着对象的使用状态而不断变化:

• 在创建一个新对象时,引用计数的值会被初始化为1;
• 当对象被一个新程序使用时,它的引用计数值会被增一;
• 当对象不再被一个程序使用时,它的引用计数值会被减一;
• 当对象的引用计数值变为0时,对象所占用的内存会被释放;

    对象的整个生命周期可以划分为创建对象、操作对象、释放对象三个阶段。

// 创建一个字符串对象s,对象的引用计数为1
robj *s=createStringObject(...)

// 对象s执行各种操作...

// 将对象s的引用计数减一,使得对象的引用计数变为0
// 导致对象s被释放
decrRefCount(s)

8.9 对象共享

    除了用于实现引用计数内存回收机制之外,对象的引用计数属性还带有对象共享的作用。举个例子,假设键A创建了一个包含整数值100的字符串作为值对象,如图8-20所示。

    如果这时键B也要创建一个同样保存了整数值100的字符串对象作为值对象,那么服务器有以下两种做法:

    1)为键B新创建一个包含整数值100的字符串对象;

    2)让键A和键B共享同一个字符串对象;

    以上两种方法很明显第二种方法更节约内存。

    在Redis中,让多个键共享同一个值对象需要执行以下两个步骤:

    1)将数据库键的值指针指向一个现有的值对象;

    2)将被共享的值对象的引用计数增一。

127.0.0.1:6379> set a 100  
OK  
127.0.0.1:6379> object refcount a  
(integer) 2  
127.0.0.1:6379> set b 100  
OK  
127.0.0.1:6379> object refcount a  
(integer) 3
127.0.0.1:6397> object refcount b
(integer) 3 

8.10 对象的空转时长

    除了前面介绍过的type,encoding,ptr和refcount四个属性之外,redisObject结构包含的最后一个属性为lru属性,该属性记录了对象最后一次被命令程序访问的时间:

typedef struct redisObject{
  // ...
  unsigned lru:22;
  // ...
}robj;

    object idletime命令可以打印出给定键的空转时长,这一空转时长就是通过将当前时间减去键的值对象的lru时间计算得出的:

127.0.0.1:6379> set msg "hello world"
OK
127.0.0.1:6379> object idletime msg
(integer) 26
127.0.0.1:6379> object idletime msg
(integer) 51
127.0.0.1:6379> get msg
"hello world"
127.0.0.1:6379> object idletime msg
(integer) 21

8.11 重点回顾

• Redis数据库中的每个键值对的键和值都是一个对象。
• Redis共有字符串、列表、哈希、集合、有序集合五种类型的对象,每种类型的对象至少都有两种或以上的编码方式,不同的编码可以在不同的使用场景上优化对象的使用效率。
• 服务器在执行某些命令之前,会先检查给定键的类型能否执行指定的命令,而检查一个键的类型就是检查见得值对象的类型。
• Redis的对象系统带有引用计数实现的内存回收机制,当一个对象不再被使用时,该对象所占用的内存就会被自动释放。
• Redis会共享值为0到9999的字符串对象。
• 对象会记录自己的最后一次被访问的时间,这个时间可以用于计算对象的空转时间。