最新资讯

在Linux服务器开发中，I/O复用是应对高并发场景的核心技术之一。它允许程序同时监听多个文件描述符（如socket），高效处理大量客户端连接而避免创建过多进程/线程带来的开销。本文将围绕I/O复用技术（select/poll/epoll）展开，构建一套可复用的服务器框架代码结构，并补充关键技术细节与实践示例，帮助开发者快速落地高性能服务器应用。

一、I/O复用技术选型：从原理到场景

Linux提供三种主流I/O复用系统调用：select、poll和epoll。在设计可复用框架前，需先明确三者的差异与适用场景，确保框架的通用性和性能适配性。

1.1 核心技术对比

下表从文件描述符上限、效率、数据结构等维度对比三种技术：

// I/O复用技术核心差异对比
| 特性                | select                  | poll                    | epoll                  |
|---------------------|-------------------------|-------------------------|------------------------|
| 文件描述符上限      | FD_SETSIZE（默认1024）  | 无上限（受系统资源限制）| 无上限（受系统资源限制）|
| 效率                | O(n)（轮询所有FD）      | O(n)（轮询所有FD）      | O(1)（事件通知）       |
| 数据结构            | fd_set（位掩码）        | pollfd数组              | 红黑树+就绪链表        |
| 触发方式            | 水平触发（LT）          | 水平触发（LT）          | LT/边缘触发（ET）       |
| 内存拷贝            | 每次调用拷贝FD集合      | 每次调用拷贝pollfd数组  | 仅初始化时拷贝         |
| 适用场景            | 小规模连接（<1000）    | 中等规模连接            | 高并发大规模连接       |

1.2 框架技术选型：epoll优先，兼容select/poll

考虑到高并发场景的普遍性，框架核心采用epoll实现I/O复用，但通过抽象层封装，预留select/poll的适配接口，确保在资源受限或旧系统环境下的兼容性。

epoll的核心优势在于：

• 事件驱动模型：仅通知就绪的文件描述符，避免无效轮询
• 边缘触发（ET）模式：减少重复触发次数，提升高并发处理效率
• 无FD上限：支持十万级以上并发连接

epoll工作原理示意图

二、可复用服务器框架的分层结构

为实现代码复用与维护性，框架采用分层设计，从下到上依次为：基础工具层、I/O复用抽象层、事件处理层、业务逻辑层。每层职责单一，通过接口解耦，便于替换或扩展。

2.1 基础工具层：通用能力封装

基础工具层提供框架依赖的通用功能，确保核心逻辑不依赖第三方库，提升可移植性。以下是关键工具模块的实现示例：

日志模块（log.h）

#ifndef _LOG_H_
#define _LOG_H_

#include 
#include 
#include 

// 日志级别
typedef enum {
    LOG_DEBUG,
    LOG_INFO,
    LOG_WARN,
    LOG_ERROR
} LogLevel;

// 设置日志级别
void log_set_level(LogLevel level);

// 日志输出（支持格式化）
void log_print(LogLevel level, const char* file, int line, const char* fmt, ...);

// 日志宏（自动填充文件和行号）
#define LOG_DEBUG(fmt, ...) log_print(LOG_DEBUG, __FILE__, __LINE__, fmt, ##__VA_ARGS__)
#define LOG_INFO(fmt, ...)  log_print(LOG_INFO,  __FILE__, __LINE__, fmt, ##__VA_ARGS__)
#define LOG_WARN(fmt, ...)  log_print(LOG_WARN,  __FILE__, __LINE__, fmt, ##__VA_ARGS__)
#define LOG_ERROR(fmt, ...) log_print(LOG_ERROR, __FILE__, __LINE__, fmt, ##__VA_ARGS__)

#endif // _LOG_H_

日志模块实现（log.c）

#include "log.h"
#include 

static LogLevel g_log_level = LOG_INFO; // 默认日志级别

void log_set_level(LogLevel level) {
    g_log_level = level;
}

void log_print(LogLevel level, const char* file, int line, const char* fmt, ...) {
    if (level < g_log_level) return;

    // 日志级别字符串
    const char* level_str[] = {"DEBUG", "INFO", "WARN", "ERROR"};
    
    // 获取当前时间
    time_t now = time(NULL);
    struct tm* tm = localtime(&now);
    char time_str[32];
    strftime(time_str, sizeof(time_str), "%Y-%m-%d %H:%M:%S", tm);

    // 输出日志头部（时间、级别、文件、行号）
    printf("[%s] [%s] [%s:%d] ", time_str, level_str[level], file, line);

    // 输出日志内容（格式化）
    va_list args;
    va_start(args, fmt);
    vprintf(fmt, args);
    va_end(args);
    printf("
");
}

// 使用示例：
// LOG_INFO("Server start on port %d", 8080);
// LOG_ERROR("Socket create failed: %s", strerror(errno));

2.2 I/O复用抽象层：统一接口设计

I/O复用抽象层定义统一的接口，屏蔽select/poll/epoll的实现差异。核心接口包括：创建复用实例、添加/删除事件、等待事件就绪、销毁实例。

I/O复用抽象接口（io_multiplex.h）

#ifndef _IO_MULTIPLEX_H_
#define _IO_MULTIPLEX_H_

#include 
#include 

// I/O复用类型
typedef enum {
    IO_MULTIPLEX_SELECT,
    IO_MULTIPLEX_POLL,
    IO_MULTIPLEX_EPOLL
} IOType;

// 事件类型
typedef enum {
    IO_EVENT_READ = 1 << 0,  // 可读事件
    IO_EVENT_WRITE = 1 << 1, // 可写事件
    IO_EVENT_ERROR = 1 << 2  // 异常事件
} IOEvent;

// I/O复用实例（ opaque 结构体，隐藏实现细节）
typedef struct IO_Multiplex IO_Multiplex;

// 创建I/O复用实例
IO_Multiplex* io_multiplex_create(IOType type);

// 添加文件描述符及关注的事件
int io_multiplex_add(IO_Multiplex* io, int fd, IOEvent events);

// 删除文件描述符
int io_multiplex_del(IO_Multiplex* io, int fd);

// 修改文件描述符关注的事件
int io_multiplex_modify(IO_Multiplex* io, int fd, IOEvent events);

// 等待事件就绪（timeout：超时时间，单位ms，-1表示阻塞）
// 返回就绪的文件描述符数量，输出参数fds和events数组存储就绪的FD和事件
int io_multiplex_wait(IO_Multiplex* io, int timeout, int* fds, IOEvent* events, int max_fds);

// 销毁I/O复用实例
void io_multiplex_destroy(IO_Multiplex* io);

#endif // _IO_MULTIPLEX_H_

以下是epoll实现的核心代码，select/poll实现可参考类似逻辑，通过统一接口对外提供服务：

epoll实现（io_multiplex_epoll.c）

#include "io_multiplex.h"
#include 
#include 
#include 
#include 
#include "log.h"

// epoll实现的私有结构体
struct IO_Multiplex {
    IOType type;
    int epoll_fd;          // epoll文件描述符
    struct epoll_event* events; // 就绪事件数组
    int max_events;        // 就绪事件数组最大长度
};

// 创建epoll实例（默认最大就绪事件数1024）
IO_Multiplex* io_multiplex_create(IOType type) {
    if (type != IO_MULTIPLEX_EPOLL) {
        LOG_ERROR("Unsupported IO type for epoll implementation");
        return NULL;
    }

    IO_Multiplex* io = (IO_Multiplex*)malloc(sizeof(IO_Multiplex));
    if (!io) {
        LOG_ERROR("Malloc IO_Multiplex failed: %s", strerror(errno));
        return NULL;
    }

    // 创建epoll实例
    io->epoll_fd = epoll_create1(EPOLL_CLOEXEC); // 执行exec时关闭FD
    if (io->epoll_fd == -1) {
        LOG_ERROR("epoll_create1 failed: %s", strerror(errno));
        free(io);
        return NULL;
    }

    io->type = type;
    io->max_events = 1024;
    io->events = (struct epoll_event*)malloc(sizeof(struct epoll_event) * io->max_events);
    if (!io->events) {
        LOG_ERROR("Malloc epoll events failed: %s", strerror(errno));
        close(io->epoll_fd);
        free(io);
        return NULL;
    }

    LOG_INFO("Epoll IO multiplex created, epoll_fd: %d", io->epoll_fd);
    return io;
}

// 添加FD及事件（默认边缘触发ET）
int io_multiplex_add(IO_Multiplex* io, int fd, IOEvent events) {
    if (!io || fd < 0 || events == 0) {
        LOG_ERROR("Invalid parameter: io=%p, fd=%d, events=%d", io, fd, events);
        return -1;
    }

    struct epoll_event ev;
    memset(&ev, 0, sizeof(ev));
    
    // 转换自定义事件类型到epoll事件类型
    if (events & IO_EVENT_READ) ev.events |= EPOLLIN | EPOLLET; // 读事件+边缘触发
    if (events & IO_EVENT_WRITE) ev.events |= EPOLLOUT | EPOLLET; // 写事件+边缘触发
    if (events & IO_EVENT_ERROR) ev.events |= EPOLLERR | EPOLLHUP; // 异常事件

    ev.data.fd = fd;

    // 添加事件到epoll实例
    if (epoll_ctl(io->epoll_fd, EPOLL_CTL_ADD, fd, &ev) == -1) {
        LOG_ERROR("epoll_ctl ADD failed (fd=%d): %s", fd, strerror(errno));
        return -1;
    }

    LOG_DEBUG("Add fd=%d to epoll, events=0x%x", fd, events);
    return 0;
}

// 等待事件就绪
int io_multiplex_wait(IO_Multiplex* io, int timeout, int* fds, IOEvent* events, int max_fds) {
    if (!io || !fds || !events || max_fds <= 0) {
        LOG_ERROR("Invalid parameter: io=%p, fds=%p, events=%p, max_fds=%d", 
                  io, fds, events, max_fds);
        return -1;
    }

    // 等待事件就绪
    int ready = epoll_wait(io->epoll_fd, io->events, io->max_events, timeout);
    if (ready == -1) {
        if (errno == EINTR) {
            LOG_DEBUG("epoll_wait interrupted by signal");
            return 0; // 信号中断，返回0（非错误）
        }
        LOG_ERROR("epoll_wait failed: %s", strerror(errno));
        return -1;
    } else if (ready == 0) {
        LOG_DEBUG("epoll_wait timeout");
        return 0; // 超时，无就绪事件
    }

    // 处理就绪事件，转换为自定义事件类型
    int count = 0;
    for (int i = 0; i < ready && count < max_fds; i++) {
        struct epoll_event* ev = &io->events[i];
        int fd = ev->data.fd;
        IOEvent ev_type = 0;

        if (ev->events & (EPOLLIN | EPOLLPRI)) ev_type |= IO_EVENT_READ;
        if (ev->events & EPOLLOUT) ev_type |= IO_EVENT_WRITE;
        if (ev->events & (EPOLLERR | EPOLLHUP)) ev_type |= IO_EVENT_ERROR;

        if (ev_type != 0) {
            fds[count] = fd;
            events[count] = ev_type;
            count++;
            LOG_DEBUG("FD=%d ready, events=0x%x", fd, ev_type);
        }
    }

    return count; // 返回就绪的FD数量
}

// 销毁epoll实例
void io_multiplex_destroy(IO_Multiplex* io) {
    if (io) {
        if (io->epoll_fd != -1) {
            close(io->epoll_fd);
            LOG_INFO("Epoll fd=%d closed", io->epoll_fd);
        }
        free(io->events);
        free(io);
        LOG_INFO("Epoll IO multiplex destroyed");
    }
}

// 注：io_multiplex_del和io_multiplex_modify实现类似，
// 分别调用epoll_ctl(EPOLL_CTL_DEL)和epoll_ctl(EPOLL_CTL_MOD)，
// 此处省略以简化代码

2.3 事件处理层：连接与请求管理

事件处理层基于I/O复用抽象层，实现连接的建立、请求的读取与解析、响应的构建与发送。核心逻辑包括：监听socket初始化、新连接接收、读写事件处理。

事件处理核心逻辑（event_handler.c）

#include "event_handler.h"
#include "io_multiplex.h"
#include "log.h"
#include 
#include 
#include 
#include 
#include 
#include 

#define MAX_READ_BUFFER 4096  // 读缓冲区大小
#define MAX_READY_FDS  1024  // 单次最大就绪FD数量

// 服务器上下文
typedef struct {
    IO_Multiplex* io;        // I/O复用实例
    int listen_fd;          // 监听socket
    uint16_t port;          // 监听端口
    EventCallback callback; // 业务逻辑回调函数
} ServerContext;

// 创建服务器实例
ServerContext* server_create(IOType io_type, uint16_t port, EventCallback callback) {
    if (port == 0 || !callback) {
        LOG_ERROR("Invalid parameter: port=%d, callback=%p", port, callback);
        return NULL;
    }

    // 1. 创建I/O复用实例
    IO_Multiplex* io = io_multiplex_create(io_type);
    if (!io) {
        LOG_ERROR("Create IO multiplex failed");
        return NULL;
    }

    // 2. 创建监听socket
    int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (listen_fd == -1) {
        LOG_ERROR("Socket create failed: %s", strerror(errno));
        io_multiplex_destroy(io);
        return NULL;
    }

    // 3. 设置socket选项（复用端口、非阻塞）
    int opt = 1;
    if (setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) == -1) {
        LOG_WARN("setsockopt SO_REUSEADDR failed: %s", strerror(errno));
    }
    if (setsockopt(listen_fd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt)) == -1) {
        LOG_WARN("setsockopt SO_REUSEPORT failed: %s", strerror(errno));
    }

    // 4. 绑定地址
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY); // 监听所有网卡
    addr.sin_port = htons(port);
    if (bind(listen_fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
        LOG_ERROR("Bind port %d failed: %s", port, strerror(errno));
        close(listen_fd);
        io_multiplex_destroy(io);
        return NULL;
    }

    // 5. 开始监听
    if (listen(listen_fd, 1024) == -1) { // 监听队列大小1024
        LOG_ERROR("Listen failed: %s", strerror(errno));
        close(listen_fd);
        io_multiplex_destroy(io);
        return NULL;
    }

    // 6. 将监听FD添加到I/O复用（关注读事件）
    if (io_multiplex_add(io, listen_fd, IO_EVENT_READ) == -1) {
        LOG_ERROR("Add listen fd to IO multiplex failed");
        close(listen_fd);
        io_multiplex_destroy(io);
        return NULL;
    }

    // 7. 创建服务器上下文
    ServerContext* ctx = (ServerContext*)malloc(sizeof(ServerContext));
    if (!ctx) {
        LOG_ERROR("Malloc ServerContext failed: %s", strerror(errno));
        close(listen_fd);
        io_multiplex_destroy(io);
        return NULL;
    }
    ctx->io = io;
    ctx->listen_fd = listen_fd;
    ctx->port = port;
    ctx->callback = callback;

    LOG_INFO("Server created, listen on 0.0.0.0:%d, listen_fd=%d", port, listen_fd);
    return ctx;
}

// 处理新连接
static int handle_new_connection(ServerContext* ctx) {
    struct sockaddr_in client_addr;
    socklen_t client_addr_len = sizeof(client_addr);
    memset(&client_addr, 0, sizeof(client_addr));

    // 接受新连接（非阻塞，因监听FD已设置为非阻塞）
    int conn_fd = accept4(ctx->listen_fd, (struct sockaddr*)&client_addr, 
                         &client_addr_len, SOCK_NONBLOCK);
    if (conn_fd == -1) {
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            LOG_DEBUG("No more new connections");
            return 0;
        }
        LOG_ERROR("Accept failed: %s", strerror(errno));
        return -1;
    }

    // 将新连接FD添加到I/O复用（关注读事件）
    if (io_multiplex_add(ctx->io, conn_fd, IO_EVENT_READ) == -1) {
        LOG_ERROR("Add conn fd=%d to IO multiplex failed", conn_fd);
        close(conn_fd);
        return -1;
    }

    LOG_INFO("New connection from %s:%d, conn_fd=%d", 
             inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port), conn_fd);
    return 0;
}

// 处理读写事件
static int handle_io_event(ServerContext* ctx, int fd, IOEvent events) {
    char buffer[MAX_READ_BUFFER];
    memset(buffer, 0, sizeof(buffer));

    // 处理读事件
    if (events & IO_EVENT_READ) {
        ssize_t n = read(fd, buffer, sizeof(buffer)-1);
        if (n == -1) {
            if (errno == EAGAIN || errno == EWOULDBLOCK) {
                LOG_DEBUG("FD=%d no more data to read", fd);
                return 0;
            }
            LOG_ERROR("Read FD=%d failed: %s", fd, strerror(errno));
            goto close_conn;
        } else if (n == 0) {
            LOG_INFO("FD=%d client closed connection", fd);
            goto close_conn;
        }

        // 调用业务逻辑回调处理请求
        buffer[n] = '';
        LOG_DEBUG("Read from FD=%d: %s (len=%zd)", fd, buffer, n);
        ctx->callback(fd, buffer, n);
    }

    // 处理写事件（示例：业务逻辑回调后如需写数据，可在此处处理）
    if (events & IO_EVENT_WRITE) {
        LOG_DEBUG("FD=%d ready for write", fd);
        // 实际场景中，需缓存待发送数据，此处省略
    }

    // 处理异常事件
    if (events & IO_EVENT_ERROR) {
        LOG_ERROR("FD=%d has error", fd);
        goto close_conn;
    }

    return 0;

close_conn:
    // 从I/O复用中删除FD，关闭连接
    io_multiplex_del(ctx->io, fd);
    close(fd);
    LOG_DEBUG("FD=%d closed", fd);
    return 0;
}

// 服务器运行主循环
int server_run(ServerContext* ctx) {
    if (!ctx) {
        LOG_ERROR("Invalid ServerContext");
        return -1;
    }

    int fds[MAX_READY_FDS];
    IOEvent events[MAX_READY_FDS];

    LOG_INFO("Server start running...");
    while (1) {
        // 等待事件就绪（阻塞模式，timeout=-1）
        int ready = io_multiplex_wait(ctx->io, -1, fds, events, MAX_READY_FDS);
        if (ready < 0) {
            LOG_ERROR("IO multiplex wait failed");
            break;
        } else if (ready == 0) {
            continue; // 超时，继续循环
        }

        // 处理每个就绪的FD
        for (int i = 0; i < ready; i++) {
            int fd = fds[i];
            IOEvent ev = events[i];

            // 区分监听FD和普通连接FD
            if (fd == ctx->listen_fd) {
                // 处理新连接
                handle_new_connection(ctx);
            } else {
                // 处理读写事件
                handle_io_event(ctx, fd, ev);
            }
        }
    }

    return -1;
}

// 销毁服务器实例
void server_destroy(ServerContext* ctx) {
    if (ctx) {
        if (ctx->listen_fd != -1) {
            close(ctx->listen_fd);
            LOG_INFO("Listen fd=%d closed", ctx->listen_fd);
        }
        io_multiplex_destroy(ctx->io);
        free(ctx);
        LOG_INFO("Server destroyed");
    }
}

2.4 业务逻辑层：可复用的业务扩展

业务逻辑层通过回调函数与事件处理层解耦，开发者只需实现具体业务逻辑（如echo服务、HTTP服务），即可接入框架。以下是echo服务的实现示例：

echo服务业务逻辑（echo_service.c）

#include "event_handler.h"
#include "log.h"
#include 
#include 

// echo服务回调函数：将接收到的数据原样返回
void echo_callback(int fd, const char* data, size_t len) {
    if (fd < 0 || !data || len == 0) {
        LOG_ERROR("Invalid parameter for echo callback");
        return;
    }

    // 原样返回数据（非阻塞写，需处理EAGAIN）
    ssize_t n = write(fd, data, len);
    if (n == -1) {
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            LOG_WARN("FD=%d write would block, need to buffer data", fd);
            // 实际场景中需缓存数据，后续可写时再发送
            return;
        }
        LOG_ERROR("Write FD=%d failed: %s", fd, strerror(errno));
        return;
    }

    LOG_DEBUG("Echo to FD=%d: %s (len=%zd, written=%zd)", fd, data, len, n);
}

// 启动echo服务器
int main(int argc, char* argv[]) {
    if (argc != 2) {
        fprintf(stderr, "Usage: %s 
", argv[0]);
        return 1;
    }

    // 设置日志级别为DEBUG
    log_set_level(LOG_DEBUG);

    // 解析端口
    uint16_t port = atoi(argv[1]);
    if (port == 0 || port > 65535) {
        LOG_ERROR("Invalid port: %s", argv[1]);
        return 1;
    }

    // 创建服务器（使用epoll）
    ServerContext* ctx = server_create(IO_MULTIPLEX_EPOLL, port, echo_callback);
    if (!ctx) {
        LOG_ERROR("Create echo server failed");
        return 1;
    }

    // 运行服务器
    server_run(ctx);

    // 销毁服务器（异常退出时）
    server_destroy(ctx);
    return 0;
}

// 编译命令：
// gcc -o echo_server echo_service.c event_handler.c io_multiplex.c io_multiplex_epoll.c log.c -Wall
// 运行：./echo_server 8080
// 测试：telnet 127.0.0.1 8080，输入任意字符，服务器将原样返回

三、框架性能优化与实践建议

注意：可复用框架不仅要保证代码的通用性，还需兼顾性能。以下优化点基于Linux内核特性与网络编程最佳实践，适用于高并发场景。

3.1 边缘触发（ET）模式的正确使用

epoll的ET模式仅在FD状态从“未就绪”变为“就绪”时触发一次事件，需注意：

• 所有FD必须设置为非阻塞：避免单次读写阻塞导致其他FD无法处理
• 读写操作需循环执行：直到返回EAGAIN/EWOULDBLOCK，确保数据读写完整

ET模式下的循环读示例

ssize_t read_all(int fd, char* buffer, size_t max_len) {
    size_t total = 0;
    while (total < max_len) {
        ssize_t n = read(fd, buffer + total, max_len - total);
        if (n == -1) {
            if (errno == EAGAIN || errno == EWOULDBLOCK) {
                LOG_DEBUG("Read all data (total=%zd)", total);
                return total; // 无更多数据，返回已读长度
            }
            LOG_ERROR("Read failed: %s", strerror(errno));
            return -1;
        } else if (n == 0) {
            LOG_DEBUG("Peer closed connection during read");
            return total; // 对方关闭连接，返回已读长度
        }
        total += n;
    }
    LOG_DEBUG("Read buffer full (total=%zd)", total);
    return total;
}

3.2 内存池与连接池：减少动态分配开销

高并发场景下，频繁malloc/free会导致内存碎片和性能损耗。框架可引入：

• 内存池：预先分配固定大小的内存块，用于存储连接上下文、读写缓冲区
• 连接池：对于长连接服务（如HTTP/2），复用已建立的连接，避免频繁TCP握手

3.3 系统参数调优：提升内核承载能力

Linux默认参数可能限制高并发性能，需修改以下内核参数（临时生效，重启后失效）：

# 1. 增大文件描述符上限（临时）
ulimit -n 65535

# 2. 永久修改文件描述符上限（需重启）
echo "* soft nofile 65535" >> /etc/security/limits.conf
echo "* hard nofile 65535" >> /etc/security/limits.conf

# 3. 调整epoll相关参数
echo 100000 > /proc/sys/net/core/somaxconn       # 监听队列最大长度
echo 1 > /proc/sys/net/ipv4/tcp_tw_reuse        # 复用TIME_WAIT状态的连接
echo 5 > /proc/sys/net/ipv4/tcp_fin_timeout     # TIME_WAIT超时时间（秒）
echo 2000 > /proc/sys/net/ipv4/tcp_max_syn_backlog # SYN队列最大长度

四、总结与扩展

本文构建的基于I/O复用的服务器框架，通过分层设计实现了代码的可复用性与可扩展性：

• 基础工具层提供通用能力，避免重复开发
• I/O复用抽象层屏蔽技术差异，支持多场景适配
• 事件处理层统一连接与事件管理，降低业务耦合
• 业务逻辑层通过回调扩展，快速接入新服务

后续可扩展方向：

• 支持HTTPS：集成OpenSSL库，添加TLS加密功能
• 多线程/多进程扩展：结合线程池，利用多核CPU资源
• 监控与统计：添加连接数、QPS、延迟等指标的统计与暴露
• 配置化：支持通过配置文件设置端口、日志级别、I/O复用类型等参数