Redis 定时事件与事件循环：Reactor 模式与单线程模型

各位听众，早上好/下午好/晚上好！

今天咱们来聊聊 Redis 的定时事件和事件循环，这俩货可是 Redis 这台高性能跑车引擎盖下的关键组件。咱们会深入到 Reactor 模式和单线程模型，保证让大家听得懂，记得住，还能用得上。放心，没有教科书式的生硬，只有接地气的解读和实战代码。

开场白：Redis，快男背后的秘密

Redis 为什么这么快？除了内存数据库这个先天优势，它的事件驱动机制和单线程模型功不可没。想象一下，你在 Redis 服务器面前，敲入各种命令，比如 GET mykey, SET mykey myvalue, EXPIRE mykey 60。这些命令，就像一个个的“事件”，需要 Redis 来处理。而 Redis 就像一个超级勤劳的管家，在“事件循环”中不停地转圈，处理这些事件，同时还要兼顾定时任务，比如过期 key 的删除。

第一部分：事件循环，管家的日常

Redis 的事件循环，说白了，就是一个永不停歇的 while 循环。这个循环主要干三件事：

1. 监听文件描述符（File Descriptor，FD）： 啥是 FD？你可以把它理解为操作系统给你的一个“文件句柄”，通过它你可以访问网络连接、文件等等。Redis 使用 select、epoll、kqueue 等系统调用来监听这些 FD，看看有没有客户端发来新的数据或者有新的连接请求。
2. 处理就绪的事件： 一旦某个 FD 变得“可读”或者“可写”，事件循环就会调用相应的“事件处理器”来处理这个事件。
3. 处理定时事件： 除了客户端请求，Redis 还需要处理一些定时的任务，比如删除过期的 key，统计一些信息等等。

用伪代码来表示，大概是这样：

while (server_is_running) {
    // 1. 监听文件描述符
    ready_fds = wait_for_events(timeout);

    // 2. 处理就绪的文件描述符
    for (fd in ready_fds) {
        process_file_event(fd);
    }

    // 3. 处理定时事件
    process_time_events();
}

第二部分：Reactor 模式，事件处理的策略

Redis 的事件处理模式，采用的是经典的 Reactor 模式。Reactor 模式的核心思想是：非阻塞 I/O + 事件分发。

• 非阻塞 I/O： Redis 使用非阻塞 I/O 来处理客户端的请求。这意味着，当 Redis 在等待客户端发送数据时，它不会傻傻地阻塞在那里，而是可以去做其他的事情，比如处理其他客户端的请求或者执行定时任务。
• 事件分发： 当某个 FD 变得可读或者可写时，Redis 会根据 FD 上注册的事件类型，调用相应的事件处理器来处理这个事件。

Reactor 模式的好处是，它可以让 Redis 在单线程的情况下，高效地处理大量的并发请求。

咱们来看一个简化的 Reactor 模式的 C 代码示例：

// 事件处理器结构体
typedef struct {
    int fd; // 文件描述符
    void (*read_handler)(int fd, void *arg); // 读事件处理器
    void (*write_handler)(int fd, void *arg); // 写事件处理器
    void *arg; // 传递给处理器的参数
} event_handler_t;

// 事件循环函数
void event_loop(event_handler_t *handlers, int num_handlers) {
    while (1) {
        fd_set read_fds, write_fds;
        int max_fd = 0;

        FD_ZERO(&read_fds);
        FD_ZERO(&write_fds);

        // 初始化 fd_set
        for (int i = 0; i < num_handlers; i++) {
            if (handlers[i].read_handler) {
                FD_SET(handlers[i].fd, &read_fds);
                if (handlers[i].fd > max_fd) {
                    max_fd = handlers[i].fd;
                }
            }
            if (handlers[i].write_handler) {
                FD_SET(handlers[i].fd, &write_fds);
                if (handlers[i].fd > max_fd) {
                    max_fd = handlers[i].fd;
                }
            }
        }

        // 使用 select 监听事件
        int ready_fds = select(max_fd + 1, &read_fds, &write_fds, NULL, NULL);

        if (ready_fds > 0) {
            // 处理就绪的事件
            for (int i = 0; i < num_handlers; i++) {
                if (FD_ISSET(handlers[i].fd, &read_fds) && handlers[i].read_handler) {
                    handlers[i].read_handler(handlers[i].fd, handlers[i].arg);
                }
                if (FD_ISSET(handlers[i].fd, &write_fds) && handlers[i].write_handler) {
                    handlers[i].write_handler(handlers[i].fd, handlers[i].arg);
                }
            }
        } else if (ready_fds < 0) {
            // 处理错误
            perror("select");
            exit(1);
        }
    }
}

// 示例读事件处理器
void read_handler(int fd, void *arg) {
    char buffer[1024];
    ssize_t bytes_read = read(fd, buffer, sizeof(buffer));

    if (bytes_read > 0) {
        printf("Received: %.*sn", (int)bytes_read, buffer);
    } else if (bytes_read == 0) {
        printf("Connection closed by clientn");
        close(fd);
    } else {
        perror("read");
        close(fd);
    }
}

// 示例主函数
int main() {
    // ... (省略创建 socket 和监听的代码) ...

    // 初始化事件处理器
    event_handler_t handlers[1];
    handlers[0].fd = client_socket;
    handlers[0].read_handler = read_handler;
    handlers[0].write_handler = NULL;
    handlers[0].arg = NULL;

    // 启动事件循环
    event_loop(handlers, 1);

    return 0;
}

这个例子简化了 Redis 的事件循环，但展示了 Reactor 模式的核心思想：通过 select 监听 FD，当 FD 可读时，调用 read_handler 处理数据。实际的 Redis 代码要复杂得多，使用了更高效的 epoll 等系统调用，并且有更完善的事件管理机制。

第三部分：定时事件，过期 key 的秘密

Redis 需要定期执行一些任务，比如：

• 删除过期的 key： 这是最常见的定时任务。当一个 key 设置了过期时间（TTL），Redis 需要在 key 过期后将其删除。
• 更新统计信息： Redis 需要定期更新一些统计信息，比如 QPS（Queries Per Second）等等。
• 执行 AOF 重写： 为了减少 AOF 文件的大小，Redis 会定期执行 AOF 重写操作。

Redis 如何实现这些定时任务呢？答案是：时间轮（Timing Wheel）。

时间轮是一种高效的定时器算法。你可以把它想象成一个钟表，钟表的刻度代表时间间隔，指针按照固定的速度旋转。每个刻度上都挂着一个任务队列，当指针指向某个刻度时，就执行该刻度上的所有任务。

Redis 实际上并没有完全使用时间轮的概念，而是使用了一种更简单的实现方式。它维护了一个链表，链表中的每个节点代表一个定时事件。每个定时事件都有一个 when 属性，表示事件的执行时间。在事件循环中，Redis 会检查链表中的定时事件，如果事件的 when 属性小于当前时间，就执行该事件。

Redis 中关于定时事件的数据结构 redisServer 中有如下字段：

• aeEventLoop *el：事件循环。
• mstime_t current_time：当前时间，毫秒级别。
• list *timers：这是一个链表，存放着所有定时事件。
• long long next_id：下一个定时事件的ID。

redisTimerProc 是定时事件处理函数。

下面是一个简化的时间轮的示例 (伪代码):

// 假设时间轮有 60 个槽，每个槽代表 1 秒
#define TIME_WHEEL_SIZE 60

// 时间轮的槽
typedef struct time_wheel_slot {
    // 任务链表
    list *tasks;
} time_wheel_slot_t;

// 时间轮结构体
typedef struct time_wheel {
    // 槽数组
    time_wheel_slot_t slots[TIME_WHEEL_SIZE];
    // 当前槽的索引
    int current_slot;
} time_wheel_t;

// 初始化时间轮
void init_time_wheel(time_wheel_t *wheel) {
    for (int i = 0; i < TIME_WHEEL_SIZE; i++) {
        wheel->slots[i].tasks = listCreate();
    }
    wheel->current_slot = 0;
}

// 添加任务到时间轮
void add_task(time_wheel_t *wheel, int delay, void (*task_func)(void *), void *arg) {
    // 计算任务应该放入哪个槽
    int slot_index = (wheel->current_slot + delay) % TIME_WHEEL_SIZE;

    // 创建一个任务结构体
    typedef struct time_wheel_task {
        void (*task_func)(void *);
        void *arg;
    } time_wheel_task_t;

    time_wheel_task_t *task = malloc(sizeof(time_wheel_task_t));
    task->task_func = task_func;
    task->arg = arg;

    // 将任务添加到槽的链表中
    listAddNodeTail(wheel->slots[slot_index].tasks, task);
}

// 推进时间轮
void tick(time_wheel_t *wheel) {
    // 获取当前槽的任务链表
    list *tasks = wheel->slots[wheel->current_slot].tasks;

    // 执行当前槽中的所有任务
    listNode *node = listFirst(tasks);
    while (node) {
        time_wheel_task_t *task = (time_wheel_task_t *)node->value;
        task->task_func(task->arg);
        listNode *next = listNext(node);
        listDelNode(tasks, node);
        free(task);
        node = next;
    }

    // 清空当前槽的任务链表
    listEmpty(tasks);

    // 移动到下一个槽
    wheel->current_slot = (wheel->current_slot + 1) % TIME_WHEEL_SIZE;
}

// 示例任务函数
void my_task(void *arg) {
    printf("Task executed! Argument: %sn", (char *)arg);
}

// 示例主函数
int main() {
    time_wheel_t wheel;
    init_time_wheel(&wheel);

    // 添加一个 5 秒后执行的任务
    add_task(&wheel, 5, my_task, "Hello, Time Wheel!");

    // 模拟时间流逝
    for (int i = 0; i < 10; i++) {
        printf("Tick: %dn", i);
        tick(&wheel);
        sleep(1); // 模拟 1 秒
    }

    return 0;
}

这个例子简化了时间轮的实现，但是展示了时间轮的核心思想：将任务分配到不同的槽中，然后定期推进时间轮，执行当前槽中的任务。Redis 的实现方式略有不同，但核心思想是类似的。

第四部分：单线程模型，简单即是美

Redis 采用单线程模型来处理所有的客户端请求。这意味着，Redis 在任何时候都只有一个线程在执行代码。

单线程模型的好处是：

• 简单： 避免了多线程带来的锁竞争和上下文切换的开销。
• 高效： 在 Redis 这种 I/O 密集型的应用场景下，单线程模型通常比多线程模型更高效。

但是，单线程模型也有一个缺点：

• 阻塞： 如果某个命令执行时间过长，会阻塞整个 Redis 服务器。

为了避免阻塞，Redis 采取了一些措施：

• 快速命令： Redis 尽量使用快速的命令，比如 GET、SET 等等。
• 避免复杂操作： 避免执行复杂的查询操作，比如 KEYS *。
• 异步操作： 对于一些耗时的操作，比如 AOF 重写，Redis 会使用异步的方式来执行。

单线程 + Reactor 模式 是 Redis 高性能的关键因素。Reactor 模式让 Redis 能够高效地处理大量的并发请求，而单线程模型避免了多线程带来的开销。

第五部分：总结与展望

咱们今天聊了 Redis 的事件循环、Reactor 模式和单线程模型。总结一下：

组件	作用
事件循环	Redis 的核心，负责监听文件描述符和处理定时事件。
Reactor模式	一种事件处理模式，通过非阻塞 I/O 和事件分发，能够高效地处理大量的并发请求。
定时事件	负责定期执行一些任务，比如删除过期的 key，更新统计信息等等。Redis 使用一种类似于时间轮的机制来实现定时事件。
单线程模型	Redis 使用单线程模型来处理所有的客户端请求。单线程模型简单高效，但是需要避免阻塞操作。

希望今天的分享能够帮助大家更好地理解 Redis 的工作原理。当然，Redis 的内部实现非常复杂，今天只是简单地介绍了一些核心概念。如果大家对 Redis 感兴趣，可以深入阅读 Redis 的源代码，相信会有更多的收获。

未来，随着硬件的发展和新的编程模型的出现，Redis 可能会在架构上进行一些调整，比如引入多线程来利用多核 CPU 的优势。但是，事件驱动和单线程模型的核心思想，相信会继续在 Redis 中发挥重要的作用。

谢谢大家！