Linux poll 多路复用详解：select 的改进与局限

struct pollfd {
    int fd;       /* 要监控的文件描述符 */
    short events; /* 关注的事件（输入参数）*/
    short revents;/* 实际发生的事件（输出参数）*/
};

events 和 revents 的取值：

关键设计：events 和 revents 分开！

• events：你设置，告诉内核你关注什么（输入）
• revents：内核设置，告诉你实际发生了什么（输出）

poll 返回后，events 不会被修改，只有 revents 被更新。这解决了 select 每次要重建集合的问题：你只需要检查 revents，而 events 始终保持你的设置，下次调用时不需要重新赋值（但 revents 需要清零）。

2.3 参数详解

• 参数 fds：pollfd 结构体数组的首地址，每个元素对应一个要监控的 fd。
• 参数 nfds：fds 数组的长度，即监控的 fd 数量。
• 参数 timeout：超时时间（毫秒）。

2.4 返回值

int ret = poll(fds, nfds, timeout);
// ret > 0：就绪的 fd 数量
// ret == 0：超时
// ret < 0：出错，查 errno

三、poll vs select：对比分析

3.1 数据结构对比

select 的位图方式：
fd_set：[bit0, bit1, bit2, ..., bit1023] 最多 1024 个 fd

poll 的 pollfd 数组：
pollfd[0]：{fd=3, events=POLLIN, revents=0}
pollfd[1]：{fd=5, events=POLLIN|POLLOUT, revents=0}
pollfd[2]：{fd=7, events=POLLIN, revents=0}
... 数组大小由用户决定，理论上无上限

poll 就像把 select 的位图升级成了一个更富有表达力的结构体数组。每个 fd 的信息自成一体，不需要在三个独立的位图之间查找。

3.2 使用方式对比

select 的使用（每次循环都很麻烦）：

// select：每次循环必须重建三个 fd_set
for(;;){
    fd_set readfds, writefds;
    FD_ZERO(&readfds);
    FD_ZERO(&writefds);
    for(int i = 0; i < n; i++)
        FD_SET(fds[i],&readfds);
    select(max_fd + 1,&readfds,&writefds,NULL,&timeout);
    // 检查结果
    for(int i = 0; i < n; i++){
        if(FD_ISSET(fds[i],&readfds)){
            /* 处理 */
        }
    }
}

poll 的使用（清晰多了）：

// poll：只需要清零 revents，events 保持不变
struct pollfd pfds[MAX_FDS];
// 初始化一次就好：
pfds[0]={fd1, POLLIN, 0};
pfds[1]={fd2, POLLIN | POLLOUT, 0};
for(;;){
    // 清零所有 revents（可选，但推荐）
    for(int i = 0; i < n; i++)
        pfds[i].revents = 0;
    poll(pfds, n,-1);
    // 检查结果
    for(int i = 0; i < n; i++){
        if(pfds[i].revents & POLLIN){
            /* 处理读 */
        }
        if(pfds[i].revents & POLLOUT){
            /* 处理写 */
        }
    }
}

3.3 优缺点总结

poll 相比 select 的优点：

poll 与 select 共同的缺点（核心性能问题）：

结论：poll 是 select 的改良版，解决了接口设计问题和数量限制，但没有从根本上解决性能问题。当连接数成千上万时，poll 和 select 都会因为 O(n) 遍历而性能下降。

四、poll 执行过程图解

4.1 一次 poll 调用的完整流程

用户态 内核态
|||
初始化 pollfd 数组
pfds[0]={3, POLLIN, 0}
pfds[1]={5, POLLIN, 0}
pfds[2]={7, POLLIN, 0}
||||
poll(pfds, 3, -1)
--- 拷贝 3 个 pollfd 到内核 --->
||||
(程序阻塞在 poll)
轮询每个 fd 的状态
fd=3：未就绪
fd=5：就绪！(有数据)
fd=7：未就绪
||||
设置就绪的 revents:
pfds[1].revents = POLLIN
||
<--- 返回 1（1 个 fd 就绪）-----
||||
检查 pfds[i].revents
pfds[1].revents & POLLIN → 处理 fd=5

五、最简单的 poll 示例

5.1 使用 poll 监控标准输入

#include <stdio.h>
#include <unistd.h>
#include <poll.h>

int main(){
    // 定义一个 pollfd，监控标准输入（fd=0）
    struct pollfd poll_fd;
    poll_fd.fd = 0;
    poll_fd.events = POLLIN; // 关注可读事件
    poll_fd.revents = 0;
    
    for(;;){
        // 超时 1000ms（1 秒）
        int ret = poll(&poll_fd, 1, 1000);
        if(ret < 0){
            perror("poll");
            continue;
        }
        if(ret == 0){
            printf("poll timeout（1 秒内无输入）\n");
            continue;
        }
        // 检查是否有读事件就绪
        if(poll_fd.revents & POLLIN){
            char buf[1024]={0};
            read(0, buf,sizeof(buf)-1);
            printf("stdin: %s", buf);
        }
        // 清零 revents，为下一轮做准备（poll 不会自动清零）
        poll_fd.revents = 0;
    }
    return 0;
}

运行效果：

• 1 秒内没有输入 → 打印 "poll timeout"
• 有输入 → 打印输入内容

六、完整的 PollServer 实现

6.1 设计思路

用 poll 实现服务器，核心思路和 select 版本一样：

1. 维护一个 pollfd 数组，代替 select 的 fd_set
2. 用 -1 标记"这个槽位空闲"（因为 poll 数组可能有空洞）
3. 新连接来了，找一个空闲槽位放入；连接断开，把那个槽位标记为 -1

教学版使用阻塞 socket + poll，适合短消息；生产环境通常配合 非阻塞 fd + 发送缓冲，避免慢连接在 send() 上阻塞整个事件循环。

pollfd 数组的管理：
[0]: {listensock, POLLIN, 0} ← 监听 socket，一直在
[1]: {fd=4, POLLIN, 0} ← 客户端 A
[2]: {-1, 0, 0} ← 空闲槽位
[3]: {fd=6, POLLIN, 0} ← 客户端 B
[4]: {-1, 0, 0} ← 空闲槽位

6.2 完整代码

// poll_server.hpp
#pragma once
#include <iostream>
#include <string>
#include <memory>
#include <poll.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <cerrno>
#include <cstring>

const static int g_default_port = 8888;
const static int g_backlog = 8;
const static int g_max_fds = 1024; // pollfd 数组的初始大小

/**
 * 简单的 TCP Socket 封装（复用自上一篇）
 */
class TcpSocket{
public:
    TcpSocket(int fd = -1):fd_(fd){}
    int GetFd() const{return fd_;}
    bool Build(int port){
        fd_ = socket(AF_INET, SOCK_STREAM, 0);
        if(fd_ < 0) return false;
        int opt = 1;
        setsockopt(fd_, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = INADDR_ANY;
        if(bind(fd_, (struct sockaddr*)&addr, sizeof(addr)) < 0) return false;
        if(listen(fd_, g_backlog) < 0) return false;
        return true;
    }
    int AcceptConnection(std::string* ip = nullptr, uint16_t* port = nullptr){
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        int sock = accept(fd_, (struct sockaddr*)&peer, &len);
        if(sock < 0) return -1;
        if(ip) *ip = inet_ntoa(peer.sin_addr);
        if(port) *port = ntohs(peer.sin_port);
        return sock;
    }
    int GetSockFd() const{return fd_;}
private:
    int fd_;
};

/**
 * 基于 poll 的 TCP 服务器
 */
class PollServer{
public:
    PollServer(int port = g_default_port):
        _port(port),
        _listen_sock(std::make_unique<TcpSocket>()),
        _is_running(false),
        _num(g_max_fds){}

    void InitServer(){
        // 初始化监听 socket
        if(!_listen_sock->Build(_port)){
            perror("build listen socket failed");
            exit(1);
        }
        printf("[PollServer] 服务器初始化完成，监听端口 %d\n", _port);
        // 初始化 pollfd 数组
        _rfds = new struct pollfd[_num];
        for(int i = 0; i < _num; i++){
            _rfds[i].fd = -1; // -1 表示空闲槽位
            _rfds[i].events = 0;
            _rfds[i].revents = 0;
        }
        // 把监听 socket 放入数组第 0 号位
        _rfds[0].fd = _listen_sock->GetSockFd();
        _rfds[0].events = POLLIN;
    }

    void Loop(){
        _is_running = true;
        while(_is_running){
            PrintDebug();
            int timeout = -1; // 永久阻塞
            int n = poll(_rfds, _num, timeout);
            switch(n){
                case 0: printf("[PollServer] poll 超时\n"); break;
                case -1: perror("poll error"); break;
                default: // 有 n 个 fd 就绪
                    HandleEvent(n); break;
            }
        }
        _is_running = false;
    }

    void Stop(){
        _is_running = false;
    }

    ~PollServer(){
        delete[] _rfds;
    }

private:
    /**
     * 处理就绪事件
     */
    void HandleEvent(int ready_count){
        for(int i = 0; i < _num; i++){
            if(_rfds[i].fd == -1) continue; // 跳过空闲槽位
            int fd = _rfds[i].fd;
            short revents = _rfds[i].revents;
            // 只处理读就绪事件
            if(!(revents & POLLIN)) continue;
            
            if(fd == _listen_sock->GetSockFd()){
                // 监听 socket 就绪：有新连接
                HandleNewConnection();
            } else {
                // 普通 socket 就绪：有数据可读
                HandleData(i, fd);
            }
            // 清零 revents（poll 不会自动清零）
            _rfds[i].revents = 0;
        }
    }

    /**
     * 处理新连接
     */
    void HandleNewConnection(){
        std::string client_ip;
        uint16_t client_port;
        int sock = _listen_sock->AcceptConnection(&client_ip, &client_port);
        if(sock == -1){
            perror("accept error");
            return;
        }
        printf("[PollServer] 新连接：%s:%d, fd=%d\n", client_ip.c_str(), client_port, sock);
        // 在 pollfd 数组中找一个空闲槽位
        int pos = FindEmptySlot();
        if(pos == -1){
            // 数组满了，可以扩容或拒绝
            printf("[PollServer] 服务器已满，拒绝连接 fd=%d\n", sock);
            close(sock);
            return;
        }
        // 将新连接加入 pollfd 数组
        _rfds[pos].fd = sock;
        _rfds[pos].events = POLLIN;
        _rfds[pos].revents = 0;
        printf("[PollServer] fd=%d 加入监控，位置 pos=%d\n", sock, pos);
    }

    /**
     * 处理普通连接的数据
     */
    void HandleData(int pos, int fd){
        char buffer[1024]={0};
        ssize_t n = recv(fd, buffer, sizeof(buffer)-1, 0);
        if(n > 0){
            // 正常数据
            buffer[n]='\0';
            printf("[PollServer] fd=%d 收到：%s\n", fd, buffer);
            // 简单的回显服务：原样返回
            std::string response = std::string("服务器收到：") + buffer;
            send(fd, response.c_str(), response.size(), 0);
        } else if(n == 0){
            // 客户端正常关闭
            printf("[PollServer] fd=%d 正常断开\n", fd);
            CloseConnection(pos);
        } else {
            // 出错
            if(errno != EINTR){
                perror("recv error");
                printf("[PollServer] fd=%d 出错，关闭\n", fd);
                CloseConnection(pos);
            }
        }
    }

    /**
     * 关闭连接，清理 pollfd 槽位
     */
    void CloseConnection(int pos){
        close(_rfds[pos].fd);
        _rfds[pos].fd = -1;
        _rfds[pos].events = 0;
        _rfds[pos].revents = 0;
    }

    /**
     * 在数组中找第一个空闲槽位（fd == -1）
     */
    int FindEmptySlot(){
        for(int i = 1; i < _num; i++){
            // 从 1 开始，0 是 listen_sock
            if(_rfds[i].fd == -1){
                return i;
            }
        }
        return -1; // 没有空闲槽位
    }

    /**
     * 打印当前监控的 fd 列表（调试用）
     */
    void PrintDebug(){
        printf("[PollServer] 当前监控的 fd：");
        for(int i = 0; i < _num; i++){
            if(_rfds[i].fd != -1){
                printf("%d ", _rfds[i].fd);
            }
        }
        printf("\n");
    }

private:
    int _port;
    std::unique_ptr<TcpSocket> _listen_sock;
    bool _is_running;
    struct pollfd* _rfds; // pollfd 数组
    int _num; // 数组大小
};

主函数：

// poll_main.cc
#include "poll_server.hpp"

int main(int argc, char* argv[]){
    int port = (argc > 1) ? atoi(argv[1]) : g_default_port;
    PollServer server(port);
    server.InitServer();
    server.Loop();
    return 0;
}

编译运行：

# 编译
g++ -std=c++14 poll_main.cc -o poll_server
# 运行（监听 8888 端口）
./poll_server 8888
# 另一个终端测试
nc 127.0.0.1 8888
hello world

6.3 关键实现细节解析

1. 为什么用 -1 标记空闲槽位？

poll 传入的是一个数组，内核会遍历 [0, nfds) 的每个元素。如果一个槽位不再使用但没有清理，内核会继续处理它，可能会产生意外行为。

用 fd = -1 标记空闲，poll 会自动忽略 fd 为负数的 pollfd（POSIX 标准保证），这是一个优雅的处理方式。

// poll 的行为：fd < 0 的元素会被忽略，revents 保持 0
// 所以可以安全地在数组中留下 fd = -1 的元素

2. events 不会被修改，但 revents 不会自动清零

// poll 返回后：
// events：不变，始终是你设置的关注事件
// revents：被内核设置为实际发生的事件
// 需要注意：revents 在下一次 poll 前应该清零
// 否则上次的结果会干扰判断
_rfds[i].revents = 0; // 处理完事件后清零

3. 扩容逻辑（生产环境应考虑）

// 当数组满了时，可以扩容
void Expand(){
    int new_num = _num * 2;
    struct pollfd* new_fds = new struct pollfd[new_num];
    // 拷贝旧数组内容
    memcpy(new_fds, _rfds, _num * sizeof(struct pollfd));
    // 初始化新增部分
    for(int i = _num; i < new_num; i++){
        new_fds[i].fd = -1;
        new_fds[i].events = 0;
        new_fds[i].revents = 0;
    }
    delete[] _rfds;
    _rfds = new_fds;
    _num = new_num;
    printf("[PollServer] 扩容至 %d 个槽位\n", _num);
}

七、select vs poll vs epoll 完整对比

7.1 三者对比总结（重要，面试必背）

7.2 性能对比直觉

假设服务器有 10000 个连接，每次只有 10 个有数据：
select/poll 的工作：
- 每次拷贝 10000 个 fd 信息到内核
- 内核遍历 10000 个 fd，找到 10 个就绪的
- 再拷贝回用户态
- O(10000) 的工作量

epoll 的工作：
- 内核维护红黑树，新 fd 只需注册一次
- 有数据时通过回调直接加入就绪队列
- epoll_wait 只返回 10 个就绪的 fd
- epoll_wait 返回就绪列表，遍历成本与就绪数 k 相关（O(k)），避免每次全量扫描 n 个 fd。
连接数越多，差距越大

八、poll 的使用场景与选择建议

8.1 什么时候选 poll 而不是 select？

• 需要监控超过 1024 个 fd（虽然现在这种场景更应该用 epoll）
• 代码已经用了 select，且 fd 数量接近上限，需要简单升级
• 目标平台不支持 epoll（非 Linux 系统）

8.2 什么时候应该直接用 epoll 而不是 poll？

• 连接数超过几百个
• 需要高并发性能
• 在 Linux 系统上开发

决策树：
要监控多个 fd？
→ 连接数少（<100）且需要跨平台？ → 用 select
→ 不需要跨平台，Linux 系统？ → 直接用 epoll（跳过 poll）
→ 需要跨平台，连接数中等？ → 用 poll

九、常见问题解答

9.1 poll 能同时监控读和写吗？

可以，在 events 中同时设置 POLLIN | POLLOUT：

pfds[i].events = POLLIN | POLLOUT; // 同时关注读和写
// poll 返回后
if(pfds[i].revents & POLLIN){
    /* 有数据可读 */
}
if(pfds[i].revents & POLLOUT){
    /* 发送缓冲区有空间 */
}

实践建议：不要一直开启 POLLOUT 监控。发送缓冲区通常都有空间，POLLOUT 几乎总是就绪，这样 poll 会不停返回，浪费 CPU。只在发送缓冲区满了、数据没发完的时候才开启 POLLOUT 监控，发完了再关掉。

9.2 poll 超时精度如何？

poll 的 timeout 参数单位是毫秒，精度受系统时钟分辨率影响，通常精度在 10ms 级别。如果需要更高精度（微秒级），需要使用 epoll_wait 或者其他高精度定时器。

9.3 POLLHUP 和 POLLERR 需要手动监控吗？

不需要。POLLHUP（挂断）和 POLLERR（错误）不需要在 events 中设置，内核会自动在 revents 中设置它们，即使你的 events 没有包含这两个标志。

// 不需要：
// pfds[i].events = POLLIN | POLLERR | POLLHUP;
// 只需要：
pfds[i].events = POLLIN;
// poll 返回后，POLLERR 和 POLLHUP 也可能被设置在 revents 中
if(pfds[i].revents & POLLERR){
    /* 处理错误 */
}
if(pfds[i].revents & POLLHUP){
    /* 对端关闭 */
}

十、总结

10.1 核心要点

10.2 记忆技巧

poll = select 的升级版：
select 的位图 → poll 的 pollfd 结构体
1024 上限 → 无上限（数组大小由你定）
三个集合混乱 → 一个结构体，events/revents 分离

但 poll 没解决的：
每次全量拷贝到内核 → epoll 来解决
O(n) 遍历找就绪 fd → epoll 来解决

总结：poll 是 select 的进化版，核心改进是用 pollfd 结构体替代位图，消除了 fd 数量上限，让接口更清晰。但 O(n) 遍历和每次全量拷贝的性能问题依然存在。下一篇，我们终于要进入重头戏——epoll，它用红黑树 + 就绪队列 + 回调机制彻底解决了这两个问题，并引入了 LT/ET 两种工作模式。epoll 是 Linux 高性能服务器的基石，也是面试最高频的考点，务必吃透。