操作系统 / 系统课时

用 poll 去掉描述符上限依赖

用 poll 去掉描述符上限依赖

当连接数开始超过 select 的固定集合边界时,可以把监听目标改成动态 pollfd 数组。本篇用一个可运行的回显服务器演示 poll 的管理方式,并明确它解决了什么,以及它仍然保留的线性扫描成本。

学习目标

  • 使用 struct pollfd 动态维护监听套接字与客户端连接
  • 正确区分 events 兴趣掩码与 revents 就绪结果
  • 说明 poll 相比 select 去掉的限制,以及仍然存在的扩展性瓶颈

poll 如何表示动态连接集合

select 把描述符压进固定大小的位图,并要求调用者反复准备集合;poll 改为传入一段 struct pollfd 数组。数组长度由程序自己管理,因此不再受 FD_SETSIZE 这种固定集合大小直接约束。

一个 pollfd 同时携带描述符、关注事件和返回事件:

c
struct pollfd {
    int fd;
    short events;
    short revents;
};

这里是结构定义片段示例,来自系统头文件的等价表示;实际程序应直接包含 <poll.h>,不要自行重复定义。

events 是调用前写入的兴趣掩码,例如 POLLIN;revents 由内核在 poll 返回时填写。把某一项的 fd 设为负数,可以暂时让 poll 忽略它。

poll 动态数组与线性扫描关系

用动态 pollfd 数组实现回显服务器

下面的服务器把第 0 项固定为监听套接字,其余项保存客户端连接;容量不够时使用 realloc 扩容。客户端关闭后,用数组最后一项覆盖空位,避免长期留下洞。

c
#include <arpa/inet.h>
#include <errno.h>
#include <poll.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <unistd.h>

#define PORT 8080
#define INITIAL_CAPACITY 16
#define BUFFER_SIZE 1024

static int create_listener(void) {
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    if (fd < 0) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    int yes = 1;
    if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) < 0) {
        perror("setsockopt");
        exit(EXIT_FAILURE);
    }

    struct sockaddr_in addr = {
        .sin_family = AF_INET,
        .sin_port = htons(PORT),
        .sin_addr.s_addr = htonl(INADDR_ANY)
    };

    if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        perror("bind");
        exit(EXIT_FAILURE);
    }
    if (listen(fd, SOMAXCONN) < 0) {
        perror("listen");
        exit(EXIT_FAILURE);
    }
    return fd;
}

static void send_all(int fd, const char *buf, size_t len) {
    size_t sent = 0;
    while (sent < len) {
        ssize_t n = send(fd, buf + sent, len - sent, 0);
        if (n > 0) {
            sent += (size_t)n;
        } else if (n < 0 && errno == EINTR) {
            continue;
        } else {
            break;
        }
    }
}

int main(void) {
    signal(SIGPIPE, SIG_IGN);
    int listen_fd = create_listener();

    nfds_t capacity = INITIAL_CAPACITY;
    nfds_t nfds = 1;
    struct pollfd *fds = calloc(capacity, sizeof(*fds));
    if (fds == NULL) {
        perror("calloc");
        return EXIT_FAILURE;
    }

    fds[0].fd = listen_fd;
    fds[0].events = POLLIN;
    printf("poll server listening on 0.0.0.0:%d\\n", PORT);

    for (;;) {
        int ready = poll(fds, nfds, -1);
        if (ready < 0) {
            if (errno == EINTR) {
                continue;
            }
            perror("poll");
            break;
        }

        if (fds[0].revents & POLLIN) {
            int client_fd = accept(listen_fd, NULL, NULL);
            if (client_fd >= 0) {
                if (nfds == capacity) {
                    capacity *= 2;
                    struct pollfd *grown = realloc(fds, capacity * sizeof(*fds));
                    if (grown == NULL) {
                        close(client_fd);
                        perror("realloc");
                        break;
                    }
                    fds = grown;
                }
                fds[nfds].fd = client_fd;
                fds[nfds].events = POLLIN;
                nfds++;
            }
        }

        for (nfds_t i = 1; i < nfds; ++i) {
            short revents = fds[i].revents;
            int remove_client = 0;

            if (revents & (POLLERR | POLLNVAL)) {
                remove_client = 1;
            } else if (revents & POLLIN) {
                char buf[BUFFER_SIZE];
                ssize_t n = recv(fds[i].fd, buf, sizeof(buf), 0);
                if (n <= 0) {
                    remove_client = 1;
                } else {
                    send_all(fds[i].fd, buf, (size_t)n);
                }
            }

            if (revents & POLLHUP) {
                remove_client = 1;
            }
            if (remove_client) {
                close(fds[i].fd);
                fds[i] = fds[nfds - 1];
                nfds--;
                i--;
            }
        }
    }

    for (nfds_t i = 0; i < nfds; ++i) {
        close(fds[i].fd);
    }
    free(fds);
    return EXIT_FAILURE;
}

预期结果:将源码保存为 poll_server.c 后,可由下方命令正常编译并进入事件循环。

在 Linux 上编译并启动:

bash
gcc -std=c11 -Wall -Wextra -O2 poll_server.c -o poll_server
./poll_server

预期输出:

text
poll server listening on 0.0.0.0:8080

另开终端,用一个短连接客户端发送并接收回显:

bash
python3 -c "import socket; s=socket.create_connection(('127.0.0.1', 8080)); s.sendall(b'hello poll\\n'); s.shutdown(socket.SHUT_WR); print(s.recv(1024).decode(), end=''); s.close()"

预期输出:

text
hello poll

端口 8080 被占用时,应先释放该端口或修改源码中的 PORT。

读懂 poll 的一次循环

每次循环有三个关键动作。程序先把当前 pollfd 数组和长度交给 poll;内核等待至少一个事件满足条件;返回后,程序仍需遍历客户端项,通过 revents 找出真正就绪的描述符。

因此,poll 改善的是集合表示和可维护性,不是把扫描成本消失掉。即使只有 1 个连接活跃,只要数组里保存了 10 万个连接,用户态仍要检查大量 revents 项;调用时也需要让内核处理这组描述符。

和 select 比较时要看清边界

维度 select poll
集合表示 fd_set 位图 pollfd 数组
固定 FD_SETSIZE 依赖 有 无
关注事件 通过多个集合表达 每项 events
就绪结果 集合被改写 写入每项 revents
大集合扫描 需要 仍需要

poll 仍受进程可打开文件数、内存和系统资源限制,所以“去掉描述符上限依赖”并不等于连接数无限。示例为突出事件 API 使用了阻塞套接字;实际高并发服务还要处理非阻塞 I/O、写缓冲和背压。当大量连接长期空闲而只有少数活跃时,更适合选择直接返回就绪项的 epoll。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

用 poll 去掉描述符上限依赖

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通