Redis IO 多路复用模型详解

事件注册过程

// 以 epoll 为例的简化逻辑
int aeCreateFileEvent(aeEventLoop *eventLoop, int fd, int mask, aeFileProc *proc, void *clientData) {
    // 1. 在 events 数组中记录事件处理器
    aeFileEvent *fe = &eventLoop->events[fd];
    // 2. 调用底层 API 注册事件
    if (aeApiAddEvent(eventLoop, fd, mask) == -1) return -1;
    // 3. 设置回调函数
    fe->mask |= mask;
    if (mask & AE_READABLE) fe->rfileProc = proc;
    if (mask & AE_WRITABLE) fe->wfileProc = proc;
    fe->clientData = clientData;
    return 0;
}

事件分发循环

void aeMain(aeEventLoop *eventLoop) {
    eventLoop->stop = 0;
    while (!eventLoop->stop) {
        // 处理事件前执行的操作（如处理异步任务）
        if (eventLoop->beforesleep != NULL) eventLoop->beforesleep(eventLoop);
        // 核心：多路复用等待事件
        aeProcessEvents(eventLoop, AE_ALL_EVENTS | AE_CALL_AFTER_SLEEP);
    }
}

int aeProcessEvents(aeEventLoop *eventLoop, int flags) {
    // 1. 计算最近的时间事件，确定多路复用的超时时间
    // 2. 调用多路复用 API（epoll_wait/kevent/select 等）
    numevents = aeApiPoll(eventLoop, tvp);
    // 3. 遍历就绪事件，调用相应的回调函数
    for (j = 0; j < numevents; j++) {
        aeFileEvent *fe = &eventLoop->events[eventLoop->fired[j].fd];
        if (fe->mask & mask & AE_READABLE) {
            fe->rfileProc(eventLoop, fd, fe->clientData, mask);
        }
        if (fe->mask & mask & AE_WRITABLE) {
            fe->wfileProc(eventLoop, fd, fe->clientData, mask);
        }
    }
    // 4. 处理时间事件
    if (flags & AE_TIME_EVENTS) processed += processTimeEvents(eventLoop);
    return processed;
}

性能优化细节

为什么 Redis 能单线程处理高并发？

• 纯内存操作：数据操作在内存中完成，速度极快
• 非阻塞 I/O：所有 Socket 设置为非阻塞模式
• 批量命令处理：支持管道（pipeline），减少网络往返
• 高效数据结构：精心优化的数据结构实现

epoll 的优势（Linux 环境下）

# select/poll 的局限性
# 1. 每次调用都需要传递所有监听的 fd（用户空间→内核空间复制）
# 2. 内核需要遍历所有 fd 检查就绪状态 O(n)
# 3. 支持的文件描述符数量有限（select 默认 1024）
# epoll 的优化
# 1. epoll_create: 创建 epoll 实例
# 2. epoll_ctl: 添加/修改/删除 fd（仅增量更新）
# 3. epoll_wait: 获取就绪事件（仅返回就绪的 fd）
# 4. 使用红黑树管理 fd，哈希表存储就绪列表 O(1) 复杂度

多线程扩展（Redis 6.0+）

Redis 6.0 引入了多线程 I/O，但注意：

配置示例（redis.conf）：

# 开启多线程 I/O
io-threads 4
# 启用 4 个 I/O 线程（通常设为 CPU 核心数）
io-threads-do-reads yes
# 启用读多线程（写默认开启）

与其他模型的对比

实际监控与调优

监控指标

# 查看 Redis 事件循环状态
redis-cli info stats | grep -E "(total_connections_received|instantaneous_ops_per_sec|total_commands_processed)"
# 查看网络 I/O
redis-cli info stats | grep -E "(total_net_input_bytes|total_net_output_bytes|rejected_connections)"

性能瓶颈识别

• CPU 瓶颈：单核跑满，考虑分片或升级 CPU
• 网络瓶颈：网络吞吐达到上限
• 内存瓶颈：OOM 或频繁交换
• 阻塞操作：慢查询、大 key、持久化阻塞

配置建议

# 调整最大连接数（根据实际情况）
maxclients 10000
# 调整 TCP backlog
tcp-backlog 511
# 调整客户端超时
timeout 0
# 永不断开，适合内网
# 合理设置内存淘汰策略
maxmemory-policy allkeys-lru

总结

Redis 的 I/O 多路复用模型是其高性能的基石：

1. 单线程事件循环避免了锁竞争和上下文切换
2. 多路复用技术高效管理大量连接
3. 纯内存操作保证极快的响应速度
4. 渐进式演进在保持核心简单的同时引入多线程优化 I/O

面试回答

Redis 之所以这么快，IO 多路复用模型是很关键的一点。我通俗地解释一下它的工作原理：

假设 Redis 是一个餐厅服务员，传统的阻塞 IO 就像是一个服务员每次只服务一桌客人，点菜、上菜都要等这一桌完事了才能服务下一桌，这样效率很低。

而 IO 多路复用呢，就像是这个服务员同时监听多个桌子的呼叫铃。服务员站在大厅里，哪一桌有需求（比如客户端发来了读写请求），他就过去处理一下，处理完马上回来继续监听。这样一个人就能同时照顾很多桌客人，效率大大提升。

在技术实现上，Redis 底层使用的是像 select、poll 这样的系统调用。它们的作用就是帮 Redis 监听大量的网络连接，一旦某个连接有数据可读或可写，就通知 Redis 去处理，而不用为每个连接创建一个线程去阻塞等待。

这样做的好处很明显：

1. 高性能：单线程就能处理大量并发连接，避免了多线程的上下文切换开销。
2. 低延迟：因为事件是即时有响应就处理，不会长时间阻塞。
3. 资源省：不需要为每个连接创建线程，内存和 CPU 消耗都更小。