poll 函数原理与 TCP 服务器实现详解
本文将从
select函数的缺陷出发，详细介绍poll函数的设计理念、核心参数、使用方法，并通过完整代码实现一个poll版 TCP 服务器，同时对比select与poll的差异，分析poll的优缺点。前言：从 select 缺陷到 poll 的诞生
select作为早期 I/O 多路复用技术，存在两个核心缺陷，这直接推动了poll函数的出现：
- 文件描述符（fd）数量上限：
select依赖fd_set位图结构（内核固定大小），默认上限通常为 1024（需修改内核参数才能调整），超过则报错。- 参数输入输出耦合：
select的fd_set既是输入参数（指定要监视的 fd），也是输出参数（标记就绪的 fd）。每次调用select前，需重新初始化fd_set，导致用户态频繁遍历和拷贝，增加额外开销。
poll函数针对这两个缺陷做了改进：
- 突破 fd 数量上限（理论无限制，仅受系统资源约束）；
- 分离输入与输出参数（通过
pollfd结构体的events和revents字段），无需每次调用前重新设置监视 fd。但需注意：
poll与select的核心逻辑一致—— 均通过轮询检测 fd 状态，效率随 fd 数量增加而线性下降。
一、poll 函数核心解析
poll函数的功能与select完全一致：监视并等待多个文件描述符的状态变化，仅关注 I/O 过程中的 “等待” 阶段。
1.1 核心参数：struct pollfd 数组
select使用位图（fd_set）管理 fd，而poll通过pollfd结构体数组管理，每个结构体对应一个待监视的 fd 及其事件。
pollfd 结构体定义
struct pollfd {
int fd; // 待监视的文件描述符（如socket、管道、普通文件）
short events; // 输入参数：用户要监视的事件（位掩码）
short revents; // 输出参数：内核返回的就绪事件（位掩码，用户无需初始化）
};
关键事件宏定义
events（输入）和revents（输出）均通过位掩码表示事件，支持多种事件的组合（用|运算符）。
| 事件宏 | 含义（events 输入 /revents 输出） | 对应 select 功能 |
|---|---|---|
| POLLIN | 有数据可读（普通 / 优先数据） | 读事件（FD_SET 读集合） |
| POLLRDNORM | 有普通数据可读 | - |
| POLLRDBAND | 有优先数据可读 | - |
| POLLPRI | 有高优先级数据可读（如带外数据） | - |
| POLLOUT | 写操作不会阻塞（普通 / 优先数据） | 写事件（FD_SET 写集合） |
| POLLWRNORM | 写普通数据不会阻塞 | - |
| POLLWRBAND | 写优先数据不会阻塞 | - |
| POLLMSG | 有 SIGPOLL 消息可用 | - |
| POLLERR | 输出专属：fd 发生错误 | 异常事件 |
| POLLHUP | 输出专属：fd 发生挂起（如客户端断开连接） | 异常事件 |
| POLLNVAL | 输出专属：fd 非法（如未打开） | 异常事件 |
使用规则：
events仅能设置 “输入事件”（如POLLIN、POLLOUT），设置POLLERR等输出事件无意义；revents由内核填充，可能包含events中的事件，也可能包含POLLERR等异常事件；- 事件组合示例：监视 fd “可读且可写”，需设置
events = POLLIN | POLLOUT； - 事件判断示例：判断 fd 是否可读，需检查
revents & POLLIN（非 0 则就绪）。
1.2 参数二：nfds（数组大小）
nfds表示pollfd数组中有效元素的数量，类型为nfds_t（通常是unsigned int或unsigned long的别名，取决于系统）。
作用：告诉内核需要遍历的pollfd结构体数量，避免内核访问数组越界。
示例：若pollfd数组为fds[2]，则nfds = 2（或通过sizeof(fds)/sizeof(fds[0])计算）。
1.3 参数三：timeout（超时时间）
timeout指定poll的阻塞时长，单位为毫秒，是纯输入参数（无select的超时参数未定义问题）。
| timeout 取值 | 含义 |
|---|---|
| -1 | 无限阻塞，直到有 fd 就绪或被信号中断 |
| 0 | 非阻塞模式，立即返回（无论是否有 fd 就绪） |
| >0 | 阻塞timeout毫秒，超时后返回（无 fd 就绪） |
1.4 返回值（返回状态）
poll的返回值直接反映调用结果，需根据返回值做不同处理：
| 返回值 | 含义 | 后续操作 |
|---|---|---|
| -1 | 调用失败（如 fd 非法、内存不足） | 检查errno（如 EBADF、EINTR），处理错误 |
| 0 | 超时（无任何 fd 就绪） | 无需处理 fd，可重新调用poll |
| >0 | 就绪 fd 的数量（revents非 0 的结构体个数） | 遍历pollfd数组，处理revents非 0 的 fd |
1.5 poll 函数简单示例（监视文件可读）
以下代码演示如何用poll监视一个文件是否可读，超时时间 5 秒：
#include
#include
#include
#include
#include
int main() {
// 以只读模式打开文件（需确保test.txt存在）
int fd = open("test.txt", O_RDONLY);
if (fd < 0) {
perror("Failed to open file");
return EXIT_FAILURE;
}
// 初始化pollfd结构体（监视fd的可读事件）
struct pollfd fds[1];
fds[0].fd = fd;
fds[0].events = POLLIN; // 关注可读事件
fds[0].revents = 0; // 输出参数，可省略初始化（内核会覆盖）
int timeout = 5000; // 超时5秒
int ret = poll(fds, 1, timeout);
if (ret == -1) {
perror("poll failed");
close(fd);
return EXIT_FAILURE;
} else if (ret == 0) {
printf("No data within 5 seconds
");
} else if (fds[0].revents & POLLIN) {
// 读取文件内容并打印
char buf[1024] = {0};
ssize_t bytes_read = read(fd, buf, sizeof(buf) - 1);
if (bytes_read > 0) {
printf("Read %zd bytes: %s
", bytes_read, buf);
}
}
close(fd);
return EXIT_SUCCESS;
}
1.6 select 与 poll 的核心差异
| 对比维度 | select | poll |
|---|---|---|
| fd 数量限制 | 有（默认 1024，需改内核） | 无（仅受系统资源约束） |
| 参数耦合性 | 输入输出耦合（fd_set 需重新初始化） | 输入输出分离（events 输入，revents 输出） |
| 效率（fd 多时） | 低（需遍历位图到最大 fd） | 略高（仅遍历有效 pollfd 数组） |
| 超时精度 | 微秒级（struct timeval） | 毫秒级（int） |
| 可移植性 | 高（所有 Unix 系统支持） | 中（部分嵌入式系统不支持） |
| 异常事件处理 | 需单独监视异常集合（如 FD_SET 异常位） | 自动在 revents 返回（POLLERR、POLLHUP） |
二、poll 版 TCP 服务器实现
poll版 TCP 服务器的逻辑与select版类似，核心差异在于用pollfd数组管理 fd，而非fd_set位图。
2.1 整体设计思路
- 初始化监听 socket：创建、绑定、监听端口；
- 管理 pollfd 数组：将监听 socket 加入数组，设置监视事件（
POLLIN）； - 循环调用 poll：阻塞等待 fd 就绪，处理超时、错误、就绪三种情况；
- 事件处理：
- 监听 socket 就绪：调用
accept接受新连接，将新 socket 加入pollfd数组； - 通信 socket 就绪：调用
read读取客户端数据，处理断开连接或错误。
- 监听 socket 就绪：调用
2.2 完整代码实现
1. 工具类：Socket.hpp（封装 socket 操作）
#pragma once
#include
#include
#include
#include
#include
#include
#include
#include
// 错误码定义
enum {
SocketErr = 2,
BindErr,
ListenErr
};
const int backlog = 10; // 监听队列长度
class Sock {
public:
Sock() : sockfd_(-1) {}
~Sock() {}
// 创建socket（TCP）
void Socket() {
sockfd_ = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd_ < 0) {
perror("socket error");
exit(SocketErr);
}
// 允许端口复用（解决服务器重启时端口占用问题）
int opt = 1;
setsockopt(sockfd_, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
}
// 绑定端口
void Bind(uint16_t port) {
struct sockaddr_in local;
memset(&local, 0, sizeof(local));
local.sin_family = AF_INET;
local.sin_port = htons(port);
local.sin_addr.s_addr = INADDR_ANY; // 绑定所有网卡IP
if (bind(sockfd_, (struct sockaddr*)&local, sizeof(local)) < 0) {
perror("bind error");
exit(BindErr);
}
}
// 监听端口
void Listen() {
if (listen(sockfd_, backlog) < 0) {
perror("listen error");
exit(ListenErr);
}
}
// 接受新连接（返回新socket，输出客户端IP和端口）
int Accept(std::string* clientip, uint16_t* clientport) {
struct sockaddr_in peer;
socklen_t len = sizeof(peer);
int newfd = accept(sockfd_, (struct sockaddr*)&peer, &len);
if (newfd < 0) {
perror("accept error");
return -1;
}
// 转换客户端IP（网络字节序→主机字节序）
char ipstr[64] = {0};
inet_ntop(AF_INET, &peer.sin_addr, ipstr, sizeof(ipstr));
*clientip = ipstr;
*clientport = ntohs(peer.sin_port);
return newfd;
}
// 关闭socket
void Close() {
if (sockfd_ != -1) {
close(sockfd_);
sockfd_ = -1;
}
}
// 获取socket文件描述符
int Fd() const { return sockfd_; }
private:
int sockfd_; // 封装的socket fd
};
2. 服务器类：PollServer.hpp
#pragma once
#include
#include "Socket.hpp"
#include
#include
// 配置参数
const uint16_t default_port = 8877;
const std::string default_ip = "0.0.0.0";
const int default_fd = -1;
const int fd_num_max = 64; // pollfd数组最大长度（可自定义扩容）
const int non_event = 0; // 无事件标记
class PollServer {
public:
PollServer(uint16_t port = default_port, const std::string& ip = default_ip)
: port_(port), ip_(ip) {
// 初始化pollfd数组（全部设为无效fd）
for (int i = 0; i < fd_num_max; ++i) {
event_fds_[i].fd = default_fd;
event_fds_[i].events = non_event;
event_fds_[i].revents = non_event;
}
}
~PollServer() {
listensock_.Close(); // 关闭监听socket
}
// 初始化服务器（创建、绑定、监听）
bool Init() {
listensock_.Socket();
listensock_.Bind(port_);
listensock_.Listen();
std::cout << "Server init success! Port: " << port_ << std::endl;
return true;
}
// 启动服务器（核心循环）
void Start() {
// 将监听socket加入pollfd数组（下标0）
int listen_fd = listensock_.Fd();
event_fds_[0].fd = listen_fd;
event_fds_[0].events = POLLIN; // 监视监听socket的可读事件
int timeout = 3000; // 超时3秒
while (true) {
int ret = poll(event_fds_, fd_num_max, timeout);
switch (ret) {
case -1: // 调用失败
perror("poll error");
break;
case 0: // 超时
std::cout << "Poll timeout (3s)..." << std::endl;
break;
default: // 有fd就绪
std::cout << "Found " << ret << " ready fd(s)!" << std::endl;
HandlerEvent(); // 处理就绪事件
break;
}
}
}
private:
// 处理就绪事件（遍历pollfd数组）
void HandlerEvent() {
for (int i = 0; i < fd_num_max; ++i) {
int fd = event_fds_[i].fd;
if (fd == default_fd) continue; // 跳过无效fd
// 检查是否有可读事件（或异常事件）
if (event_fds_[i].revents & (POLLIN | POLLERR | POLLHUP)) {
if (fd == listensock_.Fd()) {
// 监听socket就绪：接受新连接
Accept();
} else {
// 通信socket就绪：读取数据
Receiver(fd, i);
}
}
}
}
// 接受新连接（将新socket加入pollfd数组）
void Accept() {
std::string client_ip;
uint16_t client_port;
int new_fd = listensock_.Accept(&client_ip, &client_port);
if (new_fd < 0) return;
// 找到pollfd数组中的空位
int i = 1; // 下标0留给监听socket
for (; i < fd_num_max; ++i) {
if (event_fds_[i].fd == default_fd) break;
}
if (i == fd_num_max) {
// 数组满：关闭新连接（可扩展为动态扩容）
std::cout << "Server full! Close new connection (fd: " << new_fd << ")" << std::endl;
close(new_fd);
} else {
// 加入数组：监视可读事件
event_fds_[i].fd = new_fd;
event_fds_[i].events = POLLIN;
event_fds_[i].revents = non_event;
std::cout << "New connection: " << client_ip << ":" << client_port << " (fd: " << new_fd << ")" << std::endl;
PrintOnlineFds(); // 打印在线fd列表
}
}
// 读取客户端数据（处理断开和错误）
void Receiver(int fd, int idx) {
char buf[1024] = {0};
ssize_t n = read(fd, buf, sizeof(buf) - 1);
if (n > 0) {
// 读取成功：打印数据
std::cout << "Received from fd " << fd << ": " << buf << std::endl;
} else if (n == 0) {
// 客户端主动断开连接
std::cout << "Client fd " << fd << " disconnected" << std::endl;
close(fd);
event_fds_[idx].fd = default_fd; // 标记为无效fd
PrintOnlineFds();
} else {
// 读取错误（如连接重置）
perror(("Read error on fd " + std::to_string(fd)).c_str());
close(fd);
event_fds_[idx].fd = default_fd;
PrintOnlineFds();
}
}
// 打印当前在线的文件描述符
void PrintOnlineFds() {
std::cout << "Online fds: ";
for (int i = 0; i < fd_num_max; ++i) {
if (event_fds_[i].fd != default_fd) {
std::cout << event_fds_[i].fd << " ";
}
}
std::cout << std::endl;
}
private:
uint16_t port_; // 服务器端口
std::string ip_; // 服务器IP（默认0.0.0.0）
Sock listensock_; // 监听socket
struct pollfd event_fds_[fd_num_max]; // pollfd数组（管理所有待监视fd）
};
3.服务器的main函数：Main.cc
#include "PollServer.hpp"
#include // 智能指针（自动管理内存）
int main() {
// 用智能指针创建服务器对象（避免内存泄漏）
std::unique_ptr server(new PollServer(8877));
if (!server->Init()) {
std::cerr << "Server init failed!" << std::endl;
return 1;
}
// 启动服务器（进入核心循环）
server->Start();
return 0;
}
4. 编译脚本：Makefile
# 生成服务器可执行文件
poll_server: main.cc
g++ -o $@ $^ -std=c++11 -Wall # -Wall显示警告，增强代码健壮性
# 清理生成的文件
.PHONY: clean
clean:
rm -rf poll_server
2.3 服务器测试与运行
- 编译运行：
bash
make # 编译生成poll_server ./poll_server # 启动服务器 - 客户端连接（用
telnet或nc工具）：bash
telnet 127.0.0.1 8877 # 连接本地服务器 - 测试效果：
- 客户端输入数据，服务器会打印 “Received from fd XXX: 数据内容”；
- 客户端断开连接，服务器会移除该 fd 并更新在线列表；
- 3 秒无事件时，服务器打印 “Poll timeout (3s)...”。
三、poll 的优缺点分析
3.1 优点
- 突破 fd 数量限制：
pollfd数组大小由用户自定义（如示例中fd_num_max=64，可根据需求扩容），无select的 1024 上限； - 输入输出分离：
events（输入）和revents（输出）分离，无需每次调用poll前重新初始化监视 fd，减少用户态开销； - 异常事件自动返回：无需像
select那样单独监视 “异常集合”，内核会在revents中自动标记POLLERR（错误）、POLLHUP（挂起）等异常，简化代码； - fd 效率更高：
select需遍历到位图中的最大 fd，而poll仅遍历pollfd数组中的有效元素，fd 值较大时效率更优。
3.2 缺点
- 轮询机制效率低：
poll与select一样，需遍历所有监视的 fd 才能确定就绪状态，当 fd 数量庞大（如上万）时，遍历开销急剧增加，效率线性下降； - 用户态需维护数组：需手动管理
pollfd数组（如寻找空位、标记无效 fd），代码复杂度略高于select； - 数据拷贝开销：每次调用
poll时，pollfd数组需从用户态拷贝到内核态，fd 数量越多，拷贝开销越大； - 无事件驱动机制：无法像
epoll那样 “主动通知” 就绪 fd，只能被动轮询，高并发场景下性能不足。
四、总结
poll是select的改进版，核心解决了 “fd 数量上限” 和 “参数耦合” 问题，但其轮询本质未变，仍适用于中低并发场景（如 fd 数量小于 1000）。
若需处理高并发（如上万级连接），需使用 Linux 特有的epoll技术 —— 通过 “事件驱动” 和 “内核维护就绪列表”，避免轮询和频繁数据拷贝，大幅提升效率。
理解poll的设计逻辑，不仅能掌握中并发场景的 I/O 多路复用方案，也为后续学习epoll的优势奠定基础。
