8. select I/O复用：使用select()同时监控多个socket，实现单线程并发

大家好，我是你们的老朋友。今天我们来聊聊网络编程里一个非常经典的话题——select I/O复用。

说实话，我刚入行那会儿，写网络程序都是“一个客户端一个线程”的搞法。那时候机器配置不高，连接数一上来，线程切换的开销能把CPU干到100%。后来我师父跟我说：“你小子试试select吧，一个线程就能管几百个socket。”我当时还不信，直到自己动手写了一遍……嗯，真香。

8.1 为什么需要I/O复用？

先想一个问题：你写一个TCP服务器，要同时跟多个客户端通信。最朴素的做法是什么？

• 方案A：阻塞式——accept一个连接，然后recv，等这个客户端发完数据，才能处理下一个。这显然不行，一个客户端卡住，其他全得排队。
• 方案B：多线程/多进程——来一个客户端就开一个线程。连接少还行，连接一多（比如上千个），线程调度、上下文切换、内存占用……服务器直接崩给你看。

那有没有一种办法，让一个线程同时盯着多个socket？有，这就是I/O复用。说白了，就是让内核帮我们“盯着”一堆文件描述符，哪个有数据来了，就通知我们处理哪个。

8.2 select() 函数详解

select是I/O复用中最基础的一个系统调用。它的原型长这样：

#include <sys/select.h>
#include <sys/time.h>

int select(int nfds, 
           fd_set *readfds, 
           fd_set *writefds,
           fd_set *exceptfds, 
           struct timeval *timeout);

参数看着多，其实不难理解：

参数	含义
nfds	要监控的最大文件描述符 + 1。比如你监控fd 3、5、7，那nfds就是8。
readfds	要监控“可读”事件的fd集合。有数据来了，这个集合里的fd会被标记。
writefds	要监控“可写”事件的fd集合。一般用于非阻塞写。
exceptfds	要监控“异常”事件的fd集合。用得少，比如带外数据。
timeout	超时时间。NULL表示一直等，直到有事件；0表示立即返回（轮询）。

8.3 fd_set 操作宏

fd_set是一个位图结构，每个bit对应一个文件描述符。我们不能直接操作位图，必须用下面这几个宏：

FD_ZERO(fd_set *set);      // 清空集合
FD_SET(int fd, fd_set *set);  // 把fd加入集合
FD_CLR(int fd, fd_set *set);  // 把fd从集合移除
FD_ISSET(int fd, fd_set *set); // 判断fd是否在集合中（有事件）

注意：select返回后，readfds、writefds、exceptfds会被内核修改——只保留有事件发生的fd。所以每次调用select前，都得重新把要监控的fd加进去。

8.4 完整示例：单线程并发echo服务器

下面这个例子，是我当年学习select时写的第一个完整程序。它实现了一个echo服务器——客户端发什么，服务器就原样返回什么。但关键是，它只用了一个线程，就能同时服务多个客户端。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/select.h>

#define PORT 8888
#define MAX_CLIENTS 10
#define BUFFER_SIZE 1024

int main() {
    int server_fd, client_fd, max_fd, activity, i, valread;
    struct sockaddr_in address;
    int addrlen = sizeof(address);
    char buffer[BUFFER_SIZE] = {0};
    
    // 1. 创建监听socket
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }
    
    // 设置socket选项，避免"Address already in use"
    int opt = 1;
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) {
        perror("setsockopt");
        exit(EXIT_FAILURE);
    }
    
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);
    
    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }
    
    if (listen(server_fd, 3) < 0) {
        perror("listen");
        exit(EXIT_FAILURE);
    }
    
    printf("服务器启动，监听端口 %d\n", PORT);
    
    // 2. 准备客户端socket数组
    int client_sockets[MAX_CLIENTS];
    for (i = 0; i < MAX_CLIENTS; i++) {
        client_sockets[i] = 0;
    }
    
    // 3. 主循环：select + 处理事件
    while (1) {
        fd_set readfds;
        FD_ZERO(&readfds);
        
        // 把监听socket加入集合
        FD_SET(server_fd, &readfds);
        max_fd = server_fd;
        
        // 把已连接的客户端socket加入集合
        for (i = 0; i < MAX_CLIENTS; i++) {
            int sd = client_sockets[i];
            if (sd > 0) {
                FD_SET(sd, &readfds);
            }
            if (sd > max_fd) {
                max_fd = sd;
            }
        }
        
        // 4. 调用select —— 阻塞等待事件
        activity = select(max_fd + 1, &readfds, NULL, NULL, NULL);
        
        if ((activity < 0) && (errno != EINTR)) {
            perror("select error");
        }
        
        // 5. 检查监听socket是否有新连接
        if (FD_ISSET(server_fd, &readfds)) {
            if ((client_fd = accept(server_fd, (struct sockaddr *)&address, 
                                    (socklen_t*)&addrlen)) < 0) {
                perror("accept");
                continue;
            }
            
            printf("新客户端连接: %s:%d\n", 
                   inet_ntoa(address.sin_addr), ntohs(address.sin_port));
            
            // 把新客户端加入数组
            for (i = 0; i < MAX_CLIENTS; i++) {
                if (client_sockets[i] == 0) {
                    client_sockets[i] = client_fd;
                    break;
                }
            }
            
            // 如果连接数达到上限，拒绝
            if (i == MAX_CLIENTS) {
                printf("连接数已满，拒绝新连接\n");
                close(client_fd);
            }
        }
        
        // 6. 检查每个客户端socket是否有数据
        for (i = 0; i < MAX_CLIENTS; i++) {
            int sd = client_sockets[i];
            
            if (FD_ISSET(sd, &readfds)) {
                // 读取数据
                valread = read(sd, buffer, BUFFER_SIZE);
                
                if (valread == 0) {
                    // 客户端断开连接
                    printf("客户端断开: fd=%d\n", sd);
                    close(sd);
                    client_sockets[i] = 0;
                } else {
                    // 原样返回（echo）
                    buffer[valread] = '\0';
                    printf("收到: %s", buffer);
                    send(sd, buffer, valread, 0);
                }
            }
        }
    }
    
    return 0;
}

8.5 代码逻辑拆解

这段代码的核心逻辑，我画了一张流程图，方便你理解：

流程其实不复杂：

1. 创建监听socket，绑定端口，开始监听。
2. 进入主循环，每次循环开始前，把要监控的所有socket（监听socket + 客户端socket）加入fd_set。
3. 调用select，让内核告诉我们哪些socket有事件。
4. 如果是监听socket有事件，说明有新客户端连接，调用accept接收。
5. 如果是客户端socket有事件，说明有数据来了，调用read/recv读取。
6. 如果read返回0，说明客户端断开，关闭socket并从数组移除。

8.6 select的优缺点

用了这么多年select，我总结一下它的优缺点：

优点	缺点
跨平台性好，几乎所有Unix/Linux都支持	监控的fd数量有限制（默认1024，可改但麻烦）
编程模型简单，容易理解	每次调用都要把fd_set从用户态拷贝到内核态，效率低
超时控制灵活	返回后需要遍历所有fd才能知道哪些有事件（O(n)复杂度）
适合连接数不多的场景（几百个以内）	fd_set是位图，修改后需要重新设置

8.7 避坑指南

最后，分享几个我当年写select程序时踩过的坑：

• 忘记重置fd_set： 每次调用select前，必须重新FD_ZERO然后FD_SET。select会修改集合，只保留有事件的fd。
• max_fd计算错误： nfds参数是最大fd+1，不是fd的数量。我见过有人传了fd的数量进去，结果select一直不返回。
• 信号中断： select被信号中断时会返回-1，errno设为EINTR。如果你不想处理信号，可以忽略这个错误继续循环。
• 客户端断开不处理： read返回0时一定要close并移除fd，否则select会一直认为这个fd有事件，导致CPU空转。

好了，select I/O复用就讲到这里。你把这个例子跑一遍，再自己改改（比如加上写监控、超时处理），基本就掌握select的精髓了。下一章我们会聊poll，它解决了select的一些痛点，但核心思想是一样的。

---

公众号:蓝海资料掘金营，微信deep3321