poll 解决的是 select 的接口问题,不是性能问题。它把三张位图换成 pollfd 数组,把输入和输出拆成两个字段,于是调用方不必每轮重建名单,也不再有 FD_SETSIZE 这个编译期上限。代价是每次调用仍要把整份数组拷进内核、再逐个扫描。

#include <poll.h>
 
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
 
struct pollfd {
    int   fd;       /* 要监视的文件描述符 */
    short events;   /* 请求的事件,调用方填写 */
    short revents;  /* 返回的事件,内核填写 */
};

nfds 是数组元素个数,不是“最大 fd 加一”。timeout 单位是毫秒,传负数表示无限等待,传 0 表示立刻返回。它按值传递,poll 不会修改这个整数,定义一次就能反复用。

fd 为负的元素会被整条跳过

fd 小于 0 时,events 被忽略,revents 返回 0。这条规则让“删除一个连接”变成“把槽位的 fd 写成 -1”,数组不用搬动。这个槽位仍会参与拷贝和遍历,但它不产生事件。

一个常见误解是把空槽的 events 也清成 0 就完事。真正决定是否监视的是 fd 的正负,不是 events。只清 events、留着旧 fd,等于让内核继续监视一条可能已经关闭的编号。

events 是申请表,revents 是回执

events 由调用方写,revents 由内核写,两个字段不共享内存。这是 poll 和 select 最根本的区别:select 把结果覆写进输入位图,poll 把结果写进另一个字段。

revents 每次调用都会被内核重置并重新填写,调用方不需要手动清零。events 则不会被改动,所以名单可以摆在那里,只有连接增删时才需要动它。

课件在 Loop() 里留了一句注释,说 rfds 是输入输出型参数、每次都要重置。这句话在 select 上成立,在 poll 上不成立。照这句注释把每轮的 events 清 0,poll 收到的就是一张全空的申请表,服务器会安静地不再响应任何事件。

事件位分成两类:

位含义能否写进 events
POLLIN有普通数据可读可以
POLLPRI有紧急数据可读(带外数据)可以
POLLOUT普通数据可写可以
POLLRDNORM普通数据可读(同 POLLIN)可以
POLLRDBAND优先级带数据可读可以
POLLWRNORM普通数据可写(同 POLLOUT)可以
POLLWRBAND优先级带数据可写可以
POLLRDHUP对端关闭了写方向(GNU 扩展)可以
POLLERR发生错误只能回填
POLLHUP连接挂断只能回填
POLLNVALfd 没有打开只能回填

POLLERR、POLLHUP、POLLNVAL 写进 events 会被忽略,但只要条件成立,它们一定会出现在 revents 里。所以判断事件必须按位与,不能写等号:

if (revents & (POLLERR | POLLHUP | POLLNVAL)) {
    /* 先回收连接 */
} else if (revents & POLLIN) {
    /* 再读数据 */
}

课件监控标准输入的示例写的是 if (poll_fd.revents == POLLIN)。如果对端关闭,revents 可能是 POLLIN | POLLHUP,等号判断会漏掉,连接就留在名单里反复被扫描。

POLLHUP 出现时不代表缓冲里没数据。man 手册的说法是:通道里已有的数据全部读完之后,后续 read 才返回 0。所以对端关闭时常见组合是 POLLIN | POLLHUP,先读干净,再按 0 关闭。

返回值是人数,不是下标

poll 返回 revents 非零的元素个数。它不会把就绪元素挪到数组前部,顺序永远是你填的顺序。下面这种写法是错的:

int n = poll(fds, used, -1);
for (int i = 0; i < n; ++i)
    handle(fds[i]);          /* fds[i] 可能什么都没发生 */

n 只说明“有几个元素醒了”,不说明“前 n 个都醒了”。正确做法是遍历整个 used 区间,逐个检查 revents。这使得 poll 的成本始终是 O(n),即使只有一个连接就绪。

没有数量上限,不等于没有成本

poll 去掉了 FD_SETSIZE 的位图限制,数组能开多大只受内存限制。但每次调用仍要把 nfds 个 pollfd 从用户态拷进内核,内核逐个调用底层的 poll 方法,返回时再写回 revents。连接数很大而活跃的很少时,这些空槽的拷贝和扫描全是浪费。

struct pollfd 在 64 位上是 8 字节:int 4 字节,两个 short 各 2 字节。2048 个槽位就是每轮 16 KB,其中可能只有十条连接是活的。想减少浪费,可以在每轮结束后收掉尾部的空槽,但中间的空洞收不掉,除非另外维护空闲槽链表。

POLLOUT 不要常驻。发送缓冲区没满,这个位就一直成立,poll 每轮立刻返回,循环变成空转。只在确实有数据没发完时临时打开 POLLOUT,发完立刻摘掉。

一份能跑的 poll 回显服务器

#define _GNU_SOURCE
 
/* poll_echo.c
 * 编译:gcc -std=c11 -Wall -Wextra poll_echo.c -o poll_echo
 * 运行:./poll_echo,然后 nc 127.0.0.1 8888
 */
#include <arpa/inet.h>
#include <errno.h>
#include <netinet/in.h>
#include <poll.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>
 
#define MAX_CONN 256
 
int main(void)
{
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    if (lfd < 0) {
        perror("socket");
        return 1;
    }
 
    int yes = 1;
    setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));
 
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(8888);
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
 
    if (bind(lfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        perror("bind");
        close(lfd);
        return 1;
    }
    if (listen(lfd, 128) < 0) {
        perror("listen");
        close(lfd);
        return 1;
    }
 
    struct pollfd fds[MAX_CONN];
    for (int i = 0; i < MAX_CONN; ++i) {
        fds[i].fd = -1;
        fds[i].events = 0;
        fds[i].revents = 0;
    }
    fds[0].fd = lfd;
    fds[0].events = POLLIN;
    int used = 1;
 
    for (;;) {
        int n = poll(fds, (nfds_t)used, -1);
        if (n < 0) {
            if (errno == EINTR)
                continue;
            perror("poll");
            break;
        }
 
        for (int i = 0; i < used; ++i) {
            int fd = fds[i].fd;
            short rev = fds[i].revents;
 
            if (fd < 0 || rev == 0)
                continue;
 
            if (rev & (POLLERR | POLLNVAL)) {
                close(fd);
                fds[i].fd = -1;
                fds[i].events = 0;
                continue;
            }
 
            if (fd == lfd) {
                int cfd = accept(lfd, NULL, NULL);
                if (cfd < 0)
                    continue;
 
                int slot = 1;
                while (slot < MAX_CONN && fds[slot].fd != -1)
                    ++slot;
                if (slot == MAX_CONN) {
                    close(cfd);
                    continue;
                }
 
                fds[slot].fd = cfd;
                fds[slot].events = POLLIN;   /* 只登记,不立刻读 */
                if (slot + 1 > used)
                    used = slot + 1;
                continue;
            }
 
            if (rev & POLLIN) {
                char buf[1024];
                ssize_t r = recv(fd, buf, sizeof(buf), 0);
                if (r <= 0) {
                    close(fd);
                    fds[i].fd = -1;
                    fds[i].events = 0;
                    continue;
                }
 
                ssize_t sent = 0;
                while (sent < r) {
                    ssize_t w = send(fd, buf + sent, (size_t)(r - sent), MSG_NOSIGNAL);
                    if (w <= 0)
                        break;
                    sent += w;
                }
 
                if (rev & POLLHUP) {      /* 数据读完之后再回收 */
                    close(fd);
                    fds[i].fd = -1;
                    fds[i].events = 0;
                }
            } else if (rev & POLLHUP) {
                close(fd);
                fds[i].fd = -1;
                fds[i].events = 0;
            }
        }
    }
 
    for (int i = 0; i < used; ++i) {
        if (fds[i].fd >= 0)
            close(fds[i].fd);
    }
    close(lfd);
    return 0;
}

accept 之后只登记、不 recv,这一点课件做对了。accept 只表示握手完成,新连接上有没有数据还不确定;在阻塞 socket 上立刻读,可能把整条事件循环挂在这个新连接上。

课件代码里还有一处必须改:recv(fd, buffer, sizeof(buffer-1), 0)。buffer 是 char[1024],buffer - 1 先退化成指针再减一,sizeof 得到的是指针宽度,x86-64 上是 8。结果每次最多读 8 字节,数据被悄悄截断。正确写法是 sizeof(buffer) - 1。

和 select 的账要对齐

poll 修掉了 select 的两处设计问题:名单不再被结果覆写,也没有 1024 的位图上限。它没修掉的是“每次调用全量拷贝 + 全量扫描”,以及“等待关系只存在于这次调用期间”。

需要纳秒精度超时,或者想在等待时屏蔽一组信号,用 ppoll。它的参数结构和 poll 一样,只是超时换成 timespec,并多一个 sigmask 参数。需要把“每次扫描所有人”变成“只在变化时登记”,才轮到 epoll。