知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 09 - Redis 的 I/O 模型 ## Redis 为什么选择单线程 Redis 的单线程指的是**命令执行是单线程的**,网络 I/O 用的是 epoll 多路复用。 ``` Redis 的性能瓶颈不在 CPU,而在: 1. 内存带宽(数据读写速度) 2. 网络 I/O(请求/响应的传输速度) 单线程的好处: 避免多线程的锁竞争和上下文切换开销 数据结构操作不需要加锁,实现简单 命令执行顺序可预测,不会有并发问题 单线程的前提: 命令执行本身很快(微秒级),CPU 不是瓶颈 用 epoll 处理大量并发连接,不需要多线程 ``` ### 单线程事件循环(Event Loop)  *图:主线程 Event Loop 处理文件事件与时间事件* ``` Redis 的主线程就是一个无限循环,不断处理文件事件和时间事件。 ┌───────────────────────────────────────────────────────────┐ │ 主线程 Event Loop │ │ │ │ while (true) { │ │ 1. aeProcessEvents() │ │ ├── 计算下一个时间事件还有多久触发 │ │ ├── epoll_wait(fd, timeout) ← 阻塞等待文件事件 │ │ │ 超时时间 = min(时间事件触发间隔, 无限制) │ │ │ │ │ ├── 处理就绪的文件事件(读/写) │ │ │ ├── AE_READABLE → readQueryFromClient() │ │ │ └── AE_WRITABLE → sendReplyToClient() │ │ │ │ │ └── 处理到期的时间事件 │ │ └── serverCron()(每 100ms 执行) │ │ ├── 过期 key 清理 │ │ ├── 过期连接关闭 │ │ ├── AOF/RDB 自动触发 │ │ └── 主从复制心跳 │ │ 2. ... │ │ } │ └───────────────────────────────────────────────────────────┘ 关键理解: epoll_wait 可以同时监听数百个 socket 哪个 socket 有数据到了,就触发对应的 handler 没有事件时 CPU 休眠(不空转),有事件才唤醒 ```  ## Redis 的线程模型演进 ### Redis 6.0 之前:完全单线程  *图:Redis 主线程串行处理请求与后台辅助线程* ``` ┌─────────────────────────────────────────────────────┐ │ Redis 主线程 │ │ │ │ ① 接收客户端连接(accept) │ │ ② 读取请求数据(read) │ │ ③ 解析命令 │ │ ④ 执行命令(操作内存数据结构) │ │ ⑤ 写回响应(write) │ │ │ │ 所有步骤都在一个线程里完成 │ └─────────────────────────────────────────────────────┘ 后台线程(辅助,不处理命令): bio_close_file:异步关闭文件(如 AOF 重写后关闭旧文件) bio_aof_fsync:异步 fsync AOF 文件 bio_lazy_free:异步释放内存(UNLINK 命令) ``` ### Redis 6.0+:网络 I/O 多线程  *图:I/O 线程池并行读写请求,命令执行仍单线程* ``` ┌─────────────────────────────────────────────────────┐ │ │ │ I/O 线程池(多线程) │ │ ┌──────┐ ┌──────┐ ┌──────┐ │ │ │I/O线程│ │I/O线程│ │I/O线程│ ← 并行读取请求、写回响应 │ │ └──────┘ └──────┘ └──────┘ │ │ │ │ 主线程(单线程) │ │ ┌─────────────────────────────────────────────┐ │ │ │ 解析命令 → 执行命令 → 生成响应 │ │ │ └─────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────┘ 多线程只负责网络 I/O(读请求、写响应) 命令执行仍然是单线程,保证数据安全 ```  ```bash # 开启多线程 I/O(redis.conf) io-threads 4 # I/O 线程数(建议 = CPU 核数 - 1) io-threads-do-reads yes # 读操作也用多线程(默认只有写用多线程) ``` ## epoll 多路复用 Redis 用 epoll(Linux)/ kqueue(macOS)/ select(其他)实现 I/O 多路复用,一个线程同时监听数千个连接。 ### 用户态与内核态 ``` 操作系统划分了内核态空间和用户空间: 用户空间: 应用程序的运行环境(进程执行代码的空间) 不能直接访问硬件资源(内存、CPU、I/O 设备) 内核态空间: 操作系统内核运行的区域 负责管理和控制所有硬件资源 执行系统调用、内存管理、进程调度、中断处理 交互方式: 用户空间的进程需要读写文件、创建进程、分配内存等操作时 必须通过系统调用将控制权交给内核 内核在内核态下完成操作,将结果返回给用户空间 这个过程伴随着用户态到内核态的上下文切换 ``` ### I/O 模型分类 ``` 应用程序读取数据时,无法直接读取磁盘: 步骤一:等待内核从硬件(磁盘/网卡)加载数据到内核缓冲区 步骤二:内核将数据从内核缓冲区拷贝到用户缓冲区 阻塞 I/O(Blocking I/O): 两个步骤都阻塞等待 进程在等待数据期间无法做其他事 非阻塞 I/O(Non-blocking I/O): 步骤一非阻塞,用户态收到错误返回后再次尝试,循环往复直到数据就绪 步骤二仍然阻塞 问题:CPU 空转(忙轮询),浪费 CPU 资源 I/O 多路复用(I/O Multiplexing): 传统阻塞 I/O 中,一个进程处理一个 I/O 流会陷入阻塞 若要支持多个 I/O 流,需创建大量线程("一请求一线程") → 高内存消耗和上下文切换开销,难以应对高并发 I/O 多路复用:一个线程监听多个 FD(文件描述符) 某个 FD 可读/可写时得到通知,避免无效等待,充分利用 CPU ``` ### I/O 多路复用的三种实现 **一个线程监听多个 FD(文件描述符)** ``` select: 通过位图(bitmask)管理多个 FD,最多支持 1024 个 FD 每次调用需将整个 FD 位图从用户态拷贝到内核态 内核遍历所有注册的 FD,检查是否就绪 就绪的 FD 修改位图,再拷贝回用户态 缺点:FD 数量限制、每次都要全量拷贝和遍历 poll: 改进:使用动态数组(struct pollfd)存储 FD 每个元素包含 FD 和事件掩码,无 FD 数量限制(仅受系统内存限制) 缺点:仍然需要遍历所有 FD epoll(Redis 使用): 数据结构: 红黑树:内核用红黑树存储注册的 FD 和事件(O(log n) 增删改) 就绪链表:专门存储就绪的 FD,无需遍历全部 FD 事件触发模式: 水平触发(LT):只要 FD 处于就绪状态,每次 epoll_wait 都会返回 边缘触发(ET):仅在 FD 状态从"未就绪"变为"就绪"时通知一次 优势: 不需要每次拷贝全部 FD(epoll_ctl 增量注册) 不需要遍历全部 FD(只返回就绪的 FD) 支持大量并发连接(百万级) ``` ### 为什么不用多线程处理连接? ``` 传统多线程模型(一连接一线程): 1000 个连接 = 1000 个线程 线程切换开销大,内存占用高(每个线程约 1MB 栈空间) 大部分线程在等待 I/O,CPU 利用率低 epoll 模型(单线程处理所有连接): 1000 个连接 = 1 个线程 只有有数据的连接才会被处理 CPU 利用率高,内存占用低 ``` ### epoll 工作原理 ``` Redis 启动时: 创建 epoll 实例 监听服务端 socket(等待新连接) 客户端连接时: accept 新连接,得到 client_fd 将 client_fd 注册到 epoll(监听可读事件) 事件循环(aeMain): while (true) { epoll_wait(epfd, events, MAX_EVENTS, timeout) // 阻塞等待,直到有事件发生 for each event in events: if event is 新连接: accept,注册新 client_fd 到 epoll if event is 可读(客户端发来数据): read 请求数据 ``` ### epoll 的两种触发模式 ``` 水平触发(Level Triggered,LT)— Redis 使用的模式: 只要 fd 的缓冲区中还有数据,epoll_wait 每次都会返回该事件 没读完下次还会通知,不会漏掉数据 编程简单,不容易出 bug 示例: 客户端发来 1000 字节,Redis 一次只读了 500 字节 下次 epoll_wait 时,该 fd 仍然会出现在就绪列表中 Redis 继续读剩余的 500 字节 边缘触发(Edge Triggered,ET): 只在 fd 状态发生变化时通知一次(从无数据变为有数据) 如果没有一次性读完,下次不会再通知,可能导致数据滞留 必须配合非阻塞 I/O,循环读直到 EAGAIN 性能更高(减少 epoll_wait 的唤醒次数),但编程复杂 示例: 客户端发来 1000 字节,ET 模式只通知一次 如果只读了 500 字节就返回,剩余 500 字节不会再触发通知 必须循环读:while (read(fd, buf, size) > 0) { ... } Redis 为什么选择 LT 而不是 ET? Redis 是单线程处理命令,每次事件循环都会把就绪的 fd 处理完 LT 模式下,即使没读完,下次循环还会继续读,不会丢数据 ET 模式的性能优势在 Redis 这里不明显(单线程本来就不会漏处理) LT 实现更简单,不容易出 bug ``` 解析命令 执行命令 将响应写入输出缓冲区 if event is 可写(可以发送响应): write 响应数据给客户端 } ``` ### Redis 的事件驱动框架(ae) ``` Redis 自己实现了一个轻量级的事件驱动框架,叫 ae(Async Events) 两种事件: 文件事件(File Event):网络 I/O 事件(连接、读、写) 时间事件(Time Event):定时任务(如每 100ms 执行一次过期键检查) 事件循环: ┌─────────────────────────────────────────────────┐ │ aeMain 事件循环 │ │ │ │ ┌─────────────────────────────────────────┐ │ │ │ aeProcessEvents │ │ │ │ │ │ │ │ 1. 计算最近时间事件的等待时间 │ │ │ │ 2. epoll_wait(等待文件事件或超时) │ │ │ │ 3. 处理就绪的文件事件(读/写) │ │ │ │ 4. 处理到期的时间事件(定时任务) │ │ │ └─────────────────────────────────────────┘ │ │ ↑ 循环 │ └─────────────────────────────────────────────────┘ ``` ## 一次完整的请求处理流程 ``` 客户端发送:SET user:1001 "张三" 步骤 1:建立连接 客户端 TCP 连接到 Redis(6379 端口) epoll 检测到新连接事件 Redis accept,创建 client 对象,注册到 epoll 步骤 2:接收请求 epoll 检测到 client_fd 可读 Redis 从 socket 读取数据到输入缓冲区(client->querybuf) 读到:*3\r\n$3\r\nSET\r\n$9\r\nuser:1001\r\n$6\r\n张三\r\n 步骤 3:解析命令(RESP 协议) *3 → 3 个参数 $3 → 第 1 个参数长度 3 SET → 命令名 $9 → 第 2 个参数长度 9 user:1001 → key $6 → 第 3 个参数长度 6 张三 → value 步骤 4:执行命令 查找命令表,找到 SET 命令的处理函数 计算 key 的哈希,找到对应的 dict 桶 将 "张三" 存入内存(SDS 字符串) 更新 LRU 时钟 步骤 5:写回响应 将响应 "+OK\r\n" 写入输出缓冲区(client->buf) 注册 client_fd 的可写事件到 epoll epoll 检测到可写,将缓冲区数据发送给客户端 整个过程在单线程中完成,耗时约 10~100 微秒 ``` ## RESP 协议(Redis Serialization Protocol) Redis 客户端和服务端之间用 RESP 协议通信,简单高效。 ``` RESP 数据类型: + 简单字符串:+OK\r\n - 错误:-ERR unknown command\r\n : 整数::1000\r\n $ 批量字符串:$6\r\nfoobar\r\n * 数组:*2\r\n$3\r\nfoo\r\n$3\r\nbar\r\n 发送命令 SET key value: *3\r\n ← 3 个参数 $3\r\nSET\r\n ← 参数 1:SET(3 字节) $3\r\nkey\r\n ← 参数 2:key(3 字节) $5\r\nvalue\r\n ← 参数 3:value(5 字节) 接收响应: +OK\r\n ← 成功 -ERR ...\r\n ← 失败 ``` ```bash # 用 telnet 手动发送 RESP 命令(调试用) telnet localhost 6379 *3 $3 SET $4 name $5 hello # 响应:+OK ``` ## Pipeline(管道) ``` 问题:每条命令都需要一次网络往返(RTT) SET k1 v1 → 等待 OK → SET k2 v2 → 等待 OK → ... 100 条命令 = 100 次 RTT Pipeline:批量发送命令,一次性接收所有响应 发送:SET k1 v1 \r\n SET k2 v2 \r\n ... SET k100 v100 \r\n 接收:OK OK OK ... OK(100 个响应) 100 条命令 = 1 次 RTT(网络往返) ``` ```java // Jedis Pipeline 示例 Pipeline pipeline = jedis.pipelined(); for (int i = 0; i < 10000; i++) { pipeline.set("key:" + i, "value:" + i); } pipeline.sync(); // 一次性发送所有命令,接收所有响应 // 性能对比(10000 次 SET,网络延迟 1ms): // 不用 Pipeline:10000 次 × 1ms = 10 秒 // 用 Pipeline:约 0.1 秒(减少 99% 的网络等待时间) ``` ``` Pipeline vs 事务(MULTI/EXEC): Pipeline:客户端批量发送,服务端逐条执行,不保证原子性 事务:服务端收到 EXEC 后一次性执行所有命令,保证原子性 Pipeline 可以和事务结合使用: pipeline.multi() pipeline.set(...) pipeline.exec() pipeline.sync() ``` ## 哪些命令会阻塞事件循环 ``` Redis 命令执行主路径是单线程的 所以只要某个命令执行太久,就会把整个事件循环卡住 表现出来就是: 1. 所有请求 RT 变高 2. QPS 降低 3. 慢查询增多 4. 主从复制延迟上升 ``` ### 常见阻塞来源 ``` 1. 大 key 删除 DEL 一个超大的 List / Hash / Set / ZSet 释放内存时间很长 2. 全量遍历类命令 KEYS * HGETALL big_hash LRANGE 0 -1 SMEMBERS big_set ZRANGE big_zset 0 -1 3. 复杂 Lua 脚本 脚本里做了很多次循环、遍历或重命令 整个脚本执行期间都不会切出主线程 4. 持久化 / fork 抖动 BGSAVE / BGREWRITEAOF 本身主要在子进程 但 fork 那一瞬间主线程仍可能短暂阻塞 5. O(N) 或更高复杂度命令打在大对象上 平时没问题,数据一大就会突然拖慢 ``` ### 常见治理手段 ```bash 1. 删除大 key 用 UNLINK,不要直接 DEL 2. 线上排查 key 用 SCAN,不要 KEYS * 3. 避免对大集合直接 HGETALL / SMEMBERS / LRANGE 0 -1 4. Lua 脚本保持短小,避免大循环 5. 关注 slowlog、latency doctor、latest_fork_usec 6. 尽早治理 hotkey / bigkey,别等它把单线程拖死 ``` ## Redis 6.0 为什么引入多线程 ``` Redis 6.0 的多线程只针对网络请求处理,数据读写命令仍然是单线程。 限制 Redis 性能的主要瓶颈在网络 I/O 处理上: 虽然之前采用了多路复用技术 但本质上仍是同步阻塞的 I/O 模型(单线程 read/write) 高并发场景下,单线程读写 socket 成为瓶颈 多线程的好处: 减少网络 I/O 等待造成的影响 充分利用 CPU 的多核优势 网络 I/O 并行处理,命令执行仍串行,保证数据安全 ``` ## Redis 6.0 多线程 I/O 的工作流程 ``` 阶段 1:主线程 epoll_wait,等待可读事件 有数据的连接放入待读队列 阶段 2:主线程将待读队列分配给 I/O 线程 I/O 线程并行读取各自负责的连接数据(read syscall) 阶段 3:主线程等待所有 I/O 线程读取完成 阶段 4:主线程串行解析命令、执行命令(单线程,保证安全) 阶段 5:主线程将响应分配给 I/O 线程 I/O 线程并行写回响应(write syscall) 阶段 6:主线程等待所有 I/O 线程写完,进入下一轮循环 关键:命令执行(阶段 4)始终是单线程 多线程只用于 I/O 读写,不涉及数据操作 ``` ## 面试常见问题 **Q:Redis 是单线程的吗?为什么单线程还这么快?** A:Redis 的命令执行是单线程的(6.0 之前网络 I/O 也是单线程,6.0 后网络 I/O 引入多线程)。快的原因:① 纯内存操作;② 单线程避免锁竞争和上下文切换;③ epoll I/O 多路复用,一个线程处理大量连接;④ 高效的数据结构。 **Q:Redis 6.0 引入多线程解决了什么问题?** A:解决了网络 I/O 的瓶颈。在高并发场景下,单线程读写 socket 成为性能瓶颈。6.0 引入多线程并行处理网络 I/O(读请求、写响应),命令执行仍是单线程,保证数据安全。 **Q:Pipeline 和事务有什么区别?** A:Pipeline 是客户端批量发送命令减少网络往返,服务端逐条执行,不保证原子性。事务(MULTI/EXEC)是服务端收到 EXEC 后一次性执行所有命令,保证原子性(但不支持回滚)。两者可以结合使用。 **Q:Redis 的 epoll 是怎么工作的?** A:Redis 启动时创建 epoll 实例,监听服务端 socket。客户端连接后,将 client_fd 注册到 epoll 监听可读事件。事件循环中调用 epoll_wait 阻塞等待,有事件发生时处理对应的读/写操作。这样一个线程就能同时处理数千个连接,不需要为每个连接创建线程。 --- 上一篇:[08 - 事务与 Lua 脚本](./08-transaction-lua.md) | 返回:[目录](./README.md)
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入