C / C++ / 系统课时

用 select 监听多个连接

用 select 监听多个连接

一个 TCP 服务端如果为每个连接都顺序调用阻塞式 read,就可能被某个暂时没有数据的客户端卡住。select 的作用是先等待一组文件描述符中的“就绪事件”,再只处理真正可读的监听套接字和客户端连接。

学习目标

  • 理解 fd_set、最高文件描述符和 select 返回值各自的职责。
  • 使用 select 同时处理新连接、客户端数据和连接关闭。
  • 避免直接复用被 select 修改过的描述符集合。

select 的核心模型

服务端通常维护一个长期存在的 master 集合,其中放入监听套接字和所有已接收的客户端套接字。每轮循环先复制出 ready,再把副本传给 select。调用阻塞期间,内核等待至少一个描述符满足条件;返回后,ready 中只保留本轮已经就绪的描述符。

select 监听多个连接的就绪处理流程

select 的第一个参数不是描述符数量,而是“当前最大 fd + 1”。返回值表示本轮就绪描述符的数量,因此返回后只需检查集合中哪些 fd 仍被 FD_ISSET 标记。监听套接字可读通常意味着可以 accept;已连接套接字可读则意味着有数据可收,或者对端已经关闭连接。

完整服务器示例

下面的程序监听 127.0.0.1:9090,把监听套接字和所有客户端连接放进同一个读集合。客户端发来的内容会被服务器原样回显;当 recv 返回 0 时,说明对端完成了有序关闭,此时移除并关闭该 fd。

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

static int 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) {
            if (errno == EINTR) {
                continue;
            }
            return -1;
        }
        if (n == 0) {
            return -1;
        }
        sent += (size_t)n;
    }
    return 0;
}

int main(void) {
    /* 先创建并配置监听套接字。 */
    int listener = socket(AF_INET, SOCK_STREAM, 0);
    if (listener < 0) {
        perror("socket");
        return EXIT_FAILURE;
    }

    int reuse = 1;
    if (setsockopt(listener, SOL_SOCKET, SO_REUSEADDR,
                   &reuse, sizeof(reuse)) < 0) {
        perror("setsockopt");
        close(listener);
        return EXIT_FAILURE;
    }

    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(9090);
    addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

    if (bind(listener, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        perror("bind");
        close(listener);
        return EXIT_FAILURE;
    }
    if (listen(listener, 16) < 0) {
        perror("listen");
        close(listener);
        return EXIT_FAILURE;
    }

    signal(SIGPIPE, SIG_IGN);

    /* master 保存长期关注的所有读事件,ready 只用于单轮 select。 */
    fd_set master;
    FD_ZERO(&master);
    FD_SET(listener, &master);
    int maxfd = listener;

    printf("listening on 127.0.0.1:9090\n");

    for (;;) {
        /* select 会改写集合,因此每轮都从 master 复制工作集合。 */
        fd_set ready = master;

        int count = select(maxfd + 1, &ready, NULL, NULL, NULL);
        if (count < 0) {
            if (errno == EINTR) {
                continue;
            }
            perror("select");
            break;
        }

        for (int fd = 0; fd <= maxfd && count > 0; ++fd) {
            if (!FD_ISSET(fd, &ready)) {
                continue;
            }
            --count;

            if (fd == listener) {
                /* 监听套接字可读表示至少有一个连接等待 accept。 */
                int client = accept(listener, NULL, NULL);
                if (client < 0) {
                    perror("accept");
                    continue;
                }
                if (client >= FD_SETSIZE) {
                    close(client);
                    continue;
                }

                FD_SET(client, &master);
                if (client > maxfd) {
                    maxfd = client;
                }
                printf("client connected: fd=%d\n", client);
                continue;
            }

            /* 已连接套接字可读:读取数据,或识别对端关闭。 */
            char buf[1024];
            ssize_t n = recv(fd, buf, sizeof(buf), 0);
            if (n == 0) {
                printf("client closed: fd=%d\n", fd);
                close(fd);
                FD_CLR(fd, &master);
            } else if (n < 0) {
                if (errno != EINTR) {
                    perror("recv");
                    close(fd);
                    FD_CLR(fd, &master);
                }
            } else {
                printf("fd=%d read %zd bytes\n", fd, n);
                if (send_all(fd, buf, (size_t)n) < 0) {
                    perror("send");
                    close(fd);
                    FD_CLR(fd, &master);
                }
            }
        }
    }

    for (int fd = 0; fd <= maxfd; ++fd) {
        if (FD_ISSET(fd, &master)) {
            close(fd);
        }
    }
    return EXIT_SUCCESS;
}

预期结果

text
程序成功启动后阻塞在 select;有客户端连接或发送数据时,只处理对应的就绪 fd。

编译并启动服务端:

bash
cc -std=c11 -Wall -Wextra -pedantic select_server.c -o select_server
./select_server

预期输出

text
listening on 127.0.0.1:9090

另开一个终端发送数据:

bash
printf 'hello\n' | nc 127.0.0.1 9090

预期输出

text
hello

服务端会同时看到连接、读取和关闭事件;其中 fd 数字由操作系统分配,实际值可能不同:

text
client connected: fd=<ID>
fd=<ID> read 6 bytes
client closed: fd=<ID>

事件循环里最容易出错的地方

第一类错误是把 master 直接传给 select。第一次返回后,未就绪的 fd 会被清掉,下一轮就再也监听不到它们。正确做法始终是“主集合长期保存,工作集合每轮复制”。

第二类错误是忘记在连接关闭后同时执行 close(fd) 和 FD_CLR(fd, &master)。只关闭而不清集合,后续 select 可能遇到无效描述符;只清集合而不关闭,则会泄漏内核资源。

第三类边界来自 FD_SETSIZE。典型 Linux 用户态实现中它通常是 1024,FD_SET 不能安全接收超出该范围的 fd。示例在 accept 后主动检查并关闭过大的描述符,这也是 select 不适合大规模连接的重要原因之一。

什么时候适合使用 select

select 很适合教学、小型工具、连接数较少且需要兼容传统 POSIX 环境的程序。它把“等待事件”和“处理事件”分开后,已经能避免单个客户端阻塞整个服务器。

当连接数明显增大时,每轮都要复制集合并从 0 扫描到 maxfd,成本会逐渐上升;再加上 FD_SETSIZE 的限制,Linux 高并发服务通常会继续选择 poll 或 epoll。

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

目录与阅读设置

阅读设置

17

记录一个想法

用 select 监听多个连接

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

登录哪都通