使用epoll处理多个TCP线程连接

epoll 是 Linux 下的高效 I/O 复用机制，用于同时处理多个 TCP 连接。它比传统的 select 和 poll 更加高效，尤其在处理大量并发连接时表现优异。epoll 的基本思想是通过事件驱动的方式监控多个文件描述符，当文件描述符上的事件（如可读、可写）发生时，epoll 会通知应用程序进行处理。

一、创建 epoll 实例：

使用 epoll_create1() 函数创建 epoll 实例，返回一个 epoll 文件描述符。

二、注册事件：

使用 epoll_ctl() 函数将需要监控的文件描述符（如监听套接字和已连接的客户端套接字）添加到 epoll 实例中，并指定要监控的事件类型（如读事件 EPOLLIN）。

三、等待事件：

使用 epoll_wait() 函数等待事件的发生，当某个文件描述符上有事件发生时，会返回发生事件的文件描述符。

四、处理事件：

根据事件类型（如读取数据、处理连接等）执行相应的操作。

五、关闭 epoll 实例：

在不需要继续监控时，关闭 epoll 实例。

六、实现代码

#include <iostream>
#include <vector>
#include <sys/epoll.h>   // epoll API
#include <sys/types.h>
#include <sys/socket.h>  // 套接字 API
#include <arpa/inet.h>   // 网络地址转换
#include <unistd.h>      // close 函数
#include <fcntl.h>       // fcntl 函数，用于设置非阻塞
#include <cstring>       // 字符串操作
#include <stdexcept>     // 异常处理

// 设置文件描述符为非阻塞模式
void set_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0); // 获取当前的文件描述符状态标志
    if (flags == -1) {
        throw std::runtime_error("Failed to get socket flags");
    }
    // 设置文件描述符为非阻塞模式
    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
        throw std::runtime_error("Failed to set socket to non-blocking");
    }
}

// 初始化监听套接字
int init_server_socket(int port) {
    // 创建一个 IPv4 的流式套接字（TCP）
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if (listenfd == -1) {
        throw std::runtime_error("Failed to create socket");
    }

    // 配置服务器地址结构体
    sockaddr_in server_addr{};
    server_addr.sin_family = AF_INET; // 使用 IPv4
    server_addr.sin_port = htons(port); // 设置端口号（网络字节序）
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY); // 绑定到所有可用接口

    // 绑定套接字到指定的地址和端口
    if (bind(listenfd, reinterpret_cast<sockaddr*>(&server_addr), sizeof(server_addr)) == -1) {
        close(listenfd); // 出错时关闭套接字
        throw std::runtime_error("Failed to bind socket");
    }

    // 将套接字设置为监听状态
    if (listen(listenfd, SOMAXCONN) == -1) {
        close(listenfd); // 出错时关闭套接字
        throw std::runtime_error("Failed to listen on socket");
    }

    set_nonblocking(listenfd); // 设置监听套接字为非阻塞

    return listenfd; // 返回监听套接字
}

int main() {
    try {
        // 初始化服务器监听套接字
        int listenfd = init_server_socket(8081);

        // 创建 epoll 实例
        int epollfd = epoll_create1(0); // 参数为 0，使用默认行为
        if (epollfd == -1) {
            throw std::runtime_error("Failed to create epoll instance");
        }

        // 准备 epoll 事件，用于监听套接字的读事件
        epoll_event event{};
        event.data.fd = listenfd; // 设置监听的文件描述符
        event.events = EPOLLIN; // 关注可读事件
        /* EPOLLIN
        * 表示文件描述符上有数据可读。
		* 当 epoll_wait 返回时，如果事件包含 EPOLLIN，则表明可以从该文件描述符读取数据。
		* 例如，在监听套接字上发生 EPOLLIN 事件时，表示有新的客户端连接可以接受。
        */
        if (epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd, &event) == -1) {
            close(epollfd);
            close(listenfd);
            throw std::runtime_error("Failed to add listen socket to epoll");
        }

        // 存储事件的数组，用于 epoll_wait 返回的事件
        std::vector<epoll_event> events(1024);

        while (true) {
            // 等待事件发生，阻塞直到有事件发生
            int nfds = epoll_wait(epollfd, events.data(), events.size(), -1);
            if (nfds == -1) {
                throw std::runtime_error("epoll_wait failed");
            }

            // 处理每一个发生事件的文件描述符
            for (int i = 0; i < nfds; ++i) {
                if (events[i].data.fd == listenfd) {
                    // 有新的客户端连接
                    sockaddr_in client_addr{};
                    socklen_t client_addr_len = sizeof(client_addr);
                    // 接受新连接
                    int clientfd = accept(listenfd, reinterpret_cast<sockaddr*>(&client_addr), &client_addr_len);
                    if (clientfd == -1) {
                        std::cerr << "Failed to accept connection" << std::endl;
                        continue;
                    }

                    set_nonblocking(clientfd); // 设置新客户端套接字为非阻塞

                    // 添加新连接的客户端套接字到 epoll 实例
                    epoll_event client_event{};
                    client_event.data.fd = clientfd; // 客户端文件描述符
                    client_event.events = EPOLLIN | EPOLLET; // 关注可读事件，边缘触发模式
                    /* EPOLLET
                    * 表示边缘触发模式（Edge Triggered）。
                    * 在这种模式下，epoll 只在状态变化时通知应用程序，
                    * 例如数据从不可用到可用的瞬间，而不会在每次有新数据时重复通知。
                    * 边缘触发模式通常与非阻塞 I/O 一起使用，以避免丢失事件。
                    */
                    if (epoll_ctl(epollfd, EPOLL_CTL_ADD, clientfd, &client_event) == -1) {
	                     /*	EPOLL_CTL_ADD
	                    *用于将一个新的文件描述符添加到 epoll 实例中。
	                    */
                        close(clientfd); // 出错时关闭客户端套接字
                        std::cerr << "Failed to add client socket to epoll" << std::endl;
                    }
                   

                    std::cout << "Accepted a new connection" << std::endl;

                } else if (events[i].events & EPOLLIN) {
                    // 处理可读事件
                    char buffer[1024];
                    int clientfd = events[i].data.fd;
                    int bytes_read = recv(clientfd, buffer, sizeof(buffer) - 1, 0);
                    if (bytes_read <= 0) {
                        // 客户端关闭或读取错误，移除该套接字
                        epoll_ctl(epollfd, EPOLL_CTL_DEL, clientfd, nullptr);
                        /*EPOLL_CTL_DEL
                        *用于将文件描述符从 epoll 实例中移除。
                        *当不再需要监控某个文件描述符时，使用此操作来释放资源。
                        */
                        close(clientfd);
                        std::cout << "Closed connection on socket " << clientfd << std::endl;
                    } else {
                        buffer[bytes_read] = '\0'; // 确保字符串以 '\0' 结尾
                        std::cout << "Received: " << buffer << std::endl;
                        // 将接收到的数据发回客户端
                        send(clientfd, buffer, bytes_read, 0);
                    }
                }
            }
        }

        // 关闭 epoll 实例和监听套接字
        close(epollfd);
        close(listenfd);
    } catch (const std::exception& ex) {
        std::cerr << "Error: " << ex.what() << std::endl;
        return -1;
    }

    return 0;
}