计算机网络 / 系统课时

用epoll完成高并发Echo服务

用epoll完成高并发Echo服务

这一节把 Reactor 落到可运行代码:监听 socket 和连接都设为非阻塞,由 epoll 驱动读写;每条连接按需分配输出缓冲区,并通过高低水位实施背压,同时加入空闲超时和统一回收路径。

学习目标

  • 用 level-triggered epoll 完成非阻塞 Echo 事件循环
  • 用输出缓冲区和高低水位避免慢客户端无限占用内存
  • 正确处理半关闭、空闲超时和连接资源释放

Reactor 事件路径

监听器只负责接受连接,新连接注册到同一个 epoll 实例。连接可读时把字节加入待发送缓冲区,随后立即尝试 send;如果内核发送缓冲区已满,就保留剩余数据并订阅 EPOLLOUT。待发送数据达到高水位后暂停 EPOLLIN,降到低水位再恢复。

epoll Reactor Echo 事件流

Echo 没有真正的业务计算,因此本示例不引入工作线程;如果后续加入数据库、压缩或其他阻塞任务,应把业务执行放到独立线程池,但连接对象仍只由所属 I/O 线程修改。

完整实现

下面程序使用 Linux 的 accept4、epoll 和非阻塞 socket。输出缓冲区按需扩容,单连接待发送数据最多 64 KiB;HIGH_WATER 与 LOW_WATER 构成回差,避免在临界点频繁开关读事件。

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

预期结果

text
源码保存为 echo_server.c 后可由下一节的 gcc 命令编译;启动后进入 epoll 事件循环。

这份实现选择 level-triggered 模式,便于把重点放在缓冲、背压和回收。读路径仍会循环到 EAGAIN,这样即使未来切到 edge-triggered,也已经满足“单次事件尽量排空”的基本要求。

编译、运行与验证

将源码保存为 echo_server.c,先编译。

bash
gcc -O2 -Wall -Wextra -std=c11 echo_server.c -o echo_server

预期结果

text
无标准输出;退出码为 0,并生成 echo_server

启动时把 <PORT> 替换为实际未占用端口;实际端口值可能不同。

bash
./echo_server <PORT>

预期输出

text
listening on <PORT>

保持服务运行,在另一个终端用 Python 标准库发送并接收一条消息,同样先替换 <PORT>。

bash
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()'

预期输出

text
ping

如果需要承载大量连接,还要把进程的文件描述符上限调整到目标规模,并确保 MAX_FD 大于可能出现的文件描述符值;这些容量设置必须和压测目标一起确定。

背压、超时与回收边界

send 返回 EAGAIN 时,未发送字节继续留在连接缓冲区,EPOLLOUT 会在 socket 再次可写时驱动后续发送。待发送数据超过高水位后取消 EPOLLIN,能够把压力逐步传回客户端,而不是继续从内核读出数据并无限占用用户态内存。

EPOLLRDHUP 表示对端关闭写方向。程序先保留已经收到但尚未回写的数据,待缓冲区清空后再关闭连接,避免客户端发送完请求后半关闭写端时丢掉 Echo 响应。所有异常、正常关闭和空闲超时最终都进入 close_conn,因此 epoll、文件描述符和动态缓冲区只需要维护一条释放路径。

教学实现每秒扫描 MAX_FD 槽位查找 30 秒空闲连接,逻辑清楚但不是最高效的超时结构。连接规模很大时,可把这部分替换为时间轮或按到期时间维护的最小堆;输出缓冲区也可以换成对象池或分块缓冲,减少长期连接扩容后的内存驻留。

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

目录与阅读设置

阅读设置

17

记录一个想法

用epoll完成高并发Echo服务

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

登录哪都通