Linux 网络(11):IO 多路转接(select /poll/epoll)

💬 :如果你在阅读过程中有任何疑问或想要进一步探讨的内容,欢迎在评论区畅所欲言!我们一起学习、共同成长~!

👍 :如果你觉得这篇文章还不错,不妨顺手点个赞、加入收藏,并分享给更多的朋友噢~!


引言 :上一章《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 的读事件:

  1. FD_ZERO(&set) → 0000 0000

  2. FD_SET(1)、FD_SET(2)、FD_SET(5) → 0010 0011

  3. 调用 select() 阻塞等待

  4. 假设 fd=1、fd=2 就绪,fd=5 没动静 → select 返回

  5. 此时 set 被内核改成 0000 0011 ------ fd=5(从右往左第 5 位)那一位被内核清掉了!

❗因为返回后没就绪的位被清了,下一轮调用 select 前必须重新 FD_ZERO + FD_SET****把所有要监视的 fd 重新塞进去 。这就是 select 使用上最麻烦的地方。

2.5 socket 就绪条件【进阶拔高】

select 到底在等什么?对 socket 来说,"读就绪"和"写就绪"各有明确条件:

读就绪(满足任一):

  1. socket 接收缓冲区有数据,可以无阻塞 read
  2. 写端(对端)关闭:本端收到对端 FIN,read 返回 0
  3. 监听 socket 上有新连接
  4. socket 上有未处理的错误

写就绪(满足任一):

  1. socket 发送缓冲区有空闲,可以无阻塞 write
  2. 向已关闭的连接 write,触发 SIGPIPE
  3. 非阻塞 connect 结束(成功或失败)
  4. 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 常用);适合连接数量少、并发压力不大的场景。

❌ 缺点(面试必背的送分题):

  1. fd 数量有上限 :默认 1024(FD_SETSIZE),高并发场景不够。
  2. 每次调用都要重设 fd_set :因为内核返回时改了位图,用户态必须 FD_ZERO + FD_SET 从头再塞一遍。
  3. 每次调用都要把 fd_set 从用户态拷到内核态,fd 多了拷贝开销大。
  4. 内核每次都要遍历整个 fd_set 检查就绪,时间复杂度 O(n)。
  5. 返回后用户态也要遍历整个 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 数组,每个元素管一个 fd
  • nfds:数组长度
  • timeout:毫秒,-1 永久阻塞,0 立即返回

常用事件宏:POLLIN(可读)、POLLOUT(可写)、POLLERR(错误)、POLLHUP(挂起/对端关闭)、POLLRDHUP(对端关闭写一半)。

3.2 poll 的优缺点【必考核心】

✅ 优点

  1. 不再使用位图,用 pollfd 数组,没有 1024 上限、不用每次循环重新装填位图,接口更友好;

  2. 同样跨平台。

❌ 缺点

  1. 内核遍历全部传入的 pollfd 数组检测就绪,时间复杂度 O (n);
  2. 每次调用都要把整个 pollfd 数组从用户态拷贝到内核态,连接多的时候拷贝开销大;
  3. 返回就绪后,用户态依旧需要遍历整个 pollfd 数组判断哪些就绪,O (n);
  4. 没有事件就绪的主动通知机制。

💡一句话对比 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 内部有两个核心数据结构:

  1. 红黑树 :存所有通过 epoll_ctl ADD 注册进来的 fd。插入/删除/查找 O(log n),重复 ADD 能立刻查出来。
  2. 就绪双向链表 rdllist :只存已经就绪的 fd。

工作流程:

  1. epoll_create 在内核创建 eventpoll 结构体,内含红黑树根 + 就绪链表头。
  2. epoll_ctl ADD 把 fd 包成 epitem 插入红黑树,同时给这个 fd 在内核网卡中断处理程序里注册一个回调函数。
  3. 数据到达网卡 → 内核中断 → 回调函数把就绪的 epitem 挂到 rdllist 尾部。
  4. 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 的优点【必考核心】

  1. fd 无数量上限 (受 ulimit -n 限制,默认 1024 可改到几十万)。
  2. fd 集合不用每次重传 :epoll_ctl 维护一次,epoll_wait 不传 fd 列表。
  3. O(1) 返回就绪 fd:不关心的 fd 不会被遍历。
  4. 事件回调机制: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 版本基础上改三处:

  1. connfd 用 SetNonBlock() 设为非阻塞(复用 10 章工具函数)。
  2. ev.events = EPOLLIN | EPOLLET;
  3. 读数据改成 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 的优缺点

✅ 优点:

  1. 无 fd 1024 上限,上限受系统 ulimit 配置控制;
  2. 内核用红黑树维护监视 fd,只返回就绪事件,时间复杂度 O (1);
  3. 就绪事件放到内核就绪链表,不需要每次全量拷贝所有 fd;
  4. 只需要遍历就绪的 n 个事件,不用遍历全部监视 fd;
  5. 支持 LT 水平触发、ET 边缘触发两种模式,灵活度高。

❌ 缺点:

  1. 不跨平台,仅 Linux 原生支持;
  2. 连接少、所有 fd 持续活跃的场景下,红黑树、回调机制的额外开销,性能不一定优于 select/poll;
  3. 接口比 select/poll 更复杂。
相关推荐
峥嵘life1 小时前
Android16 热点「网络共享」开关的设计与实现
服务器·网络·microsoft
wno7042 小时前
CentOS下FTP服务搭建
linux·运维·centos
15Moonlight2 小时前
Linux网络(12):Reactor 模式
linux·网络
思想觉悟3 小时前
Android启动流程之点rc文件
android·linux·面试
kyle~14 小时前
嵌入式 SoC 系统
linux·c++·嵌入式·计算系统
其实防守也摸鱼16 小时前
用 Claude Code 重构遗留系统:从评估到落地的完整指南
前端·网络·人工智能·chrome·安全·重构
人生!?16 小时前
Linux 从入门到进阶 | 基础语法
linux·笔记·教程
优化Henry17 小时前
LTE 站点 S1 链路反复闪断导致小区频闪退服故障排查
运维·网络·学习·信息与通信·tdd
心之王者71617 小时前
Linux 进程信号:从产生、阻塞到捕捉与子进程回收
linux·服务器·网络