操作系统 / 系统课时
怎样处理多客户端连接
怎样处理多客户端连接
单客户端 UDS 服务通常在 accept 后直接阻塞读写,但第二个客户端一到就会暴露问题:某个慢连接可能拖住整个进程。本节用 epoll 把监听套接字和多个客户端描述符放进同一事件循环,并明确连接创建、读取和关闭的生命周期。
学习目标
- 区分监听套接字与已连接套接字在事件循环中的职责。
- 理解
poll与epoll管理多个客户端时的基本差异。 - 用非阻塞
epoll服务处理接受连接、读取数据和断开清理。
从连接生命周期组织状态
一个多客户端 UDS 服务至少同时管理三类对象:监听 fd、epoll 实例和若干客户端 fd。监听 fd 可读表示“有连接待接受”,客户端 fd 可读表示“这个连接有字节可取”,而挂断或错误事件意味着连接需要进入清理流程。
真正容易出错的地方不是调用 epoll_wait,而是生命周期管理:新 fd 必须注册,关闭前要停止继续使用对应状态,读到 EOF 要释放连接资源,应用层若还有半包数据也要一起丢弃。

选择 poll 还是 epoll
poll 每次调用都提交一组 fd,并由调用方扫描返回的 revents,实现简单,适合连接数不大或跨 Unix 平台的代码。epoll 把关注的 fd 注册到内核对象中,epoll_wait 只返回就绪事件,更适合 Linux 上较多、长期存在的连接。
两者都不能替代应用层连接状态。对于流式套接字,一次可读事件仍可能只有半条消息;服务端必须为每个连接保存输入缓冲和协议解析进度。
本节示例采用非阻塞 fd 和默认的水平触发模式,不设置 EPOLLET。即便如此,接受新连接和读取数据仍循环到 EAGAIN,这样以后切换边沿触发时不容易留下“未排空就不再收到事件”的问题。
完整实现 epoll 多客户端服务
下面的程序监听 /tmp/anystack-uds-epoll.sock。每个新连接都用 accept4 直接设置为非阻塞,并注册 EPOLLIN | EPOLLRDHUP。示例只打印收到的数据,避免把写缓冲管理混进本节;真实服务若需要回包,还应在短写或 EAGAIN 时维护发送缓冲并按需关注 EPOLLOUT。
#define _GNU_SOURCE
#include <errno.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#define SOCKET_PATH "/tmp/anystack-uds-epoll.sock"
#define MAX_EVENTS 32
static volatile sig_atomic_t stop = 0;
static void on_signal(int signo) {
(void)signo;
stop = 1;
}
static void close_client(int epfd, int fd) {
epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
close(fd);
printf("closed fd=%d\n", fd);
}
int main(void) {
signal(SIGINT, on_signal);
unlink(SOCKET_PATH);
int listen_fd = socket(
AF_UNIX,
SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC,
0
);
if (listen_fd < 0) {
perror("socket");
return 1;
}
struct sockaddr_un addr = {0};
addr.sun_family = AF_UNIX;
snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", SOCKET_PATH);
if (bind(listen_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0 ||
listen(listen_fd, 16) < 0) {
perror("bind/listen");
close(listen_fd);
unlink(SOCKET_PATH);
return 1;
}
int epfd = epoll_create1(EPOLL_CLOEXEC);
if (epfd < 0) {
perror("epoll_create1");
close(listen_fd);
unlink(SOCKET_PATH);
return 1;
}
struct epoll_event ev = {
.events = EPOLLIN,
.data.fd = listen_fd
};
if (epoll_ctl(epfd, EPOLL_CTL_ADD, listen_fd, &ev) < 0) {
perror("epoll_ctl listen");
return 1;
}
printf("listening on %s\n", SOCKET_PATH);
struct epoll_event events[MAX_EVENTS];
while (!stop) {
int nready = epoll_wait(epfd, events, MAX_EVENTS, -1);
if (nready < 0) {
if (errno == EINTR) continue;
perror("epoll_wait");
break;
}
for (int i = 0; i < nready; i++) {
int fd = events[i].data.fd;
uint32_t revents = events[i].events;
if (fd == listen_fd) {
for (;;) {
int cfd = accept4(
listen_fd,
NULL,
NULL,
SOCK_NONBLOCK | SOCK_CLOEXEC
);
if (cfd < 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK) break;
if (errno == EINTR) continue;
perror("accept4");
break;
}
struct epoll_event client_ev = {
.events = EPOLLIN | EPOLLRDHUP,
.data.fd = cfd
};
if (epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &client_ev) < 0) {
perror("epoll_ctl client");
close(cfd);
continue;
}
printf("accepted fd=%d\n", cfd);
}
continue;
}
int closed = 0;
if (revents & EPOLLIN) {
for (;;) {
char buf[512];
ssize_t n = read(fd, buf, sizeof(buf));
if (n > 0) {
printf(
"fd=%d bytes=%zd data=%.*s\n",
fd,
n,
(int)n,
buf
);
continue;
}
if (n == 0) {
close_client(epfd, fd);
closed = 1;
break;
}
if (errno == EINTR) continue;
if (errno == EAGAIN || errno == EWOULDBLOCK) break;
perror("read");
close_client(epfd, fd);
closed = 1;
break;
}
}
if (!closed &&
(revents & (EPOLLERR | EPOLLHUP | EPOLLRDHUP))) {
close_client(epfd, fd);
}
}
}
close(epfd);
close(listen_fd);
unlink(SOCKET_PATH);
printf("stopped\n");
return 0;
}预期结果
程序编译并启动后会打印 listening on /tmp/anystack-uds-epoll.sock,并持续等待客户端事件。启动并验证两个客户端
把源文件保存为 uds_epoll_server.c,先在一个终端编译并启动服务:
gcc -Wall -Wextra -O2 -o uds_epoll_server uds_epoll_server.c
./uds_epoll_server预期输出
listening on /tmp/anystack-uds-epoll.sock再在另一个终端运行两个客户端。它们各自建立独立 UDS 连接并发送一条消息:
python3 - <<'PY'
import socket
path = "/tmp/anystack-uds-epoll.sock"
clients = []
for payload in (b"alpha", b"beta"):
s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
s.connect(path)
s.sendall(payload)
clients.append(s)
for s in clients:
s.close()
print("clients sent 2 messages")
PY预期输出
clients sent 2 messages服务端随后会看到两个不同连接的接收与关闭记录。fd 数值和两个客户端的事件先后属于运行时动态值,因此实际结果可能不同:
accepted fd=<ID>
accepted fd=<ID>
fd=<ID> bytes=5 data=alpha
closed fd=<ID>
fd=<ID> bytes=4 data=beta
closed fd=<ID>当连接数继续增加时,不要把业务状态只挂在 fd 数字本身而缺少生命周期约束,因为 fd 关闭后可能被系统复用。实际服务通常维护“fd → 连接对象”的映射,在关闭路径统一完成 epoll_ctl、close、输入输出缓冲释放和协议状态清理,才能避免旧状态污染新连接。