Redis-第9章-数据库

第9章 数据库

本章将对Redis服务器的数据库实现进行详细介绍，说明服务器保存数据库的方法，客户端切换数据库的方法，数据库保存键值对的方法，以及针对数据库的添加、删除、查看、更新操作的实现方法等。除此之外，本章还会说明服务器保存键的过期时间的方法，以及服务器自动删除过期键的方法。最后，本章还会说明Redis 2.8新引入的数据库通知功能的实现方法。

9.1 服务器中的数据库
Redis服务器将所有数据库都保存在服务器状态redis.h/redisServer结构的db数组中，db数组的每个项都是一个redis.h/redisDb结构，每个redisDb结构代表一个数据库：
struct redisServer {
    // ...
    //
    一个数组，保存着服务器中的所有数据库
    redisDb *db;
    // ...
};
在初始化服务器时，程序会根据服务器状态的dbnum属性来决定应该创建多少个数据库：
struct redisServer {
    // ...
    //服务器的数据库数量
    int dbnum;
    // ...
};
dbnum属性的值由服务器配置的database选项决定，默认情况下，该选项的值为16，所以Redis服务器默认会创建16个数据库，如图9-1所示。

图9-1 服务器数据库示例

9.2 切换数据库
每个Redis客户端都有自己的目标数据库，每当客户端执行数据库写命令或者数据库读命令的时候，目标数据库就会成为这些命令的操作对象。
默认情况下，Redis客户端的目标数据库为0号数据库，但客户端可以通过执行SELECT命令来切换目标数据库。
以下代码示例演示了客户端在0号数据库设置并读取键msg，之后切换到2号数据库并执行类似操作的过程：
redis＞ SET msg "hello world"
OK
redis＞ GET msg
"hello world"
redis＞ SELECT 2
OK
redis[2]＞ GET msg
(nil)
redis[2]＞ SET msg"another world"
OK
redis[2]＞ GET msg
"another world"
在服务器内部，客户端状态redisClient结构的db属性记录了客户端当前的目标数据库，这个属性是一个指向redisDb结构的指针：
typedef struct redisClient {
// ...
//记录客户端当前正在使用的数据库
redisDb *db;
// ...
} redisClient;
redisClient.db指针指向redisServer.db数组的其中一个元素，而被指向的元素就是客户端的目标数据库。
比如说，如果某个客户端的目标数据库为1号数据库，那么这个客户端所对应的客户端状态和服务器状态之间的关系如图9-2所示。

图9-2 客户端的目标数据库为1号数据库
如果这时客户端执行命令SELECT 2，将目标数据库改为2号数据库，那么客户端状态和服务器状态之间的关系将更新成图9-3。

图9-3 客户端的目标数据库为2号数据库
通过修改redisClient.db指针，让它指向服务器中的不同数据库，从而实现切换目标数据库的功能——这就是SELECT命令的实现原理。
谨慎处理多数据库程序
到目前为止，Redis仍然没有可以返回客户端目标数据库的命令。虽然redis-cli客户端会在输入符旁边提示当前所使用的目标数据库：
redis＞ SELECT 1
OK
redis[1]＞ SELECT 2
OK
redis[2]＞
但如果你在其他语言的客户端中执行Redis命令，并且该客户端没有像redis-cli那样一直显示目标数据库的号码，那么在数次切换数据库之后，你很可能会忘记自己当前正在使用的是哪个数据库。当出现这种情况时，为了避免对数据库进行误操作，在执行Redis命令特别是像FLUSHDB这样的危险命令之前，最好先执行一个SELECT命令，显式地切换到指定的数据库，然后才执行别的命令。

9.3 数据库键空间
Redis是一个键值对（key-value pair）数据库服务器，服务器中的每个数据库都由一个redis.h/redisDb结构表示，其中，redisDb结构的dict字典保存了数据库中的所有键值对，我们将这个字典称为键空间（key space）：
typedef struct redisDb {
    // ...
    //
    数据库键空间，保存着数据库中的所有键值对
    dict *dict;
    // ...
} redisDb;
键空间和用户所见的数据库是直接对应的：
❑键空间的键也就是数据库的键，每个键都是一个字符串对象。
❑键空间的值也就是数据库的值，每个值可以是字符串对象、列表对象、哈希表对象、集合对象和有序集合对象中的任意一种Redis对象。
举个例子，如果我们在空白的数据库中执行以下命令：
redis＞ SET message "hello world"
OK
redis＞ RPUSH alphabet "a" "b" "c"
(integer)3
redis＞ HSET book name "Redis in Action"
(integer) 1
redis＞ HSET book author "Josiah L. Carlson"
(integer) 1
redis＞ HSET book publisher "Manning"
(integer) 1
那么在这些命令执行之后，数据库的键空间将会是图9-4所展示的样子：
❑alphabet是一个列表键，键的名字是一个包含字符串"alphabet"的字符串对象，键的值则是一个包含三个元素的列表对象。
❑book是一个哈希表键，键的名字是一个包含字符串"book"的字符串对象，键的值则是一个包含三个键值对的哈希表对象。
❑message是一个字符串键，键的名字是一个包含字符串"message"的字符串对象，键的值则是一个包含字符串"hello world"的字符串对象。

图9-4 数据库键空间例子
因为数据库的键空间是一个字典，所以所有针对数据库的操作，比如添加一个键值对到数据库，或者从数据库中删除一个键值对，又或者在数据库中获取某个键值对等，实际上都是通过对键空间字典进行操作来实现的，以下几个小节将分别介绍数据库的添加、删除、更新、取值等操作的实现原理。
9.3.1 添加新键
添加一个新键值对到数据库，实际上就是将一个新键值对添加到键空间字典里面，其中键为字符串对象，而值则为任意一种类型的Redis对象。
举个例子，如果键空间当前的状态如图9-4所示，那么在执行以下命令之后：
redis＞ SET date "2013.12.1"
OK
键空间将添加一个新的键值对，这个新键值对的键是一个包含字符串"date"的字符串对象，而键值对的值则是一个包含字符串"2013.12.1"的字符串对象，如图9-5所示。

图9-5 添加date键之后的键空间
9.3.2 删除键
删除数据库中的一个键，实际上就是在键空间里面删除键所对应的键值对对象。
举个例子，如果键空间当前的状态如图9-4所示，那么在执行以下命令之后：
redis＞ DEL book
(integer) 1
键book以及它的值将从键空间中被删除，如图9-6所示。

图9-6 删除book键之后的键空间
9.3.3 更新键
对一个数据库键进行更新，实际上就是对键空间里面键所对应的值对象进行更新，根据值对象的类型不同，更新的具体方法也会有所不同。
举个例子，如果键空间当前的状态如图9-4所示，那么在执行以下命令之后：
redis＞ SET message "blah blah"
OK

键message的值对象将从之前包含"hello world"字符串更新为包含"blah blah"字符串，如图9-7所示。

图9-7 使用SET命令更新message键
再举个例子，如果我们继续执行以下命令：
redis＞ HSET book page 320
(integer) 1
那么键空间中book键的值对象（一个哈希对象）将被更新，新的键值对page和320会被添加到值对象里面，如图9-8所示。

图9-8 使用HSET更新book键
9.3.4 对键取值
对一个数据库键进行取值，实际上就是在键空间中取出键所对应的值对象，根据值对象的类型不同，具体的取值方法也会有所不同。
举个例子，如果键空间当前的状态如图9-4所示，那么当执行以下命令时：
redis＞ GET message
"hello world"

GET命令将首先在键空间中查找键message，找到键之后接着取得该键所对应的字符串对象值，之后再返回值对象所包含的字符串"hello world"，取值过程如图9-9所示。

图9-9 使用GET命令取值的过程
再举一个例子，当执行以下命令时：
redis＞ LRANGE alphabet 0 -1
1)"a"
2)"b"
3)"c"
LRANGE命令将首先在键空间中查找键alphabet，找到键之后接着取得该键所对应的列表对象值，之后再返回列表对象中包含的三个字符串对象的值，取值过程如图9-10所示。

图9-10 使用LRANGE命令取值的过程
9.3.5 其他键空间操作
除了上面列出的添加、删除、更新、取值操作之外，还有很多针对数据库本身的Redis命令，也是通过对键空间进行处理来完成的。
比如说，用于清空整个数据库的FLUSHDB命令，就是通过删除键空间中的所有键值对来实现的。又比如说，用于随机返回数据库中某个键的RANDOMKEY命令，就是通过在键空间中随机返回一个键来实现的。
另外，用于返回数据库键数量的DBSIZE命令，就是通过返回键空间中包含的键值对的数量来实现的。类似的命令还有EXISTS、RENAME、KEYS等，这些命令都是通过对键空间进行操作来实现的。
9.3.6 读写键空间时的维护操作
当使用Redis命令对数据库进行读写时，服务器不仅会对键空间执行指定的读写操作，还会执行一些额外的维护操作，其中包括：
❑在读取一个键之后（读操作和写操作都要对键进行读取），服务器会根据键是否存在来更新服务器的键空间命中（hit）次数或键空间不命中（miss）次数，这两个值可以在INFO stats命令的keyspace_hits属性和keyspace_misses属性中查看。
❑在读取一个键之后，服务器会更新键的LRU（最后一次使用）时间，这个值可以用于计算键的闲置时间，使用OBJECT idletime命令可以查看键key的闲置时间。
❑如果服务器在读取一个键时发现该键已经过期，那么服务器会先删除这个过期键，然后才执行余下的其他操作，本章稍后对过期键的讨论会详细说明这一点。
❑如果有客户端使用WATCH命令监视了某个键，那么服务器在对被监视的键进行修改之后，会将这个键标记为脏（dirty），从而让事务程序注意到这个键已经被修改过，第19章会详细说明这一点。
❑服务器每次修改一个键之后，都会对脏（dirty）键计数器的值增1，这个计数器会触发服务器的持久化以及复制操作，第10章、第11章和第15章都会说到这一点。
❑如果服务器开启了数据库通知功能，那么在对键进行修改之后，服务器将按配置发送相应的数据库通知，本章稍后讨论数据库通知功能的实现时会详细说明这一点。

9.4 设置键的生存时间或过期时间
通过EXPIRE命令或者PEXPIRE命令，客户端可以以秒或者毫秒精度为数据库中的某个键设置生存时间（Time To Live，TTL），在经过指定的秒数或者毫秒数之后，服务器就会自动删除生存时间为0的键：
redis＞ SET key value
OK
redis＞ EXPIRE key 5
(integer) 1
redis＞ GET key  // 5秒之内
"value"
redis＞ GET key  // 5秒之后
(nil)
注意
SETEX命令可以在设置一个字符串键的同时为键设置过期时间，因为这个命令是一个类型限定的命令（只能用于字符串键），所以本章不会对这个命令进行介绍，但SETEX命令设置过期时间的原理和本章介绍的EXPIRE命令设置过期时间的原理是完全一样的。
与EXPIRE命令和PEXPIRE命令类似，客户端可以通过EXPIREAT命令或PEXPIREAT命令，以秒或者毫秒精度给数据库中的某个键设置过期时间（expire time）。
过期时间是一个UNIX时间戳，当键的过期时间来临时，服务器就会自动从数据库中删除这个键：
redis＞ SET key value
OK
redis＞ EXPIREAT key 1377257300
(integer) 1
redis＞ TIME
1)"1377257296"
2)"296543"
redis＞ GET key    // 1377257300之前
"value"
redis＞ TIME
1)"1377257303"
2)"230656"

redis＞ GET key    // 1377257300之后
(nil)
TTL命令和PTTL命令接受一个带有生存时间或者过期时间的键，返回这个键的剩余生存时间，也就是，返回距离这个键被服务器自动删除还有多长时间：
redis＞ SET key value
OK
redis＞ EXPIRE key 1000
(integer) 1
redis＞ TTL key
(integer) 997
redis＞ SET another_key another_value
OK
redis＞ TIME
1)"1377333070"
2)"761687"
redis＞ EXPIREAT another_key 1377333100
(integer) 1
redis＞ TTL another_key
(integer) 10
在上一节我们讨论了数据库的底层实现，以及各种数据库操作的实现原理，但是，关于数据库如何保存键的生存时间和过期时间，以及服务器如何自动删除那些带有生存时间和过期时间的键这两个问题，我们还没有讨论。
本节将对服务器保存键的生存时间和过期时间的方法进行介绍，并在下一节介绍服务器自动删除过期键的方法。
9.4.1 设置过期时间
Redis有四个不同的命令可以用于设置键的生存时间（键可以存在多久）或过期时间（键什么时候会被删除）：
❑EXPIRE＜key＞＜ttl＞命令用于将键key的生存时间设置为ttl秒。
❑PEXPIRE＜key＞＜ttl＞命令用于将键key的生存时间设置为ttl毫秒。
❑EXPIREAT＜key＞＜timestamp＞命令用于将键key的过期时间设置为timestamp所指定的秒数时间戳。
❑PEXPIREAT＜key＞＜timestamp＞命令用于将键key的过期时间设置为

timestamp所指定的毫秒数时间戳。
虽然有多种不同单位和不同形式的设置命令，但实际上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)
最终，EXPIRE、PEXPIRE和EXPIREAT三个命令都会转换成PEXPIREAT命令来执行，如图9-11所示。

图9-11 设置生存时间和设置过期时间的命令之间的转换
9.4.2 保存过期时间
redisDb结构的expires字典保存了数据库中所有键的过期时间，我们称这个字典为过期字典：
❑过期字典的键是一个指针，这个指针指向键空间中的某个键对象（也即是某个数据库键）。
❑过期字典的值是一个long long类型的整数，这个整数保存了键所指向的数据库键的过期时间——一个毫秒精度的UNIX时间戳。
typedef struct redisDb {
    // ...
    //过期字典，保存着键的过期时间
    dict *expires;
    // ...
} redisDb;
图9-12展示了一个带有过期字典的数据库例子，在这个例子中，键空间保存了数据库中的所有键值对，而过期字典则保存了数据库键的过期时间。
注意
为了展示方便，图9-12的键空间和过期字典中重复出现了两次alphabet键对象和book键对象。在实际中，键空间的键和过期字典的键都指向同一个键对象，所以不会出现任何重复对象，也不会浪费任何空间。
[插图]
图9-12 带有过期字典的数据库例子
图9-12中的过期字典保存了两个键值对：

❑第一个键值对的键为alphabet键对象，值为1385877600000，这表示数据库键alphabet的过期时间为1385877600000（2013年12月1日零时）。
❑第二个键值对的键为book键对象，值为1388556000000，这表示数据库键book的过期时间为1388556000000（2014年1月1日零时）。
当客户端执行PEXPIREAT命令（或者其他三个会转换成PEXPIREAT命令的命令）为一个数据库键设置过期时间时，服务器会在数据库的过期字典中关联给定的数据库键和过期时间。
举个例子，如果数据库当前的状态如图9-12所示，那么在服务器执行以下命令之后：
redis＞ PEXPIREAT message 1391234400000
(integer) 1
过期字典将新增一个键值对，其中键为message键对象，而值则为1391234400000（2014年2月1日零时），如图9-13所示。

图9-13 执行PEXPIREAT命令之后的数据库
以下是PEXPIREAT命令的伪代码定义：
def PEXPIREAT(key, expire_time_in_ms):
    #如果给定的键不存在于键空间，那么不能设置过期时间
    if key not in redisDb.dict:
        return0
    #在过期字典中关联键和过期时间
    redisDb.expires[key] = expire_time_in_ms
    #过期时间设置成功

return 1
9.4.3 移除过期时间
PERSIST命令可以移除一个键的过期时间：
redis＞ PEXPIREAT message 1391234400000
(integer) 1
redis＞ TTL message
(integer) 13893281
redis＞ PERSIST message
(integer) 1
redis＞ TTL message
(integer) -1
PERSIST命令就是PEXPIREAT命令的反操作：PERSIST命令在过期字典中查找给定的键，并解除键和值（过期时间）在过期字典中的关联。
举个例子，如果数据库当前的状态如图9-12所示，那么当服务器执行以下命令之后：
redis＞ PERSIST book
(integer) 1
数据库将更新成图9-14所示的状态。

图9-14 执行PERSIST之后的数据库
可以看到，当PERSIST命令执行之后，过期字典中原来的book键值对消失了，这代表数据库键book的过期时间已经被移除。
以下是PERSIST命令的伪代码定义：
def PERSIST(key):
#如果键不存在，或者键没有设置过期时间，那么直接返回

if key not in redisDb.expires:
    return0
#移除过期字典中给定键的键值对关联
redisDb.expires.remove(key)
#键的过期时间移除成功
return 1
9.4.4 计算并返回剩余生存时间
TTL命令以秒为单位返回键的剩余生存时间，而PTTL命令则以毫秒为单位返回键的剩余生存时间：
redis＞ PEXPIREAT alphabet 1385877600000
(integer) 1
redis＞ TTL alphabet
(integer) 8549007
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和-1的情况
        return ttl_in_ms
    else:

#将毫秒转换为秒
        return ms_to_sec(ttl_in_ms)
举个例子，对于一个过期时间为1385877600000（2013年12月1日零时）的键alphabet来说：
❑如果当前时间为1383282000000（2013年11月1日零时），那么对键alphabet执行PTTL命令将返回2595600000，这个值是通过用alphabet键的过期时间减去当前时间计算得出的：1385877600000-1383282000000=2595600000。
❑另一方面，如果当前时间为1383282000000（2013年11月1日零时），那么对键alphabet执行TTL命令将返回2595600，这个值是通过计算alphabet键的过期时间减去当前时间的差，然后将差值从毫秒转换为秒之后得出的。
9.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年11月1日零时），那么调用is_expired（alphabet）将返回False，因为当前时间小于alphabet键的过期时间。
❑另一方面，如果当前时间为1385964000000（2013年12月2日零时），那么调用is_expired（alphabet）将返回True，因为当前时间大于alphabet键的过期时间。
注意
实现过期键判定的另一种方法是使用TTL命令或者PTTL命令，比如说，如果对某个键执行TTL命令，并且命令返回的值大于等于0，那么说明该键未过期。在实际中，Redis检查键是否过期的方法和is_expired函数所描述的方法一致，因为直接访问字典比执行一个命令稍微快一些。

9.5 过期键删除策略
经过上一节的介绍，我们知道了数据库键的过期时间都保存在过期字典中，又知道了如何根据过期时间去判断一个键是否过期，现在剩下的问题是：如果一个键过期了，那么它什么时候会被删除呢？
这个问题有三种可能的答案，它们分别代表了三种不同的删除策略：
❑定时删除：在设置键的过期时间的同时，创建一个定时器（timer），让定时器在键的过期时间来临时，立即执行对键的删除操作。
❑惰性删除：放任键过期不管，但是每次从键空间中获取键时，都检查取得的键是否过期，如果过期的话，就删除该键；如果没有过期，就返回该键。
❑定期删除：每隔一段时间，程序就对数据库进行一次检查，删除里面的过期键。至于要删除多少过期键，以及要检查多少个数据库，则由算法决定。
在这三种策略中，第一种和第三种为主动删除策略，而第二种则为被动删除策略。
9.5.1 定时删除
定时删除策略对内存是最友好的：通过使用定时器，定时删除策略可以保证过期键会尽可能快地被删除，并释放过期键所占用的内存。
另一方面，定时删除策略的缺点是，它对CPU时间是最不友好的：在过期键比较多的情况下，删除过期键这一行为可能会占用相当一部分CPU时间，在内存不紧张但是CPU时间非常紧张的情况下，将CPU时间用在删除和当前任务无关的过期键上，无疑会对服务器的响应时间和吞吐量造成影响。
例如，如果正有大量的命令请求在等待服务器处理，并且服务器当前不缺少内存，那么服务器应该优先将CPU时间用在处理客户端的命令请求上面，而不是用在删除过期键上面。
除此之外，创建一个定时器需要用到Redis服务器中的时间事件，而当前时间事件的实现方式——无序链表，查找一个事件的时间复杂度为O（N）——并不能高效地处理大量时间事件。

因此，要让服务器创建大量的定时器，从而实现定时删除策略，在现阶段来说并不现实。
9.5.2 惰性删除
惰性删除策略对CPU时间来说是最友好的：程序只会在取出键时才对键进行过期检查，这可以保证删除过期键的操作只会在非做不可的情况下进行，并且删除的目标仅限于当前处理的键，这个策略不会在删除其他无关的过期键上花费任何CPU时间。
惰性删除策略的缺点是，它对内存是最不友好的：如果一个键已经过期，而这个键又仍然保留在数据库中，那么只要这个过期键不被删除，它所占用的内存就不会释放。
在使用惰性删除策略时，如果数据库中有非常多的过期键，而这些过期键又恰好没有被访问到的话，那么它们也许永远也不会被删除（除非用户手动执行FLUSHDB），我们甚至可以将这种情况看作是一种内存泄漏——无用的垃圾数据占用了大量的内存，而服务器却不会自己去释放它们，这对于运行状态非常依赖于内存的Redis服务器来说，肯定不是一个好消息。
举个例子，对于一些和时间有关的数据，比如日志（log），在某个时间点之后，对它们的访问就会大大减少，甚至不再访问，如果这类过期数据大量地积压在数据库中，用户以为服务器已经自动将它们删除了，但实际上这些键仍然存在，而且键所占用的内存也没有释放，那么造成的后果肯定是非常严重的。
9.5.3 定期删除
从上面对定时删除和惰性删除的讨论来看，这两种删除方式在单一使用时都有明显的缺陷：
❑定时删除占用太多CPU时间，影响服务器的响应时间和吞吐量。
❑惰性删除浪费太多内存，有内存泄漏的危险。
定期删除策略是前两种策略的一种整合和折中：
❑定期删除策略每隔一段时间执行一次删除过期键操作，并通过限制删除操作执行的时长和频率来减少删除操作对CPU时间的影响。

❑除此之外，通过定期删除过期键，定期删除策略有效地减少了因为过期键而带来的内存浪费。
定期删除策略的难点是确定删除操作执行的时长和频率：
❑如果删除操作执行得太频繁，或者执行的时间太长，定期删除策略就会退化成定时删除策略，以至于将CPU时间过多地消耗在删除过期键上面。
❑如果删除操作执行得太少，或者执行的时间太短，定期删除策略又会和惰性删除策略一样，出现浪费内存的情况。
因此，如果采用定期删除策略的话，服务器必须根据情况，合理地设置删除操作的执行时长和执行频率。

9.6 Redis的过期键删除策略
在前一节，我们讨论了定时删除、惰性删除和定期删除三种过期键删除策略，Redis服务器实际使用的是惰性删除和定期删除两种策略：通过配合使用这两种删除策略，服务器可以很好地在合理使用CPU时间和避免浪费内存空间之间取得平衡。
因为前一节已经介绍过惰性删除和定期删除两种策略的概念了，在接下来的两个小节中，我们将对Redis服务器中惰性删除和定期删除的具体实现进行说明。
9.6.1 惰性删除策略的实现
过期键的惰性删除策略由db.c/expireIfNeeded函数实现，所有读写数据库的Redis命令在执行之前都会调用expireIfNeeded函数对输入键进行检查：
❑如果输入键已经过期，那么expireIfNeeded函数将输入键从数据库中删除。
❑如果输入键未过期，那么expireIfNeeded函数不做动作。
命令调用expireIfNeeded函数的过程如图9-15所示。
expireIfNeeded函数就像一个过滤器，它可以在命令真正执行之前，过滤掉过期的输入键，从而避免命令接触到过期键。
另外，因为每个被访问的键都可能因为过期而被expireIfNeeded函数删除，所以每个命令的实现函数都必须能同时处理键存在以及键不存在这两种情况：
❑当键存在时，命令按照键存在的情况执行。
❑当键不存在或者键因为过期而被expireIfNeeded函数删除时，命令按照键不存在的情况执行。
举个例子，图9-16展示了GET命令的执行过程，在这个执行过程中，命令需要判断键是否存在以及键是否过期，然后根据判断来执行合适的动作。

图9-15 命令调用expireIfNeeded来删除过期键

图9-16 GET命令的执行过程
9.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函数的工作模式可以总结如下：
❑函数每次运行时，都从一定数量的数据库中取出一定数量的随机键进行检查，并删除其中的过期键。
❑全局变量current_db会记录当前activeExpireCycle函数检查的进度，并在下一次activeExpireCycle函数调用时，接着上一次的进度进行处理。比如说，如果当前activeExpireCycle函数在遍历10号数据库时返回了，那么下次activeExpireCycle函数执行时，将从11号数据库开始查找并删除过期键。

❑随着activeExpireCycle函数的不断执行，服务器中的所有数据库都会被检查一遍，这时函数将current_db变量重置为0，然后再次开始新一轮的检查工作。