epoll_wait函数的概念和使用案例

原创 已于 2025-08-14 20:13:36 修改 · 329 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#epoll #网络编程 #多路复用

于 2025-07-26 10:24:24 首次发布

在这里插入图片描述

epoll_wait 函数深度解析

epoll_wait 是 Linux epoll I/O 多路复用机制的核心函数，用于等待文件描述符上的 I/O 事件。相比传统的 select() 和 poll()，它在高并发场景下效率更高。

函数原型
#include <sys/epoll.h>

int epoll_wait(int epfd, 
               struct epoll_event *events,
               int maxevents, 
               int timeout);
参数详解

  1. epfd

    • epoll 实例的文件描述符（由 epoll_create1() 创建）
    • 类型：int
    • 必需参数

  2. events

    • 指向 epoll_event 结构数组的指针
    • 用于接收就绪事件
    • 类型：struct epoll_event*
    • 必需参数

  3. maxevents

    • 指定最多返回的事件数量
    • 必须大于 0 且小于等于 events 数组大小
    • 类型：int
    • 必需参数

  4. timeout

    • 等待超时时间（毫秒）：
      • -1：永久阻塞，直到事件发生
      • 0：立即返回，即使没有事件
      • >0：等待指定毫秒数
    • 类型：int
    • 必需参数
返回值
  • 成功：返回就绪的文件描述符数量（0 表示超时）
  • 失败：返回 -1，并设置 errno

完整使用案例：高性能 TCP 服务器

#include <sys/epoll.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#define MAX_EVENTS 64
#define PORT 8080
#define BUFFER_SIZE 1024

// 设置文件描述符为非阻塞模式
void set_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}

int main() {
    // 创建服务器套接字
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd < 0) {
        perror("socket creation failed");
        exit(EXIT_FAILURE);
    }

    // 设置 SO_REUSEADDR 避免端口占用
    int opt = 1;
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    
    // 绑定地址
    struct sockaddr_in addr = {
        .sin_family = AF_INET,
        .sin_port = htons(PORT),
        .sin_addr.s_addr = INADDR_ANY
    };
    
    if (bind(server_fd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
        perror("bind failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }
    
    // 开始监听
    if (listen(server_fd, SOMAXCONN) < 0) {
        perror("listen failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }
    
    printf("Server listening on port %d\n", PORT);
    
    // 创建 epoll 实例
    int epoll_fd = epoll_create1(0);
    if (epoll_fd < 0) {
        perror("epoll_create1 failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }
    
    // 添加服务器套接字到 epoll
    struct epoll_event ev;
    ev.events = EPOLLIN;  // 监听可读事件（新连接）
    ev.data.fd = server_fd;
    
    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_fd, &ev) < 0) {
        perror("epoll_ctl: server_fd");
        close(server_fd);
        close(epoll_fd);
        exit(EXIT_FAILURE);
    }
    
    // 事件存储数组
    struct epoll_event events[MAX_EVENTS];
    
    // 主事件循环
    while (1) {
        // 等待事件发生（无限期阻塞）
        int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
        
        if (nfds == -1) {
            // 处理信号中断
            if (errno == EINTR) continue;
            
            perror("epoll_wait failed");
            break;
        }
        
        // 处理所有就绪事件
        for (int i = 0; i < nfds; i++) {
            // 1. 处理新连接
            if (events[i].data.fd == server_fd) {
                struct sockaddr_in client_addr;
                socklen_t len = sizeof(client_addr);
                
                // 接受新连接
                int client_fd = accept(server_fd, 
                                      (struct sockaddr*)&client_addr, 
                                      &len);
                if (client_fd < 0) {
                    perror("accept failed");
                    continue;
                }
                
                // 设置为非阻塞模式
                set_nonblocking(client_fd);
                
                // 添加客户端到 epoll
                ev.events = EPOLLIN | EPOLLET;  // 边缘触发模式
                ev.data.fd = client_fd;
                
                if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &ev) < 0) {
                    perror("epoll_ctl: client_fd");
                    close(client_fd);
                } else {
                    printf("New connection: fd=%d\n", client_fd);
                }
            } 
            // 2. 处理客户端数据
            else {
                int client_fd = events[i].data.fd;
                
                // 检查连接关闭或错误
                if (events[i].events & (EPOLLERR | EPOLLHUP | EPOLLRDHUP)) {
                    printf("Connection closed: fd=%d\n", client_fd);
                    epoll_ctl(epoll_fd, EPOLL_CTL_DEL, client_fd, NULL);
                    close(client_fd);
                    continue;
                }
                
                // 处理可读事件（边缘触发模式）
                if (events[i].events & EPOLLIN) {
                    char buffer[BUFFER_SIZE];
                    ssize_t bytes_read;
                    
                    // ET 模式必须循环读取直到 EAGAIN
                    while (1) {
                        bytes_read = read(client_fd, buffer, sizeof(buffer));
                        
                        if (bytes_read > 0) {
                            // 简单回显处理
                            write(client_fd, buffer, bytes_read);
                        } 
                        else if (bytes_read == 0) {
                            // 对端关闭连接
                            printf("Client closed connection: fd=%d\n", client_fd);
                            epoll_ctl(epoll_fd, EPOLL_CTL_DEL, client_fd, NULL);
                            close(client_fd);
                            break;
                        }
                        else {
                            // 处理错误或非阻塞返回
                            if (errno == EAGAIN || errno == EWOULDBLOCK) {
                                // 数据已读完，等待下次事件
                                break;
                            }
                            
                            // 真实错误
                            perror("read error");
                            epoll_ctl(epoll_fd, EPOLL_CTL_DEL, client_fd, NULL);
                            close(client_fd);
                            break;
                        }
                    }
                }
            }
        }
    }
    
    // 清理资源
    close(server_fd);
    close(epoll_fd);
    return 0;
}

关键实现细节

1. 事件循环结构
while (running) {
    int nfds = epoll_wait(epfd, events, MAX_EVENTS, timeout);
    
    for (int i = 0; i < nfds; i++) {
        if (events[i].data.fd == server_fd) {
            // 处理新连接
        } else {
            // 处理客户端事件
        }
    }
}
2. 边缘触发模式处理
// ET 模式必须循环读取直到 EAGAIN
while (1) {
    bytes_read = read(fd, buf, sizeof(buf));
    
    if (bytes_read > 0) {
        // 处理数据
    }
    else if (bytes_read == 0) {
        // 关闭连接
    }
    else if (errno == EAGAIN) {
        break; // 数据已读完
    }
    else {
        // 处理真实错误
    }
}
3. 连接管理
// 添加新连接
ev.events = EPOLLIN | EPOLLET;
ev.data.fd = client_fd;
epoll_ctl(epfd, EPOLL_CTL_ADD, client_fd, &ev);

// 移除关闭的连接
epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
close(fd);

高级使用技巧

1. 超时处理
int timeout_ms = 1000; // 1秒超时
int nfds = epoll_wait(epfd, events, maxevents, timeout_ms);

if (nfds == 0) {
    // 执行定时任务（心跳检测、超时清理等）
    handle_timeout_tasks();
}
2. 自定义数据结构
struct client_context {
    int fd;
    struct sockaddr_in addr;
    time_t last_active;
};

// 添加连接时
struct client_context *ctx = malloc(sizeof(*ctx));
ctx->fd = client_fd;
ctx->last_active = time(NULL);

ev.events = EPOLLIN | EPOLLET;
ev.data.ptr = ctx;  // 使用指针存储上下文

epoll_ctl(epfd, EPOLL_CTL_ADD, client_fd, &ev);

// 事件处理时
struct client_context *ctx = events[i].data.ptr;
update_last_active(ctx); // 更新上下文
3. 触发模式混合使用
// 监听套接字使用水平触发（LT）
ev.events = EPOLLIN; 

// 数据套接字使用边缘触发（ET）
ev.events = EPOLLIN | EPOLLET | EPOLLRDHUP;

常见错误及处理

  1. 忽略 EAGAIN/EWOULDBLOCK
    在 ET 模式下必须循环读取直到返回 EAGAIN

  2. 文件描述符泄漏
    确保关闭文件描述符前从 epoll 中移除：

    epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
close(fd);

  3. 事件数组溢出
    确保 maxevents ≤ 实际数组大小

  4. 未处理信号中断
    处理 EINTR 错误：

    if (nfds == -1 && errno == EINTR) {
    // 被信号中断，重新等待
    continue;
}

性能优化建议

  1. 批量处理事件
    利用单次 epoll_wait 返回多个事件的特性，减少系统调用次数

  2. 动态调整事件集
    根据负载动态调整监控的文件描述符

  3. 使用 EPOLLONESHOT
    对于需要同步处理的场景：

    ev.events = EPOLLIN | EPOLLET | EPOLLONESHOT;
    • 事件触发后自动禁用监控
    • 处理完成后需重新启用

  4. 避免频繁修改
    批量处理 epoll_ctl 操作，减少系统调用

性能对比：在 10K 并发连接测试中，epoll 比 select 快 100 倍以上，且 CPU 使用率低 90%

适用场景

  1. 高并发网络服务器（Web 服务器、游戏服务器）
  2. 实时数据处理系统
  3. 高性能代理/网关
  4. 需要管理大量 I/O 操作的应用程序

通过合理使用 epoll_wait 和边缘触发模式，可以构建出能够处理数十万并发连接的高性能网络服务，这正是 Nginx、Redis 等高性能服务器的基础。

【C语言】epoll_wait / select
数字人生
02-01 2044
值得注意的是，`EPOLLERR` 通常与其他 I/O 事件（`EPOLLIN`、`EPOLLOUT` 等）一起返回，表示即使有错误，文件描述符也可能处于可读或可写状态。此外，对于某些类型的文件描述符（如 epoll 自己的文件描述符），`EPOLLERR` 也可能意味着某些系统层面的问题，你需要具备相应的处理逻辑。总体来说，`epoll_create1` 提供了更多的控制和扩展性，并且是推荐使用的方式，如果你的环境中存在支持它的 Linux 内核版本。数以万计的文件描述符。
epoll使用详解（精髓）
热门推荐
ljx0305的专栏
04-11 28万+
epoll - I/O event notification facility在linux的网络编程中，很长的时间都在使用select来做事件触发。在linux新的内核中，有了一种替换它的机制，就是epoll。相比于select，epoll最大的好处在于它不会随着监听fd数目的增长而降低效率。因为在内核中的select实现中，它是采用轮询来处理的，轮询的fd数目越多，自然耗时越多。并且，在linu
epoll_wait
weixin_41812346的博客
05-18 739
epoll_wait是 Linux 系统中 I/O 多路复用机制 epoll 的核心函数之一，用于等待文件描述符上的事件发生。它是高性能网络服务器编程中常用的函数，特别是在需要处理大量并发连接的场景下。
epoll学习：epoll_wait函数详解
个人工作中学到的专业技术与职业发展知识笔记
11-24 2万+
epoll_wait：等待监听的所有fd相应事件的产生。
epoll_create1函数含义和使用案例
最新发布
weixin_42108533的博客
07-26 654
epoll_create1是Linux中创建epoll实例的核心函数，相比已废弃的epoll_create，它支持EPOLL_CLOEXEC标志，避免exec时文件描述符泄漏。该函数返回epoll文件描述符，失败时返回-1。典型使用场景包括高性能服务器开发，需配合epoll_ctl和epoll_wait实现I/O多路复用。关键注意事项包括：资源管理（及时关闭fd）、错误检查、线程安全以及监控数量限制。现代Linux服务器开发中，epoll_create1(EPOLL_CLOEXEC)是创建epoll实例的推
epoll_wait使用
08-01
3. 等待就绪事件：使用epoll_wait函数等待就绪事件的发生。当有事件发生时，epoll_wait会将就绪事件的信息填充到events数组中，并返回就绪事件的数量。 4. 处理就绪事件：根据返回的就绪事件数量，遍历events数组，...
IO复用之epoll模型
qq_43589451的博客
01-27 853
epoll 是 Linux 操作系统提供的一种高性能的事件通知机制，用于处理大量文件描述符上的事件。它是一种 I/O 事件通知机制，通常用于处理网络编程中的并发连接。在传统的 I/O 模型中，程序通常使用 select 或 poll 函数来等待多个文件描述符上的事件。这种方式有一些性能上的限制，特别是当需要监视的文件描述符数量很大时。epoll 的设计旨在解决这些性能问题。
linux epoll多线程编程 例子
01-19
epoll是对传统select和poll模型的改进，它引入了“事件就绪”的概念，并使用了“红黑树”数据结构存储监控的文件描述符（FD），从而在添加、删除和查询FD时具有O(1)的时间复杂度。此外，epoll支持水平触发和边缘触发...
epoll 反应堆模型（Libevent库核心思想）
weixin_43200943的博客
04-14 1096
epoll 反应堆模型是从 libevent 库里面抽取的核心代码
epoll_wait 。。
linbounconstraint的专栏
11-20 800
/********************************* * mkfifo p1 p2 * cat > p1 * cat > p2 *FileName: epoll_wait.c *Author : Dai *Version : 1 *Date : 2014.09.19 *Description: 用epoll_wait监听多个管道，管道中有内容就读出 （1）
epoll_wait这么用就对了
认知 行动 坚持
05-22 1655
平时不仅要多写程序，而且，要多看别人是怎么写程序的，多阅读优秀的源码。 最近，对redis源码感兴趣，重点看了一下网络模块，遇到了我熟悉的epoll, 来看一小段程序： static int aeApiPoll(aeEventLoop *eventLoop, struct timeval *tvp) { aeApiState *state = eventLoop->apidata; int retval, numevents = 0; retval = epoll_w
epoll_wait函数
aolitianya的博客
04-17 1948
linux中epoll_wait函数定义和使用
epoll_wait() 函数
fucheng的博客
05-13 1634
epoll_wait() 函数
linux wait 系统调用,epoll_wait 系统调用
weixin_29351351的博客
05-11 357
epoll_wait, epoll_pwait - wait for an I/O event on an epoll filedescriptor以上两个系统调用等待epoll fd上的IO 事件#include int epoll_wait(int epfd, struct epoll_event *events,int maxevents, int timeout);int epo...
epoll简介与示例的整理
永远在跟随，从未去超越
04-08 1802
名词解释：man epoll之后，得到如下结果： NAME        epoll - I/O event notification facility SYNOPSIS        #include DEscrīptION        epoll is a variant of poll(2) that can be used either as Edge or Level       
epoll_wait详解
zhoumuyu_yu的博客
01-11 6万+
epoll_pwait，等待epoll文件描述符上的I / O事件。 #include <sys / epoll.h> int epoll_wait（int epfd，struct epoll_event * events，int maxevents，int timeout）; epoll_wait（）系统调用等待文件描述符epfd引用的epoll实例上的事件。事件所指向的存储区域将包含可供调用者使用的事件。 epoll_wait（）最多返回最大事件。 maxevents...
Epoll原理解析_epoll_wait
2401_86963300的博客
09-11 1180
假如能够预先传入一个 Socket 列表，如果列表中的 Socket 都没有数据，挂起进程，直到有一个 Socket 收到数据，唤醒进程。下图的计算机中运行着 A、B 与 C 三个进程，其中进程 A 执行着上述基础网络程序，一开始，这 3 个进程都被操作系统的工作队列所引用，处于运行状态，会分时执行。然后调用 Select，如果 FDS 中的所有 Socket 都没有数据，Select 会阻塞，直到有一个 Socket 接收到数据，Select 返回，唤醒进程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

青草地溪水旁

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值