chapter9 数据库

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.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号数据库,那么这个客户端所对应的客户端状态和服务器状态之间的关系如图9-2所示。

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

    通过修改redisClient.db指针,让它指向服务器中的不同数据库,从而实现切换目标数据库的功能--这就是select命令的实现原理。

9.3 数据库键空间

    Redis是一个键值对(key-value pair)数据库服务器,服务器中的每个数据库都有一个redis.h/redisDb结构表示,其中,redisDb结构的dict字典保存了数据库中的所有键值对,将这个字典称为键空间(key space):

typedef struct redisDb{
  // ...
  // 数据库键空间,保存着数据库中的所有键值对
  dict *dict;
  // ...
}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

9.3.1 添加新键

    添加一个新键值对到数据库,实际上就是一个新键值对添加到键空间字典里面,其中键为字符串对象,而值则为任意一种类型的Redis对象。

    举个例子,执行以下命令,如图9-5所示:

127.0.0.1:6379> set date "2013.12.1"
OK

9.3.2 删除键

    举个例子,如果键空间当前的状态如图9-4所示,执行如下代码,如图9-6所示。

9.3.3 更新键

    举个例子,如果键空间的状态如图9-4所示,执行如下命令以后,如图9-7所示:

127.0.0.1:6379> set message "blah blah"
OK

    再举个例子,继续执行以下命令:如图9-8所示

127.0.0.1:6379> hset book page 320
(integer) 1

9.3.4 对键取值

    举个例子,如果键空间的状态如图9-4所示,执行以下命令,如图9-9

redis> get message
"hello world"

127.0.0.1:6379> lrange alphabet 0 -1
1) "a"
2) "b"
3) "c"

9.3.5 其他键空间操作

    用于清空整个数据库的flushdb命令,就是通过删除键空间中的所有键值对来实现的。又比如说,用于随机返回数据库中某个键的randomkey命令,就是通过在键空间中随机返回一个键来实现的。

    另外,用于返回数据库键数量的dbsize命令,就是通过返回键空间中包含的键值对的数量来实现的。类似的命令还有EXISTS,RENAME,KEYS等,这些命令都是通过对键空间进行操作来实现的。

9.3.6 读写键空间时的维护操作

    当使用Redis命令对数据库进行读写时,服务器不仅会对键空间执行指定的读写操作,还会执行一些额外的维护操作,其中包括:

• 在读取一个键之后(读操作和写操作都要对键进行读取),服务器会根据键是否存在来更新服务器的键空间命中(hit)次数或键空间不命中(miss)次数,这两个值可以在INFO stats命令的keyspace_hits属性和keyspace_misses属性中查看。
• 在读取一个键之后,服务器会更新键的LRU(最后一次使用)时间,这个值可以用于计算键的闲置时间,使用OBJECT idletime <key>命令可以查看键key的闲置时间。
• 如果服务器在读取一个键时发现该键已经过期,那么服务器会先删除这个过期键,然后才执行余下的其他操作。
• 如果客户端使用WATCH命令监视了某个键,那么服务器再对被监视的键进行修改之后,会将这个键标记为脏(dirty),从而让事物程序注意到这个键已经被修改过。
• 服务器每次修改一个键后,都会对脏(dirty)键计数器的值增1,这个计数器会触发服务器的持久化以及复制操作。
• 如果服务器开启了数据库通知功能,那么在对键进行修改之后,服务器将按配置发送相应的数据库通知。

9.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
"value"
127.0.0.1:6379> get key
(nil)

    与expire命令和pexpire命令类似,客户端可以通过expireat命令或pexpireat命令,以秒后者毫秒精度给数据库中的某个键设置过期时间(expire time)。

    过期时间是一个UNIX时间戳,当键的过期时间来临时,服务器就会自动从数据库总删除这个键:

127.0.0.1:6379> set key value
OK
127.0.0.1:6379> expireat key 1521930400
(integer) 1
127.0.0.1:6379> time
1) "1521930350"
2) "439607"
127.0.0.1:6379> get key
"value"
127.0.0.1:6379> time
1) "1521930406"
2) "421538"
127.0.0.1:6379> get key
(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) 997
127.0.0.1:6379> pttl key
(integer) 993035

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)

9.4.2 保存过期时间

    redisDb结构的expires字典保存了数据库中所有键的过期时间,我们称这个字典为过期字典:

• 过期字典的键是一个指针,这个指针指向键空间中的某个键对象(也即是某个数据库键).
• 过期字典的值是一个long long类型的整数,这个整数保存了键所指的数据库键的过期时间--一个毫秒精度的UNIX时间戳.

typedef struct redisDb{
  // ...
  // 过期字典,保存着键的生存时间
  dict *expires;
  // ...
}redisDb;

    图9-12展示了一个带有过期字典的数据库例子,在这个例子中,键空间保存了数据库总的所有键值对,而过期字典则保存了数据库键的过期时间。

    举个例子,如果数据库当前的状态如图9-12所示,那么在服务器执行以下命令之后:

redis>PEXPIREAT message 1391234400000
(integer) 1

    以下是PEXPIREAT命令的伪代码定义:

def PEXPIREAT(key,expire_time_in_ms):
  # 如果给定的键不存在于键空间,那么不能设置过期时间
  if key not in redisDb.dict:
    return 0
  # 在过期字典中关联键和过期时间
  redisDb.expires[key]=expire_time_in_ms
  # 过期时间设置成功
  return 1

9.4.3 移除过期时间

    persist命令可以移除一个键的过期时间:

127.0.0.1:6379> set message "hello,world"
OK
127.0.0.1:6379> pexpireat message 1000000000000000
(integer) 1
127.0.0.1:6379> ttl message
(integer) 998478065034
127.0.0.1:6379> persist message
(integer) 1
127.0.0.1:6379> ttl message
(integer) -1

    persist命令就是pexpireat命令的反操作:persist命令在过期字典中查找给定的键,并解除键和值(过期时间)在过期字典中的关联。

    举个例子,如果数据库当前的状态如图9-12所示,那么当服务器执行以下命令之后:

redis>persist book
(integer) 1

    persist命令的伪代码定义:

def PERSIST(key):
  # 如果键不存在,或者键没有设置过期时间,那么直接返回
  if key not in redisDb.expires:
    return 0;
  # 移除过期字典中给定键的键值对关联
  redisDb.expires.remove(key)
  # 键的过期时间移除成功
  return 1

9.4.4 计算并返回剩余生存时间

    TTL命令以秒为单位返回键的剩余生存时间,而PTTL命令则以毫秒为单位返回键的剩余生存时间:

127.0.0.1:6379> pexpireat alphabet 10000000000000
(integer) 1
127.0.0.1:6379> ttl alphabet
(integer) 8478064161
127.0.0.1:6379> pttl alphabet
(integer) 8478064154901

    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=PPTL(key)
  if ttl_in_ms < 0:
    # 处理返回值为-2和-1的情况
    return ttl_in_ms
  else:
    # 将毫秒转换为秒
    return ms_to_sec(ttl_in_ms)

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_timme_in_ms:
    # 是,键已经过期
    return True
  else:
    # 否,键未过期
    return false

9.5 过期键删除策略

• 定时删除：在设置键的过期时间的同时，创建一个定时器（timer），让定时器在键的过期时间来临时，立即执行对键的删除操作
• 惰性删除：放任过期键不管，每次从键空间取键时，检查所取键是否过期，如果过期，删除该键，若没有过期，返回该键
• 定期删除：每隔一段时间，程序对数据库进行依次检查，删除数据库里的过期键。
  

9.5.1 定时删除

• 定时删除策略对内存是最友好的:通过使用定时器,定时删除策略可以保证过期键会尽可能地被删除,并释放过期键所占用的内存。
• 另一方面,定时删除策略的缺点是,它对CPU时间是最不友好的:在过期键比较多的情况下,删除过期键这一行为可能会占用相当一部分CPU时间,在内存不紧张但是CPU时间非常紧张的情况下,将CPU时间用在删除和当前任务无关的过期键上,无疑会对服务器的响应时间和吞吐量造成影响。
• 除此之外,创建一个定时器需要用到Redis服务器中的时间事件,而当时间事件的实现方式--无序链表,查找一个事件的时间复杂度为O(N)--并不能高效地处理大量时间事件。
• 因此,要让服务器创建大量的定时器,从而实现定时器删除策略,在现阶段来说并不现实。

9.5.2 惰性删除

• 惰性删除策略对CPU时间来说是最友好的:程序只会取出键时才对键进行过期检查,这可以保证删除过期键的操作只会在非做不可的情况下进行,并且删除的目标仅限于当前处理的键,这个策略不会在删除其他无关的过期键上花费任何CPU时间。
• 惰性删除策略的缺点是,它对内存是最不友好的:如果一个键已经过期,而这个键有仍然保留在数据库中,那么只要这个过期键不被删除,它所占用的内存就不会释放

9.5.3 定期删除

    从上面对定时删除和惰性删除的讨论来看，这两种删除方式在单一使用时都有明显的缺陷:

• 定时删除占用太多CPU 时间，影响服务器的响应时间和吞吐量。
• 惰性删除浪费太多内存，有内存泄漏的危险。

    定期删除策略是前两种策略的一种整合和折中:

• 定期删除策略每隔一段时间执行一次删除过期键操作，并通过限制删除操作执行的时长和频率来减少删除操作对CPU 时间的影响。
• 除此之外，通过定期删除过期键，定期删除策略有效地减少了因为过期键而带来的内存浪费。

    定期删除策略的难点是确定删除操作执行的时长和频率:

• 如果删除操作执行得太频繁，或者执行的时间太长，定期删除策略就会退化成定时删除策略，以至于将C P U 时间过多地消耗在删除过期键上面。
• 如果删除操作执行得太少，或者执行的时间太短，定期删除策略又会和惰性删除策略一样，出现浪费内存的情况。

    因此，如果采用定期删除策略的话，服务器必须根据情况，合理地设置删除操作的执行时长和执行频率。

9.6 Redis的过期键删除策略

    Redis服务器实际使用的是惰性删除和定期删除两种策略: 通过配合使用这两种删除策略，服务器可以很好地在合理使用CPU时间和避免浪费内存空间之间取得平衡。

9.6.1 惰性删除策略的实现

    过期键的惰性删除策略由db.c/expirelfNeeded 函数实现，所有读写数据库的Redis命令在执行之前都会调用expirelfNeeded 函数对输入键进行检查:

• 如果输入键已经过期，那么expirelfNeeded 函数将输入键从数据库中删除。
• 如果输入键未过期， 那么expirelfNeeded 函数不做动作。

命令调用expirelfNeeded 函数的过程如图9- 15 所示。

expirelfNeeded 函数就像一个过滤器，它可以在命令真正执行之前，过搜、掉过期的输入键，从而避免命令接触到过期键。

另外，因为每个被访问的键都可能因为过期而被expirelfNeeded 函数删除，所以每个命令的实现函数都必须能同时处理键存在以及键不存在这两种情况:

• 当键存在时，命令按照键存在的情况执行。
• 当键不存在或者键因为过期而被expirelfNeeded 函数删除时，命令按照键不存在的情况执行。

举个例子，图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,然后再次开始新一轮的检查工作。
  

9.7 AOF、RDB和复制功能对过期键的处理

9.7.1生成RDB文件

    在执行SAVE命令或者BGSAVE命令创建一个新的RDB文件时,程序会对数据库中的键进行检查,已过期的键不会被保存到新创建的RDB文件中。

    举个例子,如果数据库中包含三个键K1,k2,k3,并且K2已经过期,那么当执行SAVE命令或者BGSAVE命令时,程序只会将k1和k3的数据保存到RDB文件中,而k2则会被忽略。

    因此,数据库中包含过期键不会对生成新的RDB文件造成影响。

9.7.2 载入RDB文件

    在启动Redis服务器时,如果服务器开启了RDB功能,那么服务器将对RDB文件进行载入:

• 如果服务器以主服务器模式运行,那么在载入RDB文件时,程序会对文件中保存的键进行检查,未过期的键会被载入到数据库中,而过期键则会被忽略,所以过期键对载入RDB文件的服务器不会造成影响。
• 如果服务器以从服务器模式运行,那么在载入RDB文件时,文件中保存的所有键,不论是否过期,都会被载入到数据库中。不过,因为主从服务器在进行数据同步的时候,从服务器的数据库就会被清空,所以一般来讲,过期键对载入RDB文件的从服务器也不会造成影响。

9.7.3 AOF文件写入

    当服务器以AOF持久化模式运行时,如果数据库中的某个键已经过期,但它还没有被惰性删除或者定期删除,那么AOF文件不会因为这个过期键而产生任何影响。

    当过期键被惰性删除或者定期删除之后,程序会向AOF文件追加(append)一条DEL命令,来显式的记录该键已被删除。

    举个例子,如果客户端使用get message命令,试图访问过期的message键,那么服务器将执行以下三个动作:

1)从数据库中删除message键。

2)追加一条DEL message命令到AOF文件。

3)向执行GET命令的客户端返回空回复。

9.7.4 AOF重写

    在执行AOF重写的过程中,程序会对数据库中的键进行检查,已过期的键不会被保存到重写后的AOF文件中。

9.7.5 复制

    当服务器运行在复制模式下时，从服务器的过期键删除动作由主服务器控制：

• 主服务器在删除一个过期键之后，会显式地向所有从服务器发送一个DEL命令，告知从服务器删除这个过期键
• 从服务器在执行客户端发送的读命令时，即使碰到过期键也不会将过期键删除，而是继续像处理未过期的键一样来处理过期键。
• 从服务器只有在接到主服务器发来的DEL命令之后，才会删除过期键。

    通过由主服务器来控制从服务器统一地删除过期键，可以保证主从服务器数据的一致性，也正是因为这个原因，当一个过期键仍然存在于主服务器的数据库时，这个过期键在从服务器里的复制品也会继续存在。

    举个例子，有一对主从服务器，它们的数据库中都保存着同样的三个键message、xxx和yyy，其中message为过期键，如图9-17所示。

    如果这时有客户端向从服务器发送命令GET message，那么从服务器将发现message键已经过期，但从服务器并不会删除message键，而是继续将message键的值返回给客户端，就好像message键并没有过期一样，如图9-18所示。

    假设在此之后，有客户端向主服务器发送命令GET message，那么主服务器将发现键message已经过期：主服务器会删除message键，向客户端返回空回复，并向从服务器发送DEL message命令，如图9-19所示。

    从服务器在接收到主服务器发来的DEL message命令之后，也会从数据库中删除message键，在这之后，主从服务器都不再保存过期键message了，如图9-20所示。

9.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_ _keyevent@0_ _:de1
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选项决定了服务器所发送通知的类型:

• 想让服务器发送所有类型的键空间通知和键事件通知，可以将选项的值设置为AKE。

• 想让服务器发送所有类型的键空间通知，可以将选项的值设置为AK。

• 想让服务器发送所有类型的键事件通知，可以将选项的值设置为AE。

• 想让服务器只发送和字符串键有关的键空间通知，可以将选项的值设置为K$。

• 想让服务器只发送和列表键有关的键事件通知，可以将选项的值设置为E1。

9.8.1 发送通知

    发送数据库通知的功能是由notify.c/notifyKeyspaceEvent函数实现的：

void notifyKeyspaceEvent(int type,char *event,robj *key,int dbid);

    函数的type参数是当前想要发送的通知的类型，程序会根据这个值来判断通知是否就是服务器配置notify-keyspace-events选项所选定的通知类型，从而决定是否发送通知。
    event、keys和dbid分别是事件的名称、产生事件的键，以及产生事件的数据库号码，函数会根据type参数以及这三个参数来构建事件通知的内容，以及接收通知的频道名。
    每当一个Redis命令需要发送数据库通知的时候，该命令的实现函数就会调用notify-KeyspaceEvent函数，并向函数传递传递该命令所引发的事件的相关信息。
    例如，以下是SADD命令的实现函数saddCommand的其中一部分代码：

void saddCommand(redisClient*c){
     // ...
     //
     如果至少有一个元素被成功添加，那么执行以下程序
     if (added) {
          // ...
          //发送事件通知
          notifyKeyspaceEvent(REDIS_NOTIFY_SET,"sadd",c-＞argv[1],c-＞db-＞id);
     }
     // ...
}

    当SADD命令至少成功地向集合添加了一个集合元素之后，命令就会发送通知，该通知的类型为REDIS_NOTIFY_SET（表示这是一个集合键通知），名称为sadd（表示这是执行SADD命令所产生的通知）。
    以下是另一个例子，展示了DEL命令的实现函数delCommand的其中一部分代码：

voi delCommand(redisClient *c){
    int deleted=0,j;
    //遍历所有输入键
    for (j=1; j＜c-＞argc; j++){
        //尝试删除键
        if (dbDelete(c-＞db,c-＞argv[j])){
            // ...
            //删除键成功，发送通知
            notifyKeyspaceEvent(REDIS_NOTIFY_GENERIC,
                "del",c-＞argv[j],c-＞db-＞id);
            // ...
        }
    }
    // ...

}

    在delCommand函数中，函数遍历所有输入键，并在删除键成功时，发送通知，通知的类型为REDIS_NOTIFY_GENERIC（表示这是一个通用类型的通知），名称为del（表示这是执行DEL命令所产生的通知）。

9.8.2 发送通知的实现

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函数执行以下操作：
1）server.notify_keyspace_events属性就是服务器配置notify-keyspace-events选项所设置的值，如果给定的通知类型type不是服务器允许发送的通知类型，那么函数会直接返回，不做任何动作。
2）如果给定的通知是服务器允许发送的通知，那么下一步函数会检测服务器是否允许发送键空间通知，如果允许的话，程序就会构建并发送事件通知。
3）最后，函数检测服务器是否允许发送键事件通知，如果允许的话，程序就会构建并发送事件通知。
    另外，pubsubPublishMessage函数是PUBLISH命令的实现函数，执行这个函数等同于执行PUBLISH命令，订阅数据库通知的客户端收到的信息就是由这个函数发出的。

9.9 重点回顾

• Redis服务器的所有数据库都保存在redisServer.db数组中，而数据库的数量则由redisServer.dbnum属性保存。

• 客户端通过修改目标数据库指针，让它指向redisServer.db数组中的不同元素来切换不同的数据库。

• 数据库主要由dict和expires两个字典构成，其中dict字典负责保存键值对，而expires字典则负责保存键的过期时间。

• 因为数据库由字典构成，所以对数据库的操作都是建立在字典操作之上的。

• 数据库的键总是一个字符串对象，而值则可以是任意一种Redis对象类型，包括字符串对象、哈希表对象、集合对象、列表对象和有序集合对象，分别对应字符串键、哈希表键、集合键、列表键和有序集合键。

• expires字典的键指向数据库中的某个键，而值则记录了数据库键的过期时间，过期时间是一个以毫秒为单位的UNIX时间戳。

• Redis使用惰性删除和定期删除两种策略来删除过期的键：惰性删除策略只在碰到过期键时才进行删除操作，定期删除策略则每隔一段时间主动查找并删除过期键。

• 执行SAVE命令或者BGSAVE命令所产生的新RDB文件不会包含已经过期的键。

• 执行BGREWRITEAOF命令所产生的重写AOF文件不会包含已经过期的键。

• 当一个过期键被删除之后，服务器会追加一条DEL命令到现有AOF文件的末尾，显式地删除过期键。

• 当主服务器删除一个过期键之后，它会向所有从服务器发送一条DEL命令，显式地删除过期键。

• 从服务器即使发现过期键也不会自作主张地删除它，而是等待主节点发来DEL命令，这种统一、中心化的过期键删除策略可以保证主从服务器数据的一致性。

• 当Redis命令对数据库进行修改之后，服务器会根据配置向客户端发送数据库通知。