【Linux IO多路复用 】 Linux 网络编程 认知负荷与Epoll：高性能I-O多路复用的实现与优化

#include <iostream>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <vector>
using namespace std;
int main() {
    // 创建TCP套接字并监听客户端连接
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if (listenfd == -1) {
        cerr << "Failed to create socket!" << endl;
        return -1;
    }
    // 设置套接字为非阻塞模式
    int flags = fcntl(listenfd, F_GETFL, 0);
    fcntl(listenfd, F_SETFL, flags | O_NONBLOCK);
    // 绑定地址和端口号
    sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = INADDR_ANY;
    addr.sin_port = htons(8000);
    if (bind(listenfd, (sockaddr*) &addr, sizeof(addr)) == -1) {
        cerr << "Failed to bind address!" << endl;
        return -1;
    }
    // 开始监听
    if (listen(listenfd, 10) == -1) {
        cerr << "Failed to listen!" << endl;
        return -1;
    }
    // 使用epoll_create()创建一个epoll实例并获取epoll文件描述符
    int epollfd = epoll_create(1);
    if (epollfd == -1) {
        cerr << "Failed to create epoll instance!" << endl;
        return -1;
    }
    // 使用epoll_ctl()将监听套接字添加到内核事件表中，并设置关注EPOLLIN事件
    epoll_event event;
    memset(&event, 0, sizeof(event));
    event.events = EPOLLIN | EPOLLET;
    event.data.fd = listenfd;
    if (epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd, &event) == -1) {
        cerr << "Failed to add event to epoll!" << endl;
        return -1;
    }
    // 使用一个循环调用epoll_wait()，等待活跃的文件描述符及相关事件
    vector<epoll_event> events(10);
    while (true) {
        int num = epoll_wait(epollfd, events.data(), events.size(), -1);
        if (num == -1) {
            cerr << "Failed to wait for events!" << endl;
            return -1;
        }
        // 遍历活跃的文件描述符及相关事件
        for (int i = 0; i < num; ++i) {
            int fd = events[i].data.fd;
            uint32_t ev = events[i].events;
            // 监听套接字上有新的连接
            if (fd == listenfd && (ev & EPOLLIN)) {
                sockaddr_in client_addr;
                socklen_t client_len = sizeof(client_addr);
                int clientfd = accept(listenfd, (sockaddr*) &client_addr, &client_len);
                if (clientfd == -1) {
                    cerr << "Failed to accept connection!" << endl;
                    continue;
                }
                           // 设置客户端套接字为非阻塞模式
            int flags = fcntl(clientfd, F_GETFL, 0);
            fcntl(clientfd, F_SETFL, flags | O_NONBLOCK);
            // 将客户端套接字添加到内核事件表中，并关注EPOLLIN事件
            event.events = EPOLLIN | EPOLLET;
            event.data.fd = clientfd;
            if (epoll_ctl(epollfd, EPOLL_CTL_ADD, clientfd, &event) == -1) {
                cerr << "Failed to add event to epoll!" << endl;
                return -1;
            }
            cout << "New connection from " << inet_ntoa(client_addr.sin_addr) << ":" << ntohs(client_addr.sin_port) << endl;
        }
        // 已连接套接字上有数据到达
        else if (ev & EPOLLIN) {
            char buffer[1024];
            int n = read(fd, buffer, sizeof(buffer));
            if (n == -1) {
                cerr << "Failed to read from socket!" << endl;
                continue;
            }
            else if (n == 0) {
                cout << "Connection closed by peer." << endl;
                close(fd);
                epoll_ctl(epollfd, EPOLL_CTL_DEL, fd, nullptr);
                continue;
            }
            // 回显数据到客户端
            if (write(fd, buffer, n) == -1) {
                cerr << "Failed to write to socket!" << endl;
                continue;
            }
        }
        // 发生错误或文件描述符被关闭
        else if (ev & (EPOLLERR | EPOLLHUP | EPOLLRDHUP)) {
            cout << "Error or hangup on socket." << endl;
            close(fd);
            epoll_ctl(epollfd, EPOLL_CTL_DEL, fd, nullptr);
        }
    }
}
// 关闭监听套接字
close(listenfd);
return 0;

#define MAX_EVENTS 1024
struct epoll_event events[MAX_EVENTS];
int nfds = epoll_wait(epfd, events, MAX_EVENTS, -1);

struct epoll_event ev;
ev.events = EPOLLIN | EPOLLET;
ev.data.fd = fd;
epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);

// 任务处理函数
void process_event(void *arg) {
    // 处理事件，例如读取数据、写入数据等
}
int main() {
    // 创建线程池
    ThreadPool thread_pool;
    thread_pool.init(4); // 4个工作线程
    // 创建epoll实例
    int epfd = epoll_create1(0);
    // 添加、修改、删除事件等操作
    while (1) {
        struct epoll_event events[MAX_EVENTS];
        int nfds = epoll_wait(epfd, events, MAX_EVENTS, -1);
        for (int i = 0; i < nfds; i++) {
            // 将事件处理任务放入线程池
            thread_pool.add_task(process_event, &events[i]);
        }
    }
    // 关闭线程池
    thread_pool.shutdown();
    return 0;
}

#ifndef EPOLL_SERVER_H
#define EPOLL_SERVER_H
#include <string>
#include <thread>
#include <atomic>
#include <mutex>
#include <condition_variable>
#include <map>
#include <vector>
#include <chrono>
#include <functional>
#include <unordered_map>
#include <memory>
#include "thread_pool.h"
enum class CloseType {
    SHUTDOWN,
    CLOSE
};
class EpollServer {
public:
    /**
     * @brief 构造函数
     */
    EpollServer();
    /**
     * @brief 析构函数
     */
    ~EpollServer();
/**
@brief 初始化服务器
@param ip 服务器的 IP 地址
@param port 服务器的端口
@param thread_num 工作线程的数量
@return 初始化是否成功
设置服务器的 IP、端口以及工作线程的数量，并创建监听套接字和 epoll 实例。
*/
bool init(const std::string &ip, uint16_t port, int thread_num);
/**
@brief 运行服务器
启动工作线程、接受连接线程以及处理事件线程。
*/
void run();
/**
@brief 停止服务器
关闭服务器并释放相关资源。
*/
void stop();
/**
@brief 处理客户端连接
*/
void acceptConnection();
/**
@brief 处理 epoll 事件
*/
void processEvents();
/**
@brief 获取服务器 IP 地址
@return 服务器 IP 地址字符串
*/
std::string getIPAddress() const;
/**
@brief 设置连接超时时间（毫秒）
@param timeout 超时时间（毫秒）
*/
void setConnectionTimeout(int timeout);
/**
@brief 添加一个处理请求的回调函数
@param path 请求路径
@param handler 处理请求的回调函数
*/
void registerRequestHandler(const std::string &path, void (*handler)(const std::string &, std::string &));
/**
@brief 设置一个默认的请求处理回调函数
@param handler 处理请求的回调函数
*/
void setDefaultRequestHandler(const std::function<void(const std::string &, std::string &)> &handler);
/**
@brief 开启 TLS 加密通信
@param cert_file 证书文件路径
@param key_file 私钥文件路径
@return 是否开启成功
*/
bool enableTLS(const std::string &cert_file, const std::string &key_file);
/**
 * @brief 获取指定客户端的信息
 * @param client_fd 客户端套接字文件描述符
 * @return 一个 std::pair，包含客户端的 IP 地址和端口号
 */
std::pair<std::string, uint16_t> getClientInfo(int client_fd);
/**
 * @brief 获取服务器运行时间
 * @return 服务器运行时间（以秒为单位）
 * 计算自服务器启动以来经过的时间。
 */
double getServerUptime() const;
/**
@brief 获取当前客户端连接数
@return 客户端连接数
*/
size_t getClientCount();
/**
@brief 获取服务器端口号
@return 服务器端口号
*/
uint16_t getPort() const;
/**
@brief 获取处理的请求总数
@return 处理的请求总数
*/
uint64_t getTotalRequests() const;
/**
@brief 发送消息给指定的连接
@param client_fd 客户端套接字文件描述符
@param message 要发送的消息
*/
void sendMessage(int client_fd, const std::string &message);
/**
@brief 广播消息给所有连接
@param message 要广播的消息
*/
void broadcastMessage(const std::string &message);
/**
@brief 设置最大连接数
@param max_load 最大连接数
@return 是否设置成功
*/
bool setMaxLoad(size_t max_load);
/**
@brief 断开指定客户端连接
@param client_fd 客户端套接字文件描述符
*/
bool disconnectClient(int client_fd, CloseType close_type);
/**
@brief 获取所有客户端连接的 IP 地址和端口号
@param client_connections 存储客户端连接的 IP 地址和端口号的 vector
@return 是否获取成功
*/
bool getClientConnections(std::vector<std::pair<std::string, uint16_t>>& client_connections);
/**
@brief 设置新连接回调函数
@param callback 新连接回调函数
*/
void setOnNewConnection(const std::function<void(int)> &callback);
/**
@brief 设置连接断开回调函数
@param callback 连接断开回调函数
*/
void setOnConnectionClosed(const std::function<void(int)> &callback);
/**
@brief 设置读取数据回调函数
@param callback 读取数据回调函数
*/
void setOnRead(const std::function<void(int, const std::string &)> &callback);
/**
@brief 设置写入数据回调函数
@param callback 写入数据回调函数
*/
void setOnWrite(const std::function<void(int)> &callback);
/**
@brief 设置错误回调函数
@param callback 错误回调函数
*/
void setOnError(const std::function<void(int, const std::string &)> &callback);
/**
@brief 设置超时回调函数
@param callback 超时回调函数
*/
void setOnTimeout(const std::function<void(int)> &callback);
private:
  // 监听套接字
  int listen_fd_;
  // epoll实例
  int epoll_fd_;
  // 服务器运行状态
  std::atomic_bool running_;
  // 线程池
  ThreadPool thread_pool_;
  // 接受连接的线程
  std::thread accept_thread_;
  // 处理事件的线程
  std::thread event_threads_;
  // 用于线程同步的互斥锁
  std::mutex mtx_;
  // 用于线程同步的条件变量
  std::condition_variable cv_;
  // 服务器 IP 地址
  std::string ip_;
  // 服务器端口号
  uint16_t port_;
  // 已处理的请求总数
  uint64_t total_requests_;
  // 保护客户端映射的互斥锁
  std::mutex client_map_mtx_;
  // 客户端映射
  std::map<int, std::shared_ptr<Client>> client_map_;
  // 最大连接数阈值
  size_t max_load_;
  // 连接超时时间（秒）
  int connection_timeout_;
  // 客户端连接时间映射
  std::map<int, std::chrono::steady_clock::time_point> connection_time_map_;
  // 保护连接时间映射的互斥锁
  std::mutex connection_time_mtx_;
  
  // TLS 上下文
  std::shared_ptr<void> tls_context_;
  // TLS 证书
  std::shared_ptr<void> tls_cert_;
  // TLS 私钥
  std::shared_ptr<void> tls_key_;
  // 连接断开回调
  std::function<void(int)> on_connection_closed_;
  // 读取数据回调
  std::function<void(int, const std::string &)> on_read_;
  // 写入数据回调
  std::function<void(int)> on_write_;
  // 错误回调
  std::function<void(int, const std::string &)> on_error_;
  // 超时回调
  std::function<void(int)> on_timeout_;
  // 默认请求处理回调函数
  std::function<void(const std::string &, std::string &)> default_request_handler_;
  // 处理请求的回调函数映射
  std::unordered_map<std::string, std::function<void(const std::string &, std::string &)>> request_handlers_;
  // 最大连接数
  int max_connections_;
  //记录开始时间
  std::chrono::system_clock::time_point start_time;
/**
 * @brief 处理HTTP请求
 * @param client_fd 客户端套接字文件描述符
 * @param request 客户端发送的HTTP请求
 * 
 * 根据客户端发送的HTTP请求，查找并调用相应的请求处理函数。若找不到对应的处理函数，
 * 则使用默认请求处理函数。如果没有默认处理函数，则返回 404 Not Found 错误。
 */
  void handleHttpRequest(int client_fd, const std::string & request)
/**
 * @brief 检查连接超时
 * 遍历连接时间映射，检查是否有连接超时，如有，则断开连接。
 */
  void checkConnectionTimeout();
/**
 * @brief 事件处理任务
 * @param arg 传递给事件处理任务的参数
 * 处理来自 epoll 实例的事件。根据事件类型调用适当的回调函数。
 */
  static void handleEvent(std::shared_ptr<void> arg);
};
#endif // EPOLL_SERVER_H

void EpollServer::acceptConnection() {
    while (running_) {
        struct sockaddr_in client_addr;
        socklen_t addr_len = sizeof(client_addr);
        int client_fd = accept(listen_fd_, (struct sockaddr *)&client_addr, &addr_len);
        if (client_fd < 0) {
            // 错误处理
            continue;
        }
        {
            std::unique_lock<std::mutex> lock(client_map_mtx_);
            if (client_map_.size() >= max_load_) {
                // 超过最大负载阈值，拒绝新的连接
                close(client_fd);
                continue;
            }
            client_map_.insert(client_fd);
        }
        // 设置套接字为非阻塞
        int flags = fcntl(client_fd, F_GETFL, 0);
        fcntl(client_fd, F_SETFL, flags | O_NONBLOCK);
        // 设置连接超时时间
        struct timeval timeout;
        timeout.tv_sec = connection_timeout_ / 1000;
        timeout.tv_usec = (connection_timeout_ % 1000) * 1000;
        setsockopt(client_fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
        setsockopt(client_fd, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
        // 将新的连接添加到 epoll 实例
        struct epoll_event ev;
        ev.events = EPOLLIN | EPOLLET;
        ev.data.fd = client_fd;
        if (epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, client_fd, &ev) < 0) {
            // 错误处理
        }
        // 新客户端连接成功，调用回调函数
        if (on_new_connection_) {
            on_new_connection_(client_fd);
        }
    }
}
void EpollServer::processEvents() {
    const int max_events = 10;
    struct epoll_event events[max_events];
    while (running_) {
        // 使用较小的超时值（例如 5000 毫秒）
        int nfds = epoll_wait(epoll_fd_, events, max_events, 5000);        
//       int nfds = epoll_wait(epoll_fd_, events, max_events, -1);
        if (nfds < 0) {
            // 错误处理
            continue;
        }
        for (int i = 0; i < nfds; i++) {
            // 将事件处理任务放入线程池
            thread_pool_.add_task(handleEvent, &events[i]);
        }
    }
}
void EpollServer::handleEvent(void *arg) {
    if (!arg) {
        // 错误处理
        return;
    }
    struct epoll_event *event = reinterpret_cast<epoll_event *>(arg);
    int client_fd = event->data.fd;
    if (event->events & EPOLLIN) {
        // 读取数据
        char buffer[1024];
        ssize_t bytes_read;
        // 使用循环读取，处理边缘触发模式
        while ((bytes_read = read(client_fd, buffer, sizeof(buffer))) > 0) {
            const std::string request(buffer, bytes_read);
            // 处理HTTP请求
            handleHttpRequest(client_fd, request);
        }
        if (bytes_read == 0 || (bytes_read < 0 && errno != EAGAIN && errno != EWOULDBLOCK)) {
            // 客户端关闭连接或发生错误，关闭套接字
            close(client_fd);
            // 从 client_map_ 中移除客户端套接字
            {
                std::unique_lock<std::mutex> lock(client_map_mtx_);
                client_map_.erase(client_fd);
            }
            // 如果存在 on_connection_closed_ 回调，则执行它
            if (on_connection_closed_) {
                on_connection_closed_(client_fd);
            }
        }
        // ...其他代码（获取客户端 IP、端口，发送消息等）
    } else if (event->events & EPOLLOUT) {
        // 写入数据
        // ...
        // 如果存在 on_write_ 回调，则执行它
        if (on_write_) {
            on_write_(client_fd);
        }
    } else if (event->events & (EPOLLERR | EPOLLHUP)) {
        // 错误处理
        if (on_error_) {
            on_error_(client_fd, "Error event occurred");
        }
    }
}
void handleHttpRequest(int client_fd, const std::string & request){
    std::string response;
    // 如果存在 on_read_ 回调，则执行它
    if (on_read_) {
        on_read_(client_fd, request);
    }
    
    // 解析请求路径
    std::istringstream iss(request);
    std::string method, path;
    iss >> method >> path;
    // 查找路径对应的请求处理函数
    auto handler_it = request_handlers_.find(path);
    if (handler_it != request_handlers_.end()) {
        // 调用路径对应的请求处理函数
        handler_it->second(request, response);
    } else if (default_request_handler_) {
        // 使用默认请求处理函数
        default_request_handler_(request, response);
    } else {
        // 没有找到请求处理函数，返回错误信息
        response = "HTTP/1.1 404 Not Found\r\n\r\n";
    }
    // 发送响应
    ssize_t bytes_written = write(client_fd, response.data(), response.size());
    if (bytes_written < 0) {
        // 错误处理
        if (on_error_) {
            on_error_(client_fd, "Failed to write response");
        }
        break;
    }
    // 递增 total_requests_
    total_requests_++;
}
bool EpollServer::init(const std::string &ip, uint16_t port, int thread_num) {
    ip_ = ip;
    // 创建监听套接字
    listen_fd_ = socket(AF_INET, SOCK_STREAM, 0);
    if (listen_fd_ < 0) {
        // 错误处理
        return false;
    }
    // 绑定 IP 和端口
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(port);
    inet_pton(AF_INET, ip.c_str(), &server_addr.sin_addr);
    if (bind(listen_fd_, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        // 错误处理
        return false;
    }
    // 开始监听
    if (listen(listen_fd_, SOMAXCONN) < 0) {
        // 错误处理
        return false;
    }
    // 创建 epoll 实例
    epoll_fd_ = epoll_create1(0);
    if (epoll_fd_ < 0) {
        // 错误处理
        return false;
    }
    // 初始化线程池
    if (!thread_pool_.init(thread_num)) {
        // 错误处理
        return false;
    }
    // 为start_time_赋值
    start_time_ = std::chrono::system_clock::now();
    return true;
}
void EpollServer::run() {
    running_ = true;
    accept_thread_ = std::thread(&EpollServer::acceptConnection, this);
    for (int i = 0; i < thread_pool_.thread_num(); i++) {
        event_threads_.emplace_back(&EpollServer::processEvents, this);
    }
     // 启动检查连接超时的线程
    timeout_thread_ = std::thread(&EpollServer::checkConnectionTimeout, this);
    // 等待线程结束
    accept_thread_.join();
    for (auto &t : event_threads_) {
        t.join();
    }
}
void EpollServer::stop() {
    running_ = false;
    // 通知所有已连接的客户端即将关闭连接
    for (const auto &connection : connections_) {
        shutdown(connection, SHUT_RDWR);
    }
    // 关闭监听套接字
    close(listen_fd_);
    // 关闭 epoll 实例
    close(epoll_fd_);
    // 停止线程池
    thread_pool_.stop();
    // 通知并等待线程结束
    accept_thread_.join();
    for (auto &t : event_threads_) {
        t.join();
    }
    // 等待检查连接超时的线程结束
    if (timeout_thread_.joinable()) {
        timeout_thread_.join();
    }
}
void EpollServer::setConnectionTimeout(int timeout) {
    if (timeout < 0) {
        throw std::invalid_argument("timeout must be a positive value");
    }
    connection_timeout_ = timeout;
}
void EpollServer::checkConnectionTimeout() {
    while (running_) {
        {
            std::unique_lock<std::mutex> lock(connection_time_mtx_);
            for (auto it = connection_time_map_.begin(); it != connection_time_map_.end();) {
                auto now = std::chrono::steady_clock::now();
                auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(now - it->second);
                if (duration.count() > connection_timeout_) {
                    // 超时，调用回调函数
                    if (on_timeout_) {
                        on_timeout_(it->first);
                    }
                    // ...断开连接等其他操作
                    // 从映射中删除超时的连接
                    it = connection_time_map_.erase(it);
                } else {
                    ++it;
                }
            }
        }
        // 检查间隔
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
}
void EpollServer::registerRequestHandler(const std::string &path, void (*handler)(const std::string &, std::string &)) {
    std::unique_lock<std::mutex> lock(client_map_mtx_);
    request_handlers_[path] = handler;
}
void EpollServer::setDefaultRequestHandler(const std::function<void(const std::string &, std::string &)> &handler) {
    default_request_handler_ = handler;
}
// 获取当前连接的客户端数量
size_t EpollServer::getClientCount() {
    std::unique_lock<std::mutex> lock(client_map_mtx_);
    return client_map_.size();
}
bool EpollServer::getClientConnections(std::vector<std::pair<std::string, uint16_t>>& client_connections) {
    std::unique_lock<std::mutex> lock(connection_time_mtx_);
    for (const auto& connection : client_map_) {
     std::pair<std::string, uint16_t> client_info = getClientInfo(connection.first);
    client_connections.emplace_back(client_info);
    }
    return true;
}
std::pair<std::string, uint16_t> EpollServer::getClientInfo(int client_fd) {
    struct sockaddr_in client_addr;
    socklen_t addr_len = sizeof(client_addr);
    if (getpeername(client_fd, (struct sockaddr *)&client_addr, &addr_len) < 0) {
        // 处理异常情况
        std::cerr << "Error getting client info: " << strerror(errno) << std::endl;
        return {"", 0};
    }
    char ip[INET_ADDRSTRLEN];
    inet_ntop(AF_INET, &client_addr.sin_addr, ip, sizeof(ip));
    return {ip, ntohs(client_addr.sin_port)};
}
bool EpollServer::disconnectClient(int client_fd, CloseType close_type) {
    if (close_type == CloseType::SHUTDOWN) {
        if (shutdown(client_fd, SHUT_RDWR) < 0) {
            std::cerr << "Error disconnecting client using shutdown: " << strerror(errno) << std::endl;
            return false;
        }
    } else if (close_type == CloseType::CLOSE) {
        if (close(client_fd) < 0) {
            std::cerr << "Error disconnecting client using close: " << strerror(errno) << std::endl;
            return false;
        }
    }
    if (epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, client_fd, nullptr) < 0) {
        // 错误处理
        std::cerr << "Error removing client from epoll: " << strerror(errno) << std::endl;
        return false;
    }
    std::unique_lock<std::mutex> lock(client_map_mtx_);
    client_map_.erase(client_fd);
    return true;
}
double EpollServer::getServerUptime() const {
    std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::seconds>(now - start_time_);
    return duration.count();
}
bool EpollServer::setMaxLoad(size_t max_load) {
    if (max_load == 0) {
        std::cerr << "Invalid max load value." << std::endl;
        return false;
    }
    std::unique_lock<std::mutex> lock(max_load_mtx_);
    max_load_ = max_load;
    return true;
}
   
void EpollServer::scheduleTimer(int interval, const std::function<void()>& task) {
    auto timer_thread = std::make_shared<std::thread>([this, interval, task]() {
        while (running_) {
            std::this_thread::sleep_for(std::chrono::seconds(interval));
            if (running_) {
                try {
                    task();
                } catch (const std::exception& e) {
                    std::cerr << "Exception in timer task: " << e.what() << std::endl;
                } catch (...) {
                    std::cerr << "Unknown exception in timer task" << std::endl;
                }
            }
        }
    });
    timer_thread->detach(); // 将定时器线程设置为分离状态
    {
        std::unique_lock<std::mutex> lock(timer_threads_mtx_);
        timer_threads_.push_back(timer_thread);
    }
}
uint16_t EpollServer::getPort() const {
    return port_;
}
uint64_t EpollServer::getTotalRequests() const {
    return total_requests_;
}
void EpollServer::sendMessage(int client_fd, const std::string &message) {
    std::lock_guard<std::mutex> lock(client_map_mtx_);
    auto it = client_map_.find(client_fd);
    if (it != client_map_.end()) {
        if (it->second->isConnected()) {
            try {
                it->second->sendMessage(message);
            } catch (const std::runtime_error &e) {
                // 处理异常情况，如：发送消息失败
                std::cerr << "Error sending message to client: " << e.what() << std::endl;
            }
        } else {
            std::cerr << "Error: client connection closed." << std::endl;
        }
    } else {
        std::cerr << "Error: client not found." << std::endl;
    }
}
void EpollServer::broadcastMessage(const std::string &message) {
    std::lock_guard<std::mutex> lock(client_map_mtx_);
    for (const auto &client_pair : client_map_) {
        if (client_pair.second->isConnected()) {
            try {
                client_pair.second->sendMessage(message);
            } catch (const std::runtime_error &e) {
                // 处理异常情况，如：发送消息失败
                std::cerr << "Error broadcasting message to client: " << e.what() << std::endl;
            }
        } else {
            std::cerr << "Error: client connection closed." << std::endl;
        }
    }
}
std::string EpollServer::getIPAddress() const {
    return ip_;
}
EpollServer::EpollServer()
    : running_(false),
      listen_fd_(-1),
      epoll_fd_(-1),
      connection_timeout_(0),
      max_load_(0),
      total_requests_(0),
      start_time_(std::chrono::system_clock::now()) {
}
EpollServer::~EpollServer() {
    if (running_) {
        stop();
    }
}
void EpollServer::setOnNewConnection(const std::function<void(int)> &callback) {
    on_new_connection_ = callback;
}
void EpollServer::setOnConnectionClosed(const std::function<void(int)> &callback) {
    on_connection_closed_ = callback;
}
void EpollServer::setOnRead(const std::function<void(int, const std::string &)> &callback) {
    on_read_ = callback;
}
void EpollServer::setOnWrite(const std::function<void(int)> &callback) {
    on_write_ = callback;
}
void EpollServer::setOnError(const std::function<void(int, const std::string &)> &callback) {
    on_error_ = callback;
}
void EpollServer::setOnTimeout(const std::function<void(int)> &callback) {
    on_timeout_ = callback;
}
// 开启 TLS 加密通信
bool EpollServer::enableTLS(const std::string &cert_file, const std::string &key_file) {
    try {
        // 创建并初始化 TLS 上下文，证书和私钥
        // 这里需要根据实际的 TLS 库进行实现
        // 示例代码：
        // tls_context_ = std::make_shared<TLSContext>(...);
        // tls_cert_ = std::make_shared<TLSCert>(cert_file);
        // tls_key_ = std::make_shared<TLSKey>(key_file);
        //
        // if (!tls_context_ || !tls_cert_ || !tls_key_) {
        //     throw std::runtime_error("Failed to create TLS context, cert or key");
        // }
        // 在此处实际配置 TLS，这取决于所使用的 TLS 库
        // 示例代码：
        // if (!tls_context_->configure(tls_cert_, tls_key_)) {
        //     throw std::runtime_error("Failed to configure TLS context");
        // }
        return true;
    } catch (const std::exception &e) {
        // 处理异常并打印错误信息
        std::cerr << "Error enabling TLS: " << e.what() << std::endl;
        return false;
    }
}