Redis 服务器是一个事件驱动程序，它主要处理如下两种事件：
- 文件事件：利用 I/O 复用机制，监听 Socket 等文件描述符上发生的事件。这类事件主要由客户端（或其他Redis 服务器）发送网络请求触发。
- 时间事件：定时触发的事件，负责完成 Redis 内部定时任务，如生成
RDB文件、清除 过期数据等。
Redis 事件机制概述
Redis 利用 I/O 复用机制实现网络通信。I/O 复用是一种高性能 I/O 模型，它可以利用单进程监听多个客户端连接，当某个连接状态发生变化（如可读、可写）时，操作系统会发送事件（这些事件称为已就绪事件）通知进程处理该连接的数据。很多 UNIX 系统都实现了 I/O 复用机制，但它们对外提供的系统 API 并不相同，包括 POSIX（可移植操作系统接口）标准定义的 select、Linux 的 epoll、Solaris 10 的 evport、OS X 和 FreeBSD 的 kqueue。为此，Redis 实现了自己的事件机制，支持不同系统的 I/O 复用 API。
Redis 事件机制的实现代码在 ae.h、ae.c 中，它实现了高层逻辑，负责控制进程，使其阻塞等待事件就绪或处理已就绪的事件，并为不同系统的 I/O 复用 API 定义了一致的 Redis API：
aeApiCreate：初始化I/O复用机制的上下文环境。aeApiAddEvent、aeApiDelEvent：添加或删除一个监听对象。aeApiPoll：阻塞进程，等待事件就绪或给定时间到期。
ae_select.c、ae_epoll.c、ae_evport.c、ae kqueue.c 是 Redis 针对不同系统 I/O 复用机制的适配代码，分别调用 select、epoll、evport、kqueue 实现了上述 Redis API，ae.c 会在 Redis 服务启动时根据操作系统支持的 I/O 复用 API 选择使用合适的适配代码。
为了描述方便，将
ae.h、ae.c称为AE抽象层，将ae_select.c、ae _epoll.c等称为 I/O 复用层。
aeEventLoop
aeEventLoop是 Redis 中的事件循环器，负责管理事件。
/* State of an event based program */
typedef struct aeEventLoop {
int maxfd; /* highest file descriptor currently registered */
int setsize; /* max number of file descriptors tracked */
long long timeEventNextId;
time_t lastTime; /* Used to detect system clock skew */
aeFileEvent *events; /* Registered events */
aeFiredEvent *fired; /* Fired events */
aeTimeEvent *timeEventHead;
int stop;
void *apidata; /* This is used for polling API specific data */
aeBeforeSleepProc *beforesleep;
aeBeforeSleepProc *aftersleep;
int flags;
} aeEventLoop;
这段代码定义了 Redis 中异步事件处理库的状态结构体 aeEventLoop。下面是对该结构体中各个字段的详细解释：
-
int maxfd;：当前注册的文件描述符中的最大值。在事件循环中，用于记录当前追踪的最高文件描述符。 -
int setsize;：最大追踪的文件描述符数目。用于指定事件循环追踪的最大文件描述符数量。 -
long long timeEventNextId;：待分配的下一个时间事件的 ID。用于唯一标识每个时间事件。 -
time_t lastTime;：用于检测系统时钟偏差的时间戳。用于检测系统时钟的偏差，以确保时间事件的准确性。 -
aeFileEvent *events;：已注册的文件事件数组。用于存储已注册的文件事件。 -
aeFiredEvent *fired;：触发的事件数组。用于存储触发的事件。 -
aeTimeEvent *timeEventHead;：时间事件链表的头指针。用于存储时间事件，以便按时间顺序执行。 -
int stop;：停止标志位。当该标志位为真时，事件循环将停止运行。 -
void *apidata;：用于特定于轮询API的数据指针。用于存储轮询API特定的数据，不同的轮询API可能需要不同的数据结构。 -
aeBeforeSleepProc *beforesleep;：睡眠前的回调函数。在事件循环进入睡眠状态之前调用的回调函数。 -
aeBeforeSleepProc *aftersleep;：睡眠后的回调函数。在事件循环从睡眠状态唤醒之后调用的回调函数。 -
int flags;：标志位。用于记录一些状态信息或控制事件循环的行为。
这个结构体定义了事件循环的状态，包括了已注册的文件事件、触发的事件、时间事件等信息。通过这个结构体，Redis 能够高效地处理异步事件，并根据需要执行相应的操作。
aeFileEvent
aeFileEvent存储了一个文件描述符上已经注册的文件事件。
/* File event structure */
typedef struct aeFileEvent {
int mask; /* one of AE_(READABLE|WRITABLE|BARRIER) */
aeFileProc *rfileProc;
aeFileProc *wfileProc;
void *clientData;
} aeFileEvent;
这段代码定义了 Redis 中异步事件处理库中文件事件的结构体 aeFileEvent。下面是对该结构体中各个字段的详细解释：
-
int mask;：事件类型掩码，表示文件事件的类型。可以是以下之一：AE_READABLE：可读事件，表示文件描述符可读。AE_WRITABLE：可写事件，表示文件描述符可写。AE_BARRIER：屏障事件，用于实现特定的同步机制。
-
aeFileProc *rfileProc;：可读事件处理函数指针。指向处理可读事件的回调函数。 -
aeFileProc *wfileProc;：可写事件处理函数指针。指向处理可写事件的回调函数。 -
void *clientData;：客户数据指针。用于存储与事件相关的自定义数据，以便在事件回调函数中使用。
这个结构体定义了文件事件的属性，包括事件类型、处理函数以及客户数据。通过这个结构体，Redis 能够管理文件事件，并在文件描述符可读或可写时调用相应的回调函数来处理事件。
aeFileEvent中并没有记录文件描述符fd的属性。POSIX标准对文件描述符fd有以下约束：
（1）值为0、1、2的文件描述符分别表示标准输入、标准输出和错误输出。
（2）每次新打开的文件描述符，必须使用当前进程中最小可用的文件描述符。
Redis充分利用文件描述符的这些特点，定义了一个数组aeEventLoop.events来存储已注册的文件事件。数组索引即文件描述符，数组元素即该文件描述符上注册的文件事件，如aeFileEvent.events[99]存放了值为 9 9的文件描述符的文件事件。
I/O复用层会将已就绪的事件转化为aeFiredEvent，存放在aeEventLoop.fired中，等待事件循环器处理。
aeFiredEvent
/* A fired event */
typedef struct aeFiredEvent {
int fd;
int mask;
} aeFiredEvent;
这段代码定义了 Redis 中异步事件处理库中触发事件的结构体 aeFiredEvent。下面是对该结构体中各个字段的详细解释：
-
int fd;：触发事件的文件描述符。表示触发了事件的文件描述符。 -
int mask;：触发的事件类型掩码。表示触发了哪种类型的事件，可以是以下之一：AE_READABLE：可读事件。AE_WRITABLE：可写事件。
这个结构体用于存储触发的事件信息，包括触发事件的文件描述符和事件类型。在事件循环中，当某个文件描述符上发生了对应的事件时，就会生成一个 aeFiredEvent 结构体实例，并将其存储在相应的数组中，以供事件循环处理。
aeTimeEvent
aeTimeEvent中存储了一个时间事件的信息。
/* Time event structure */
typedef struct aeTimeEvent {
long long id; /* time event identifier. */
long when_sec; /* seconds */
long when_ms; /* milliseconds */
aeTimeProc *timeProc;
aeEventFinalizerProc *finalizerProc;
void *clientData;
struct aeTimeEvent *prev;
struct aeTimeEvent *next;
int refcount; /* refcount to prevent timer events from being
* freed in recursive time event calls. */
} aeTimeEvent;
这段代码定义了 Redis 中异步事件处理库中时间事件的结构体 aeTimeEvent。下面是对该结构体中各个字段的详细解释：
-
long long id;：时间事件的唯一标识符。用于唯一标识每个时间事件。 -
long when_sec;：时间事件触发的秒数部分。表示时间事件触发的绝对时间的秒数部分。 -
long when_ms;：时间事件触发的毫秒数部分。表示时间事件触发的绝对时间的毫秒数部分。 -
aeTimeProc *timeProc;：时间事件处理函数指针。指向处理时间事件的回调函数。 -
aeEventFinalizerProc *finalizerProc;：时间事件终结器函数指针。指向时间事件的终结器函数，用于清理时间事件的资源。 -
void *clientData;：客户数据指针。用于存储与时间事件相关的自定义数据，以便在时间事件处理函数中使用。 -
struct aeTimeEvent *prev;和struct aeTimeEvent *next;：双向链表的前驱和后继指针。用于将时间事件连接成双向链表，以便按时间顺序执行。 -
int refcount;：引用计数。用于防止在递归时间事件调用中释放计时器事件。当一个时间事件被递归调用多次时，引用计数会增加，直到递归调用结束后再减少。
这个结构体用于表示时间事件的属性和状态，包括触发时间、处理函数、终结器函数等。通过这个结构体，Redis 能够管理和调度时间事件，以便在指定的时间点执行相应的操作。
Redis 启动时创建的事件
aeCreateEventLoop
Redis 启动时，
initServer函数调用aeCreateEvent函数创建一个时间循环器，存储在server.el属性中。
/* When configuring the server eventloop, we setup it so that the total number
* of file descriptors we can handle are server.maxclients + RESERVED_FDS +
* a few more to stay safe. Since RESERVED_FDS defaults to 32, we add 96
* in order to make sure of not over provisioning more than 128 fds. */
#define CONFIG_FDSET_INCR (CONFIG_MIN_RESERVED_FDS+96)
#define CONFIG_MIN_RESERVED_FDS 32
void initServer(void) {
// ···
server.el = aeCreateEventLoop(server.maxclients+CONFIG_FDSET_INCR);
// ···
}
aeEventLoop *aeCreateEventLoop(int setsize) {
aeEventLoop *eventLoop;
int i;
// 创建并初始化 aeEventLoop 结构体
if ((eventLoop = zmalloc(sizeof(*eventLoop))) == NULL) goto err;
eventLoop->events = zmalloc(sizeof(aeFileEvent)*setsize);
eventLoop->fired = zmalloc(sizeof(aeFiredEvent)*setsize);
if (eventLoop->events == NULL || eventLoop->fired == NULL) goto err;
eventLoop->setsize = setsize;
eventLoop->lastTime = time(NULL);
eventLoop->timeEventHead = NULL;
eventLoop->timeEventNextId = 0;
eventLoop->stop = 0;
eventLoop->maxfd = -1;
eventLoop->beforesleep = NULL;
eventLoop->aftersleep = NULL;
eventLoop->flags = 0;
if (aeApiCreate(eventLoop) == -1) goto err;
/* Events with mask == AE_NONE are not set. So let's initialize the
* vector with it. */
// 初始化 aeFileEvent.mask 字段
for (i = 0; i < setsize; i++)
eventLoop->events[i].mask = AE_NONE;
return eventLoop;
err:
if (eventLoop) {
zfree(eventLoop->events);
zfree(eventLoop->fired);
zfree(eventLoop);
}
return NULL;
}
aeApiCreate
aeApiCreate 由 I/O 复用层实现，这时 Redis 已经根据运行系统选择了具体的 I/O 复用层适配代码，该函数会调用到 ae_select.c，ae_epoll.c，ae_kqueue.c 其中的一个实现，并初始化具体的 I/O 复用机制执行的上下文环境。
下面是调用到 ae_epoll.c 中的 aeApiCreate 函数的代码。
typedef struct aeApiState {
int epfd;
struct epoll_event *events;
} aeApiState;
static int aeApiCreate(aeEventLoop *eventLoop) {
aeApiState *state = zmalloc(sizeof(aeApiState));
if (!state) return -1; // 空间开辟失败
// 最大文件描述符数量
state->events = zmalloc(sizeof(struct epoll_event)*eventLoop->setsize);
if (!state->events) { // 空间开辟失败
zfree(state);
return -1;
}
// 现在 epoll_create 的参数并没有什么作用
state->epfd = epoll_create(1024); /* 1024 is just a hint for the kernel */
if (state->epfd == -1) {
zfree(state->events);
zfree(state);
return -1;
}
eventLoop->apidata = state;
return 0;
}
aeCreateFileEvent
Redis 启动时，调用 aeCreateFileEvent 函数为 TCP Socker 等文件描述符注册了 AE_READABLE 文件事件的处理函数。所以，事件循环器会监听 TCP Socket，并使用指定函数来处理 AE_READABLE 事件。
void initServer(void) {
// ···
/* Create an event handler for accepting new connections in TCP and Unix
* domain sockets. */
for (j = 0; j < server.ipfd_count; j++) {
if (aeCreateFileEvent(server.el, server.ipfd[j], AE_READABLE,
acceptTcpHandler,NULL) == AE_ERR)
{
serverPanic(
"Unrecoverable error creating server.ipfd file event.");
}
}
for (j = 0; j < server.tlsfd_count; j++) {
if (aeCreateFileEvent(server.el, server.tlsfd[j], AE_READABLE,
acceptTLSHandler,NULL) == AE_ERR)
{
serverPanic(
"Unrecoverable error creating server.tlsfd file event.");
}
}
if (server.sofd > 0 && aeCreateFileEvent(server.el,server.sofd,AE_READABLE,
acceptUnixHandler,NULL) == AE_ERR) serverPanic("Unrecoverable error creating server.sofd file event.");
/* Register a readable event for the pipe used to awake the event loop
* when a blocked client in a module needs attention. */
if (aeCreateFileEvent(server.el, server.module_blocked_pipe[0], AE_READABLE,
moduleBlockedClientPipeReadable,NULL) == AE_ERR) {
serverPanic(
"Error registering the readable event for the module "
"blocked clients subsystem.");
}
// ···
}
-
第一个
for循环用于遍历服务器的 TCP 套接字数组，对每个 TCP 套接字注册可读事件，并指定了处理函数acceptTcpHandler。这个处理函数用于接受客户端的 TCP 连接。 -
第二个
for循环用于遍历服务器的TLS（Transport Layer Security）套接字数组，对每个TLS套接字注册可读事件，并指定了处理函数acceptTLSHandler。这个处理函数用于接受客户端的TLS连接。 -
如果服务器的 Unix 域套接字描述符
server.sofd大于 0，则使用aeCreateFileEvent()函数注册了 Unix 域套接字的可读事件，并指定了处理函数acceptUnixHandler。这个处理函数用于接受客户端的 Unix 域连接。 -
最后，使用
aeCreateFileEvent()函数注册了一个可读事件，监听用于唤醒事件循环的管道。当模块中的阻塞客户端需要处理时，会往这个管道中写入数据，以唤醒事件循环，从而执行相应的处理函数moduleBlockedClientPipeReadable。
因此，客户端来连接时，如果是 TCP、TLS 或 Unix 域连接，将会触发相应的可读事件处理函数，从而处理客户端的连接请求
- 参数：
eventLoop：指向要添加文件事件的事件循环（aeEventLoop结构体）的指针。fd：要添加事件的文件描述符。这个文件描述符应该是在事件循环中需要被监听的文件描述符之一。mask：指定要监听的事件类型，可以是AE_READABLE、AE_WRITABLE。AE_READABLE表示监听文件描述符的可读事件，AE_WRITABLE表示监听文件描述符的可写事件。因为传递事件处理函数的参数只有一个，因此理论上是不能给一个文件描述符同时注册读事件和写事件的呢！proc：指向事件发生时要调用的处理函数的指针。对于可读事件，通常是一个读取数据的函数；对于可写事件，通常是一个写入数据的函数。clientData：一个指针，用于传递给处理函数的客户数据。可以是任意类型的数据，通常用于传递一些上下文信息给处理函数。
int aeCreateFileEvent(aeEventLoop *eventLoop, int fd, int mask,
aeFileProc *proc, void *clientData)
{
if (fd >= eventLoop->setsize) {
errno = ERANGE;
return AE_ERR;
}
aeFileEvent *fe = &eventLoop->events[fd];
if (aeApiAddEvent(eventLoop, fd, mask) == -1)
return AE_ERR;
fe->mask |= mask;
if (mask & AE_READABLE) fe->rfileProc = proc;
if (mask & AE_WRITABLE) fe->wfileProc = proc;
fe->clientData = clientData;
if (fd > eventLoop->maxfd)
eventLoop->maxfd = fd;
return AE_OK;
}
这段代码是 Redis 中用于创建文件事件的函数 aeCreateFileEvent。下面是对函数中的各个部分的详细解释：
-
if (fd >= eventLoop->setsize) { errno = ERANGE; return AE_ERR; }：首先，函数检查要创建的文件描述符fd是否超出了事件循环中追踪的文件描述符的范围。如果超出范围，则将错误号设置为ERANGE，表示参数超出范围，然后返回AE_ERR，表示创建文件事件失败。 -
aeFileEvent *fe = &eventLoop->events[fd];：然后，函数通过文件描述符fd在事件循环的events数组中找到对应的文件事件结构体，并将其赋值给fe变量。这样就可以操作该文件描述符对应的文件事件了。 -
if (aeApiAddEvent(eventLoop, fd, mask) == -1) return AE_ERR;：接下来，函数调用aeApiAddEvent函数向特定事件循环API中添加指定文件描述符和事件类型的事件。如果添加事件失败，则返回AE_ERR，表示创建文件事件失败。 -
fe->mask |= mask;：然后，函数将要创建的事件类型掩码mask添加到文件事件结构体中的mask字段中。这样，文件事件结构体就记录了该文件描述符上关注的所有事件类型。 -
if (mask & AE_READABLE) fe->rfileProc = proc;和if (mask & AE_WRITABLE) fe->wfileProc = proc;：根据事件类型掩码mask，函数设置文件事件结构体中的读事件处理函数指针rfileProc和写事件处理函数指针wfileProc。如果创建的是可读事件，则将proc赋值给rfileProc；如果是可写事件，则将proc赋值给wfileProc。 -
fe->clientData = clientData;：最后，函数将客户数据指针clientData存储到文件事件结构体中的clientData字段中，以便在事件发生时能够获取到相关的客户数据。 -
if (fd > eventLoop->maxfd) eventLoop->maxfd = fd;：如果当前文件描述符fd大于事件循环中记录的最大文件描述符maxfd，则更新maxfd为fd，以确保maxfd始终记录着当前最大的文件描述符。 -
最后，函数返回
AE_OK，表示创建文件事件成功。
这个函数的作用是向事件循环中添加文件事件，设置文件描述符上关注的事件类型和处理函数，并将相关信息保存到事件循环的数据结构中，以便后续的事件处理。
aeCreateTimeEvent
Redis 启动的时候也调用 aeCreateTimeEvent 函数创建了一个处理函数为 serverCron 的时间事件，负责处理 Redis 中的定时事件。
void initServer(void) {
// ···
/* Create the timer callback, this is our way to process many background
* operations incrementally, like clients timeout, eviction of unaccessed
* expired keys and so forth. */
if (aeCreateTimeEvent(server.el, 1, serverCron, NULL, NULL) == AE_ERR) {
serverPanic("Can't create event loop timers.");
exit(1);
}
// ···
}
这段代码是在初始化 Redis 服务器时创建了一个定时器事件，用于周期性地执行一些后台操作。具体来说：
aeCreateTimeEvent函数用于在事件循环中创建一个定时器事件。server.el是指向 Redis 服务器事件循环的指针。1是指定了事件的间隔时间，单位为毫秒。这里设置为 1 毫秒，表示每隔 1 毫秒就会触发一次定时器事件。serverCron是一个处理定时器事件的处理函数，用于执行后台操作，例如处理客户端超时、删除过期的键等等。这个函数是 Redis 服务器的主事件循环函数之一。NULL是指定给处理函数的参数。这里没有额外的参数需要传递给处理函数，所以设置为NULL。- 最后一个参数也是
NULL，用于传递事件的 finalizer 函数，当事件被删除时调用。在这里没有指定 finalizer 函数。
这段代码的作用是在 Redis 服务器初始化时创建一个定时器事件，用于周期性地执行一些后台操作。例如，通过定时器事件，可以定期检查客户端的超时情况、清理过期的键、执行 AOF（Append-Only File） 持久化等任务。
- 参数：
eventLoop：指向事件循环（aeEventLoop结构体）的指针，用于将定时器事件添加到特定的事件循环中。milliseconds：指定定时器事件触发的时间间隔，单位是毫秒。proc：指定定时器事件触发时要调用的处理函数的指针，即定时器事件的处理函数。clientData：一个指针，用于传递给处理函数的客户数据。可以是任意类型的数据，通常用于传递一些上下文信息给处理函数。finalizerProc：指定一个可选的最终器处理函数的指针。当定时器事件被删除时，将调用这个最终器处理函数。
long long aeCreateTimeEvent(aeEventLoop *eventLoop, long long milliseconds,
aeTimeProc *proc, void *clientData,
aeEventFinalizerProc *finalizerProc)
{
// 生成新的定时器事件的唯一标识符
long long id = eventLoop->timeEventNextId++;
aeTimeEvent *te;
// 分配并初始化一个新的定时器事件结构体
te = zmalloc(sizeof(*te));
if (te == NULL) return AE_ERR;
te->id = id;
// 设置定时器事件的触发时间
aeAddMillisecondsToNow(milliseconds,&te->when_sec,&te->when_ms);
// 设置定时器事件的处理函数、客户数据和最终器处理函数
te->timeProc = proc;
te->finalizerProc = finalizerProc;
te->clientData = clientData;
// 将新的定时器事件添加到事件循环的定时器事件链表中
te->prev = NULL;
te->next = eventLoop->timeEventHead;
te->refcount = 0;
if (te->next)
te->next->prev = te;
eventLoop->timeEventHead = te;
// 返回新创建的定时器事件的唯一标识符
return id;
}
serverCron
- 函数功能：服务器定时器事件处理函数，用于周期性地执行服务器的各种后台任务。
- 参数：
eventLoop：指向事件循环（aeEventLoop结构体）的指针，但此处未使用该参数。id：定时器事件的唯一标识符，但此处未使用该参数。clientData：指向客户数据的指针，但此处未使用该参数。
int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
int j;
UNUSED(eventLoop); // 防止编译器警告，表示未使用的参数
UNUSED(id); // 防止编译器警告，表示未使用的参数
UNUSED(clientData); // 防止编译器警告，表示未使用的参数
/* 软件看门狗：如果我们在这里处理不够快，将发送 SIGALRM 信号 */
if (server.watchdog_period) watchdogScheduleSignal(server.watchdog_period);
/* 更新时间缓存 */
updateCachedTime(1);
server.hz = server.config_hz;
/* 根据已配置客户端的数量调整 server.hz 的值。如果客户端数量很多，
* 我们希望以更高的频率调用 serverCron() 函数。*/
if (server.dynamic_hz) {
while (listLength(server.clients) / server.hz >
MAX_CLIENTS_PER_CLOCK_TICK)
{
server.hz *= 2;
if (server.hz > CONFIG_MAX_HZ) {
server.hz = CONFIG_MAX_HZ;
break;
}
}
}
// 每 100ms 运行一次
run_with_period(100) {
// 跟踪统计指标
trackInstantaneousMetric(STATS_METRIC_COMMAND,server.stat_numcommands);
trackInstantaneousMetric(STATS_METRIC_NET_INPUT,
server.stat_net_input_bytes);
trackInstantaneousMetric(STATS_METRIC_NET_OUTPUT,
server.stat_net_output_bytes);
}
/* LRU 时钟处理 */
server.lruclock = getLRUClock();
/* 记录自启动以来的最大内存使用量 */
if (zmalloc_used_memory() > server.stat_peak_memory)
server.stat_peak_memory = zmalloc_used_memory();
run_with_period(100) {
/* 可能会比较慢，所以这里进行采样 */
server.cron_malloc_stats.process_rss = zmalloc_get_rss();
server.cron_malloc_stats.zmalloc_used = zmalloc_used_memory();
/* 获取分配器信息，也可能会比较慢 */
zmalloc_get_allocator_info(&server.cron_malloc_stats.allocator_allocated,
&server.cron_malloc_stats.allocator_active,
&server.cron_malloc_stats.allocator_resident);
/* 如果获取不到，就使用 Lua 内存进行计算 */
if (!server.cron_malloc_stats.allocator_resident) {
size_t lua_memory = lua_gc(server.lua,LUA_GCCOUNT,0)*1024LL;
server.cron_malloc_stats.allocator_resident = server.cron_malloc_stats.process_rss - lua_memory;
}
if (!server.cron_malloc_stats.allocator_active)
server.cron_malloc_stats.allocator_active = server.cron_malloc_stats.allocator_resident;
if (!server.cron_malloc_stats.allocator_allocated)
server.cron_malloc_stats.allocator_allocated = server.cron_malloc_stats.zmalloc_used;
}
/* 收到 SIGTERM 信号，安全地关闭服务器 */
if (server.shutdown_asap) {
if (prepareForShutdown(SHUTDOWN_NOFLAGS) == C_OK) exit(0);
serverLog(LL_WARNING,"SIGTERM received but errors trying to shut down the server, check the logs for more information");
server.shutdown_asap = 0;
}
/* 显示非空数据库的一些信息 */
run_with_period(5000) {
for (j = 0; j < server.dbnum; j++) {
long long size, used, vkeys;
size = dictSlots(server.db[j].dict);
used = dictSize(server.db[j].dict);
vkeys = dictSize(server.db[j].expires);
if (used || vkeys) {
serverLog(LL_VERBOSE,"DB %d: %lld keys (%lld volatile) in %lld slots HT.",j,used,vkeys,size);
/* dictPrintStats(server.dict); */
}
}
}
/* 显示连接的客户端信息 */
if (!server.sentinel_mode) {
run_with_period(5000) {
serverLog(LL_DEBUG,
"%lu clients connected (%lu replicas), %zu bytes in use",
listLength(server.clients)-listLength(server.slaves),
listLength(server.slaves),
zmalloc_used_memory());
}
}
/* 异步处理客户端 */
clientsCron();
/* 处理后台数据库操作 */
databasesCron();
/* 如果正在进行后台保存或 AOF 重写，检查它们是否结束 */
if (hasActiveChildProcess() || ldbPendingChildren())
{
checkChildrenDone();
} else {
/* 如果没有后台保存或 AOF 重写操作，则检查是否需要执行保存或 AOF 重写 */
for (j = 0; j < server.saveparamslen; j++) {
struct saveparam *sp = server.saveparams+j;
/* 如果达到指定的更改数量、时间间隔，并且上次的保存成功或已经超过了重试延迟时间 */
if (server.dirty >= sp->changes &&
server.unixtime-server.lastsave > sp->seconds &&
(server.unixtime-server.lastbgsave_try >
CONFIG_BGSAVE_RETRY_DELAY ||
server.lastbgsave_status == C_OK))
{
serverLog(LL_NOTICE,"%d changes in %d seconds. Saving...",
sp->changes, (int)sp->seconds);
rdbSaveInfo rsi, *rsiptr;
rsiptr = rdbPopulateSaveInfo(&rsi);
// 后台保存
rdbSaveBackground(server.rdb_filename,rsiptr);
break;
}
}
/* 如果 AOF 处于打开状态，并且没有后台进程运行，并且 AOF 文件大小超过了重写最小大小 */
if (server.aof_state == AOF_ON &&
!hasActiveChildProcess() &&
server.aof_rewrite_perc &&
server.aof_current_size > server.aof_rewrite_min_size)
{
// 计算增长百分比
long long base = server.aof_rewrite_base_size ?
server.aof_rewrite_base_size : 1;
long long growth = (server.aof_current_size*100/base) - 100;
// 如果增长超过了设定的百分比，则开始自动重写 AOF
if (growth >= server.aof_rewrite_perc) {
serverLog(LL_NOTICE,"Starting automatic rewriting of AOF on %lld%% growth",growth);
// 后台进行 AOF 重写
rewriteAppendOnlyFileBackground();
}
}
}
/* AOF 延迟刷新：尝试在每个 cron 周期检查慢 fsync 是否已完成 */
if (server.aof_flush_postponed_start) flushAppendOnlyFile(0);
/* AOF 写入错误：在这种情况下，我们也有一个要刷新的缓冲区，
* 并在成功时清除 AOF 错误，以使数据库再次可写，
* 然而，在 'hz' 设置为更高的频率时，每秒尝试一次足够了。 */
run_with_period(1000) {
if (server.aof_last_write_status == C_ERR)
flushAppendOnlyFile(0);
}
/* 如果需要，清除已暂停的客户端标志 */
clientsArePaused(); /* 不检查返回值，只使用副作用 */
/* 复制 cron 函数 -- 用于重新连接到主服务器、
* 检测传输失败、启动后台 RDB 传输等等。 */
run_with_period(1000) replicationCron();
/* 运行 Redis 集群 cron */
run_with_period(100) {
if (server.cluster_enabled) clusterCron();
}
/* 如果处于 sentinel 模式，则运行 sentinel 计时器 */
if (server.sentinel_mode) sentinelTimer();
/* 清理过期的 MIGRATE 缓存套接字 */
run_with_period(1000) {
migrateCloseTimedoutSockets();
}
/* 如果没有足够的待处理工作，则停止 I/O 线程 */
stopThreadedIOIfNeeded();
/* 如果需要，调整跟踪键表的大小。
* 这也在每个命令执行时进行，但是我们希望确保如果最后一个命令通过 CONFIG SET 更改了值，
* 那么服务器将执行该操作，即使完全空闲也是如此。 */
if (server.tracking_clients) trackingLimitUsedSlots();
/* 如果设置了对应的标志，则启动定时 BGSAVE。
* 这在我们由于 AOF 重写而被迫延迟 BGSAVE 时非常有用。 */
if (!hasActiveChildProcess() &&
server.rdb_bgsave_scheduled &&
(server.unixtime-server.lastbgsave_try > CONFIG_BGSAVE_RETRY_DELAY ||
server.lastbgsave_status == C_OK))
{
rdbSaveInfo rsi, *rsiptr;
rsiptr = rdbPopulateSaveInfo(&rsi);
if (rdbSaveBackground(server.rdb_filename,rsiptr) == C_OK)
server.rdb_bgsave_scheduled = 0;
}
/* 触发 cron 循环模块事件 */
RedisModuleCronLoopV1 ei = {REDISMODULE_CRON_LOOP_VERSION,server.hz};
moduleFireServerEvent(REDISMODULE_EVENT_CRON_LOOP,
0,
&ei);
server.cronloops++; // 记录 cron 循环次数
return 1000/server.hz; // 返回下一次调用该函数的时间间隔
}
serverCron 时间事件非常重要，负责完成 Redis 中的大部分内部任务，如定时持久化数据、清除过期数据、清除过期客户端等。另一部分内部任务则在 beforeSleep 函数中触发（事件循环器每次阻塞前都调用的钩子函数）。
aeMain
Redis 启动的最后，调用 aeMain 函数，启动事件循环器。
void aeMain(aeEventLoop *eventLoop) {
eventLoop->stop = 0;
while (!eventLoop->stop) {
aeProcessEvents(eventLoop, AE_ALL_EVENTS|
AE_CALL_BEFORE_SLEEP|
AE_CALL_AFTER_SLEEP);
}
}
只要不是 stop 状态， while 循环就一直执行下去，调用 aeProcessEvents 函数处理事件。Redis是一个事件驱动程序，正是该事件循环器驱动Redis 运行并提供服务。
aeProcessEvents
- 函数功能：处理每一个待处理的时间事件，然后处理每一个待处理的文件事件（这些文件事件可能由刚处理的时间事件回调注册）。如果没有特殊标志，该函数会一直睡眠，直到某个文件事件触发，或者下一个时间事件发生（如果有的话）。
- 参数：
eventLoop：事件循环结构体，包含所有事件的数据。flags：指定要处理的事件类型和一些额外的行为。- 如果
flags为 0，该函数不做任何事情并返回。 - 如果
flags设置了AE_ALL_EVENTS，所有类型的事件都会被处理。 - 如果
flags设置了AE_FILE_EVENTS，文件事件会被处理。 - 如果
flags设置了AE_TIME_EVENTS，时间事件会被处理。 - 如果
flags设置了AE_DONT_WAIT，该函数会尽快返回，直到所有能处理的事件都处理完毕为止。 - 如果
flags设置了AE_CALL_AFTER_SLEEP，在睡眠后会调用aftersleep回调。 - 如果
flags设置了AE_CALL_BEFORE_SLEEP，在睡眠前会调用beforesleep回调。
- 如果
- 返回值：该函数返回处理的事件数量。
int aeProcessEvents(aeEventLoop *eventLoop, int flags)
{
int processed = 0, numevents;
/* 没有要做的事情？直接返回 */
if (!(flags & AE_TIME_EVENTS) && !(flags & AE_FILE_EVENTS)) return 0;
/* 注意，我们希望即使没有文件事件要处理，只要我们想处理时间事件，
* 也要调用 select()，以便在下一个时间事件准备好触发之前进入睡眠。 */
// // [2](见注解2)
if (eventLoop->maxfd != -1 ||
((flags & AE_TIME_EVENTS) && !(flags & AE_DONT_WAIT))) {
int j;
aeTimeEvent *shortest = NULL;
struct timeval tv, *tvp;
/* 找到最近的时间事件 */
if (flags & AE_TIME_EVENTS && !(flags & AE_DONT_WAIT))
shortest = aeSearchNearestTimer(eventLoop);
if (shortest) {
long now_sec, now_ms;
aeGetTime(&now_sec, &now_ms);
tvp = &tv;
/* 我们需要等待多长时间，直到下一个时间事件触发？ */
long long ms =
(shortest->when_sec - now_sec)*1000 +
shortest->when_ms - now_ms;
if (ms > 0) {
tvp->tv_sec = ms/1000;
tvp->tv_usec = (ms % 1000)*1000;
} else {
tvp->tv_sec = 0;
tvp->tv_usec = 0;
}
} else {
/* 如果我们需要检查事件但由于 AE_DONT_WAIT 需要尽快返回，
* 我们需要将超时时间设置为 0 */
if (flags & AE_DONT_WAIT) {
tv.tv_sec = tv.tv_usec = 0;
tvp = &tv;
} else {
/* 否则我们可以阻塞 */
tvp = NULL; /* 永远等待 */
}
}
/* 如果 eventLoop 的标志设置了 AE_DONT_WAIT，则设置超时时间为 0 */
if (eventLoop->flags & AE_DONT_WAIT) {
tv.tv_sec = tv.tv_usec = 0;
tvp = &tv;
}
/* 在睡眠前调用 beforesleep 回调（如果设置了相应的标志） */
if (eventLoop->beforesleep != NULL && flags & AE_CALL_BEFORE_SLEEP)
eventLoop->beforesleep(eventLoop);
/* 调用多路复用 API，它只会在超时或某个事件触发时返回 */
// 在注解 2 的判断中成立的话，进程就会在这里阻塞住
numevents = aeApiPoll(eventLoop, tvp);
/* 在睡眠后调用 aftersleep 回调（如果设置了相应的标志） */
if (eventLoop->aftersleep != NULL && flags & AE_CALL_AFTER_SLEEP)
eventLoop->aftersleep(eventLoop);
/* 处理已触发的文件事件 */
for (j = 0; j < numevents; j++) {
aeFileEvent *fe = &eventLoop->events[eventLoop->fired[j].fd];
int mask = eventLoop->fired[j].mask;
int fd = eventLoop->fired[j].fd;
int fired = 0; /* 当前 fd 触发的事件数量 */
/* 通常我们先执行可读事件，然后再执行可写事件。
* 这是有用的，因为有时我们可以在处理查询后立即服务查询的回复。
*
* 但是，如果 mask 中设置了 AE_BARRIER，我们的应用程序要求我们做相反的事情：
* 在可读事件之后绝不触发可写事件。在这种情况下，我们反转调用顺序。
* 这在例如我们希望在 beforeSleep() 钩子中执行一些操作（如将文件同步到磁盘）
* 之后再回复客户端时非常有用。 */
// [1](见注解 1)
int invert = fe->mask & AE_BARRIER;
/* 注意 "fe->mask & mask & ..." 代码：也许一个已经处理的事件
* 删除了一个已触发且我们还没有处理的元素，
* 因此我们检查事件是否仍然有效。
*
* 如果调用顺序未反转，则触发可读事件。 */
if (!invert && fe->mask & mask & AE_READABLE) {
fe->rfileProc(eventLoop,fd,fe->clientData,mask);
fired++;
fe = &eventLoop->events[fd]; /* 刷新以防止调整大小。 */
}
/* 触发可写事件 */
if (fe->mask & mask & AE_WRITABLE) {
if (!fired || fe->wfileProc != fe->rfileProc) {
fe->wfileProc(eventLoop,fd,fe->clientData,mask);
fired++;
}
}
/* 如果我们需要反转调用，现在在可写事件之后触发可读事件 */
if (invert) {
fe = &eventLoop->events[fd]; /* 刷新以防止调整大小。 */
if ((fe->mask & mask & AE_READABLE) &&
(!fired || fe->wfileProc != fe->rfileProc))
{
fe->rfileProc(eventLoop,fd,fe->clientData,mask);
fired++;
}
}
processed++;
}
}
/* 检查时间事件 */
if (flags & AE_TIME_EVENTS)
processed += processTimeEvents(eventLoop);
return processed; /* 返回处理的文件/时间事件数量 */
}
-
通常 Redis 先处理
AE_READABLE事件，再处理AE_WRITABLE事件，这有助于服务器尽快处理请求并回复结果给客户端。 -
我们来看这个判断条件哈：
eventLoop->maxfd != -1:maxfd是事件循环中当前注册的最大文件描述符。如果maxfd不等于 -1，意味着有文件事件需要处理。通常情况下，maxfd的初始值是 -1，当有文件事件被注册时，它会被更新为所注册的最大文件描述符的值。因此，这个条件成立表示事件循环中有文件事件等待处理。
(flags & AE_TIME_EVENTS) && !(flags & AE_DONT_WAIT):flags & AE_TIME_EVENTS：检查传递的标志中是否包含AE_TIME_EVENTS标志。如果包含，表示需要处理时间事件。!(flags & AE_DONT_WAIT)：检查传递的标志中是否未包含AE_DONT_WAIT标志。如果未包含，表示允许等待，而不是立即返回。
当这两个条件同时成立时，表示需要处理时间事件，并且在处理时间事件时可以等待，而不是立即返回。这意味着即使没有文件事件可处理，也需要调用
select()或类似的系统调用来等待时间事件触发。计算进程的最大阻塞时间：
- 查找最先执行的时间事件，如果能找到，则将这个事件减去当前时间作为进程的最大阻塞时间。
- 找不到时间事件，检查
flags参数中是否有AE_DONT_WAIT标志，若不存在，进程将一直被阻塞，直到有文件事件就绪。；若存在，则进程不阻塞，将不断询问系统是否有已就绪的文件事件。另外，如果eventLoop.flags中存在AE_DONT_WAIT标志，那么进程也不会阻塞。
由于 Redis 只有一个处理函数为 serverCron 的时间事件，这里进程的最大阻塞时间为 serverCron 时间事件的下次执行时间。
processTimeEvents
- 函数功能：处理 Redis 中的时间事件（如定时任务）。它遍历事件循环中的时间事件列表，执行到期的时间事件，并删除需要删除的事件。
- 参数：
aeEventLoop *eventLoop：指向事件循环的指针，包含了所有的事件数据。
- 返回值：返回处理的时间事件数量。
/* 处理时间事件 */
static int processTimeEvents(aeEventLoop *eventLoop) {
int processed = 0; // 记录处理的事件数量
aeTimeEvent *te; // 当前处理的时间事件指针
long long maxId; // 当前时间事件最大ID
time_t now = time(NULL); // 获取当前时间
/* 如果系统时钟被调整到未来，然后再设置回正确的时间，
* 时间事件可能会随机延迟。通常这意味着计划的操作不会及时执行。
*
* 这里我们试图检测系统时钟偏差，并在这种情况下强制尽快处理所有时间事件：
* 处理事件提前比无限期延迟它们更安全，实践表明确实如此。 */
// 上一次执行事件的时间比当前时间还大，说明系统时间混乱了 (由于系统时间偏移的原因) 这里将所有时间事件 when_sec 设置为 0 ，这样会导致时间事件提前执行，由于提前执行事件的危害小于延后执行，所以 Redis 这么做的
if (now < eventLoop->lastTime) {
te = eventLoop->timeEventHead;
while(te) { // 遍历所有时间事件
te->when_sec = 0; // 将所有时间事件的时间设置为0
te = te->next; // 移动到下一个时间事件
}
}
eventLoop->lastTime = now; // 更新最后一次处理事件的时间
te = eventLoop->timeEventHead; // 初始化为时间事件链表的头部
maxId = eventLoop->timeEventNextId - 1; // 设置当前最大时间事件ID
while(te) { // 遍历时间事件链表
long now_sec, now_ms; // 当前时间的秒和毫秒
long long id;
/* 移除计划删除的事件。 */
if (te->id == AE_DELETED_EVENT_ID) {
aeTimeEvent *next = te->next; // 记录下一个时间事件
/* 如果此计时器事件存在引用，则不释放它。
* 当前递增用于递归的 timeProc 调用。 */
if (te->refcount) { // 如果引用计数大于0，跳过删除
te = next;
continue;
}
if (te->prev) // 如果有前一个事件，更新前一个事件的 next 指针
te->prev->next = te->next;
else // 否则更新事件链表头部
eventLoop->timeEventHead = te->next;
if (te->next) // 如果有下一个事件，更新下一个事件的 prev 指针
te->next->prev = te->prev;
if (te->finalizerProc) // 如果有清理函数，调用它
te->finalizerProc(eventLoop, te->clientData);
zfree(te); // 释放事件内存
te = next; // 移动到下一个时间事件
continue;
}
/* 确保我们不处理在本次迭代中由时间事件创建的时间事件。
* 注意这个检查当前没有用处：我们总是将新计时器添加到头部，
* 然而如果我们改变了实现细节，这个检查可能会再次有用：
* 我们保留它以防将来需要。 */
if (te->id > maxId) { // 如果事件ID大于最大ID，跳过处理
te = te->next;
continue;
}
aeGetTime(&now_sec, &now_ms); // 获取当前时间的秒和毫秒
if (now_sec > te->when_sec || // 如果当前秒数大于事件触发秒数，或
(now_sec == te->when_sec && now_ms >= te->when_ms)) // 当前秒数等于事件触发秒数且当前毫秒数大于等于事件触发毫秒数
{
int retval;
id = te->id; // 保存事件ID
te->refcount++; // 增加引用计数
// 调用事件处理函数。该函数执行时间事件的逻辑并返回事件下次执行的间隔时间。时间下次执行间隔时间等于 AE_NORMAL，代表该事件需要被删除，将 aeTimeEvent.id 置为 AE_DELETED_EVENT_ID 以便 processTimeEvents 下次调用的时候将其删除
retval = te->timeProc(eventLoop, id, te->clientData);
te->refcount--; // 减少引用计数
processed++; // 增加处理事件数量
if (retval != AE_NOMORE) { // 如果返回值不是AE_NOMORE
aeAddMillisecondsToNow(retval, &te->when_sec, &te->when_ms); // 更新事件的触发时间
} else { // 否则标记事件为删除
te->id = AE_DELETED_EVENT_ID;
}
}
te = te->next; // 移动到下一个时间事件
}
return processed; // 返回处理的事件数量
}
由于 Redis 中只有 serverCron 时间事件，所以这里直接遍历所有时间事件也不会有性能问题。另外，Redis 提供了 hz 配置项，代表 serverCron 时间事件的每秒执行次数，默认为 10，即每隔 100 毫秒执行一次 serverCron 时间事件。
Redis 事件机制执行流程如下图所示。这种事件机制并不是 Redis 独有的，Nety、MysSQL 等程序都是事件驱动的，都使用了类似的事件机制。
总结
- Redis 采用事件驱动机制，即通过一个死循环，不断处理服务中发生的事件。
- Redis 事件机制可以处理文件事件和时间事件。文件事件由系统 I/O 复用机制产生，通常由客户端请求触发。时间事件定时触发，负责定时执行Redis 内部任务。
494
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
