TCP并发服务器与I/O多路复用（select）

在Linux网络编程中，构建一个能够同时处理多个客户端连接的TCP服务器是一个经典问题。传统的单线程服务器在调用accept或recv时会阻塞，导致无法及时响应其他客户端的请求。本文将探讨TCP并发服务器的设计思路，重点介绍I/O多路复用中的select函数，并通过示例代码展示如何利用它实现一个简单的并发服务器。同时，还会补充Linux四种I/O模型的简单示例，帮助理解不同I/O方式的特点。

一、问题：阻塞I/O下的单线程服务器

考虑一个最基本的TCP服务器：

c

// 创建socket、bind、listen…
while (1) {
int client_fd = accept(server_fd, …); // 阻塞直到有连接
char buf[1024];
recv(client_fd, buf, sizeof(buf), 0); // 阻塞等待数据
// 处理数据…
close(client_fd);
}

这个模型存在严重缺陷：

• 如果某个客户端连接后一直不发送数据，recv将一直阻塞，后续的连接请求无法被accept。

• 无法同时处理多个已连接的客户端。

根本原因在于阻塞I/O：当程序执行一个I/O操作（如accept、recv）时，如果数据尚未准备好，进程会被挂起，直到内核完成操作。

二、解决方案概述

为了解决上述问题，通常有两种思路：

在Linux中，I/O多路复用主要有三种实现：select、poll、epoll。

三、Linux的四种I/O模型

在深入select之前，有必要回顾一下Linux下的I/O模型：

下面通过简单的代码示例演示这四种模型的行为。

3.1 阻塞I/O示例

c

#include <stdio.h>
#include <unistd.h>

int main() {
char buf[1024];
printf("阻塞等待输入：\\n");
int n = read(0, buf, sizeof(buf)); // 阻塞，直到有数据
buf[n] = '\\0';
printf("读取到：%s", buf);
return 0;
}

执行后程序停留在read调用处，直到用户输入数据。

3.2 非阻塞I/O示例

c

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>

int main() {
char buf[1024];
int flags = fcntl(0, F_GETFL);
fcntl(0, F_SETFL, flags | O_NONBLOCK); // 设置非阻塞

printf("非阻塞轮询，输入 'quit' 退出\\n");
while (1) {
int n = read(0, buf, sizeof(buf));
if (n > 0) {
buf[n] = '\\0';
printf("读取到：%s", buf);
if (buf[0] == 'q' && buf[1] == 'u' && buf[2] == 'i' && buf[3] == 't')
break;
} else if (errno == EAGAIN) {
// 无数据，做其他事情
printf("无数据，继续轮询…\\n");
sleep(1);
} else {
perror("read error");
break;
}
}
return 0;
}

非阻塞模式下，没有数据时read立即返回-1并置errno为EAGAIN，程序可轮询。

3.3 异步I/O示例（信号驱动）

c

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <string.h>

#define MAX_LEN 1024

void sigio_handler(int sig) {
char buf[MAX_LEN];
int n = read(0, buf, sizeof(buf));
if (n > 0) {
buf[n] = '\\0';
printf("\\n异步收到：%s", buf);
}
}

int main() {
// 设置标准输入为异步模式
int flags = fcntl(0, F_GETFL);
fcntl(0, F_SETFL, flags | O_ASYNC);
fcntl(0, F_SETOWN, getpid()); // 设置接收信号的进程
signal(SIGIO, sigio_handler);

printf("异步I/O示例，输入数据后内核发送SIGIO信号\\n");
while (1) {
printf("主程序做其他事情…\\n");
sleep(2);
}
return 0;
}

当用户输入数据时，内核发送SIGIO信号，进程在信号处理函数中读取数据。

3.4 I/O多路复用示例（select）

c

#include <stdio.h>
#include <sys/select.h>
#include <unistd.h>

int main() {
fd_set readfds;
struct timeval tv;
int ret;

FD_ZERO(&readfds);
FD_SET(0, &readfds); // 监视标准输入

tv.tv_sec = 5; // 超时5秒
tv.tv_usec = 0;

printf("等待输入，超时5秒…\\n");
ret = select(1, &readfds, NULL, NULL, &tv);
if (ret == -1) {
perror("select");
} else if (ret == 0) {
printf("超时，无输入\\n");
} else {
if (FD_ISSET(0, &readfds)) {
char buf[1024];
int n = read(0, buf, sizeof(buf));
buf[n] = '\\0';
printf("读取到：%s", buf);
}
}
return 0;
}

select同时监视标准输入，若有数据则读，否则超时退出。

四、select 函数详解

4.1 函数原型

c

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

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

4.2 参数说明

• nfds：监视的文件描述符中最大数值加1（即 max_fd + 1），用于提高效率。

• readfds：指向可读描述符集合的指针，若某个描述符可读，则对应位被设置。我们通常传入希望监视可读事件的描述符集合。

• writefds：可写描述符集合。

• exceptfds：异常描述符集合。

• timeout：指定等待时间：

  • NULL：无限等待，直到有描述符就绪。

  • 固定时间：等待指定时间，若超时则返回0。

  • 设置为0：立即返回（轮询模式）。

4.3 返回值

• 成功：返回就绪（可读、可写或异常）的文件描述符总数。

• 超时：返回0。

• 出错：返回-1。

4.4 操作 fd_set 的宏

c

void FD_ZERO(fd_set *set); // 清空集合
void FD_SET(int fd, fd_set *set); // 将fd加入集合
void FD_CLR(int fd, fd_set *set); // 将fd从集合中移除
int FD_ISSET(int fd, fd_set *set); // 判断fd是否在集合中（即是否就绪）

五、使用 select 实现 TCP 并发服务器

5.1 设计思路

5.2 示例代码

c

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

#define PORT 8888
#define MAX_CLIENTS 10

int main() {
int listen_fd, client_fd, max_fd, activity, i, valread;
int client_sockets[MAX_CLIENTS] = {0};
struct sockaddr_in server_addr, client_addr;
socklen_t addr_len = sizeof(client_addr);
char buffer[1024];

// 1. 创建监听套接字
if ((listen_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
perror("socket failed");
exit(EXIT_FAILURE);
}

// 设置端口复用
int opt = 1;
setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = INADDR_ANY;
server_addr.sin_port = htons(PORT);

// 2. 绑定
if (bind(listen_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
perror("bind failed");
close(listen_fd);
exit(EXIT_FAILURE);
}

// 3. 监听
if (listen(listen_fd, 3) < 0) {
perror("listen");
close(listen_fd);
exit(EXIT_FAILURE);
}

printf("Listening on port %d\\n", PORT);

fd_set readfds;

while (1) {
FD_ZERO(&readfds);
FD_SET(listen_fd, &readfds);
max_fd = listen_fd;

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

// 等待事件
activity = select(max_fd + 1, &readfds, NULL, NULL, NULL);
if (activity < 0 && errno != EINTR) {
perror("select error");
break;
}

// 处理新连接
if (FD_ISSET(listen_fd, &readfds)) {
client_fd = accept(listen_fd, (struct sockaddr *)&client_addr, &addr_len);
if (client_fd < 0) {
perror("accept");
continue;
}
printf("新连接: fd=%d, ip=%s, port=%d\\n",
client_fd, inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

for (i = 0; i < MAX_CLIENTS; i++) {
if (client_sockets[i] == 0) {
client_sockets[i] = client_fd;
break;
}
}
}

// 处理客户端数据
for (i = 0; i < MAX_CLIENTS; i++) {
int sd = client_sockets[i];
if (FD_ISSET(sd, &readfds)) {
valread = read(sd, buffer, sizeof(buffer) – 1);
if (valread == 0) {
// 客户端关闭连接
getpeername(sd, (struct sockaddr *)&client_addr, &addr_len);
printf("客户端断开: ip=%s, port=%d\\n",
inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
close(sd);
client_sockets[i] = 0;
} else {
buffer[valread] = '\\0';
printf("收到: %s", buffer);
send(sd, buffer, valread, 0); // 回显
}
}
}
}

close(listen_fd);
return 0;
}

5.3 关键点说明

• 使用 client_sockets 数组保存所有已连接的客户端套接字。

• 每次调用 select 前重新构造 readfds，并计算 max_fd。

• 根据 FD_ISSET 判断是监听套接字就绪（新连接）还是客户端套接字就绪（数据可读）。

• 当客户端关闭连接时，read 返回0，此时关闭套接字并从数组中清除。

六、select 的优缺点

优点

• 跨平台性好（几乎所有Unix-like系统都支持）。

• 接口简单，易于理解。

缺点

• 单个进程可监视的文件描述符数量受 FD_SETSIZE 限制（通常为1024）。

• 每次调用 select 都需要将整个 fd_set 从用户态拷贝到内核态，开销随描述符数量增加而增大。

• 返回后需要遍历所有描述符来检查哪些就绪，效率较低。

七、总结

通过 select 实现I/O多路复用，我们可以用单线程管理多个TCP连接，有效避免了阻塞I/O带来的并发问题。尽管 select 有性能瓶颈，但它是理解多路复用模型的基础。掌握它之后，再学习 epoll 等高阶机制将更加容易。

同时，通过对比阻塞、非阻塞、异步和多路复用四种I/O模型的简单示例，可以更清晰地理解每种模型的工作原理和适用场景。在实际开发中，可根据需求选择合适的并发模型。