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

1.4 返回值处理

poll 的返回值直接反映调用结果：

1.5 简单示例：监视文件可读

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

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

int main() {
    int fd = open("test.txt", O_RDONLY);
    if (fd < 0) {
        perror("Failed to open file");
        return EXIT_FAILURE;
    }

    struct pollfd fds[1];
    fds[0].fd = fd;
    fds[0].events = POLLIN;
    fds[0].revents = 0;

    int ret = poll(fds, 1, 5000); // 超时 5 秒
    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 整体设计思路

1. 初始化监听 socket：创建、绑定、监听端口；
2. 管理 pollfd 数组：将监听 socket 加入数组，设置监视事件（POLLIN）；
3. 循环调用 poll：阻塞等待 fd 就绪，处理超时、错误、就绪三种情况；
4. 事件处理：监听 socket 就绪接受新连接，通信 socket 就绪读取数据或处理断开。

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() {}

    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;
        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);
        }
    }

    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;
        }
        char ipstr[64] = {0};
        inet_ntop(AF_INET, &peer.sin_addr, ipstr, sizeof(ipstr));
        *clientip = ipstr;
        *clientport = ntohs(peer.sin_port);
        return newfd;
    }

    void Close() {
        if (sockfd_ != -1) {
            close(sockfd_);
            sockfd_ = -1;
        }
    }

    int Fd() const { return sockfd_; }

private:
    int sockfd_;
};

2. 服务器类：PollServer.hpp

核心逻辑，维护 pollfd 数组并处理事件循环。

#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;
const int non_event = 0;

class PollServer {
public:
    PollServer(uint16_t port = default_port, const std::string& ip = default_ip)
        : port_(port), ip_(ip) {
        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(); }

    bool Init() {
        listensock_.Socket();
        listensock_.Bind(port_);
        listensock_.Listen();
        std::cout << "Server init success! Port: " << port_ << std::endl;
        return true;
    }

    void Start() {
        int listen_fd = listensock_.Fd();
        event_fds_[0].fd = listen_fd;
        event_fds_[0].events = POLLIN;
        int timeout = 3000;

        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:
                    std::cout << "Found " << ret << " ready fd(s)!" << std::endl;
                    HandlerEvent();
                    break;
            }
        }
    }

private:
    void HandlerEvent() {
        for (int i = 0; i < fd_num_max; ++i) {
            int fd = event_fds_[i].fd;
            if (fd == default_fd) continue;

            if (event_fds_[i].revents & (POLLIN | POLLERR | POLLHUP)) {
                if (fd == listensock_.Fd()) {
                    Accept();
                } else {
                    Receiver(fd, i);
                }
            }
        }
    }

    void Accept() {
        std::string client_ip;
        uint16_t client_port;
        int new_fd = listensock_.Accept(&client_ip, &client_port);
        if (new_fd < 0) return;

        int i = 1;
        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." << 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 << std::endl;
            PrintOnlineFds();
        }
    }

    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;
            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_;
    Sock listensock_;
    struct pollfd event_fds_[fd_num_max];
};

3. 主函数：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

.PHONY: clean
clean:
	rm -rf poll_server

2.3 测试与运行

编译运行后，可用 telnet 或 nc 连接本地服务器测试。

telnet 127.0.0.1 8877

若 3 秒无事件，服务器会打印超时信息；有新连接时会更新在线 fd 列表。

三、Poll 的优缺点分析

3.1 优点

1. 突破 fd 数量限制：pollfd 数组大小由用户自定义，无 select 的 1024 上限；
2. 输入输出分离：events 和 revents 分离，无需每次调用前重新初始化；
3. 异常事件自动返回：内核会在 revents 中自动标记 POLLERR、POLLHUP 等异常；
4. fd 效率更高：仅遍历有效 pollfd 数组，fd 值较大时优于 select。

3.2 缺点

1. 轮询机制效率低：需遍历所有监视的 fd，当 fd 数量庞大时效率线性下降；
2. 用户态需维护数组：需手动管理 pollfd 数组，代码复杂度略高于 select；
3. 数据拷贝开销：每次调用 poll 时，数组需从用户态拷贝到内核态；
4. 无事件驱动机制：无法像 epoll 那样主动通知，高并发场景下性能不足。

四、总结

poll 是 select 的改进版，核心解决了 fd 数量上限和参数耦合问题，但其轮询本质未变，仍适用于中低并发场景。若需处理高并发，建议使用 Linux 特有的 epoll 技术。理解 poll 的设计逻辑，也为后续学习 epoll 的优势奠定基础。