计算机网络 / 系统课时
用epoll完成高并发Echo服务
用epoll完成高并发Echo服务
这一节把 Reactor 落到可运行代码:监听 socket 和连接都设为非阻塞,由 epoll 驱动读写;每条连接按需分配输出缓冲区,并通过高低水位实施背压,同时加入空闲超时和统一回收路径。
学习目标
- 用 level-triggered
epoll完成非阻塞 Echo 事件循环 - 用输出缓冲区和高低水位避免慢客户端无限占用内存
- 正确处理半关闭、空闲超时和连接资源释放
Reactor 事件路径
监听器只负责接受连接,新连接注册到同一个 epoll 实例。连接可读时把字节加入待发送缓冲区,随后立即尝试 send;如果内核发送缓冲区已满,就保留剩余数据并订阅 EPOLLOUT。待发送数据达到高水位后暂停 EPOLLIN,降到低水位再恢复。

Echo 没有真正的业务计算,因此本示例不引入工作线程;如果后续加入数据库、压缩或其他阻塞任务,应把业务执行放到独立线程池,但连接对象仍只由所属 I/O 线程修改。
完整实现
下面程序使用 Linux 的 accept4、epoll 和非阻塞 socket。输出缓冲区按需扩容,单连接待发送数据最多 64 KiB;HIGH_WATER 与 LOW_WATER 构成回差,避免在临界点频繁开关读事件。
#define _GNU_SOURCE
#include <errno.h>
#include <netinet/in.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 <time.h>
#include <unistd.h>
#define MAX_EVENTS 1024
#define MAX_FD 100000
#define HIGH_WATER (48 * 1024)
#define LOW_WATER (16 * 1024)
#define MAX_PENDING (64 * 1024)
#define IDLE_TIMEOUT_MS 30000ULL
typedef struct {
int fd;
char *out;
size_t cap;
size_t off;
size_t len;
int read_paused;
int peer_closed;
uint64_t last_active;
} Conn;
static Conn *conns[MAX_FD];
static uint64_t now_ms(void) {
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return (uint64_t)ts.tv_sec * 1000ULL + (uint64_t)ts.tv_nsec / 1000000ULL;
}
static int modify_interest(int epfd, Conn *c) {
struct epoll_event ev = {0};
ev.events = EPOLLRDHUP;
if (!c->read_paused && !c->peer_closed) ev.events |= EPOLLIN;
if (c->len > 0) ev.events |= EPOLLOUT;
ev.data.fd = c->fd;
return epoll_ctl(epfd, EPOLL_CTL_MOD, c->fd, &ev);
}
static void close_conn(int epfd, int fd) {
Conn *c = conns[fd];
if (!c) return;
epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
close(fd);
free(c->out);
free(c);
conns[fd] = NULL;
}
static int add_conn(int epfd, int fd) {
if (fd < 0 || fd >= MAX_FD) return -1;
Conn *c = calloc(1, sizeof(*c));
if (!c) return -1;
c->fd = fd;
c->last_active = now_ms();
conns[fd] = c;
struct epoll_event ev = {0};
ev.events = EPOLLIN | EPOLLRDHUP;
ev.data.fd = fd;
if (epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev) < 0) {
conns[fd] = NULL;
free(c);
return -1;
}
return 0;
}
static int queue_bytes(Conn *c, const char *data, size_t n) {
if (n > MAX_PENDING - c->len) return -1;
/* 已发送前缀占空间时先压紧,避免无意义扩容。 */
if (c->off > 0 && c->off + c->len + n > c->cap) {
memmove(c->out, c->out + c->off, c->len);
c->off = 0;
}
size_t need = c->off + c->len + n;
if (need > c->cap) {
size_t next = c->cap ? c->cap : 4096;
while (next < need && next < MAX_PENDING) next *= 2;
if (next > MAX_PENDING) next = MAX_PENDING;
if (next < need) return -1;
char *p = realloc(c->out, next);
if (!p) return -1;
c->out = p;
c->cap = next;
}
memcpy(c->out + c->off + c->len, data, n);
c->len += n;
return 0;
}
static int handle_read(Conn *c) {
char buf[4096];
for (;;) {
/* 高水位时停止继续读,让 TCP 接收窗口承担上游背压。 */
if (c->len >= HIGH_WATER) {
c->read_paused = 1;
break;
}
size_t room = MAX_PENDING - c->len;
if (room == 0) {
c->read_paused = 1;
break;
}
size_t want = room < sizeof(buf) ? room : sizeof(buf);
ssize_t n = recv(c->fd, buf, want, 0);
if (n > 0) {
if (queue_bytes(c, buf, (size_t)n) < 0) return -1;
c->last_active = now_ms();
continue;
}
if (n == 0) {
c->peer_closed = 1;
break;
}
if (errno == EINTR) continue;
if (errno == EAGAIN || errno == EWOULDBLOCK) break;
return -1;
}
if (c->len >= HIGH_WATER) c->read_paused = 1;
return 0;
}
static int handle_write(Conn *c) {
while (c->len > 0) {
ssize_t n = send(c->fd, c->out + c->off, c->len, MSG_NOSIGNAL);
if (n > 0) {
c->off += (size_t)n;
c->len -= (size_t)n;
c->last_active = now_ms();
continue;
}
if (n == 0) break;
if (errno == EINTR) continue;
if (errno == EAGAIN || errno == EWOULDBLOCK) break;
return -1;
}
if (c->len == 0) c->off = 0;
/* 低水位再恢复读,形成高低水位回差,避免频繁切换事件兴趣。 */
if (c->read_paused && c->len <= LOW_WATER) c->read_paused = 0;
return 0;
}
int main(int argc, char **argv) {
if (argc != 2) {
fprintf(stderr, "usage: %s <port>\n", argv[0]);
return 2;
}
char *end = NULL;
long port_long = strtol(argv[1], &end, 10);
if (!end || *end != '\0' || port_long < 1 || port_long > 65535) {
fprintf(stderr, "invalid port\n");
return 2;
}
int port = (int)port_long;
signal(SIGPIPE, SIG_IGN);
int lfd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
if (lfd < 0) {
perror("socket");
return 1;
}
int one = 1;
setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
struct sockaddr_in addr = {0};
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_ANY);
addr.sin_port = htons((uint16_t)port);
if (bind(lfd, (struct sockaddr *)&addr, sizeof(addr)) < 0 ||
listen(lfd, 4096) < 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 lev = {0};
lev.events = EPOLLIN;
lev.data.fd = lfd;
if (epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &lev) < 0) {
perror("epoll_ctl");
close(epfd);
close(lfd);
return 1;
}
printf("listening on %d\n", port);
fflush(stdout);
struct epoll_event events[MAX_EVENTS];
for (;;) {
int n = epoll_wait(epfd, events, MAX_EVENTS, 1000);
if (n < 0) {
if (errno == EINTR) continue;
perror("epoll_wait");
break;
}
for (int i = 0; i < n; ++i) {
int fd = events[i].data.fd;
uint32_t e = events[i].events;
if (fd == lfd) {
/* 非阻塞监听器必须一直 accept 到 EAGAIN,避免积压连接。 */
for (;;) {
int cfd = accept4(
lfd, NULL, NULL, SOCK_NONBLOCK | SOCK_CLOEXEC
);
if (cfd >= 0) {
if (add_conn(epfd, cfd) < 0) close(cfd);
continue;
}
if (errno == EINTR) continue;
if (errno == EAGAIN || errno == EWOULDBLOCK) break;
perror("accept4");
break;
}
continue;
}
if (fd < 0 || fd >= MAX_FD || !conns[fd]) continue;
Conn *c = conns[fd];
int dead = 0;
if (e & (EPOLLERR | EPOLLHUP)) dead = 1;
if (!dead && (e & EPOLLIN) && handle_read(c) < 0) dead = 1;
if (!dead && (e & EPOLLRDHUP)) c->peer_closed = 1;
/* 有待发送数据时先尝试直接写,写不完再依赖 EPOLLOUT。 */
if (!dead && c->len > 0 && handle_write(c) < 0) dead = 1;
if (!dead) {
if (c->peer_closed && c->len == 0) {
dead = 1;
} else if (modify_interest(epfd, c) < 0) {
dead = 1;
}
}
if (dead) close_conn(epfd, fd);
}
/* 教学版按 fd 扫描空闲连接;生产环境可换成时间轮或最小堆。 */
uint64_t now = now_ms();
for (int fd = 0; fd < MAX_FD; ++fd) {
Conn *c = conns[fd];
if (c && now - c->last_active >= IDLE_TIMEOUT_MS) {
close_conn(epfd, fd);
}
}
}
close(epfd);
close(lfd);
return 1;
}预期结果
源码保存为 echo_server.c 后可由下一节的 gcc 命令编译;启动后进入 epoll 事件循环。这份实现选择 level-triggered 模式,便于把重点放在缓冲、背压和回收。读路径仍会循环到 EAGAIN,这样即使未来切到 edge-triggered,也已经满足“单次事件尽量排空”的基本要求。
编译、运行与验证
将源码保存为 echo_server.c,先编译。
gcc -O2 -Wall -Wextra -std=c11 echo_server.c -o echo_server预期结果
无标准输出;退出码为 0,并生成 echo_server启动时把 <PORT> 替换为实际未占用端口;实际端口值可能不同。
./echo_server <PORT>预期输出
listening on <PORT>保持服务运行,在另一个终端用 Python 标准库发送并接收一条消息,同样先替换 <PORT>。
python3 -c 'import socket; s=socket.create_connection(("127.0.0.1", int("<PORT>"))); s.sendall(b"ping\n"); print(s.recv(5).decode(), end=""); s.close()'预期输出
ping如果需要承载大量连接,还要把进程的文件描述符上限调整到目标规模,并确保 MAX_FD 大于可能出现的文件描述符值;这些容量设置必须和压测目标一起确定。
背压、超时与回收边界
send 返回 EAGAIN 时,未发送字节继续留在连接缓冲区,EPOLLOUT 会在 socket 再次可写时驱动后续发送。待发送数据超过高水位后取消 EPOLLIN,能够把压力逐步传回客户端,而不是继续从内核读出数据并无限占用用户态内存。
EPOLLRDHUP 表示对端关闭写方向。程序先保留已经收到但尚未回写的数据,待缓冲区清空后再关闭连接,避免客户端发送完请求后半关闭写端时丢掉 Echo 响应。所有异常、正常关闭和空闲超时最终都进入 close_conn,因此 epoll、文件描述符和动态缓冲区只需要维护一条释放路径。
教学实现每秒扫描 MAX_FD 槽位查找 30 秒空闲连接,逻辑清楚但不是最高效的超时结构。连接规模很大时,可把这部分替换为时间轮或按到期时间维护的最小堆;输出缓冲区也可以换成对象池或分块缓冲,减少长期连接扩容后的内存驻留。