计算机网络 / 系统课时
用epoll跑通一个Echo服务
用epoll跑通一个Echo服务
这一节把监听套接字、accept、连接读写和关闭统一放进一个 epoll 事件循环,得到一个能真实运行的最小 Echo 服务。重点不是业务协议,而是看清监听事件和连接事件如何共存,并用并发客户端验证单线程可以同时管理多条连接。
学习目标
- 用
epoll_create1、epoll_ctl、epoll_wait组织监听与连接事件。 - 正确处理非阻塞
accept、读取、部分写入与连接关闭。 - 用并发客户端验证多个连接都能收到原样回显。
Echo服务的事件流
服务端只保留一个事件循环,但循环里有两类文件描述符:监听套接字负责产生新连接,已连接套接字负责产生读写事件。监听套接字就绪时反复 accept4,直到返回 EAGAIN;连接可读时接收一块数据,再把同一块数据写回客户端。

这里使用水平触发模式。每次只读取一块数据也不会丢失后续通知;如果 send 因发送缓冲区已满只写出一部分,就暂时只监听 EPOLLOUT,等剩余数据发完再恢复 EPOLLIN。这同时避免覆盖尚未发完的缓冲区。
实现最小服务器
下面代码面向 Linux,使用非阻塞 socket。每个连接对象只保留一块待回显缓冲区,因此足够展示事件管理和最小背压策略,而不会把协议解析等额外问题混进来。
#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;
}预期结果
源码可由后续 gcc 命令编译;编译成功后得到 echo_epoll 可执行文件。这个实现一次只允许每个连接存在一块待发送数据;当写入未完成时暂停该连接的读事件。生产实现通常会使用输出队列,并给每条连接设置内存上限,但这里的结构已经能够正确处理部分写入。
编译并启动
把源码保存为 echo_epoll.c,在 Linux 上执行下面命令。将 <PORT> 替换为实际监听端口,例如 9090。
gcc -O2 -Wall -Wextra echo_epoll.c -o echo_epoll
PORT="<PORT>"
./echo_epoll "$PORT"预期输出
listening on 0.0.0.0:<PORT>如果编译器提示 accept4 未声明,应确认代码顶部存在 _GNU_SOURCE,并在 Linux/glibc 环境编译。若端口被占用,bind/listen 会报告 Address already in use,更换端口后重新启动即可。
验证多连接并发
保持服务端运行,在另一终端执行并发测试。脚本同时建立 20 条 TCP 连接,每条发送不同文本,并检查收到的内容是否与发送内容完全一致;同样把 <PORT> 替换为实际端口。
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预期输出
20 True这个结果说明 20 条连接都完成了独立的发送与回显。客户端线程只是压测工具;服务端本身仍然只有一个事件循环线程,连接并发来自 epoll 对大量就绪事件的集中等待与逐个处理。