《Reids 设计与实现》第六章 数据库

《Reids 设计与实现》第六章 数据库

一、服务器中的数据库

Redis 服务器将所有数据库都保存在服务器状态 redisServer 结构的 db 数组中，db 数组的每个项都是一个 redisDb 结构，每个 redisDb 结构代表一个数据库

struct redisServer{
	//...
	//一个数组，保存着服务器中的所有数据库
	redisDb *db;
	//... 
};

在初始化服务器时，程序会根据服务器状态的 dbnum 属性来决定应该创建多少个数据库：

struct redisServer{
	//...
	//服务器的数据库数量
	int dbnum;
	//... 
}; 

dbnum 属性的值由服务器配置的 database 选项决定，默认情况下，该选项的值为 16，所以 Redis 服务器默认会创建 16 个数据库，如图 9-1 所示

二、切换数据库

每个 Redis 客户端都有自己的目标数据库，每当客户端执行数据库写命令或者数据库读命令的时候，目标数据库就会成为这些命令的操作对象

默认情况下，Redis 客户端的目标数据库为 0 号数据库，但客户端可以通过执行 SELECT 命令来切换目标数据库

以下代码示例演示了客户端在 0 号数据库设置并读取键 msg，之后切换到 2 号数据库并执行类似操作的过程：

redis>SET msg "hello world"
OK

redis>GET msg
"hello world"

redis>SELECT 2

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 数组的其中一个元素，而被指向的元素就是客户端的目标数据库。通过修改 redisClient.db 指针，让它指向服务器中的不同数据库，从而实现切换目标数据库的功能 —— 这就是 SELECT 命令的实现原理

谨慎处理多数据库程序

到目前为止，Redis 仍然没有可以返回客户端目标数据库的命令。虽然 redis-cli 客户端会在输入符旁边提示当前所使用的目标数据库，但如果你在其他语言的客户端中执行 Redis 命令，并且该客户端没有像 redis-cli 那样一直显示目标数据库的号码，那么在数次切换数据库之后，你很可能会忘记自己当前正在使用的是哪个数据库。当出现这种情况时，为了避免对数据库进行误操作，在执行 Redis 命令，特别是像 FLUSHDB 这样的危险命令之前，最好先执行一个 SELECT 命令，显示地切换到指定的数据库，然后再执行别的命令

三、数据库键空间

Redis 是一个键值对（key-value pair）数据库服务器，服务器中的每个数据库都由一个 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” 的字符串对象

因为数据库的键空间是一个字典，所以所有针对数据库的操作，比如添加一个键值对到数据库，或者从数据库中删除一个键值对，又或者在数据库中获取某个键值对等，实际上都是通过键空间字典进行操作来实现的，以下几个小节将分别介绍数据库的添加、删除、更新、取值等操作的实现原理

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

删除键
删除数据库中的一个键，实际上就是在键空间里面删除键所对应的键值对对象

更新键
对一个数据库键进行更新，实际上就是对键空间里面键所对应的值对象进行更新，根据值对象的类型不同，更新的具体方法也会有所不同

对键取值
对一个数据库键进行取值，实际上就是在键空间中取出键所对应的值对象，根据值对象的类型不同，具体的取值方法也会有所不同

其他键空间操作

除了上面列出的添加、删除、更新、取值操作之外，还有很多针对数据库本身的 Redis 命令，也是通过对键空间进行处理来完成的

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

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

读写键空间时的维护操作

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

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

四、设置键的生存时间或过期时间

通过 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
(interger) 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 命令接受一个带有生存时间或者过期时间的键，返回这个键的剩余生存时间，也就是，返回距离这个键被服务器自动删除还有多长时间

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 命令一样

2.保存过期时间

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

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

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

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

为了展示方便， 图 9-12 的键空间和过期字典中重复出现了两次 alphabet 键对象和 book 键对象。在实际中，键空间的键和过期字典的键都指向同一个键对象，所以不会出现任何重复对象，也不会浪费任何空间

图 9-12 中的过期字典保存了两个键值对：

• 第一个键值对的键为 alphabet 键对象，值为 1385877600000，这表示数据库键 alphabet 的过期时间为 1385877600000（2013 年 12 月 1 日零时）
• 第二个键值对的键为 book 键对象，值为 138855600000，这表示数据库键 book 的过期时间为 138855600000（2014年 1 月 1 日 零时）

当客户端执行 PEXPIREAT 命令（或者其他三个会转换成 PEXPIREAT 命令的命令）为一个数据库键设置过期时间时，服务器会在数据库的过期字典中关联给定的数据库键和过期时间

3.移除过期时间

PERSIST 命令可以移除一个键的过期时间：

redis>PEXPIREAT message 139123400000
(integer) 1

redis>TTL message
(integer) 13893281

redis>PERSIST message
(integer) 1

redis>TTL message
(integer) -1

PERSIST 命令就是 PEXPIREAT 命令的反操作：PERSIST 命令在过期字典中查找给定的键，并解除键和值（过期时间）在过期字典中的关联

4.计算并返回剩余生存时间

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

redis>PEXPIREAT alphabet 1385877600000
(integer) 1

redis>TTL alphabet
(integer) 8549007

redis>PTTL alphabet
(integer) 8549001011

TTL 和 PTTL 两个命令都是通过计算键的过期时间和当前时间之间的差来实现的

5.过期键的判定

通过过期字典，程序可以用以下步骤检查一个给定键是否过期：

1. 检查给定键是否存在于过期字典：如果存在，那么取得键的过期时间
2. 检查当前 UNIX 时间戳是否大于键的过期时间：如果是的话，那么键已经过期：否则的话，键未过期

实现过期键判定的另一种方法是使用 TTL 命令或者 PTLL 命令，比如说，如果对某个键执行 TTL 命令，并且命令返回的值大于等于 0，那么说明该键未过期。但是在实际中，Redis 底层不会采用这种方法，因为直接访问字典比执行一个命令要快一些

五、过期键删除策略

如果一个键过期了，那么它什么时候会被删除呢？这个问题有三种可能的答案，它们分别代表了三种不同的删除策略：

• 定时删除：在设置键的过期时间的同时，创建一个定时器（timer），让定时器在键的过期时间来临时，立即执行对键的删除操作
• 惰性删除：放任键过期不管，但是每次从键空间中获取数据键时，都检查取得的键是否过期，如果过期的话，就删除该键；如果没有过期，就返回该键
• 定期删除：每隔一段时间，程序就对数据库进行一次检查，删除里面的过期键。至于要删除多少过期键，以及要检查多少个数据库，则由算法决定

在这三种策略中，第一种和第三种为主动删除策略，第二种则为被动删除策略

1.定时删除

定时删除策略对内存是最友好的：通过使用定时器，定时删除策略可以保证过期键会尽可能快地被删除，并释放过期键所占用的内存

另一方面，定时删除策略的缺点是，它对 CPU 时间是最不友好的：在过期键比较多的情况下，删除过期键这一行为可能会占用相当一部分 CPU 时间，在内存不紧张但是 CPU 时间非常紧张的情况下，将 CPU 时间用再删除和当前任务无关的过期键上，无疑会对服务器的响应时间和吞吐量造成影响

除此之外，创建一个定时器需要用到 Redis 服务器中的时间事件，而当前时间事件的实现方式 —— 无序链表，查找一个事件的时间复杂度为 O(N) —— 并不能高效地处理大量的时间事件

因此，要让服务器创建大量的定时器，从而实现定时删除策略，在现阶段来说并不现实

2.惰性删除

惰性删除策略对CPU 时间来说时最友好的：程序只会在取出键时才对键进行过期检查，这可以保证删除过期键的操作只会在非做不可的情况下进行，并且删除的目标仅限于当前处理的键，这个策略不会在删除其他无关的过期键上花费任何 CPU 时间

惰性删除的缺点是，它对内存是最不友好的：如果一个键已经过期，而这个键又仍然保留在数据库中，那么只要这个过期键不被删除，它所占用的内存就不会释放

在使用惰性删除策略时，如果数据库中有非常多的过期键，而这个鞋过期键又恰好没有被访问到的话，那么它们也许永远也不会被删除（除非用户手动执行 FLUSHDB），我们甚至可以将这种情况看作是一种内存泄漏 —— 无用的垃圾数据占用了大量的内存，而服务器却不会自己去释放它们，这对于运行状态非常依赖于内存的 Redis 服务器来说，肯定不是一个好消息

3.定期删除

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

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

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

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

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

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

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

六、Redis 的过期键删除策略

1.惰性删除策略的实现

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

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

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

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

2.定期删除策略的实现

过期键的定期删除策略由 activeExpireCycle 函数实现，每当 Redis 的服务器周期性操作 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.dnum
	else:
		db_numbers = DEFAULT_DB_NUMBERS

	#遍历各个数据库
	for i in range(db_numbers):
	
		#如果 current_db 的值等于服务器的数据库数量
		#这表示检查程序已经遍历了服务器的所有数据库一次
		#将 current_db 重置为 0，开始新的一轮遍历
		if current_db == server.dnum:
			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，然后再次开始新一轮的检查工作

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

1.生成 RDB 文件

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

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

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

2.载入 RDB 文件

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

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

举个例子，如果数据库中包含三个键 k1、k2、k3，并且 k2 已经过期，那么当服务器启动时：

• 如果服务器以主服务器模式运行，那么程序只会将 k1 和 k3 载入到数据库，k2 会被忽略
• 如果服务器以从服务器模式运行，那么 k1、k2 和 k3 都会被载入到数据库

3.AOF 文件写入

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

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

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

1. 从数据库中删除 message 键
2. 追加一条 DEL message 命令到 AOF 文件

4.AOF 重写

和生成 RDB 文件时类似，在执行 AOF 重写的过程中，程序会对数据库中的键进行检查，已过期的键不会被保存到重写后的 AOF 文件中

举个例子，如果数据库中包含三个键 k1、k2、k3，并且 k2 已经过期，那么在进行重写工作时，程序只会对 k1 和 k3 进行重写， 而 k2 则会被忽略

因此，数据库中包含过期键不会对 AOF 重写造成影响

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 所示

八、数据库通知

数据库通知是 Redis 2.8 版本增加的功能，这个功能可以让客户端通过订阅给定的频道或者模式，来获知数据库中键的变化，以及数据库中命令的执行情况

举个例子，以下代码展示了客户端如何获取 0 号数据库中针对 message 键执行的所有命令：

127.0.0.1:6379>SUBSCRIBE _ _ kespace@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"					//执行 EXPIRE 命令
2)"_ _keyspace@0_ _:message"
3)"expire"

1)"message"					//执行 DEL 命令
2)"_ _keyspace@0_ _:message"
3)"del"

根据发回的通知显示，先后共有 SET、EXPIRE、DEL 三个命令对键 message 进行了操作

这一类关注 “某个键执行了什么命令” 的通知称为键空间通知（key-space notification），除此之外，还有一类称为键事件通知（key-event notification）的通知，它们关注的是 “某个命令被什么键执行了”

以下是一个键事件通知的例子，代码展示了客户端如何获取 0 号数据库中所有执行 DEL 命令的键：

127.0.0.1:6379>SUBSCRIBE _ _ keyevent@0_ _:del
Reading message... (press Ctrl-C to quit)

1)"subscribe"				//订阅信息
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$
• 想让服务器只发送和列表键有关的键事件通知，可以将选项的值设置为 El

关于数据库通知功能的详细用法，以及 notify-keyspace-events 选项的更多设置，Redis 的官方文档已经做了很详细的介绍，这里不再赘述

1.发送通知

发送数据库通知的功能是由 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 命令所产生的通知）

2.发送通知的实现

以下是 notifyKeyspaceEvent 函数的伪代码实现：

def notifyKeyspaceEvent(type, event, key, dbid):

	#如果给定的通知不是服务器允许发送的通知，那么直接返回
	if not(server.notigy_keyspace_events & type):
		return

	#发送键空间通知
	if server.notify_keyspace_events & REDIS_NOTIFY_KEYEVENT: 
		
		#将通知发送给频道 __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. 最后，函数检测服务器是否允许发送键事件通知，如果允许的话，程序就i构建并发送事件通知

另外，pubsubPublishMessage 函数是 PUBLISH 命令的实现函数，执行这个函数等同于执行 PUBLISH 命令，订阅数据库通知的客户端收到的信息就是由这个函数发出的

九、重点回顾

• Redis 服务器的所有数据库都保存在 redisServer.db 数组中，而数据库的数量则由 redisServer.dbnum 属性保存
• 客户端通过修改目标数据库指针，让它指向 redisServer.db 数组中的不同元素来切换不同的数据库
• 数据库主要由 dict 和 expires 两个字典构成，其中 dict 字典负责保存键值对，而 expires 字典则负责保存键的过期时间
• 因为数据库由字典构成，所以对数据库的操作都是建立在字典操作之上的
• 数据库的键总是一个字符串对象，而值则记录了数据库键的过期事件，过期时间是一个以毫秒为单位的 UNIX 时间戳
• Redis 使用惰性删除和定期删除两种策略来删除过期的键：惰性删除策略只在碰到过期键时才进行删除操作，定期删除策略则每隔一段时间主动查找并删除过期键
• 执行 SAVE 命令或者 BGSAVE 命令所产生的新 AOF 文件不会包含已经过期的键
• 当一个过期键被删除之后，服务器会追加一条 DEL 命令到现有 AOF 文件的末尾，显示地删除过期键
• 当主服务器删除一个过期键之后，它会向所有从服务器发送一条 DEL 命令，显式地删除过期键
• 从服务器即使发现过期键也不会自作主张地删除它，而是等待主节点发来 DEL 命令，这种统一、中心化地过期键删除策略可以保证主从服务器数据的一致性
• 当 Redis 命令对数据库进行修改之后，服务器会根据配置向客户端发送数据库通知