操作系统 / 系统课时

怎样处理多客户端连接

怎样处理多客户端连接

单客户端 UDS 服务通常在 accept 后直接阻塞读写,但第二个客户端一到就会暴露问题:某个慢连接可能拖住整个进程。本节用 epoll 把监听套接字和多个客户端描述符放进同一事件循环,并明确连接创建、读取和关闭的生命周期。

学习目标

  • 区分监听套接字与已连接套接字在事件循环中的职责。
  • 理解 poll 与 epoll 管理多个客户端时的基本差异。
  • 用非阻塞 epoll 服务处理接受连接、读取数据和断开清理。

从连接生命周期组织状态

一个多客户端 UDS 服务至少同时管理三类对象:监听 fd、epoll 实例和若干客户端 fd。监听 fd 可读表示“有连接待接受”,客户端 fd 可读表示“这个连接有字节可取”,而挂断或错误事件意味着连接需要进入清理流程。

真正容易出错的地方不是调用 epoll_wait,而是生命周期管理:新 fd 必须注册,关闭前要停止继续使用对应状态,读到 EOF 要释放连接资源,应用层若还有半包数据也要一起丢弃。

多客户端 UDS 的 epoll 连接生命周期

选择 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。

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

预期结果

text
程序编译并启动后会打印 listening on /tmp/anystack-uds-epoll.sock,并持续等待客户端事件。

启动并验证两个客户端

把源文件保存为 uds_epoll_server.c,先在一个终端编译并启动服务:

bash
gcc -Wall -Wextra -O2 -o uds_epoll_server uds_epoll_server.c
./uds_epoll_server

预期输出

text
listening on /tmp/anystack-uds-epoll.sock

再在另一个终端运行两个客户端。它们各自建立独立 UDS 连接并发送一条消息:

bash
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

预期输出

text
clients sent 2 messages

服务端随后会看到两个不同连接的接收与关闭记录。fd 数值和两个客户端的事件先后属于运行时动态值,因此实际结果可能不同:

text
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、输入输出缓冲释放和协议状态清理,才能避免旧状态污染新连接。

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

目录与阅读设置

阅读设置

17

记录一个想法

怎样处理多客户端连接

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

登录哪都通