poll 函数原理与 TCP 服务器实现详解

本文将从select函数的缺陷出发，详细介绍poll函数的设计理念、核心参数、使用方法，并通过完整代码实现一个poll版 TCP 服务器，同时对比select与poll的差异，分析poll的优缺点。

前言：从 select 缺陷到 poll 的诞生

select作为早期 I/O 多路复用技术，存在两个核心缺陷，这直接推动了poll函数的出现：

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仅能设置 “输入事件”（如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的超时参数未定义问题）。

1.4 返回值（返回状态）

poll的返回值直接反映调用结果，需根据返回值做不同处理：

1.5 poll 函数简单示例（监视文件可读）

以下代码演示如何用poll监视一个文件是否可读，超时时间 5 秒：

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

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\\n");
} 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\\n", bytes_read, buf);
}
}

close(fd);
return EXIT_SUCCESS;
}

1.6 select 与 poll 的核心差异

二、poll 版 TCP 服务器实现

poll版 TCP 服务器的逻辑与select版类似，核心差异在于用pollfd数组管理 fd，而非fd_set位图。

2.1 整体设计思路

2.2 完整代码实现

1. 工具类：Socket.hpp（封装 socket 操作）

#pragma once
#include <iostream>
#include <string>
#include <unistd.h>
#include <cstring>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <errno.h>

// 错误码定义
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 <iostream>
#include "Socket.hpp"
#include <poll.h>
#include <unistd.h>

// 配置参数
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 <memory> // 智能指针（自动管理内存）

int main() {
// 用智能指针创建服务器对象（避免内存泄漏）
std::unique_ptr<PollServer> 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 服务器测试与运行

三、poll 的优缺点分析

3.1 优点

3.2 缺点

四、总结

poll是select的改进版，核心解决了 “fd 数量上限” 和 “参数耦合” 问题，但其轮询本质未变，仍适用于中低并发场景（如 fd 数量小于 1000）。

若需处理高并发（如上万级连接），需使用 Linux 特有的epoll技术 —— 通过 “事件驱动” 和 “内核维护就绪列表”，避免轮询和频繁数据拷贝，大幅提升效率。

理解poll的设计逻辑，不仅能掌握中并发场景的 I/O 多路复用方案，也为后续学习epoll的优势奠定基础。