本章将对Redis服务器的数据库实现进行详细介绍，说明服务器保存数据库的方法，数据库保存键值对的方法，以及针对数据库的增删改查的实现方法，服务器保存键的过期时间的方法，以及服务器自动删除过期键的方法，以及Redis2.8新引入的数据库通知功能的实现方法。
1.1 服务器中的数据库
Redis服务器将所有数据库都保存在服务器状态server.h/redisServer结构的db数组中，db数组的每个项都是一个server.h/redisDb结构，每个redisDb结构代表一个数据库：
struct redisServer {
// ...
//一个数组，保存着服务器中的所有数据库
redisDb *db;
// ...
//服务器的数据库数量
int dbnum;
};
dbnum属性的值由服务器配置的database选项决定，默认情况下，该选项的值为16，所以Redis服务器默认会创建16个数据库，如下图所示。
1.2 切换数据库
每个Redis客户端都有自己的目标数据库，每当客户端执行数据库写命令或者数据库读命令的时候，目标数据库就会成为这些命令的操作对象。
默认情况下，Redis客户端的目标数据库为0号数据库，但客户端可以通过执行SELECT命令来切换目标数据库。
以下代码示例演示了客户端在0号数据库设置并读取键msg，之后切换到2号数据库并执行类似操作的过程：
127.0.0.1:6379> SET msg "hello world"
OK
127.0.0.1:6379> GET msg
"hello world"
127.0.0.1:6379> SELECT 2
OK
127.0.0.1:6379[2]> GET msg
(nil)
127.0.0.1:6379[2]> SET msg "another world"
OK
127.0.0.1:6379[2]> GET msg
"another world"
在服务器内部，客户端状态redisClient结构的db属性记录了客户端当前的目标数据库，这个属性是一个指向redisDb结构的指针：
typedef struct redisClient {
// ...
//记录客户端当前正在使用的数据库
redisDb *db;
// ...
} redisClient;
redisClient.db指针指向redisServer.db数组的其中一个元素，而被指向的元素就是客户端的目标数据库。
比如说，如果某个客户端的目标数据库为1号数据库，那么这个客户端所对应的客户端状态和服务器状态之间的关系如下图：
如果这时客户端执行命令SELECT2，将目标数据库改为2号数据库，那么客户端状态和服务器状态之间的关系将更新如下：
注意：因为目前，Redis仍然没有可以返回客户端目标数据库的命令，多次切换后可能会忘记自己当前所使用的数据库，所以要谨慎处理多数据库程序。
1.3 数据库空间
Redis是一个键值对数据库服务器，服务器中的每个数据库都由一个redisDb结构表示，其中，redisDb结构的dict字典保存了数据库中的所有键值对，我们称这个字典为键空间(key space)。
typedef struct redisDb {
/* 当前数据库的键空间 */
dict *dict;
/* 键的过期时间 */
dict *expires;
/* 处于阻塞状态的键和相应的client（主要用于List类型的阻塞操作）*/
dict *blocking_keys;
/* 准备好数据可以解除阻塞状态的键和相应的client */
dict *ready_keys;
/* 被watch命令监控的key和相应client */
dict *watched_keys;
/* 数据库ID标识 */
int id;
/* 数据库内所有键的平均TTL（生存时间） */
long long avg_ttl;
/*逐一尝试整理碎片的关键名称列表 */
list *defrag_later;
} redisDb;
键空间和用户所见的数据库是直接对应的：
- 键空间的键也就是数据库的键，每个键都是一个字符串对象。
- 键空间的值也就是数据库的值，每个值可以是字符串对象、列表对象、哈希表对象、集合对象和有序集合对象中的任意一种Redis对象。
举个例子，如果我们在空白的数据库中执行以下命令：
127.0.0.1:6379> SET message "hello world"
OK
127.0.0.1:6379> RPUSH alphabet "a" "b" "c"
(integer) 3
127.0.0.1:6379> HSET book name "Redis in Action"
(integer) 1
127.0.0.1:6379> HSET book author "Josiah L.Carlson"
(integer) 1
127.0.0.1:6379> HSET book publisher "Manning"
(integer) 1
那么执行这些命令之后，数据库键空间将会如下图1所示：
- alphabet是一个列表键，键的名字是一个包含字符串“alphabet”的字符串对象，键的值则是一个包含三个元素的列表对象。
- book是一个哈希表键，键的名字是一个包含字符串“book”的字符串对象，键的值则是一个包含三个键值对的哈希表对象
- message是一个字符串键，键的名字是一个包含字符串“message”的字符串对象，键的值是一个包含字符串“hello world”的字符串对象。
图1
因为数据库的键空间是一个字典，所以针对数据库的操作，比如添加、删除键值对，实际上都是通过对键空间字典进行操作来实现的。
1.3.1 添加新键
添加一个新键值对到数据库，实际上就是将一个新键值对添加到键空间字典里面，其中键为字符串对象，而值则为任意一种类型的Redis对象。
举个例子，如果键空间当前状态如上图1所示，那么在执行以下命令之后：
127.0.0.1:6379> SET date "2013.12.1"
OK
键空间将添加一个新的键值对，这个新键值对的键是一个包含字符串“date”的字符串对象，而键值对的值则是一个包含字符串“2013.12.1”的字符串对象，如下图所示：
1.3.2 删除键
删除数据库中的一个键，实际上就是在键空间里面删除键所对应的键值对对象。
举个例子，如果键空间当前的状态如图1所示，执行以下命令后，键book以及它的值将从键空间中被删除。
1.3.3 更新键
同理，更新键实际上就是对键空间里面键所对应的值对象进行更新。
127.0.0.1:6379> SET message "blah blah"
OK
127.0.0.1:6379> HSET book page 320
(integer) 1
1.3.4 对键取值
对一个数据库键进行取值，实际上就是在键空间中取出键所对应的值对象，根据值对象的类型不同，具体取值方法也会有所不同。
举个例子，当键空间如图1所示，当执行以下命令时，GET命令将首先在键空间查找键message，找到键之后接着去的该键所对应的字符串对象值，之后再返回值对象所包含的字符串“hello world”，取值过程如下图：
127.0.0.1:6379> GET message
"hello world"
再举个例子，先找键alphabet，再找该键所对应的列表对象值，之后再返回列表对象中包含的三个字符串对象的值。
127.0.0.1:6379> LRANGE alphabet 0 -1
1) "a"
2) "b"
3) "c"
1.3.5 其他键空间操作
除了增删改查之外，还有许多针对数据库本身的Redis命令，也是通过键空间进行处理来完成的。
比如说，用于清空整个数据库的FLUSHDB命令；用于随机返回数据库中某个键的RANDOMKEY命令；返回数据库键数量的DBSIZE等。
1.3.6 读写键空间时的维护操作
当使用Redis命令对数据库进行读写时，服务器不仅会对键空间执行指定的读写操作，还会执行一些额外的维护操作，包括：
1.在读取一个键后（读操作和写操作都要对键进行读取），服务器会根据键是否存在来更新服务器的键空间命中（hit）次数或键空间不命中（miss）次数，这两个值可以在INFO stats命令的keyspace_hits属性和keyspace_misses属性中查看。
2.在读取一个键后，服务器会更新键的LRU（最后一次使用）时间，这个值可以用于计算键的闲置时间，使用OBJECT idletime命令可以查看键key的闲置时间。
3.如果服务器在读取一个键时发现该键已经过期，那么服务器会先删除这个过期键，然后才执行余下的其他操作。
4.如果有客户端使用WATCH命令监视了某个键，那么服务器在对被监视的键及进行修改之后，会将这个键标记为脏（dirty），从而让事务程序注意到这个键已经被修改过。
5.服务器每次修改一个键之后，都会对脏（dirty）键计数器的值增1，这个计数器会触发服务器的持久化以及复制操作。
6.如果服务器开启了数据库通知功能，那么在对键进行修改之后，服务器将按配置发送相应的数据库通知。
1.4 设置键的生存时间或过期时间
通过EXPIRE命令或者PEXPIRE命令，客户端可以以秒或者毫秒精度为数据库中的某个键设置生存时间（Time To Live，TTL），在经过指定的秒数或者毫秒数之后，服务器就会自动删除生存时间为0的键。
127.0.0.1:6379> SET key value
OK
127.0.0.1:6379> EXPIRE key 5
(integer) 1
127.0.0.1:6379> GET key //5秒之内
"value"
127.0.0.1:6379> GET key //5秒之后
(nil)
注意：SETEX命令可以在设置一个字符串键的同时为键设置过期时间，因为这个命令是一个类型限定的命令（只用于字符串键），所以本章不会介绍，但SETEX命令设置过期时间的原理和本章介绍的EXPIRE命令设置过期时间的原理是完全一样的。
与expire命令和pexpire命令类似，客户端可以通过expireat命令或者pexpireat命令，以秒或者毫秒精度给数据库中的某个键设置过期时间(expire time)
过期时间是一个UNIX时间戳，当键的过期时间来临，服务器就会自动从数据库中删除整个键。
127.0.0.1:6379> SET key value
OK
127.0.0.1:6379> EXPIREAT key 1377257300
(integer) 1
127.0.0.1:6379> TIME
1) "1608185226"
2) "872362"
127.0.0.1:6379> GET key //1377257300之后
(nil)
TTL命令和PTTL命令接受一个带有生存时间或者过期时间的键，返回整个键的剩余生存时间。
127.0.0.1:6379> SET key value
OK
127.0.0.1:6379> EXPIRE key 1000
(integer) 1
127.0.0.1:6379> TTL key
(integer) 996
127.0.0.1:6379> SET another_key another_value
OK
127.0.0.1:6379> TIME
1) "1608185507"
2) "851144"
127.0.0.1:6379> EXPIREAT another_key 1377333100
(integer) 1
127.0.0.1:6379> TTL another_key
(integer) -2
1.4.1 设置过期时间
Redis有四个不同的命令可以用于设置键的生存时间（键可以存在多久）或过期时间（键什么时候会被删除）：
❑EXPIRE＜key＞＜ttl＞命令用于将键key的生存时间设置为ttl秒。
❑PEXPIRE＜key＞＜ttl＞命令用于将键key的生存时间设置为ttl毫秒。
❑EXPIREAT＜key＞＜timestamp＞命令用于将键key的过期时间设置为timestamp所指定的秒数时间戳。
❑PEXPIREAT＜key＞＜timestamp＞命令用于将键key的过期时间设置为timestamp所指定的毫秒数时间戳。
EXPIREAT命令与EXPIRE命令的差别在于前者使用Unix时间作为第二个参数表示键的生存时间的截止时间。PEXPIREAT命令与EXPIREAT命令的区别是前者的时间单位是毫秒。
虽然有多种不同单位和不同形式的设置命令，但实际上EXPIRE、PEXPIRE、EXPIREAT三个命令都是使用PEXPIREAT命令来实现的：无论客户端执行的是以上四个命令中的哪一个，经过转换之后，最终的执行效果都和执行PEXPIREAT命令一样。如下图所示
首先，EXPIRE命令可以转换成PEXPIRE命令
def EXPIRE(key,ttl_in_sec)
#将TTL从秒转换成毫秒
ttl_in_ms = sec_to_ms(ttl_in_sec)
PEXPIRE(key,ttl_in_ms)
接着，PEXPIRE命令又可以转换成PEXPIREAT命令：
def PEXPIRE(key,ttl_in_ms)
#获取以毫米计算的当前UNIX时间戳
now_ms = get_current_unix_timestamp_in_ms()
#当前时间加上TTL，得出毫秒格式的键过期时间
PEXPIREAT（key,now_ms+ttl_in_ms）
并且，EXPIREAT命令也可以转换成PEXPIREAT命令：
def EXPIREAT(key,expire_time_in_sec)
#将过期时间转换为毫秒
expire_time_in_ms = sec_to_ms(expire_time_in_sec)
PEXPIREAT(key,expire_time_in_ms)
1.4.2 保存过期时间
redisDB结构的expires字典保存了数据库中所有键的过期时间，我们称这个字典为过期字典:
过期字典的键是一个指针，这个指针指向键空间中的某个键对象( 也即是某个数据库键)。
过期字典的值是一个long long 类型的整数，这个整数保存了键所指向的数据库键的过期时间:一个毫秒精度的UNIX 时间戳。
typedef struct redisDb {
//...
// 过期字典，保存着键的过期时间
dict *expires ;
//...
} redisDb;
如下图2展示了一个带有过期字典的数据库例子，在这个例子中，键空间保存了数据库中的所有键值对，而过期字典则保存了数据库键的过期时间。
过期字典将新增一个键值对， 其中键为message 键对象，而值则为1391234400000(2014年2月1日零时) 。
下图中的过期字典保存了两个键值对:
第一个键值对的键为alphabet 键对象，值为1385877600000 ，这表示数据库键alphabet 的过期时间为1385877600000 (2013年12月1日零时)。
第二个键值对的键为book键对象，值为1388556000000，这表示数据库键book的过期时间为1388556000000(2014年1月1日零时)。
图2
当客户端执行PEXPIREAT 命令(或者其他三个会转换成PEXPIREAT命令的命令)为一个数据库键设置过期时间时，服务器会在数据库的过期字典中关联给定的数据库键和过期时间。
举个例子， 如果数据库当前的状态如图2 所示， 那么在服务器执行以下命令之后:
redis> PEXPIREAT message 1 391234400000
(integer) 1
过期字典将新增一个键值对，其中键为message键对象，而值则为1391234400000(2014年2月1日零时)，如下图所示。
以下是PEXPlREAT 命令的伪代码定义:
def PEXPIREAT(key,expire_time_in_ms) :
#如果给定的键不存在于键空间，那么不能设置过期时间
if key not in redisDB.dict :
return 0
#在过期字典中关联键和过期时间
redisDB.expires[key]=expire_tirne_in_ms
#过期时间设置成功
return 1
1.4.3 移除过期时间
PERSIST命令可以移除一个键的过期时间:
redis>PEXPlREAT message 1391234400000
(integer) 1
redis>TTL message
(integer) 13893281
redis> PERSIST message
(integer) 1
redis> TTL message
(integer) - 1
PERSIST命令就是PEXPIREAT命令的反操作: PERSIST 命令在过期字典中查找给定的键,并解除键和值(过期时间)在过期字典中的关联。
举个例子,如果数据库当前的状态如图2所示,那么当服务器执行以下命令之后:
redis> PERSIST book
(integer) 1
可以看到,当PERSIST命令执行之后,过期字典中原来的book键值对消失了,这代表数据库键book的过期时间已经被移除。
以下是PERSIST 命令的伪代码定义:
def PERSIST(key) :
#如果键不存在,或者键没有设置过期时间,那么直接返回
if key not in redisDB.expires:
return 0
#移除过期字典中给定键的键值对关联
redisDB.expires.remove(key)
#键的过期时间移除成功
return 1
1.4.4 计算并返回剩余生存时间
TTL 命令以秒为单位返回键的剩余生存时间， 而P TTL 命令则以毫秒为单位返回键的剩余生存时间:
redis> PEXPIREAT alphabet 1385877600000
(integer) 1
redis> TTL alphabet
(integer) 85 49007
redis> PTTL alphabet
(integer) 8549001011
TTL 和PTTL 两个命令都是通过计算键的过期时间和当前时间之间的差来实现的，以下
是这两个命令的伪代码实现:
def PTTL (key) :
#键不存在于数据库
if key not in redisDb.dict:
return -2
#尝试取得键的过期时间
#如果键没有设置过期时间，那么expire_time_in_ms将为None
expire_time_in_ms = redisDB.expires.get(key)
#键没有设置过期时间
if expire time in ms is None:
return -1
#获得当前时间
now_ms = get_current_unix _timestamp_in_ms ()
#过期时间减去当前时间， 得出的差就是键的剩余生存时间
return(expire_time_in_ms - now_ms)
def TTL(key):
#获取以毫秒为单位的剩余生存时间
ttl_in_ms = PTTL (key )
if ttl_in_ms < 0:
#处理返回值为2 和斗的情况
return ttl_in_ms
else:
#将毫秒转换为秒
return ms_to_sec(ttl_in_ms)
举个例子，对于一个过期时间为1385877600000(2013年12月1日零时)的键alphabet来说:
如果当前时间为1383282000000 (2013年11月1日零时)，那么对键alphabet执行PTTL命令将返回2595600000 ，这个值是通过用a1phabet 键的过期时间减去当前时间计算得出的: 1385877600000-1383282000000=25956000000
另一方面,如果当前时间为1383282000000 ( 2013年11月1日零时),那么对键alphabet执行TTL命令将返回2595600,这个值是通过计算alphabet 键的过期时间减去当前时间的差，然后将差值从毫秒转换为秒之后得出的。
1.4.5 过期键的判定
通过过期字典，程序可以用以下步骤检查一个给定键是否过期:
1 )检查给定键是否存在于过期字典:如果存在，那么取得键的过期时间。
2 )检查当前UNIX 时间戳是否大于键的过期时间: 如果是的话，那么键已经过期;否则的话，键未过期。
可以用伪代码来描述这一过程:
def is expired(key) :
#取得键的过期时间
expire_time_in_ms = redisDB.expires.get(key)
#键没有设置过期时间
if expire_time_in_ms is none:
return false
#取得当前时间的UNIX 时间戳
now_ms = get_current_unix_timestamp_in_ms()
#检查当前时间是否大于键的过期时间
if now_ms > expire time_in_ms :
#是，键已经过期
return true
else :
# 否，键未过期
return false
举个例子，对于一个过期时间为1385877600000 (2013年12月1日零时)的键alphabet来说:
如果当前时间为1383282000000 (2013 年II 月1 日零时)，那么调用is_expired ( alphabet ) 将返回False ，因为当前时间小于alphabet 键的过期时间。
另一方面，如果当前时间为1385964000000 (2013年12月2日零时)，那么调用is_expired(alphabet) 将返回True. 因为当前时间大于alphabet 键的过期时间。
注意
实现过期键判定的另一种方法是使用TTL 命令或者PTTL 命令，比如说，如采对某个键执行TTL 命令，并且命令返回的位大于等于0 ，那么说明该键未过期。在实际中， Redis检查键是否过期的方法和is_expired函数所描述的方法一致，因为直接访问字典比执行一个命令稍微快一些。
1.5 过期键删除策略
如果一个键过期了，那么它什么时候会被删除呢?
这个问题有三种可能的答案，它们分别代表了三种不同的删除策略:
1.定时删除:在设置键的过期时间的同时，创建一个定时器( timer ). 让定时器在键的过期时间来临时，立即执行对键的删除操作。
2.惰性删除:放任键过期不管，但是每次从键空间中获取键时，都检查取得的键是否过期，如果过期的话，就删除该键;如果没有过期，就返回该键。
3.定期删除: 每隔一段时间，程序就对数据库进行一次检查，删除里面的过期键。至于要删除多少过期键，以及要检查多少个数据库， 则由算法决定。
在这三种策略中，第一种和第三种为主动删除策略， 而第二种则为被动删除策略。
1.5.1 定时删除
定时删除策略对内存是最友好的:通过使用定时器，定时删除策略可以保证过期键会尽可能快地被删除，并释放过期键所占用的内存。
另一方面，定时删除策略的缺点是，它对CPU 时间是最不友好的:在过期键比较多的情况下，删除过期键这一行为可能会占用相当一部分CPU 时间，在内存不紧张但是CPU 时间非常紧张的情况下.将CPU 时间用在删除和当前任务无关的过期键上，无疑会对服务器的响应时间和吞吐量造成影响。
例如，如果正有大量的命令请求在等待服务器处理，并且服务器当前不缺少内存，那么服务器应该优先将CPU 时间用在处理客户端的命令请求上面，而不是用在删除过期键上面。除此之外，创建一个定时器需要用到Redis 服务器中的时间事件，而当前时间事件的实现方式一一无序链表，查找一个事件的时间复杂度为O(N)一并不能高效地处理大量时间事件。
因此，要让服务器创建大量的定时器，从而实现定时删除策略，在现阶段来说并不现实。
1.5.2 惰性删除
惰性删除策略对CPU 时间来说是最友好的:程序只会在取出键时才对键进行过期检查，这可以保证删除过期键的操作只会在非做不可的情况下进行， 并且删除的目标仅限于当前处理的键，这个策略不会在删除其他无关的过期键上花费任何CPU时间。
惰性删除策略的缺点是，它对内存是最不友好的: 如果一个键已经过期，而这个键又仍然保留在数据库中，那么只要这个过期键不被删除，它所占用的内存就不会释放。在使用惰性删除策略时，如果数据库中有非常多的过期键，而这些过期键又恰好没有被访问到的话，那么它们也许永远也不会被删除(除非用户手动执行FLUSHDB),我们甚至可以将这种情况看作是一种内存泄漏一一无用的垃圾数据占用了大量的内存，而服务器却不会自己去释放它们，这对于运行状态非常依赖于内存的Redis服务器来说，肯定不是一个好消息。
举个例子，对于一些和时间有关的数据，比如日志(log) ，在某个时间点之后，对它们的访问就会大大减少，甚至不再访问，如果这类过期数据大量地积压在数据库中，用户以为服务器已经自动将它们删除了，但实际上这些键仍然存在， 而且键所占用的内存也没有释放，那么造成的后果肯定是非常严重的。
1.5.3 定期删除
从上面对定时删除和惰性删除的讨论来看，这两种删除方式在单一使用时都有明显的缺陷:
定时删除占用太多CPU 时间，影响服务器的响应时间和吞吐量。惰性删除浪费太多内存，有内存泄漏的危险。
定期删除策略是前两种策略的一种整合和折中:
定期删除策略每隔一段时间执行一次删除过期键操作，并通过限制删除操作执行的时长和频率来减少删除操作对CPU 时间的影响。除此之外，通过定期删除过期键，定期删除策略有效地减少了因为过期键而带来的内存浪费。定期删除策略的难点是确定删除操作执行的时长和频率:
如果删除操作执行得太频繁，或者执行的时间太长，定期删除策略就会退化成定时删除策略，以至于将C P U 时间过多地消耗在删除过期键上面。
如果删除操作执行得太少，或者执行的时间太短，定期删除策略又会和惰性删除策略一样，出现浪费内存的情况。
因此，如果采用定期删除策略的话，服务器必须根据情况，合理地设置删除操作的执行时长和执行频率。
1.6 Redis 的过期键删除策略
我们讨论了定时删除、惰性删除和定期删除三种过期键删除策略， Redis服务器实际使用的是惰性删除和定期删除两种策略: 通过配合使用这两种删除策略，服务器可以很好地在合理使用CPU时间和避免浪费内存空间之间取得平衡。
接下来我们将对Redis服务器中惰性删除和定期删除的具体实现进行说明。
1.6.1 惰性删除策略的实现
过期键的惰性删除策略由db.c/expirelfNeeded 函数实现，所有读写数据库的Redis命令在执行之前都会调用expirelfNeeded 函数对输入键进行检查:
- 如果输入键已经过期，那么expirelfNeeded 函数将输入键从数据库中删除。
- 如果输入键未过期， 那么expirelfNeeded 函数不做动作。
命令调用expirelfNeeded 函数的过程如下图所示。
expirelfNeeded 函数就像一个过滤器，它可以在命令真正执行之前，过搜、掉过期的输入键，从而避免命令接触到过期键。
另外，因为每个被访问的键都可能因为过期而被expirelfNeeded 函数删除，所以每个命令的实现函数都必须能同时处理键存在以及键不存在这两种情况:
当键存在时，命令按照键存在的情况执行。
当键不存在或者键因为过期而被expirelfNeeded 函数删除时，命令按照键不存在的情况执行。
举个例子，下图展示了GET 命令的执行过程，在这个执行过程中，命令需要判断键是否存在以及键是否过期，然后根据判断来执行合适的动作
1.6.2 定期删除策略的实现
过期键的定期删除策略由redis.c/activeExpireCycle 函数实现，每当Redis 的
服务器周期性操作redis.c/serverCron 函数执行时,activeExpireCycle 函数就会被调用， 它在规定的时间内，分多次遍历服务器中的各个数据库，从数据库的expires 字
典中随机检查一部分键的过期时间，并删除其中的过期键。
整个过程可以用伪代码描述如下:
#默认每次检查的数据库数量
DEFAULT_DB_NUMBERS = 16
#默认每个数据库检查的键数量
DEFAULT_KEY_NUMBERS = 20
#全局变量，记录检查进度
current_db = 0
def activeExpireCycle():
#初始化要检查的数据库数量
#如果服务榕的数据库数量比DEFAULT DB NUMBERS 要小
#那么以服务器的数据库数量为准
if server.dbnum < DEFAULT_DB_NUMBERS :
db_numbers = server.dbnum
else :
db_numbers = DEFAULT_DB_NUMBERS
#遍历各个数据库
for i in range(db_numbers) :
#如果current_db 的值等于服务榕的数据库数量
#这表示检查程序已经遍历了服务榕的所有数据库一次
#将current_db重置为0 ，开始新的一轮遍历
if current_db == server.dbnum:
current_db = 0
#获取当前要处理的数据库
redisDB = server.db[current db)
#将数据库索引增1 ，指向下一个要处理的数据库
current_db += 1
#检查数据库键
for j in range(DEFAULT_KEY_NUMBERS):
#如果数据库中没有一个键带有过期时间，那么跳过这个数据库
if redisDB.expires.size () == 0: break
# 随机获取一个带有过期时间的键
key with_ttl = redisDb.expires.get_random_key ()
#检查键是否过期，如果过期就删除它
if is_expired (key with ttl):
delete_key (key_with_ttl )
#已达到时间上限，停止处理
if reach_time_limit(): return
activeExpireCycle 函数的工作模式可以总结如下:
1.函数每次运行时，都从一定数量的数据库中取出一定数量的随机键进行检查， 并删除其中的过期键。
2.全局变量current db 会记录当前activeExpireCycle 函数检查的进度，并在下一次activeExpireCycle 函数调用时，接着上一次的进度进行处理。比如说，如果当前activeExpireCycle 函数在遍历10 号数据库时返回了，那么下次activeExpireCycle 函数执行时，将从11号数据库开始查找并删除过期键。
3.随着activeExpireCycle函数的不断执行，服务器中的所有数据库都会被检查一遍，这时函数将current_db变量重置为0,然后再次开始新一轮的检查工作。
1.7 AOF、RDB和复制功能对过期键的处理
1.7.1生成RDB文件
在执行SAVE命令或者BGSAVE命令创建一个新的RDB文件时，程序会对数据库中的键进行检查，已过期的键不会被保存到新创建的RDB文件中。
举个例子，如果数据库中包含三个键k1、k2、k3，并且k2已经过期，那么当执行SAVE命令或者BGSAVE命令时，程序只会将k1和k3的数据保存到RDB文件中，而k2则会被忽略。
因此，数据库中包含过期键不会对生成新的RDB文件造成影响。
可参考rdb.c中函数rdbSave()函数源码：
/* Iterate this DB writing every entry
*
* 遍历数据库，并写入每个键值对的数据
*/
while((de = dictNext(di)) != NULL) {
sds keystr = dictGetKey(de);
robj key, *o = dictGetVal(de);
long long expire;
// 根据 keystr ，在栈中创建一个 key 对象
initStaticStringObject(key,keystr);
// 获取键的过期时间
expire = getExpire(db,&key);
// 保存键值对数据
if (rdbSaveKeyValuePair(&rdb,&key,o,expire,now) == -1) goto werr;
}
rdbSaveKeyValuePair函数实现如下：
/* Save a key-value pair, with expire time, type, key, value.
*
* 将键值对的键、值、过期时间和类型写入到 RDB 中。
*
* On error -1 is returned.
*
* 出错返回 -1 。
*
* On success if the key was actually saved 1 is returned, otherwise 0
* is returned (the key was already expired).
*
* 成功保存返回 1 ，当键已经过期时，返回 0 。
*/
int rdbSaveKeyValuePair(rio *rdb, robj *key, robj *val,
long long expiretime, long long now)
{
/* Save the expire time
*
* 保存键的过期时间
*/
if (expiretime != -1) {
/* If this key is already expired skip it
*
* 不写入已经过期的键
*/
if (expiretime < now) return 0;
if (rdbSaveType(rdb,REDIS_RDB_OPCODE_EXPIRETIME_MS) == -1) return -1;
if (rdbSaveMillisecondTime(rdb,expiretime) == -1) return -1;
}
/* Save type, key, value
*
* 保存类型，键，值
*/
if (rdbSaveObjectType(rdb,val) == -1) return -1;
if (rdbSaveStringObject(rdb,key) == -1) return -1;
if (rdbSaveObject(rdb,val) == -1) return -1;
return 1;
}
1.7.2 载入RDB文件
在启动Redis服务器时，如果服务器开启了RDB功能，那么服务器将对RDB文件进行载入：
1.如果服务器以主服务器模式运行，那么在载入RDB文件时，程序会对文件中保存的键进行检查，未过期的键会被载入到数据库中，而过期键则会被忽略，所以过期键对载入RDB文件的主服务器不会造成影响；
2.如果服务器以从服务器模式运行，那么在载入RDB文件时，文件中保存的所有键，不论是否过期，都会被载入到数据库中。不过，因为主从服务器在进行数据同步的时候，从服务器的数据库就会被清空，所以一般来讲，过期键对载入RDB文件的从服务器也不会造成影响；
举个例子，如果数据库包含三个键k1，k2，k3，并且k2已经过期，那么当服务器启动时：
1.如果服务器以主服务器模式运行，那么程序只会将k1和k3载入到数据库，k2会被忽略。
2.如果服务器以从服务器模式运行，那么k1，k2，k3都会被载入到数据库
这部分代码可以查看rdb.c中rdbLoad()函数源码：
/* Check if the key already expired. This function is used when loading
* an RDB file from disk, either at startup, or when an RDB was
* received from the master. In the latter case, the master is
* responsible for key expiry. If we would expire keys here, the
* snapshot taken by the master may not be reflected on the slave.
*
* 如果服务器为主节点的话，
* 那么在键已经过期的时候，不再将它们关联到数据库中去
*/
if (server.masterhost == NULL && expiretime != -1 && expiretime < now) {
decrRefCount(key);
decrRefCount(val);
// 跳过
continue;
}
1.7.3 AOF文件写入
当服务器以AOF持久化模式运行时，如果数据库中的某个键已经过期，但它还没有被惰性删除或者定期删除，那么AOF文件不会因为这个过期键而产生任何影响。
当过期键被惰性删除或者定期删除之后，程序会向AOF文件追加（append）一条DEL命令，来显式地记录该键已被删除。
举个例子，如果客户端使用GET message命令，试图访问过期的message键，那么服务器将执行以下三个动作：
1）从数据库中删除message键。
2）追加一条DEL message命令到AOF文件。（根据AOF文件增加的特点，AOF只有在客户端进行请求的时候才会有这个DEL操作）
3）向执行GET命令的客户端返回空回复。
这部分就是Redis中的惰性删除策略中expireIfNeeded函数的使用。关于惰性删除策略这一部分在Redis惰性删除策略一篇中有讲。所以这里就不赘述了。
需要提示一下的是：expireIfNeeded函数是在db.c/lookupKeyRead()函数中被调用，lookupKeyRead函数用于在执行读取操作时取出键key在数据库db中的值。
1.7.4 AOF重写
和生成RDB文件时类似，在执行AOF重写的过程中，程序会对数据库中的键进行检查，已过期的键不会被保存到重写后的AOF文件中。
举个例子，如果数据库中包含三个键k1、k2、k3，并且k2已经过期，那么在进行重写工作时，程序只会对k1和k3进行重写，而k2则会被忽略。
这一部分如果掌握了AOF重写的方法的话，那就自然理解了。
1.7.5 复制
当服务器运行在复制模式下时，从服务器的过期键删除动作由主服务器控制：
主服务器在删除一个过期键之后，会显式地向所有从服务器发送一个DEL命令，告知从服务器删除这个过期键；
从服务器在执行客户端发送的读命令时，即使碰到过期键也不会将过期键删除，而是继续像处理未过期的键一样来处理过期键；
从服务器只有在接到主服务器发来的DEL命令之后，才会删除过期键。
举个例子，有一对主从服务器，它们的数据库中都保存着同样的三个键message、xxx和yyy，其中message为过期键，如图所示
如果这时有客户端向从服务器发送命令GET message，那么从服务器将发现message键已经过期，但从服务器并不会删除message键，而是继续将message键的值返回给客户端，就好像message键并没有过期一样。
假设在此之后，有客户端向主服务器发送命令GET message，那么主服务器将发现键message已经过期：主服务器会删除message键，向客户端返回空回复，并向从服务器发送DEL message命令，如图所示：
从服务器在接收到主服务器发来的DEL message命令之后，也会从数据库中删除message键，在这之后，主从服务器都不再保存过期键message了，如图所示：
1.8 数据库通知
数据库通知是Redis2.8版本新增加的功能,这个功能可以让客户端通过订阅给定的频道或者模式,来获知数据库中键的变化,以及数据库中命令的执行情况。
举个例子,以下代码展示了客户端如何获取0号数据库中针对message键执行的所有命令:
127.0.0.1:6379>SUBSCRIBE _ _keyspace@0_ _:message
Reading messages . . . (press Ctrl-C to quit)
1) "subscribe" //订阅信息
2) "_ _keyspace@0_:message"
3) (integer) 1
1) "message" //执行SET 命令
2) "_ _keyspace@0_: message"
3) "set"
1) "message" //执行EXPIE命令
2) " keyspace@0_:message"
3) "expire"
1) "message" //执行DEL 命令
2) "_ _keyspace@0_: message "
3) "de1"
根据发回的通知显示，先后共有SET、EXPlRE 、DEL 三个命令对键message进行了操作。
这一类关注"某个键执行了什么命令"的通知称为键空间通知(key-space-notification),除此之外，还有另一类称为键事件通知(key-event-notification)的通知,它们关注的是"某个命令被什么键执行了" 。
以下是一个键事件通知的例子，代码展示了客户端如何获取0 号数据库中所有执行DEL 命令的键:
127.0.0.1:6379> SUBSCRIBE _ _keyspace@0_ _:del
Reading messages. . . (press Ctrl-C to quit)
1) "subcribe" //订阅信息
2) "_ _keyevent@0_ _:del"
3) (integer) 1
1) "message" //键key执行了DEL命令
2) "keyevent@0_ _:del"
3) "key"
1) "message" //键number执行了DEL命令
2) "_ _keyevent@0_ _:del"
3) "number"
1) "message" //键message执行了DEL命令
2) "keyevent@0_ _:del"
3) "message"
根据发回的通知显示,key、number、message三个键先后执行了DEL 命令。
服务器配置的notify-keyspace-events选项决定了服务器所发送通知的类型:
1.想让服务器发送所有类型的键空间通知和键事件通知，可以将选项的值设置为AKE。
2.想让服务器发送所有类型的键空间通知，可以将选项的值设置为AK。
3.想让服务器发送所有类型的键事件通知，可以将选项的值设置为AE。
4.想让服务器只发送和字符串键有关的键空间通知，可以将选项的值设置为K$。
5.想让服务器只发送和列表键有关的键事件通知，可以将选项的值设置为E1。
关于数据库通知功能的详细用法,以及notify-keyspace-events选项的更多设置,Redis 的官方文档已经做了很详细的介绍,这里不再赘述。
1.8.1 发送通知
发送数据库通知的功能是由notify.c/notifyKeyspaceEvent函数实现的：
void notifyKeyspaceEvent(int type, char *event, robj *key, int dbid);
函数的type参数是当前想要发送的通知类型，程序会根据这个值来判断通知是否就是服务器配置notify-keyspace-events选项所定的同志类型，从而决定是否发送通知。
event、keys、dbid分别是事件的名称、产生事件的键、以及产生事件的数据库号码，函数会根据这几个参数构建时间通知的内容，以及接受通知的频道名。
当redis命令需要发送数据库通知时，该命令的实现函数就会调用notifyKeyspaceEvent函数并传递相关参数。
例如，以下是SADD命令的实现函数saddCommand其中一部分代码：
void saddCommand(redisClient*c){
//...
//如果至少一个元素被成功添加，那么执行以下程序
if(added){
//..
//发送事件通知
notifyKeyspaceEvent(REDIS_NOTIFY_SET,"sadd",c-->argy[1],c->db->id);
//...
}
}
当SADD命令至少添加一个集合元素之后，命令就会发送通知，该通知的类型为REDIS_NOTIFY_SET（表示这是一个集合通知），名为sadd（表示这是执行SADD命令所产生的通知）
1.8.2 发送通知的实现
以下是notifyKeyspaceEvent函数的伪代码实现:
def notifyKeyspaceEvent(type,event,key,dbid):
#如果给定的通知不是服务器允许发送的通知，那么直接返回
if not(server.notify_keyspace_events&type) :
return
#发送键空间通知
if server.notify_keyspace_events&REDIS_NOTIFY_KEYSPACE:
#将通知发送给频道__ keyspace@<dbid>__ :<key>
#内容为键所发生的事件<event>
#构建频道名字
chan="keyspace@{dbid}:{key}".format(dbid=dbid,key=key)
#发送通知
pubsubPublishMessage(chan,event)
#发送键事件通知
if server.notify_keyspace_events&REDIS_NOTIFY_KEYEVENT:
#将通知发送给频道_keyevent@<dbid>_:<event>
#内容为发生事件的键<key>
#构建频道名字
chan="keyevent@{dbid}:{event}".format(dbid=dbid, event=event)
#发送通知
pubsubPublishMessage(chan, key)
notifyKeyspaceEvent函数执行以下操作：
-
server.notify_keyspace_events属性就是服务器配置notify-keyspace-events选项所设置的值,如果给定的通知类型type不是服务器允许发迭的通知类型,那么函数会直接返回,不做任何动作。
-
如果给定的通知是服务器允许发送的通知，那么下一步函数会检测服务器是否允许发送键空间通知，如果允许的话，程序就会构建并发送事件通知。
-
最后，函数检测服务器是否允许发送键事件通知，如果允许的话，程序就会构建并发送事件通知。
另外，pubsubPublishMessage函数是PUBLISH命令的实现函数，执行这个函数等同于执行PUBLISH命令，订阅数据库通知的客户端收到的信息就是由这个函数发出的.
扫一扫
670
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
