深入理解 Linux epoll：高性能事件驱动的核心技术

最新推荐文章于 2024-07-03 20:18:43 发布

程序修炼之道

最新推荐文章于 2024-07-03 20:18:43 发布

阅读量1.3k

点赞数 32

文章标签： c++ linux 音视频计算机网络

本文链接：https://blog.csdn.net/qq_44913712/article/details/138281725

版权

介绍

在高并发网络编程中，有效地管理大量的客户端连接是至关重要的。传统的 I/O 多路复用技术如 select 和 poll 在连接数较少时表现良好，但在连接数增加时性能下降明显。而 Epoll 则是一种高效的 I/O 多路复用技术，被广泛应用于服务器编程中，特别是在大规模并发连接的场景下。

Epoll 概述

Epoll 是 Linux 内核提供的一种事件通知机制，用于处理大量的 I/O 事件。Epoll 在管理大量连接时具有更高的效率和性能。其主要特点包括：

支持边缘触发和水平触发模式： Epoll 提供了两种工作模式，分别是边缘触发（Edge Triggered，简称 ET）和水平触发（Level Triggered，简称 LT）。在边缘触发模式下，只有当状态变化时才会触发事件，而在水平触发模式下，只要状态处于可读或可写状态，就会触发事件。
零拷贝： epoll 可以在内核态和用户态之间传递数据，避免了不必要的数据拷贝，提高了性能。
支持大量连接： epoll 使用红黑树和双链表等数据结构来管理事件，能够高效地处理数以万计的连接。

Epoll 实现原理

Epoll 的实现原理主要包括以下几个关键步骤：

1. 事件驱动

epoll 是基于事件驱动的机制，它只在文件描述符上有事件发生时才会通知应用程序，而不是像传统的 select 和 poll 那样定期轮询所有注册的文件描述符。这样可以避免不必要的系统调用，减少了系统资源的消耗。

2. 内核事件表

epoll 使用内核事件表来管理注册的文件描述符和相关事件。内核会监视这些文件描述符上的事件，并在事件发生时将事件添加到就绪队列中。这种设计避免了用户空间和内核空间之间的频繁数据交换，提高了系统的整体性能。

3. 零拷贝技术

在处理大量数据时，epoll 使用零拷贝技术来减少数据在用户空间和内核空间之间的复制次数。当数据从网络接口到达内核缓冲区时，epoll 可以直接将数据从内核缓冲区传输到用户空间的应用程序缓冲区，而不需要额外的数据复制操作，提高了数据传输的效率。

4. 多种触发模式选择

epoll 提供了多种触发模式选择，包括水平触发模式（EPOLLLT）和边缘触发模式（EPOLLET）。水平触发模式下，只要文件描述符上有事件发生，epoll 就会通知应用程序，即使应用程序没有处理完所有事件。

而边缘触发模式只在文件描述符状态发生变化时通知应用程序，需要应用程序主动处理完所有事件后才能继续等待新的事件。

epoll 主要的 API 包括：

1.创建一个 epoll 实例，

返回一个文件描述符，`size` 参数在新版 Linux 中已被忽略，但仍需提供一个正整数值。

epoll_create(int size);

2. 控制 epoll 实例的操作。

`epfd` 是 epoll 实例的文件描述符，`op` 是操作类型，可以是 `EPOLL_CTL_ADD`、`EPOLL_CTL_MOD` 或 `EPOLL_CTL_DEL`，分别用于添加、修改或删除文件描述符到 epoll 实例中。`fd` 是要操作的文件描述符，`event` 是一个指向 epoll_event 结构体的指针，描述了关注的事件类型和对应的数据。

epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

3.等待文件描述符上的事件发生。

`epfd` 是 epoll 实例的文件描述符，`events` 是一个数组，用于存放就绪事件的信息，`maxevents` 表示 `events` 数组的最大长度，`timeout` 表示超时时间（单位为毫秒），如果设置为 `-1`，表示无限等待直到有事件发生，如果设置为 `0`，表示立即返回，如果设置为正整数，则表示等待指定的毫秒数后返回。函数返回就绪事件的数量。

epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

Epoll 应用示例

下面是一个简单的示例，演示了如何使用 Epoll 实现一个简单的 TCP 服务器：

#include <iostream>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/epoll.h>
#include <fcntl.h>
#include <cstring>
#include <vector>

#define MAX_EVENTS 10
#define MAX_BUFFER_SIZE 1024

int set_non_blocking(int sockfd) {
    int flags = fcntl(sockfd, F_GETFL, 0);
    if (flags == -1) {
        perror("fcntl");
        return -1;
    }
    if (fcntl(sockfd, F_SETFL, flags | O_NONBLOCK) == -1) {
        perror("fcntl");
        return -1;
    }
    return 0;
}

int main() {
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd == -1) {
        perror("socket");
        return 1;
    }

    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(8080);

    if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
        perror("bind");
        return 1;
    }

    if (listen(server_fd, SOMAXCONN) == -1) {
        perror("listen");
        return 1;
    }

    int epoll_fd = epoll_create1(0);
    if (epoll_fd == -1) {
        perror("epoll_create1");
        return 1;
    }

    struct epoll_event event;
    event.events = EPOLLIN;
    event.data.fd = server_fd;
    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_fd, &event) == -1) {
        perror("epoll_ctl: server_fd");
        return 1;
    }

    std::vector<int> client_fds;

    struct epoll_event events[MAX_EVENTS];
    while (true) {
        int num_events = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
        if (num_events == -1) {
            perror("epoll_wait");
            return 1;
        }

        for (int i = 0; i < num_events; ++i) {
            if (events[i].data.fd == server_fd) {
                // New connection
                struct sockaddr_in client_addr;
                socklen_t client_addr_len = sizeof(client_addr);
                int client_fd = accept(server_fd, (struct sockaddr *)&client_addr, &client_addr_len);
                if (client_fd == -1) {
                    perror("accept");
                    continue;
                }
                std::cout << "New connection from " << inet_ntoa(client_addr.sin_addr) << ":" << ntohs(client_addr.sin_port) << std::endl;

                set_non_blocking(client_fd);

                event.events = EPOLLIN | EPOLLET;
                event.data.fd = client_fd;
                if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &event) == -1) {
                    perror("epoll_ctl: client_fd");
                    return 1;
                }

                client_fds.push_back(client_fd);
            } else {
                // Handle client data
                char buffer[MAX_BUFFER_SIZE];
                ssize_t bytes_read = read(events[i].data.fd, buffer, sizeof(buffer));
                if (bytes_read == -1) {
                    if (errno != EAGAIN && errno != EWOULDBLOCK) {
                        perror("read");
                        close(events[i].data.fd);
                    }
                } else if (bytes_read == 0) {
                    std::cout << "Client disconnected" << std::endl;
                    close(events[i].data.fd);
                    client_fds.erase(std::remove(client_fds.begin(), client_fds.end(), events[i].data.fd), client_fds.end());
                } else {
                    buffer[bytes_read] = '\0';
                    std::cout << "Received data from client " << events[i].data.fd << ": " << buffer << std::endl;
                }
            }
        }
    }

    close(epoll_fd);
    close(server_fd);
    return 0;
}