💬 :如果你在阅读过程中有任何疑问或想要进一步探讨的内容,欢迎在评论区畅所欲言!我们一起学习、共同成长~!
👍 :如果你觉得这篇文章还不错,不妨顺手点个赞、加入收藏,并分享给更多的朋友噢~!
引言 :上一章《Linux网络(10):五种 IO 模型》我们用"钓鱼"比喻讲清了五种模型的区别------IO 多路转接就是 2.4 IO多路复用,核心思想是把"等"的时间重叠。本章正式落地三个系统调用:select、poll、epoll,下一章 Reactor 反应堆就是 epoll 的工程化封装。
📌 联动 :本章所有 socket 操作复用《Linux网络(03):Socket 编程 TCP》的 socket/bind/listen/accept;非阻塞设置复用《Linux网络(10):五种 IO 模型》4.2 的 SetNonBlock();fd 概念回顾《Linux系统(05):基础 IO》4. 文件描述符 fd。
1. 为什么还需要多路转接【必考核心】
先回顾 《Linux网络(03):Socket 编程 TCP》的痛点:单执行流 TCP 服务器同一时刻只能串行服务一个客户端,第二个客户端 connect 成功但只能排在全连接队列里等;多线程版虽然解决了并发,但每来一个连接就创建一个线程,连接数一多,线程创建/销毁和调度开销直接拖垮服务器。
💡 核心矛盾 :read/accept 默认阻塞,一个线程同一时刻只能等一个 fd。要在单线程内同时等几百上千个 fd,就必须有一个系统调用帮我们"批量等"------这就是 IO 多路转接。
所有多路转接 API 只有一个核心动作:等。告诉内核"帮我盯着这堆 fd,哪个就绪了叫醒我",返回后再由用户态挨个处理就绪的 fd。
2. select
2.1 select 函数原型【必考核心】
cpp
#include <sys/select.h>
// select(最大fd+1, 读集合,写集合,异常集合,超时时间)
int select(int nfds,
fd_set *readfds,
fd_set *writefds,
fd_set *exceptfds,
struct timeval *timeout);
| 参数 | 含义 |
|---|---|
| nfds | 被监视的 fd 中最大 fd + 1 |
| readfds | 输入输出型参数,调用时用户告知内核需要监视哪些 fd 的读事件是否就绪,返回时内核告知用户哪些 fd 的读事件已就绪。 |
| writefds | 输入输出型参数,调用时用户告知内核需要监视哪些 fd 的写事件是否就绪,返回时内核告知用户哪些 fd 的写事件已就绪;不需要监视则传 NULL |
| exceptfds | 输入输出型参数,调用时用户告知内核需要监视哪些 fd 的异常事件是否就绪,返回时内核告知用户哪些 fd 的异常事件已就绪;不需要监视则传 NULL |
| timeout | 输入输出型参数,调用时由用户设置 select 的等待时间,返回时 timeout 会被改成剩余时间(详见 2.3) |
- 输入输出型参数:调用函数时,传给它一个带初始数据的变量;函数执行中修改此变量,函数返回后,从此变量拿到函数输出结果,不靠 return 返回这份结果。
select 返回值三态:
| 返回值 | 含义 | 处理 |
|---|---|---|
| >0 | 就绪 fd 的个数 | 遍历 fd_set 找就绪 fd |
| 0 | timeout 超时,无事件 | 继续下一轮 |
| -1 | 出错 | 看 errno,EINTR 被信号中断要重试 |
为什么 readfds 是输入输出型参数?
select 返回就绪 fd 总个数,不单独返回就绪 fd 清单,于是直接原地修改传入的 fd_set 位图,把未就绪位清掉,只留就绪位。所以 readfds 既是用户告诉内核 "用户要监视哪些 fd" 的输入,又是内核传回 "哪些 fd 就绪" 的输出,也就是输入输出型参数。
2.2 fd_set:本质是位图【必考核心】
fd_set 是一个位图 ,每一位(bit)标记一个 fd,从右往左第 n 位为 bit=1 表示关注 fd=n。
用户不能自己位运算,系统提供 4 个宏:
cpp
FD_ZERO(fd_set *set); // 清空整个位图,全置0
FD_SET(int fd, fd_set *set); // fd对应比特位设 1,监视该fd事件
FD_CLR(int fd, fd_set *set); // fd对应比特位清 0,取消监视监视该fd事件
int FD_ISSET(int fd, fd_set *set); // 判断fd对应比特位是否为 1
// select 会修改位图,必须 FD_ISSET 校验
⚠️【高频易错】fd_set 大小固定。glibc 中 FD_SETSIZE = 1024,意味着 select 默认最多监视 1024 个 fd。想改要重新编译内核,工程上没人这么干------这就是 select 被淘汰的原因之一。
2.3 timeout 三态【必考核心】
cpp
struct timeval {
long tv_sec; // 秒
long tv_usec; // 微秒
};
| timeout 取值 | select 行为 |
|---|---|
| NULL | 永久阻塞,直到某个 fd 就绪 |
| {0, 0} | 非阻塞,检查一遍立刻返回 |
| {n, 0} | 阻塞最多 n 秒,超时返回 0 |
⚠️【高频易错】timeout 也是输入输出型参数:返回时它会被改成剩余时间。所以循环里每次都要重新赋值。
2.4 一次 select 执行过程【必考核心】
假设我们监视 fd=1、fd=2、fd=5 的读事件:
-
FD_ZERO(&set) → 0000 0000
-
FD_SET(1)、FD_SET(2)、FD_SET(5) → 0010 0011
-
调用 select() 阻塞等待
-
假设 fd=1、fd=2 就绪,fd=5 没动静 → select 返回
-
此时 set 被内核改成 0000 0011 ------ fd=5(从右往左第 5 位)那一位被内核清掉了!
❗因为返回后没就绪的位被清了,下一轮调用 select 前必须重新 FD_ZERO + FD_SET****把所有要监视的 fd 重新塞进去 。这就是 select 使用上最麻烦的地方。
2.5 socket 就绪条件【进阶拔高】
select 到底在等什么?对 socket 来说,"读就绪"和"写就绪"各有明确条件:
读就绪(满足任一):
- socket 接收缓冲区有数据,可以无阻塞 read
- 写端(对端)关闭:本端收到对端 FIN,read 返回 0
- 监听 socket 上有新连接
- socket 上有未处理的错误
写就绪(满足任一):
- socket 发送缓冲区有空闲,可以无阻塞 write
- 向已关闭的连接 write,触发 SIGPIPE
- 非阻塞 connect 结束(成功或失败)
- socket 上有未处理的错误
💡 select 判定 socket 读写就绪,本质就是检查缓冲区能不能无阻塞读写,外加连接状态变化、套接字出错这几类情况。就绪只是不阻塞,不代表读写一定成功。
2.6 select 单线程服务器工作流程【必考核心】
select 本身不认识业务,它只告诉你"哪些 fd 就绪了"。服务器要自己维护一个 fd_array[] 数组记录当前正在监视哪些 fd。
掌握程度:能口述完整流程、说清为什么需要 fd_array,即可。
cpp
1. 创建 listen_sock,bind,listen
2. fd_array[] 所有位置初始化为 -1(无效),fd_array[0] = listen_sock
3. for(;;) {
FD_ZERO(&readfds);
maxfd = listen_sock;
for (fd in fd_array) {
if (fd == -1) continue;
FD_SET(fd, &readfds);
maxfd = max(maxfd, fd);
}
n = select(maxfd+1, &readfds, NULL, NULL, NULL);
if (n < 0) { perror; continue; }
// 遍历 fd_array,用 FD_ISSET 找就绪的 fd
for (fd in fd_array) {
if (!FD_ISSET(fd, &readfds)) continue;
if (fd == listen_sock) {
// 监听套接字读就绪 = 有新连接
connfd = accept(listen_sock, ...);
// 找 fd_array 里一个空位存 connfd
} else {
// connfd 读就绪 = 客户端发数据了
n = read(connfd, buf, ...);
if (n == 0) { close(connfd); 从 fd_array 删掉; }
else 处理数据;
}
}
}
2.7 极简实操(CentOS7):select 监视标准输入
掌握程度:能编译运行、认出「清位图→加 fd→select 等→FD_ISSET 判断」四步顺序,即可,不用默写。
cpp
// select_stdin.c
#include <stdio.h>
#include <unistd.h>
#include <sys/select.h>
int main() {
fd_set read_fds; // 定义被监视读事件的fd集合
while (1) { // 持续监视标准输入
FD_ZERO(&read_fds); // 清空位图
FD_SET(0, &read_fds); // fd=0(标准输入)加入监视
printf("> ");
fflush(stdout); // 刷新标准输出缓冲区,不等待换行符立刻打印
// select(最大fd+1,读集合,写集合,异常集合,超时时间)
int ret = select(1, &read_fds, NULL, NULL, NULL);
if (ret < 0) { perror("select"); continue; }
// 判断fd=0是否在就绪集合里(select会修改位图,必须FD_ISSET校验)
if (FD_ISSET(0, &read_fds)) {
char buf[1024] = {0};
read(0, buf, sizeof(buf)-1); // 从标准输入读数据,预留1字节放'\0'
printf("input: %s", buf);
}
}
return 0;
}


2.8 select 单线程回显服务器核心骨架【必考核心】
📌 联动 : 《Linux网络(03):Socket 编程 TCP》2.2 单执行流服务端代码
💡 select 单线程回显服务器能同时服务多个客户端,不需要多线程。
掌握程度:能独立写出核心逻辑骨架,打印、次要错误处理可简化,记住「select 位图每次循环必须重设」是核心。
cpp
// select_server.cpp ------ 只保留面试核心,业务回显
#include <iostream>
#include <string> // std::stoi
#include <strings.h> // bzero
#include <unistd.h>
#include <sys/types.h> // socklen_t,ssize_t
#include <sys/socket.h> // 套接字系统调用
#include <sys/select.h> // select、fd_set、FD系列宏
#include <netinet/in.h> // 网络地址结构体头文件:sockaddr_in,INADDR_ANY,端口/IP类型
#include <arpa/inet.h> // 网络字节序转换函数
using namespace std;
#define BACKLOG 5
#define MAX_FD 1024
int main(int argc, char* argv[]) {
uint16_t port = stoi(argv[1]);
// 1. 创建套接字:TCP 用 SOCK_STREAM
int listen_sock = socket(AF_INET, SOCK_STREAM, 0);
// 端口复用:解决Ctrl+C后快速重启时TIME_WAIT导致bind失败
int opt = 1;
setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
// 2. 填充本地地址
struct sockaddr_in local;
bzero(&local, sizeof(local));
local.sin_family = AF_INET;
local.sin_port = htons(port);
local.sin_addr.s_addr = htonl(INADDR_ANY);
bind(listen_sock, (struct sockaddr*)&local, sizeof(local));
// 3. 套接字设为监听状态
listen(listen_sock, BACKLOG);
// 【用一个数组保存所有要监视的 fd,-1 表示空位】
int fd_array[MAX_FD];
for (int i = 0; i < MAX_FD; i++) fd_array[i] = -1;
fd_array[0] = listen_sock;
// 4. 多路转接循环:select 位图每次循环必须重设
while (true) {
fd_set readfds;
FD_ZERO(&readfds);
int maxfd = listen_sock;
// 【遍历监视数组,填fd_set】
for (int i = 0; i < MAX_FD; i++) {
if (fd_array[i] == -1) continue;
FD_SET(fd_array[i], &readfds);
if (fd_array[i] > maxfd) maxfd = fd_array[i];
}
int n = select(maxfd + 1, &readfds, NULL, NULL, NULL);
if (n < 0) continue;
// 【遍历fd_array,分发就绪事件】
for (int i = 0; i < MAX_FD; i++) {
if (fd_array[i] == -1) continue;
if (!FD_ISSET(fd_array[i], &readfds)) continue;
if (fd_array[i] == listen_sock) {
// ① 监听套接字就绪 = 有新连接
struct sockaddr_in peer;
socklen_t len = sizeof(peer);
int connfd = accept(listen_sock, (struct sockaddr*)&peer, &len);
if (connfd < 0) continue;
// 找空位存入新connfd
for (int j = 0; j < MAX_FD; j++) {
if (fd_array[j] == -1) {
fd_array[j] = connfd;
break;
}
}
}
else {
// ② connfd就绪 = 客户端发数据 / 关闭连接
char buffer[1024];
ssize_t rn;
rn = read(fd_array[i], buffer, sizeof(buffer) - 1);
if (rn > 0) {
buffer[rn] = '\0';
write(fd_array[i], buffer, rn); // write原样回显给客户端
}
else {
close(fd_array[i]);
fd_array[i] = -1;
}
}
}
}
close(listen_sock); // 6.
return 0;
}
2.9 select 的优缺点【必考核心】
✅ 优点: 接口简单,跨平台兼容性好(Windows、Linux 都支持,Windows Socket 常用);适合连接数量少、并发压力不大的场景。
❌ 缺点(面试必背的送分题):
- fd 数量有上限 :默认 1024(
FD_SETSIZE),高并发场景不够。 - 每次调用都要重设 fd_set :因为内核返回时改了位图,用户态必须
FD_ZERO + FD_SET从头再塞一遍。 - 每次调用都要把 fd_set 从用户态拷到内核态,fd 多了拷贝开销大。
- 内核每次都要遍历整个 fd_set 检查就绪,时间复杂度 O(n)。
- 返回后用户态也要遍历整个 fd_array 用
FD_ISSET找就绪的,又是 O(n)。
⚠️【高频易错】不要把"select 最多 1024"和"进程最多打开 1024 个文件"混淆------后者是进程级 ulimit -n,前者是 select API 写死的位图大小,两回事。
3. poll 选学
poll 是 select 的改良版,面试单独考得少,但经常放在 select/poll/epoll 对比里一起问。
3.1 poll 函数接口【必考核心】
cpp
#include <poll.h>
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
struct pollfd {
int fd; // 要监视的 fd
short events; // 期望关心的事件(输入)
short revents; // 内核返回的实际发生事件(输出)
};
fds:pollfd 数组,每个元素管一个 fdnfds:数组长度timeout:毫秒,-1 永久阻塞,0 立即返回
常用事件宏:POLLIN(可读)、POLLOUT(可写)、POLLERR(错误)、POLLHUP(挂起/对端关闭)、POLLRDHUP(对端关闭写一半)。
3.2 poll 的优缺点【必考核心】
✅ 优点
-
不再使用位图,用 pollfd 数组,没有 1024 上限、不用每次循环重新装填位图,接口更友好;
-
同样跨平台。
❌ 缺点
- 内核遍历全部传入的
pollfd数组检测就绪,时间复杂度 O (n); - 每次调用都要把整个 pollfd 数组从用户态拷贝到内核态,连接多的时候拷贝开销大;
- 返回就绪后,用户态依旧需要遍历整个 pollfd 数组判断哪些就绪,O (n);
- 没有事件就绪的主动通知机制。
💡一句话对比 poll 和 select :poll 解决了 select 的1024 上限、位图重填两个痛点,但没有解决 select 最核心的 O (n) 遍历问题。
4. epoll
epoll 是 Linux 2.6 之后高性能网络服务器的事实标准,Nginx、Redis、muduo 都用它。这是本章绝对核心。
4.1 epoll 三个系统调用【必考核心】
epoll 把 select 的一次调用拆成了三步:
cpp
#include <sys/epoll.h>
// ① 创建 epoll 实例,返回 epfd(也是一个 fd!用完要 close)
int epoll_create(int size); // size自Linux 2.6.8起被忽略,传个>0的数即可
// ② 往 epfd 里增/删/改监视的 fd
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
// ③ 等待事件就绪
int epoll_wait(int epfd, struct epoll_event *events,
int maxevents, int timeout);
epoll_ctl 的 op:
| op | 含义 |
|---|---|
EPOLL_CTL_ADD |
新增一个要监视的 fd |
EPOLL_CTL_MOD |
修改已监视 fd 的关心事件 |
EPOLL_CTL_DEL |
移除一个 fd |
cpp
struct epoll_event {
uint32_t events; // 关心的事件:EPOLLIN / EPOLLOUT / EPOLLET ...
epoll_data_t data; // 用户自定义数据,一般塞 fd 或指针
};
常用事件宏:
| 宏 | 含义 |
|---|---|
EPOLLIN |
可读(含对端正常关闭) |
EPOLLOUT |
可写 |
EPOLLET |
边缘触发(ET),默认是水平触发(LT) |
EPOLLRDHUP |
对端关闭写一半(Linux 2.6.17+) |
EPOLLERR |
出错 |
EPOLLHUP |
挂起 |
💡 关键区别 :select 是"调用时才告诉内核要监视谁";epoll 是"平时用 epoll_ctl 把 fd 登记到内核里,epoll_wait 只是阻塞等结果"。登记和等待分离了。
4.2 epoll 工作原理【必考核心】
epoll 内部有两个核心数据结构:
- 红黑树 :存所有通过
epoll_ctl ADD注册进来的 fd。插入/删除/查找 O(log n),重复 ADD 能立刻查出来。 - 就绪双向链表 rdllist :只存已经就绪的 fd。
工作流程:
epoll_create在内核创建eventpoll结构体,内含红黑树根 + 就绪链表头。epoll_ctl ADD把 fd 包成epitem插入红黑树,同时给这个 fd 在内核网卡中断处理程序里注册一个回调函数。- 数据到达网卡 → 内核中断 → 回调函数把就绪的
epitem挂到 rdllist 尾部。 epoll_wait只看 rdllist 是否为空:空就阻塞,非空就把就绪事件拷贝给用户态 events 数组返回。
💡 面试答法:
- select/poll 每次都要把全部 fd 列表拷给内核、内核遍历一遍;epoll 只在
ctl ADD时拷一次,之后wait不拷全量。 - select/poll 返回后用户要遍历全部 fd 找就绪的;epoll_wait 返回的数组里只有就绪的 fd,O(1) 拿到就绪列表。
- 这就是 epoll 在 C10K(同时支持 10000 个客户端连接)场景下吊打 select/poll 的根本原因。
⚠️【高频易错】网上有人说"epoll 用 mmap 把内核就绪队列映射到用户态,零拷贝"------这个说法不准确 。struct epoll_event 是用户态自己分配的,epoll_wait 仍然要把就绪事件从内核态拷到用户态。省掉的是"每次拷全部监视 fd",不是"零拷贝"。
4.3 epoll 相比 select/poll 的优点【必考核心】
- fd 无数量上限 (受
ulimit -n限制,默认 1024 可改到几十万)。 - fd 集合不用每次重传 :
epoll_ctl维护一次,epoll_wait不传 fd 列表。 - O(1) 返回就绪 fd:不关心的 fd 不会被遍历。
- 事件回调机制:fd 就绪时内核主动把它挂到就绪链表,不需要轮询。
4.4 LT 水平触发 和 ET 边缘触发【必考核心】
epoll 默认工作在 LT(Level Triggered,水平触发) 模式,加 EPOLLET 就进入 ET(Edge Triggered,边缘触发)。
| 模式 | 行为 |
|---|---|
| LT | 缓冲区有数据没读完,该 fd 对应的就绪事件会持续留在 epoll 就绪队列,epoll_wait 每次都提醒,直到读完 |
| ET | 状态变化那一刻(新数据到达)通知一次,缓冲区遗留老数据,不会再次触发事件、不会重新加入就绪队列,没读完也不再提醒 |
对比表:
| 维度 | LT(默认) | ET(EPOLLET) |
|---|---|---|
| 通知时机 | 只要缓冲区还有数据,每次 wait 都返回 | 只在状态变化那一刻(新数据到达)通知一次 |
| 是否必须一次读完 | 否 | 是 |
| 支持阻塞 fd | 支持 | 不支持,必须非阻塞 |
| 触发频率 | 高 | 低(性能更好) |
| 使用难度 | 简单 | 易写 bug |
| 典型代表 | epoll 默认、select、poll | Nginx |
💡 select/poll 只能工作在 LT 模式;epoll 默认 LT,可选 ET。
4.5 ET 模式为什么必须非阻塞【高频易错】
这是面试连环追问的经典坑,必须讲清楚:
场景 :客户端发了 10K 数据,服务器一次 read 只读了 1K(TCP 流式 read 不保证一次读完)。
- 如果是阻塞 fd + ET 模式 :剩下 9K 在内核接收缓冲区里,但 ET 不会再通知你。你去
read剩下的 9K 时,因为已经没有新数据触发事件,read会一直阻塞------整个 epoll 线程被卡死,其他客户端全饿死。 - 正确做法 :connfd 设为非阻塞 ,用
while循环read,直到返回EAGAIN/EWOULDBLOCK(说明缓冲区读干净了)才停下来。
📌 联动:非阻塞设置和 errno 判断直接复用《Linux网络(10):五种 IO 模型》4.2 的 SetNonBlock() 函数和 4.4 的 errno 三分支(EAGAIN/EINTR/真错误)。
cpp
// ET 模式下的标准读循环(核心片段)
while (true) {
ssize_t n = read(fd, buf, sizeof(buf));
if (n > 0) { /* 处理读到的 n 字节 */ continue; }
if (n == 0) { /* 对端关闭,close(fd) */ break; }
if (errno == EAGAIN || errno == EWOULDBLOCK) break; // 读干净了,退出
if (errno == EINTR) continue; // 被信号中断,重试
/* 真错误 */ break;
}
4.6 epoll 适用场景【进阶拔高】
epoll 不是万能的:
- ✅ 高并发 + 连接活跃度低(长连接场景,如 IM、HTTP 服务器):几万连接里同时活跃的可能就几百个,epoll O(1) 返回就绪列表的优势才体现。
- ❌ 连接数少 + 全部活跃 (如本机两台机器互发数据):epoll 的红黑树/回调反而徒增开销,直接
read/多线程更划算。
💡 面试答法:"epoll 适合 C10K 以上、长连接、活跃连接占比低的场景;连接少且都活跃时,select/poll 甚至阻塞 IO 反而更简单高效。"
4.7 epoll 服务器 LT 模式骨架(CentOS7)【必考核心】
掌握程度:能独立写出核心骨架,错误打印可省略。
关键点:epoll 三个核心接口(epoll_create、epoll_ctl、epoll_wait)、红黑树在内核维护监视 fd、epoll_wait 只遍历就绪 n 个事件、LT 模式特性、连接关闭时必须先 EPOLL_CTL_DEL 再 close;
💡 对比 select:不再需要用户层 fd_array,哪些 fd 在被监视由内核红黑树维护,eventsi.data.fd 直接拿就绪 fd。
cpp
// epoll_server_LT.cpp
#include <iostream>
#include <string> // std::stoi
#include <strings.h> // bzero
#include <unistd.h>
#include <sys/types.h> // socklen_t,ssize_t
#include <sys/socket.h> // 套接字系统调用
#include <sys/epoll.h>
#include <netinet/in.h> // 网络地址结构体头文件
#include <arpa/inet.h> // 网络字节序转换函数
using namespace std;
#define BACKLOG 5
#define MAX_EVENTS 1024
int main(int argc, char* argv[]) {
uint16_t port = stoi (argv [1]);
// 1. 创建套接字:TCP 用 SOCK_STREAM
int listen_sock = socket(AF_INET, SOCK_STREAM, 0);
// 端口复用:解决Ctrl+C后快速重启时TIME_WAIT导致bind失败
int opt = 1;
setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
// 2. 填充本地地址
struct sockaddr_in local;
bzero(&local, sizeof(local));
local.sin_family = AF_INET;
local.sin_port = htons(port);
local.sin_addr.s_addr = htonl(INADDR_ANY);
bind(listen_sock, (struct sockaddr*)&local, sizeof(local));
// 3. 套接字设为监听状态
listen(listen_sock, BACKLOG);
// ① 创建 epoll 实例
int epfd = epoll_create(10);
// ② 把 listen_sock 加入 epoll 监视
struct epoll_event ev;
ev.events = EPOLLIN;
ev.data.fd = listen_sock;
epoll_ctl(epfd, EPOLL_CTL_ADD, listen_sock, &ev);
struct epoll_event events[MAX_EVENTS];
// 4. 多路转接循环
while (true) {
// ③ 阻塞等就绪事件
int n = epoll_wait(epfd, events, MAX_EVENTS, -1);
if (n < 0) continue;
// 【只遍历 n 个就绪fd,不是全部fd】
for (int i = 0; i < n; i++) {
int fd = events[i].data.fd;
if (fd == listen_sock) {
// ① 监听套接字就绪 = 有新连接
struct sockaddr_in peer; socklen_t len = sizeof(peer);
int connfd = accept(listen_sock, (struct sockaddr*)&peer, &len);
if (connfd < 0) continue;
ev.events = EPOLLIN;
ev.data.fd = connfd;
epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev);
}
else {
// ② connfd就绪 = 客户端发数据 / 关闭连接
char buf[1024];
ssize_t rn;
rn = read(fd, buf, sizeof(buf)-1);
if (rn > 0) {
buf[rn] = '\0';
write(fd, buf, rn); // write原样回显给客户端
}
else {
epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
close(fd);
}
}
}
}
close(epfd);
close(listen_sock);
return 0;
}
4.8 ET 模式改造要点【进阶拔高】
在 LT 版本基础上改三处:
- connfd 用 SetNonBlock() 设为非阻塞(复用 10 章工具函数)。
- ev.events = EPOLLIN | EPOLLET;
- 读数据改成 4.5 节那个 while + EAGAIN 退出 的循环。
⚠️ 还有一个常被忽略的坑:listen_sock 如果也设成 ET,必须用 while((connfd=accept(...)) > 0) 循环 accept 到 EAGAIN,否则同一时刻三个客户端同时连过来,ET 只通知一次,后两个连接会等到下一个事件才被 accept。初学者 listen_sock 先用 LT,connfd 用 ET 即可。
4.9 惊群问题【冷门了解】
多进程/多线程同时 epoll_wait 同一个 listen_sock 时,新连接到来会把所有进程都唤醒,但只有一个能 accept 成功,其余白醒一趟,这就是惊群。Linux 2.6 之后内核已经只唤醒一个 epoll_wait,这个考点近年极少单独考,知道名词即可。
5. select / poll / epoll 终极对比【必考核心】
| 维度 | select | poll | epoll |
|---|---|---|---|
| 数据结构 | 三个位图 fd_set | pollfd 数组 | 红黑树 + 就绪链表 |
| fd 数量上限 | 1024 | 无(受 ulimit) | 无(受 ulimit) |
| 每次调用传参 | 全量 fd_set 拷给内核 | 全量 pollfd 拷给内核 | epoll_wait 不传 fd |
| 内核遍历 | 每次 O(n) 轮询 | 每次 O(n) 轮询 | O(1) 看就绪链表 |
| 返回方式 | 修改原位图,用户 O(n) FD_ISSET | 遍历 revents,O(n) | 直接返回就绪数组,O(就绪数) |
| 触发模式 | 只支持 LT | 只支持 LT | 默认 LT,可选 ET |
| 效率随 fd 数增长 | 线性下降 | 线性下降 | 基本不变(活跃连接多时才降) |
| 适用场景 | 跨平台、少量 fd | 类 Unix、fd 较多 | Linux 高并发服务器 |
💡一句话对比:epoll 解决了 select、poll 的 O (n) 遍历痛点,但不是万能方案,有适用场景。
epoll 的优缺点
✅ 优点:
- 无 fd 1024 上限,上限受系统 ulimit 配置控制;
- 内核用红黑树维护监视 fd,只返回就绪事件,时间复杂度 O (1);
- 就绪事件放到内核就绪链表,不需要每次全量拷贝所有 fd;
- 只需要遍历就绪的 n 个事件,不用遍历全部监视 fd;
- 支持 LT 水平触发、ET 边缘触发两种模式,灵活度高。
❌ 缺点:
- 不跨平台,仅 Linux 原生支持;
- 连接少、所有 fd 持续活跃的场景下,红黑树、回调机制的额外开销,性能不一定优于 select/poll;
- 接口比 select/poll 更复杂。
