计算机网络 / 系统课时

用epoll跑通一个Echo服务

用epoll跑通一个Echo服务

这一节把监听套接字、accept、连接读写和关闭统一放进一个 epoll 事件循环,得到一个能真实运行的最小 Echo 服务。重点不是业务协议,而是看清监听事件和连接事件如何共存,并用并发客户端验证单线程可以同时管理多条连接。

学习目标

  • 用 epoll_create1、epoll_ctl、epoll_wait 组织监听与连接事件。
  • 正确处理非阻塞 accept、读取、部分写入与连接关闭。
  • 用并发客户端验证多个连接都能收到原样回显。

Echo服务的事件流

服务端只保留一个事件循环,但循环里有两类文件描述符:监听套接字负责产生新连接,已连接套接字负责产生读写事件。监听套接字就绪时反复 accept4,直到返回 EAGAIN;连接可读时接收一块数据,再把同一块数据写回客户端。

epoll Echo 服务事件流

这里使用水平触发模式。每次只读取一块数据也不会丢失后续通知;如果 send 因发送缓冲区已满只写出一部分,就暂时只监听 EPOLLOUT,等剩余数据发完再恢复 EPOLLIN。这同时避免覆盖尚未发完的缓冲区。

实现最小服务器

下面代码面向 Linux,使用非阻塞 socket。每个连接对象只保留一块待回显缓冲区,因此足够展示事件管理和最小背压策略,而不会把协议解析等额外问题混进来。

c
#define _GNU_SOURCE
#include <arpa/inet.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <unistd.h>

#define MAX_EVENTS 128
#define BUF_SIZE 4096

typedef struct {
    int fd;
    size_t used;
    size_t sent;
    char buf[BUF_SIZE];
} Conn;

static void close_conn(int epfd, Conn *c) {
    epoll_ctl(epfd, EPOLL_CTL_DEL, c->fd, NULL);
    close(c->fd);
    free(c);
}

static int set_events(int epfd, Conn *c, uint32_t events) {
    struct epoll_event ev = {.events = events, .data.ptr = c};
    return epoll_ctl(epfd, EPOLL_CTL_MOD, c->fd, &ev);
}

static int flush_echo(int epfd, Conn *c) {
    while (c->sent < c->used) {
        ssize_t n = send(c->fd, c->buf + c->sent,
                         c->used - c->sent, MSG_NOSIGNAL);
        if (n > 0) {
            c->sent += (size_t)n;
            continue;
        }
        if (n < 0 && errno == EINTR) {
            continue;
        }
        if (n < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
            return set_events(epfd, c, EPOLLOUT);
        }
        return -1;
    }

    c->used = 0;
    c->sent = 0;
    return set_events(epfd, c, EPOLLIN);
}

int main(int argc, char **argv) {
    int port = argc > 1 ? atoi(argv[1]) : 9090;
    int lfd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
    if (lfd < 0) {
        perror("socket");
        return 1;
    }

    int yes = 1;
    setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));

    struct sockaddr_in addr = {
        .sin_family = AF_INET,
        .sin_port = htons((uint16_t)port),
        .sin_addr.s_addr = htonl(INADDR_ANY)
    };

    if (bind(lfd, (struct sockaddr *)&addr, sizeof(addr)) < 0 ||
        listen(lfd, SOMAXCONN) < 0) {
        perror("bind/listen");
        close(lfd);
        return 1;
    }

    int epfd = epoll_create1(EPOLL_CLOEXEC);
    if (epfd < 0) {
        perror("epoll_create1");
        close(lfd);
        return 1;
    }

    struct epoll_event listen_ev = {.events = EPOLLIN, .data.ptr = NULL};
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &listen_ev) < 0) {
        perror("epoll_ctl listen");
        close(epfd);
        close(lfd);
        return 1;
    }

    printf("listening on 0.0.0.0:%d\n", port);

    struct epoll_event events[MAX_EVENTS];
    for (;;) {
        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) {
            Conn *c = events[i].data.ptr;

            if (c == NULL) {
                for (;;) {
                    int cfd = accept4(lfd, NULL, NULL,
                                      SOCK_NONBLOCK | SOCK_CLOEXEC);
                    if (cfd < 0) {
                        if (errno == EINTR) continue;
                        if (errno == EAGAIN || errno == EWOULDBLOCK) break;
                        perror("accept4");
                        break;
                    }

                    Conn *new_conn = calloc(1, sizeof(*new_conn));
                    if (new_conn == NULL) {
                        close(cfd);
                        continue;
                    }

                    new_conn->fd = cfd;
                    struct epoll_event ev = {
                        .events = EPOLLIN,
                        .data.ptr = new_conn
                    };
                    if (epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &ev) < 0) {
                        close(cfd);
                        free(new_conn);
                    }
                }
                continue;
            }

            if (events[i].events & (EPOLLERR | EPOLLHUP)) {
                close_conn(epfd, c);
                continue;
            }

            if (events[i].events & EPOLLIN) {
                ssize_t n = recv(c->fd, c->buf, sizeof(c->buf), 0);
                if (n > 0) {
                    c->used = (size_t)n;
                    c->sent = 0;
                    if (flush_echo(epfd, c) < 0) close_conn(epfd, c);
                } else if (n == 0) {
                    close_conn(epfd, c);
                } else if (errno != EINTR &&
                           errno != EAGAIN &&
                           errno != EWOULDBLOCK) {
                    close_conn(epfd, c);
                }
                continue;
            }

            if (events[i].events & EPOLLOUT) {
                if (flush_echo(epfd, c) < 0) close_conn(epfd, c);
            }
        }
    }

    close(epfd);
    close(lfd);
    return 0;
}

预期结果

text
源码可由后续 gcc 命令编译;编译成功后得到 echo_epoll 可执行文件。

这个实现一次只允许每个连接存在一块待发送数据;当写入未完成时暂停该连接的读事件。生产实现通常会使用输出队列,并给每条连接设置内存上限,但这里的结构已经能够正确处理部分写入。

编译并启动

把源码保存为 echo_epoll.c,在 Linux 上执行下面命令。将 <PORT> 替换为实际监听端口,例如 9090。

bash
gcc -O2 -Wall -Wextra echo_epoll.c -o echo_epoll
PORT="<PORT>"
./echo_epoll "$PORT"

预期输出

text
listening on 0.0.0.0:<PORT>

如果编译器提示 accept4 未声明,应确认代码顶部存在 _GNU_SOURCE,并在 Linux/glibc 环境编译。若端口被占用,bind/listen 会报告 Address already in use,更换端口后重新启动即可。

验证多连接并发

保持服务端运行,在另一终端执行并发测试。脚本同时建立 20 条 TCP 连接,每条发送不同文本,并检查收到的内容是否与发送内容完全一致;同样把 <PORT> 替换为实际端口。

bash
PORT="<PORT>" python3 - <<'PY'
import concurrent.futures
import os
import socket

port = int(os.environ["PORT"])

def round_trip(i):
    payload = f"client-{i}\n".encode()
    with socket.create_connection(("127.0.0.1", port), timeout=2) as s:
        s.sendall(payload)
        data = s.recv(1024)
    return data == payload

with concurrent.futures.ThreadPoolExecutor(max_workers=20) as pool:
    results = list(pool.map(round_trip, range(20)))

print(len(results), all(results))
PY

预期输出

text
20 True

这个结果说明 20 条连接都完成了独立的发送与回显。客户端线程只是压测工具;服务端本身仍然只有一个事件循环线程,连接并发来自 epoll 对大量就绪事件的集中等待与逐个处理。

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

目录与阅读设置

阅读设置

17

记录一个想法

用epoll跑通一个Echo服务

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

登录哪都通