Linux高级I/O：多路转接模型

在这里插入图片描述

一.常见的IO模型介绍
二.多路转接I/O
- - 1.select
  - - 1.1.函数解析
    - 1.2. select特点和缺点
    - 1.3.基于 select 的多客户端网络服务器
  - 2.poll
  - - 2.1.poll函数解析
    - 2.2.poll特点和缺点
    - 2.3.基于poll的tcp服务器
  - 3.epoll
  - - 3.1.系列函数解析
    - 3.2.epoll原理解析
    - 2.3.基于 select 的多客户端网络服务器
    - 3.4.epoll的优点
三.LT和ET

一.常见的IO模型介绍

在 Linux 中，主要有以下几种 I/O 模型：

阻塞 I/O：在阻塞 I/O 模型中，当进程请求 I/O 操作时，它会被挂起，直到该操作完成。这种方式进程在等待 I/O 的同时不能做其他的事。
非阻塞 I/O：非阻塞 I/O 允许进程发出 I/O 请求后立即返回，进程可以继续执行其他操作。为了检查 I/O 是否完成，进程需要通过轮询方式不断检查状态，所以也常称为非阻塞轮询IO，这种方式可以减少等待时间，但是在高频率轮询时很消耗cpu资源。
I/O 多路复用：I/O 多路复用通过使用 select、poll 或 epoll 等系统调用，使一个进程/线程能够同时监视多个文件描述符。该模型在处理多个并发连接时效率较高，适合网络服务器等应用场景。
信号驱动 I/O：在信号驱动 I/O 模型中，进程在发出 I/O 请求后可以继续执行其他任务，操作的完成通过信号通知。这种方式可以减少轮询，但是处理起来较为复杂。
异步 I/O：异步 I/O 是最先进的模型，进程发出 I/O 请求后立即返回，并在操作完成时通过回调函数或其他机制获得通知。异步 I/O 模型通常提供最高的性能，适合高负载、高并发的应用程序。

二.多路转接I/O

1.select

1.1.函数解析

#include <sys/select.h>

int pselect(int nfds, fd_set *restrict readfds,
              fd_set *restrict writefds, fd_set *restrict errorfds,
              const struct timespec *restrict timeout,
              const sigset_t *restrict sigmask);
              
int select(int nfds, fd_set *restrict readfds,
              fd_set *restrict writefds, fd_set *restrict errorfds,
              struct timeval *restrict timeout);
              
void FD_CLR(int fd, fd_set *fdset);
int FD_ISSET(int fd, fd_set *fdset);
void FD_SET(int fd, fd_set *fdset);
void FD_ZERO(fd_set *fdset);

nfds：待监视的文件描述符最大值 + 1。
readfds：指向一组需要监视“可读”事件的文件描述符集合。
writefds：指向一组需要监视“可写”事件的文件描述符集合。
exceptfds：指向一组需要监视异常事件的文件描述符集合。
timeout：timeout 是一个 struct timeval 结构体，包含等待的秒数和微秒数，如果在超时时间内有文件描述符变为可用状态，select 会返回，返回值是可用的文件描述符数量。如果发生错误，select 返回 -1，并设置 errno。
select 函数返回就绪的文件描述符数，如果返回 0 则表示超时。

fd_set的介绍
fd_set 是一个位图结构，用于存储多个文件描述符。select 使用宏来操作 fd_set，常见的宏有：

FD_ZERO(fd_set *set)：将文件描述符集合置空。
FD_SET(int fd, fd_set *set)：将文件描述符 fd加入集合。
FD_CLR(int fd, fd_set *set)：将文件描述符 fd 从集合中移除。
FD_ISSET(int fd, fd_set *set)：检查文件描述符 fd 是否在集合中，并且是否准备就绪。

下面是一个简单的使用演示代码：

fd_set readfds;
FD_ZERO(&readfds);
FD_SET(sockfd, &readfds);
int maxfd = sockfd + 1;

int result = select(maxfd, &readfds, nullptr, nullptr, nullptr);
if (result > 0) {
    if (FD_ISSET(sockfd, &readfds)) {
        // 处理读操作
    }
}

初始化fd_set集合将需要监控的fd添加进去，接着调用select函数，maxfd是需要监控的fd集合中最大值再加1，select可以同时监控读事件、写事件、异常事件。timeout设置为nullptr标识阻塞等待直到事件有就绪的或者出错。

1.2. select特点和缺点

特点：

多路复用：select 允许一个进程同时监控多个文件描述符，等待其中一个或多个变为可读、可写或异常状态。
可以处理不同类型的文件描述符:能够监控常规文件、套接字、管道等多种类型的文件描述符。
跨平台支持:在许多 Unix-like 操作系统以及 Windows 中都有支持，具有良好的移植性。

缺点：

性能瓶颈:当监控的文件描述符数量很大时，select 的性能会显著下降。每次调用 select 都需要遍历所有文件描述符，增加了开销。
文件描述符数量限制:select 有文件描述符的数量限制（通常是 1024，取决于类型fd_set的大小），超过这个限制就不能监控更多的描述符。
每次调用都需要重置:每次调用 select 都需要重新设置文件描述符集合，这在处理多个连接时会带来额外的开销。
无优先级支持:select 不能为不同的文件描述符设置优先级，所有的描述符在监控时是平等的。
不适合高并发场景:在高并发情况下（如数千个连接），select 的效率会下降，通常需要使用其他机制（如 poll、epoll 或 kqueue）来更好地处理大量并发连接。

1.3.基于 select 的多客户端网络服务器

下面我们来实现一个简单的基于 select 的 TCP 服务器来窥探他的使用（附上详细注释）：

#pragma once

#include <iostream>
#include <sys/select.h>
#include <sys/time.h>
#include <string>

#include "Socket.hpp"

using namespace std;

// 默认端口号
static const uint16_t defaultport = 8888;
// 最大文件描述符数量
static const int fd_num_max = (sizeof(fd_set) * 8);
int defaultfd = -1; // 默认文件描述符，表示未使用

class SelectServer
{
public:
    // 构造函数，初始化端口和文件描述符数组
    SelectServer(uint16_t port = defaultport) : _port(port)
    {
        for (int i = 0; i < fd_num_max; i++)
        {
            fd_array[i] = defaultfd; // 初始化所有文件描述符为默认值
        }
    }

    // 初始化服务器，创建套接字、绑定和监听
    bool Init()
    {
        _listensock.Socket(); // 创建套接字
        _listensock.Bind(_port); // 绑定到指定端口
        _listensock.Listen(); // 开始监听

        return true;
    }

    // 接受新的连接
    void Accepter()
    {
        // 处理连接事件
        string clientip; // 客户端IP
        uint16_t clientport = 0; // 客户端端口
        int sock = _listensock.Accept(&clientip, &clientport); // 接受连接
        if (sock < 0) return; // 失败则返回


        // 将新连接的sock添加到fd_array数组
        int pos = 1; // 从1开始，0位置为监听套接字
        for (; pos < fd_num_max; pos++) // 查找可用的位置
        {
            if (fd_array[pos] != defaultfd)
                continue; // 当前位置已被占用，继续查找
            else
                break; // 找到可用位置
        }
        if (pos == fd_num_max) // 如果数组已满
        {
            close(sock); // 关闭新连接
        }
        else // 有空位
        {
            fd_array[pos] = sock; // 存储新连接的文件描述符
        }
    }

    // 接收数据
    void Recver(int fd, int pos)
    {
        char buffer[1024]; // 缓冲区
        ssize_t n = read(fd, buffer, sizeof(buffer) - 1); // 读取数据
        if (n > 0) // 有数据到达
        {
            buffer[n] = 0; // 结束符
            cout << "get a messge: " << buffer << endl; // 输出接收到的信息
        }
        else if (n == 0) // 客户端关闭连接
        {
            close(fd); // 关闭连接
            fd_array[pos] = defaultfd; // 从数组中移除
        }
        else // 发生错误
        {
            close(fd); // 关闭连接
            fd_array[pos] = defaultfd; // 从数组中移除
        }
    }

    // 分发事件
    void Dispatcher(fd_set &rfds)
    {
        for (int i = 0; i < fd_num_max; i++) // 遍历文件描述符数组
        {
            int fd = fd_array[i];
            if (fd == defaultfd)
                continue; // 跳过未使用的描述符

            if (FD_ISSET(fd, &rfds)) // 检查描述符是否就绪
            {
                if (fd == _listensock.Fd()) // 如果是监听套接字
                {
                    Accepter(); // 处理新连接
                }
                else // 其他连接
                {
                    Recver(fd, i); // 接收数据
                }
            }
        }
    }

    // 启动服务器
    void Start()
    {
        int listensock = _listensock.Fd(); // 获取监听套接字的文件描述符
        fd_array[0] = listensock; // 将监听套接字放入数组的第一个位置
        while (true)
        {
            fd_set rfds; // 文件描述符集合
            FD_ZERO(&rfds); // 清空集合

            int maxfd = fd_array[0]; // 最大文件描述符
            for (int i = 0; i < fd_num_max; i++) // 遍历文件描述符数组
            {
                if (fd_array[i] == defaultfd)
                    continue; // 跳过未使用的描述符
                FD_SET(fd_array[i], &rfds); // 将就绪的描述符加入集合
                if (maxfd < fd_array[i]) // 更新最大文件描述符
                {
                    maxfd = fd_array[i];
                }
            }

            // 设置超时为 0，非阻塞轮询
            struct timeval timeout = {0, 0}; // 超时设置为 0

            // 调用 select 检测事件
            int n = select(maxfd + 1, &rfds, nullptr, nullptr, timeout);
            switch (n)
            {
            case 0:
                cout << "time out, timeout: " << timeout.tv_sec << "." << timeout.tv_usec << endl; // 超时处理
                break;
            case -1:
                cerr << "select error" << endl; // 错误处理
                break;
            default:
                cout << "get a new link!!!!!" << endl;
                Dispatcher(rfds); // 处理就绪的事件
                break;
            }
        }
    }

    // 析构函数，关闭监听套接字
    ~SelectServer()
    {
        _listensock.Close(); // 关闭套接字
    }

private:
    Sock _listensock; // 监听套接字对象
    uint16_t _port; // 服务器端口
    int fd_array[fd_num_max]; // 文件描述符数组，用于维护连接
};

2.poll

2.1.poll函数解析

#include <poll.h>

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

fds: 传入一个结构体数组，用于保存需要监控的文件描述符以及感兴趣的事件。
nfds: 数组 fds 中的文件描述符个数。
timeout: 指定超时时间，单位为毫秒。
返回值小于0表示出错，等于表示超时，大于0表示事件就绪。

pollfd 结构体

struct pollfd {
    int fd;         // 文件描述符
    short events;   // 需要监控的事件
    short revents;  // 实际发生的事件，由 poll 填充
};

fd: 需要监控的文件描述符。
events: 指定感兴趣的事件，比如 POLLIN（可读）、POLLOUT（可写）等。
revents: 存储实际发生的事件，由 poll 调用后填充。

events和revents的取值:

事件类型	`events` 值	`revents` 值	描述
可读事件	`POLLIN`	`POLLIN`	数据可读，通常指套接字上有数据可读
可写事件	`POLLOUT`	`POLLOUT`	数据可写，通常指套接字可以发送数据
错误事件	`POLLERR`	`POLLERR`	发生错误，需要处理
挂起事件	`POLLHUP`	`POLLHUP`	连接已关闭或挂起
非法请求	`POLLNVAL`	`POLLNVAL`	监控的文件描述符无效
超时	-	-	当设置的超时时间到达，但没有事件发生

2.2.poll特点和缺点

poll的优点：

无文件描述符限制：与 select 不同，poll 不受文件描述符数量的限制，因此可以处理更多的连接。
简单性：poll 的使用相对select简单，容易理解和实现。

poll的缺点：

线性扫描：在事件发生时，poll 会线性扫描所有文件描述符，效率较低。对于大量文件描述符，响应时间可能变长。
性能问题：每次调用 poll 时，都需要传递整个文件描述符数组，性能降低
不支持边缘触发：poll **不支持边缘触发模式

2.3.基于poll的tcp服务器

下面我们来实现一个简单的基于poll的 TCP 服务器来窥探他的使用（附上详细注释）：

#pragma once

#include <iostream>
#include <poll.h>       // 引入poll头文件，用于多路复用
#include <sys/time.h>   // 时间操作相关
#include "Socket.hpp"   // 自定义的Socket类，封装了socket的基本操作

using namespace std;

static const uint16_t defaultport = 8888; // 默认监听端口号为8888
static const int fd_num_max = 128;         // 最大支持的文件描述符数量
int defaultfd = -1;                       // 默认无效的文件描述符值
const int _no events = 0;                        // 无事件标志

class PollServer
{
public:
    // 构造函数，初始化监听端口号，并设置poll事件数组
    PollServer(uint16_t port = defaultport) 
            : _port(port)
    {
        for (int i = 0; i < fd_num_max; i++) // 初始化所有的文件描述符和事件
        {
            _event_fds[i].fd = defaultfd;    // 将所有文件描述符设置为默认值
            _event_fds[i].events = _no events; // 清空所有事件类型
            _event_fds[i].revents = _no events; // 清空所有返回事件
        }
    }

    // 初始化服务器，创建监听套接字并绑定到指定端口
    bool Init()
    {
        _listensock.Socket();   // 创建监听socket
        _listensock.Bind(_port); // 绑定到指定端口
        _listensock.Listen();   // 开始监听
        return true;            // 初始化成功返回true
    }

    // 处理新连接的客户端
    void Accepter()
    {
        // 有新的连接事件触发，接收连接
        string clientip;         // 用于存储客户端IP地址
        uint16_t clientport = 0;      // 用于存储客户端端口号
        int sock = _listensock.Accept(&clientip, &clientport); // 接收客户端连接，返回新socket
        if (sock < 0) return;         // 如果返回值小于0，表示接收失败

        // 将新连接的socket放入_event_fds数组
        int pos = 1;
        for (; pos < fd_num_max; pos++) // 查找空闲的数组位置
        {
            if (_event_fds[pos].fd != defaultfd) // 如果当前文件描述符已经被占用，继续寻找
                continue;
            else
                break; // 找到空闲位置退出循环
        }
        if (pos == fd_num_max) // 如果位置满了，无法接收更多客户端
        {
            close(sock); // 关闭新连接
        }
        else
        {
            // 将新socket添加到poll事件数组中，监听读事件
            _event_fds[pos].fd = sock;
            _event_fds[pos].events = POLLIN; // 监听读事件
            _event_fds[pos].revents = _no events; // 初始化返回事件
            PrintFd(); // 打印当前在线的fd列表
        }
    }

    // 处理客户端发送过来的消息
    void Recver(int fd, int pos)
    {
        char buffer[1024];                // 接收数据的缓冲区
        ssize_t n = read(fd, buffer, sizeof(buffer) - 1); // 从客户端读取数据
        if (n > 0) // 正常读取到数据
        {
            buffer[n] = 0;                // 将数据末尾补上字符串结束符
            cout << "get a messge: " << buffer << endl; // 打印接收到的消息
        }
        else if (n == 0) // 客户端主动断开连接
        {
            close(fd);                    // 关闭文件描述符
            _event_fds[pos].fd = defaultfd; // 从事件数组中移除该客户端
        }
        else // 读取出错
        {
            close(fd);                    // 关闭文件描述符
            _event_fds[pos].fd = defaultfd; // 从事件数组中移除该客户端
        }
    }

    // 事件分发器，处理所有准备好的事件
    void Dispatcher()
    {
        for (int i = 0; i < fd_num_max; i++) // 遍历所有的文件描述符
        {
            int fd = _event_fds[i].fd;
            if (fd == defaultfd)  // 如果是默认值，说明该位置空闲，跳过
                continue;

            if (_event_fds[i].revents & POLLIN) // 如果当前文件描述符有读事件
            {
                if (fd == _listensock.Fd()) // 如果是监听socket上的事件，处理新的连接
                {
                    Accepter(); // 处理新连接
                }
                else // 如果是普通客户端socket上的事件
                {
                    Recver(fd, i); // 接收客户端消息
                }
            }
        }
    }

    // 服务器主循环，启动服务器并进入事件处理
    void Start()
    {
        _event_fds[0].fd = _listensock.Fd(); // 将监听socket放入第一个位置
        _event_fds[0].events = POLLIN;       // 监听读事件
        int timeout = 1000; // 设置poll的超时时间为3秒
        for (;;)
        {
            // 调用poll函数，监控事件
            int n = poll(_event_fds, fd_num_max, timeout);
            switch (n)
            {
            case 0: // 超时无事件
                cout << "time out... " << endl;
                break;
            case -1: // 发生错误
                cerr << "poll error" << endl;
                break;
            default: // 有事件发生
                cout << "get a new link!!!!!" << endl;
                Dispatcher(); // 分发处理就绪的事件
                break;
            }
        }
    }

    // 打印当前在线的文件描述符列表
    void PrintFd()
    {
        cout << "fd list: ";
        for (int i = 0; i < fd_num_max; i++) // 遍历所有的文件描述符
        {
            if (_event_fds[i].fd == defaultfd) // 跳过无效的文件描述符
                continue;
            cout << _event_fds[i].fd << " "; // 打印文件描述符
        }
        cout << endl;
    }

    // 析构函数，关闭监听socket
    ~PollServer()
    {
        _listensock.Close();
    }

private:
    Sock _listensock;                      // 自定义封装的监听socket
    uint16_t _port;                        // 服务器监听的端口号
    struct pollfd _event_fds[fd_num_max];  // poll事件数组，保存所有的文件描述符及其事件
};

3.epoll

epoll 是 Linux 下用于处理 I/O 事件的高效多路复用机制，适用于需要处理大量并发连接的网络服务器，相较于poll提供了更好的性能，可以说是他的升级版。

3.1.系列函数解析

int epoll_create(int size);

创建一个 epoll 实例，返回一个文件描述符（指向的struct_file对象细节在原理讲解），用于后续的 epoll_ctl 和 epoll_wait 调用。

参数：

size：指定要监听的最大文件描述符数量。
返回值：成功返回 epoll 文件描述符，失败返回 -1 并设置 errno。

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

控制 epoll 实例的行为，包括添加、修改或删除文件描述符的事件。

参数：

epfd：由 epoll_create 返回的 epoll 文件描述符。
op：操作类型，可以是以下之一：

EPOLL_CTL_ADD：添加文件描述符。
EPOLL_CTL_MOD：修改文件描述符。
EPOLL_CTL_DEL：删除文件描述符。

fd：要操作的文件描述符。
event：指向 epoll_event 结构的指针，描述要监听的事件。
返回值：成功返回 0，失败返回 -1 并设置 errno。

epoll_event 结构:

struct epoll_event {
    uint32_t events;    // 事件类型
    epoll_data_t data;  // 用户数据
};
union epoll_data {
    void *ptr;         // 用户自定义数据指针
    int fd;            // 文件描述符
    uint32_t u32;      // 无符号整型数据
    uint64_t u64;      // 无符号长整型数据
};

events：

类型：uint32_t
描述：要监听的事件类型，可以多个组合。
常用的事件类型包括：

EPOLLIN：表示文件描述符可读。
EPOLLOUT：表示文件描述符可写。
EPOLLERR：表示发生错误。
EPOLLHUP：表示挂起事件。
EPOLLET：边缘触发模式（Edge Triggered），意味着在状态变化时才通知。

使用示例：

struct epoll_event event;
event.events = EPOLLIN | EPOLLET; // 监听可读事件，设置为边缘触发模式
event.data.fd = socket_fd;         // 关联的文件描述符

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

功能：等待事件发生，返回已就绪的个数。

参数：

epfd：由 epoll_create 返回的 epoll 文件描述符。
events：保存就绪事件。
maxevents：events 数组的大小。
timeout：等待的时间，单位是毫秒。可以设置为 0（不阻塞），-1（永久等待），或正值（指定超时时间）。
返回值：成功时返回就绪事件的数量，失败返回 -1 并设置 errno。

3.2.epoll原理解析

当调用 epoll_create 时，内核会执行以下操作：

L创建一个 eventpoll 结构体实例，用于管理注册的文件描述符及其事件。
返回一个文件描述符（fd），该 fd 代表了 eventpoll 结构体。

eventpoll 结构体内容：

struct eventpoll {
    struct list_head        wq_entry;     // 等待队列条目，用于管理等待事件的线程
    struct hlist_head       rdlist;       // 用于管理注册的可读事件的文件描述符
    struct hlist_head       pr_list;      // 用于优先级处理的链表
    struct rb_root          rbr_tree;     // 红黑树，管理注册的文件描述符
    struct rb_root          rbr_wait;     // 等待事件的红黑树
    wait_queue_head_t       wait;         // 等待队列，用于线程调度
    int                     epfd;         // epoll 文件描述符
    int                     wakeup;       // 唤醒标志
    // 其他字段...
};

主要使用过程解析：连接基于tcp实现的epoll多客户端网络服务器后，将需要监控的fd添加到红黑树（rbr_tree），等待网卡数据就绪发送中断信号，将数据向上交付后，在红黑树查找到对应的fd，将此结点（包含fd和对应事件）插入就绪队列中（wq_entry），便于用户调用epoll_wait获取就绪节点。

epoll模型原理：
在这里插入图片描述

2.3.基于 select 的多客户端网络服务器

#pragma once

#include <iostream>
#include <memory>
#include <sys/epoll.h>
#include "Socket.hpp"
#include "Epoller.hpp"
using namespace std;

// 定义事件常量
const int num = 64; // epoll 事件数组的最大数量

// EpollServer 类，用于处理基于 epoll 的服务器逻辑
class EpollServer 
{

public:
    // 构造函数，初始化端口、监听套接字和 epoller
    EpollServer(uint16_t port)
        : _port(port),
          _listsocket_ptr(new Sock()), // 创建一个新的套接字对象
          _epoller_ptr(new Epoller())   // 创建一个新的 epoller 对象
    {
    }

    // 初始化服务器
    void Init()
    {
        _listsocket_ptr->Socket(); // 创建套接字
        _listsocket_ptr->Bind(_port); // 绑定端口
        _listsocket_ptr->Listen(); // 开始监听    
    }

    // 接收新连接
    void Accepter()
    {
        string clientip; // 客户端 IP 地址
        uint16_t clientport;  // 客户端端口
        int sock = _listsocket_ptr->Accept(&clientip, &clientport); // 接收新连接
        if (sock > 0)
        {
            // 将新连接的套接字添加到 epoll 中进行事件监听
            _epoller_ptr->EpllerUpdate(EPOLL_CTL_ADD, sock, EPOLLIN);
        }
    }

    // 测试用的接收函数
    void Recver(int fd)
    {
        char buffer[1024]; // 接收缓冲区
        ssize_t n = read(fd, buffer, sizeof(buffer) - 1); // 读取数据
        if (n > 0)
        {
            buffer[n] = 0; // 确保字符串结束
            cout << "get a messge: " << buffer << endl; // 输出接收到的消息
            
            // 发送回显消息
            string echo_str = "server echo $ ";
            echo_str += buffer;
            write(fd, echo_str.c_str(), echo_str.size());
        }
        else if (n == 0)
        {
            _epoller_ptr->EpllerUpdate(EPOLL_CTL_DEL, fd, 0); // 从 epoll 中移除
            close(fd); // 关闭套接字
        }
        else
        {
            // 发生接收错误
            _epoller_ptr->EpllerUpdate(EPOLL_CTL_DEL, fd, 0); // 从 epoll 中移除
            close(fd); // 关闭套接字
        }
    }

    // 分发事件处理
    void Dispatcher(struct epoll_event revs[], int num)
    {
        for (int i = 0; i < num; i++)
        {
            uint32_t events = revs[i].events; // 获取事件类型
            int fd = revs[i].data.fd; // 获取文件描述符
            if (events & EPOLLIN) // 可读事件
            {
                if (fd == _listsocket_ptr->Fd()) // 如果是监听套接字
                {
                    Accepter(); // 接受新连接
                }
                else
                {
                    // 处理普通套接字的可读事件
                    Recver(fd);
                }
            }
            else
            {}
        }
    }

    // 启动服务器
    void Start()
    {
        // 将监听套接字添加到 epoll 中进行事件监听
        _epoller_ptr->EpllerUpdate(EPOLL_CTL_ADD, _listsocket_ptr->Fd(), EPOLLIN);
        struct epoll_event temp[num]; // 创建事件数组
        while(true)
        {
            int n = _epoller_ptr->EpollerWait(revs, num); // 等待事件发生
            if (n > 0)
            {
                // 有事件就绪
                Dispatcher(temp, n); // 分发事件
            }
            else if (n == 0)
            {
                lg(Info, "time out ..."); // 超时日志
            }
            else
            {
                lg(Error, "epll wait error"); // 错误日志
            }
        }
    }

    // 析构函数，关闭监听套接字
    ~EpollServer()
    {
        _listsocket_ptr->Close(); // 关闭监听套接字
    }

private:
    shared_ptr<Sock> _listsocket_ptr; // 监听套接字指针
    shared_ptr<Epoller> _epoller_ptr; // epoller 指针
    uint16_t _port; // 服务器端口
};

Epoll.hpp
#pragma once

#include <cerrno>
#include <cstring>
#include <sys/epoll.h>

class Epoller
{
    static const int size = 128;

public:
    Epoller()
    {
        _epfd = epoll_create(size);
        if (_epfd == -1)
        {}
        else
        {
            cout<<"epoll_create success "<<_epfd<<endl;
        }
    }
    int EpollerWait(struct epoll_event revents[], int num)
    {
        int n = epoll_wait(_epfd, revents, num, -1);
        return n;
    }
    int EpllerUpdate(int oper, int sock, uint32_t event)
    {
        int n = 0;
        if (oper == EPOLL_CTL_DEL)
        {
            n = epoll_ctl(_epfd, oper, sock, nullptr);
            if (n != 0)
            {
				cout<<"epoll_ctl error"<<endl;
            }
        }
        else
        {
            struct epoll_event ev;
            ev.events = event;
            ev.data.fd = sock;

            n = epoll_ctl(_epfd, oper, sock, &ev);
            if (n != 0)
            {
                cout<<"epoll_ctl error"<<endl;
            }
        }
        return n;
    }
    ~Epoller()
    {
        if (_epfd >= 0)
            close(_epfd);
    }

private:
    int _epfd;
    int _timeout{1000};
};

3.4.epoll的优点

高性能：相比于 select 和 poll，epoll 在处理大量文件描述符时性能更优，尤其是在有很多文件描述符处于非活动状态时。epoll
使用内核中的红黑树和链表来管理文件描述符，能够快速地插入、删除和查找事件。
支持边缘触发和水平触发：epoll 支持两种工作模式：水平触发（Level Triggered, LT）：默认模式，只有当文件描述符处于可读或可写状态时，epoll_wait 才会返回。边缘触发（Edge Triggered,
ET）：只有在状态改变时才会通知，这意味着你需要在事件发生时一次性读取所有数据，这种模式更加高效，但需要开发者小心处理。
不限制文件描述符数量：epoll 可以处理的文件描述符数量大于 select 的 1024 限制，具体数量仅受系统资源限制。
减少上下文切换：epoll 通过在内核中管理事件，减少了用户空间和内核空间之间的切换，从而提高了性能。

三.LT和ET

epoll 的 LT 和 ET 模式解析

epoll 提供了两种工作模式：水平触发（Level Triggered, LT）和边缘触发（Edge Triggered, ET）。这两种模式适用于不同的场景，epoll默认是LT。

1. 水平触发（LT）

工作方式：
- 在 LT 模式下，只要文件描述符处于可读或可写状态，epoll_wait 就会返回该文件描述符。
- 如果文件描述符有未读的数据，epoll_wait 会多次通知，即使在没有新数据到达的情况下，只要状态满足条件，它都会返回，支持阻塞读写和非阻塞读写。

2. 边缘触发（ET）

工作方式：
- 在 ET 模式下，epoll_wait 只在状态变化时通知事件。例如，文件描述符从不可读变为可读时，才会触发。
- 一旦事件被触发，开发者需要尽可能地读取所有可用数据，直到 EAGAIN 错误出现，只支持非阻塞的读写。每次通知都必须把本轮的数据全取走，必须非阻塞读。
LT 适用场景：
- 简单的应用场景，或者对性能要求不高的情况。
- 需要处理大量连接但不要求高并发性能的应用。
ET 适用场景：
- 高性能网络服务，处理大量并发连接的场景，如高负载的 Web 服务器。
- 需要尽量减少系统调用次数，提升性能的应用。