Redis事件模型

原创于 2025-06-25 00:14:26 发布 · 836 阅读

27 ·

CC 4.0 BY-SA版权

文章标签：

#redis #数据库 #缓存

Redis 专栏收录该内容

21 篇文章

订阅专栏

Redis是一个事件驱动的内存数据库，它通过高效的事件处理机制来处理客户端请求和定时任务。本文将深入探讨Redis的事件模型，包括事件驱动设计、I/O多路复用、文件事件处理器和时间事件处理器。

事件驱动模型

事件驱动的基本概念

事件驱动编程是一种编程范式，程序的执行流程由事件（如用户操作、传感器输入、消息传递等）来决定。在事件驱动模型中，程序会等待并响应事件的发生，而不是按照预定义的顺序执行。

Redis采用事件驱动模型的主要原因：

高效处理并发连接：可以用单线程处理大量并发客户端连接，避免了多线程编程的复杂性和线程切换开销。
响应性能优化：事件驱动模型可以最小化I/O等待时间，提高系统的响应性能。
简化编程模型：避免了复杂的线程同步和锁机制，降低了开发和维护难度。

Redis事件循环

Redis的事件驱动模型核心是一个事件循环(Event Loop)，它不断地监听和处理各种事件。Redis的事件分为两大类：

文件事件(File Events)：用于处理Redis服务器与客户端之间的网络通信，如接受连接、读取命令、返回结果等。
时间事件(Time Events)：用于执行定时任务，如定期删除过期键、统计信息更新、持久化操作等。

事件循环的基本流程：

while (!server.shutdown_asap) {
    // 处理文件事件和时间事件
    aeProcessEvents(server.el, AE_ALL_EVENTS|AE_CALL_AFTER_SLEEP);
    
    // 处理后台任务
    backgroundCleanupStep(REDIS_FAST_CLEANUP);
    
    // 如果服务器关闭标志被设置，尝试优雅地关闭服务器
    if (server.shutdown_asap) {
        if (prepareForShutdown(SHUTDOWN_NOFLAGS) == C_OK) break;
        server.shutdown_asap = 0; // 取消关闭
    }
}

I/O多路复用

多路复用技术简介

I/O多路复用是一种允许单个进程同时监视多个文件描述符的技术，当其中任何一个文件描述符准备好进行I/O操作时，多路复用器会通知应用程序。这使得应用程序可以在单线程中高效地处理多个连接。

Redis支持多种I/O多路复用技术：

select：最早的I/O多路复用技术，支持的平台最广，但性能相对较低，且有文件描述符数量限制(通常为1024)。
poll：类似于select，但没有文件描述符数量限制，性能略优于select。
epoll：Linux平台专有，性能最好，没有文件描述符数量限制，是Redis在Linux上的首选。
kqueue：BSD系统(如macOS)专有，性能与epoll相当。
evport：Solaris系统专有。

Redis中的多路复用实现

Redis对这些多路复用技术进行了封装，提供了统一的接口，在不同平台上自动选择最优的实现：

// 根据平台选择最优的多路复用实现
static int aeApiCreate(aeEventLoop *eventLoop) {
#ifdef HAVE_EVPORT
    return aeEvportCreate(eventLoop);
#else
    #ifdef HAVE_EPOLL
    return aeEpollCreate(eventLoop);
    #else
        #ifdef HAVE_KQUEUE
        return aeKqueueCreate(eventLoop);
        #else
            #ifdef HAVE_SELECT
            return aeSelectCreate(eventLoop);
            #else
            return -1; // 没有可用的多路复用实现
            #endif
        #endif
    #endif
#endif
}

以epoll为例，Redis的多路复用实现：

typedef struct aeApiState {
    int epfd;           // epoll实例的文件描述符
    struct epoll_event *events; // 事件数组
} aeApiState;

// 创建epoll实例
static int aeEpollCreate(aeEventLoop *eventLoop) {
    aeApiState *state = zmalloc(sizeof(aeApiState));
    if (!state) return -1;
    
    // 创建epoll实例
    state->epfd = epoll_create(1024); 
    if (state->epfd == -1) {
        zfree(state);
        return -1;
    }
    
    // 分配事件数组
    state->events = zmalloc(sizeof(struct epoll_event)*eventLoop->setsize);
    if (!state->events) {
        close(state->epfd);
        zfree(state);
        return -1;
    }
    
    eventLoop->apidata = state;
    return 0;
}

// 监听文件描述符上的事件
static int aeEpollAddEvent(aeEventLoop *eventLoop, int fd, int mask) {
    aeApiState *state = eventLoop->apidata;
    struct epoll_event ee = {0};
    
    // 获取已注册的事件
    int op = eventLoop->events[fd].mask == AE_NONE ?
            EPOLL_CTL_ADD : EPOLL_CTL_MOD;
    
    // 设置要监听的事件
    ee.events = 0;
    mask |= eventLoop->events[fd].mask; // 合并已有事件
    if (mask & AE_READABLE) ee.events |= EPOLLIN;
    if (mask & AE_WRITABLE) ee.events |= EPOLLOUT;
    ee.data.fd = fd;
    
    // 注册事件
    if (epoll_ctl(state->epfd, op, fd, &ee) == -1) return -1;
    return 0;
}

// 等待事件发生
static int aeEpollPoll(aeEventLoop *eventLoop, struct timeval *tvp) {
    aeApiState *state = eventLoop->apidata;
    int retval, numevents = 0;
    
    // 等待事件发生，最多等待tvp指定的时间
    retval = epoll_wait(state->epfd, state->events, eventLoop->setsize,
            tvp ? (tvp->tv_sec*1000 + tvp->tv_usec/1000) : -1);
    
    // 处理发生的事件
    if (retval > 0) {
        int j;
        numevents = retval;
        for (j = 0; j < numevents; j++) {
            int mask = 0;
            struct epoll_event *e = state->events+j;
            
            if (e->events & EPOLLIN) mask |= AE_READABLE;
            if (e->events & EPOLLOUT) mask |= AE_WRITABLE;
            if (e->events & EPOLLERR) mask |= AE_WRITABLE|AE_READABLE;
            if (e->events & EPOLLHUP) mask |= AE_WRITABLE|AE_READABLE;
            
            eventLoop->fired[j].fd = e->data.fd;
            eventLoop->fired[j].mask = mask;
        }
    }
    return numevents;
}

文件事件处理器

文件事件的概念

文件事件是Redis对套接字操作的抽象，当套接字变为可读或可写时，就会产生相应的文件事件。Redis的文件事件处理器使用I/O多路复用技术来同时监听多个套接字，并根据套接字目前执行的任务来为套接字关联不同的事件处理器。

文件事件类型

Redis主要处理两类文件事件：

AE_READABLE：套接字可读事件，表示客户端发送了命令请求，或者新客户端连接到服务器。
AE_WRITABLE：套接字可写事件，表示服务器可以向客户端发送命令回复，或者执行其他写操作。

文件事件处理器的实现

Redis的文件事件处理器由以下组件组成：

事件循环(aeEventLoop)：维护着监听套接字、已注册的事件处理器等信息。
I/O多路复用程序：负责监听多个套接字，并向事件分派器传送产生事件的套接字。
事件分派器：接收I/O多路复用程序传来的套接字，并根据套接字产生的事件类型调用相应的事件处理器。
事件处理器：实际处理事件的函数，如连接应答处理器、命令请求处理器、命令回复处理器等。

// 事件循环结构
typedef struct aeEventLoop {
    int maxfd;   // 当前注册的最大文件描述符
    int setsize; // 事件槽大小
    long long timeEventNextId; // 下一个时间事件ID
    time_t lastTime;     // 最后一次执行时间事件的时间
    aeFileEvent *events; // 已注册的文件事件
    aeFiredEvent *fired; // 已触发的文件事件
    aeTimeEvent *timeEventHead; // 时间事件链表头
    int stop;      // 事件循环停止标志
    void *apidata; // 多路复用库的私有数据
    aeBeforeSleepProc *beforesleep; // 事件循环睡眠前的钩子函数
    aeBeforeSleepProc *aftersleep;  // 事件循环睡眠后的钩子函数
} aeEventLoop;

// 文件事件结构
typedef struct aeFileEvent {
    int mask; // 事件类型掩码，AE_READABLE或AE_WRITABLE
    aeFileProc *rfileProc; // 读事件处理器
    aeFileProc *wfileProc; // 写事件处理器
    void *clientData;      // 客户端数据
} aeFileEvent;

// 已触发的文件事件
typedef struct aeFiredEvent {
    int fd;   // 文件描述符
    int mask; // 事件类型掩码
} aeFiredEvent;

文件事件处理流程

创建事件循环：服务器初始化时创建事件循环。
注册事件处理器：服务器将套接字与事件处理器关联起来。
等待事件发生：事件循环不断调用I/O多路复用程序等待事件发生。
分派事件：当有事件发生时，事件分派器会调用相应的事件处理器。
处理事件：事件处理器执行相应的操作，如接受连接、读取命令、发送回复等。

// 处理文件事件和时间事件
int aeProcessEvents(aeEventLoop *eventLoop, int flags) {
    int processed = 0, numevents;
    
    // 如果没有事件要处理，直接返回
    if (!(flags & AE_TIME_EVENTS) && !(flags & AE_FILE_EVENTS)) return 0;
    
    // 如果有文件事件要处理，或者需要阻塞等待
    if (eventLoop->maxfd != -1 || ((flags & AE_TIME_EVENTS) && !(flags & AE_DONT_WAIT))) {
        struct timeval tv, *tvp;
        
        // 计算需要等待的时间
        if (flags & AE_TIME_EVENTS && !(flags & AE_DONT_WAIT))
            tvp = aeGetNearestTimer(eventLoop, &tv);
        else {
            if (flags & AE_DONT_WAIT) {
                tv.tv_sec = tv.tv_usec = 0;
                tvp = &tv;
            } else {
                tvp = NULL; // 永久阻塞
            }
        }
        
        // 调用多路复用API等待事件发生
        numevents = aeApiPoll(eventLoop, tvp);
        
        // 处理文件事件
        for (int 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;
            
            // 如果是读事件且有读事件处理器，调用读事件处理器
            if (fe->mask & mask & AE_READABLE) {
                fired = 1;
                fe->rfileProc(eventLoop, fd, fe->clientData, mask);
            }
            
            // 如果是写事件且有写事件处理器，调用写事件处理器
            if (fe->mask & mask & AE_WRITABLE) {
                if (!fired || fe->wfileProc != fe->rfileProc) {
                    fe->wfileProc(eventLoop, fd, fe->clientData, mask);
                }
            }
            
            processed++;
        }
    }
    
    // 处理时间事件
    if (flags & AE_TIME_EVENTS)
        processed += processTimeEvents(eventLoop);
    
    return processed;
}

常见的文件事件处理器

Redis中常见的文件事件处理器包括：

连接应答处理器(acceptTcpHandler)：监听服务器监听套接字的AE_READABLE事件，当有新客户端连接时，创建客户端状态并将客户端套接字的AE_READABLE事件与命令请求处理器关联。
命令请求处理器(readQueryFromClient)：监听客户端套接字的AE_READABLE事件，当客户端发送命令请求时，读取命令并解析，然后调用相应的命令执行函数。
命令回复处理器(sendReplyToClient)：监听客户端套接字的AE_WRITABLE事件，当客户端可写时，向客户端发送命令执行结果。

时间事件处理器

时间事件的概念

时间事件是Redis用来处理那些需要在指定时间点执行的操作，如定期删除过期键、定期保存RDB文件、更新服务器统计信息等。

时间事件类型

Redis的时间事件分为两类：

定时事件：在指定的时间点执行一次，执行完后会被删除。
周期性事件：每隔指定时间间隔执行一次，执行完后会更新下次执行时间。

时间事件结构

// 时间事件结构
typedef struct aeTimeEvent {
    long long id;       // 时间事件ID
    long when_sec;      // 秒级时间戳
    long when_ms;       // 毫秒级时间戳
    aeTimeProc *timeProc; // 时间事件处理函数
    aeEventFinalizerProc *finalizerProc; // 事件释放函数
    void *clientData;   // 客户端数据
    struct aeTimeEvent *next; // 指向下一个时间事件
} aeTimeEvent;

// 时间事件处理函数类型
typedef int aeTimeProc(struct aeEventLoop *eventLoop, long long id, void *clientData);

// 时间事件释放函数类型
typedef void aeEventFinalizerProc(struct aeEventLoop *eventLoop, void *clientData);

时间事件处理流程

创建时间事件：服务器初始化时创建各种时间事件。
计算最近的时间事件：事件循环计算最近要执行的时间事件，用于设置I/O多路复用程序的等待时间。
执行时间事件：当时间事件到达执行时间时，事件循环会调用时间事件的处理函数。
更新或删除时间事件：根据处理函数的返回值，更新时间事件的下次执行时间或删除时间事件。

// 处理时间事件
static int processTimeEvents(aeEventLoop *eventLoop) {
    int processed = 0;
    aeTimeEvent *te;
    long long maxId;
    time_t now = time(NULL);
    
    // 如果系统时间被调整，更新所有时间事件
    if (now < eventLoop->lastTime) {
        te = eventLoop->timeEventHead;
        while(te) {
            te->when_sec = 0;
            te = te->next;
        }
    }
    eventLoop->lastTime = now;
    
    // 遍历时间事件链表
    te = eventLoop->timeEventHead;
    maxId = eventLoop->timeEventNextId-1;
    while(te) {
        long now_sec, now_ms;
        long long id;
        
        // 跳过无效的时间事件
        if (te->id > maxId) {
            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;
            
            // 调用时间事件处理函数
            retval = te->timeProc(eventLoop, id, te->clientData);
            processed++;
            
            // 根据返回值处理时间事件
            if (retval != AE_NOMORE) {
                // 更新时间事件的下次执行时间
                aeAddMillisecondsToNow(retval, &te->when_sec, &te->when_ms);
            } else {
                // 删除时间事件
                aeDeleteTimeEvent(eventLoop, id);
            }
            
            // 重新获取头节点，因为可能已经被修改
            te = eventLoop->timeEventHead;
        } else {
            te = te->next;
        }
    }
    return processed;
}

常见的时间事件

Redis中的常见时间事件包括：

serverCron：Redis的主要时间事件，默认每100毫秒执行一次，负责执行各种定期任务，如：
- 更新服务器统计信息
- 删除过期键
- 关闭超时的客户端连接
- 执行持久化操作
- 主从复制相关操作
- 集群相关操作
- 等等
clientsCron：处理客户端相关的定期任务，如检查客户端是否空闲超时、是否需要关闭等。
databasesCron：处理数据库相关的定期任务，如删除过期键、触发键空间通知等。