Linux C/C++ 学习日记（20）：实现一个简易的百万并发服务器（三）：代码测试，理解影响服务器CPU和内存的因素

注：该文用于个人学习记录和知识交流，如有不足，欢迎指点。

代码在最后面，大家可以拷贝下来运行一下，按着我的步骤测试

希望大家做完这个百万并发服务器实验，能够明白影响CPU、内存变化的因素，这样我们才能够依此优化我们的代码和参数配置！！！

一、运行代码测试

运行4台虚拟机：1台做服务器、3台做客户端。3台客户端同时向服务器请求连接。

该代码测试需要花费11-12分钟（根据测试可知每0.7s建立1000个连接可知）

htop实时查看CPU、内存的大小。

1.第一次记录（连接请求前）

初始内存：1.58G

2.之后每隔20万个连接记录一次

                                                          图1（20万连接）

                                                      图2（40万连接）

                                                        图3（60万连接）

                                                           图4（80万连接）

                                                               图5（100万连接）

3. 此时3个客户端都已到达设置的最大连接数（34000条连接），服务器端有1020000个连接：

3.1 我们快速断开3个客户端程序，同一时间关闭100万条连接。观察CPU突然暴增！！！！

3.2 过一会后回复正常

3.3 .此时关闭服务器，发现CPU暴增！！！

二、 数据分析

1. 百万服务器内存变化量

0-20万：0.56GB

20万-40万：0.56GB

40万-60万：0.56GB

60万-80万：0.56GB

80万-100万：0.54GB

根据我的参数配置解释

2. 三个客户端同时按“CTRL C”强制关闭，服务器端CPU突然飙升

总的来说：

1.同时要处理100万个TCP断开，内核同时回收大量的连接资源 

2.TCP 全局锁、nf_conntrack 哈希表锁等全局锁竞争激烈，上下文切换开销大；

3.我们再制造大型服务器时一定要对大量用户同时断开连接导致CPU飙升这一情况做出优化！！！

3.服务器强制关闭，CPU飙升原因

当服务器进程被强制终止（如 kill -2）且未主动调用close()时。

以上这些都会使CPU增加。至于为什么客户端明明都已经断开了，服务器CPU突然飙升，然后又逐步下降，接着再关闭服务器端，服务器端CPU又突然飙射的原因：

我的看法是，服务器端强制关闭，会更快的触发TCP连接断开的信号，资源回收的更加迅速，所以有种CPU又飙升的现象。

4. 对比 “服务器主动 close() 触发四次挥手”，强制中断的 CPU 压力更小，核心差异：

简言之：RST 是 “暴力断开”，跳过了四次挥手的状态等待和多轮报文交互，内核操作更 “轻量化”，因此 CPU 峰值通常更低。

（大家不信的话可以通过修改代码来对比观察，本代码是强制中断，大家可用编写一个信号捕捉函数handle捕获SIGINT为2的信号实现正常的close。）

三、CPU和内存的差异

1.本质区别：角色与功能

2.CPU 使用率变化的核心因素

CPU 使用率反映其运算资源的繁忙程度，波动由 “指令执行的密集度” 决定：

结合”强制关闭客户端，100万个连接同时断开，服务器CPU飙升“来理解：

备注：

3.内存使用率变化的核心因素

四、代码样例：

代码设计看不懂的可以去看我之前的文章：这里简要说明一下

Linux C/C++ 学习日记（11）select/poll/epoll 实现网络io的多路复用-CSDN博客

Linux C/C++ 学习日记（14）：TCP协议头、TCP的五元组结构、TCP连接的状态转移详解-CSDN博客

客户端使用的端口有1024 – 65535 （64511）个，3台客户端共可用的端口有193,533个。

根据TCP的五元组结构可知，服务器提供可连接的端口至少为6个（本程序中提供了100个）。

1. 服务器代码

#include <stdio.h> // 标准输入输出库（用于printf、perror等）
#include <string.h> // 字符串处理库（用于memset、memcpy等内存操作）
#include <stdlib.h> // 标准库（用于atoi、exit等）

#include <netinet/tcp.h> // TCP协议相关定义（如TCP选项）
#include <arpa/inet.h> // 网络地址转换库（用于htons、inet_addr等）
#include <pthread.h> // 线程库（本代码未使用，仅包含，可根据需求移除）

#include <errno.h> // 错误处理库（用于errno变量，判断系统调用错误）
#include <fcntl.h> // 文件控制库（用于fcntl设置非阻塞IO）
#include <unistd.h> // 系统调用库（用于close、read、write、sleep等）
#include <sys/epoll.h> // epoll IO多路复用库（核心：epoll_create、epoll_wait、epoll_ctl）
#include <sys/time.h> // 时间库（用于gettimeofday获取系统时间，统计连接建立耗时）

// 宏定义：全局常量配置
#define BUFFER_LENGTH 1024 // 接收数据的缓冲区大小（1024字节）
#define EPOLL_SIZE 1024 // epoll事件数组的最大容量（一次最多处理1024个就绪事件）
#define MAX_PORT 100 // 服务器监听的端口数量（共100个连续端口）
// 宏定义：计算两个timeval结构体的时间差（单位：毫秒）
#define TIME_SUB_MS(tv1, tv2) ((tv1.tv_sec – tv2.tv_sec) * 1000 + (tv1.tv_usec – tv2.tv_usec) / 1000)

/**
* @brief 判断当前文件描述符（fd）是否为监听fd
* @param fd 待判断的文件描述符
* @param fds 存储所有监听fd的数组（sockfds）
* @return 若fd是监听fd，返回该fd；否则返回0
*/
int islistenfd(int fd, int *fds)
{
// 遍历所有监听fd（共MAX_PORT个）
int i = 0;
for (i = 0; i < MAX_PORT; i++)
{
// 匹配到监听fd，返回该fd
if (fd == *(fds + i))
return fd;
}
// 未匹配，返回0（表示是客户端fd）
return 0;
}

// 程序入口：./tcp_server 起始端口号（如./tcp_server 8888，监听8888~8987共100个端口）
int main(int argc, char *argv[])
{
// 1. 命令行参数校验：需传入起始端口号（argc至少为2）
if (argc < 2)
{
printf("Param Error: 请传入起始端口号，格式：./tcp_server [起始端口]\\n");
return -1;
}

// 时间变量：用于统计每1000个连接的建立耗时
struct timeval tv_begin;
gettimeofday(&tv_begin, NULL); // 初始化起始时间（获取当前系统时间）
int connections = 0; // 统计当前服务器的总连接数

// 解析命令行参数：获取起始端口号（字符串转整数）
int port = atoi(argv[1]);
int sockfds[MAX_PORT] = {0}; // 存储所有监听fd的数组（共MAX_PORT个）
// 创建epoll实例：参数1为"size"（已废弃，仅需传入大于0的值即可），返回epoll文件描述符
int epfd = epoll_create(1);
if (epfd < 0) { // 容错：epoll创建失败
perror("epoll_create failed");
return 1;
}

// 2. 循环创建MAX_PORT个监听socket（每个socket对应一个端口）
int i = 0;
for (i = 0; i < MAX_PORT; i++)
{
// 创建TCP socket：AF_INET（IPv4）、SOCK_STREAM（流式TCP）、0（默认协议）
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) { // 容错：socket创建失败
perror("socket failed");
return 2;
}

// 初始化服务器地址结构（IPv4）
struct sockaddr_in addr;
memset(&addr, 0, sizeof(struct sockaddr_in)); // 内存清零（避免脏数据）
addr.sin_family = AF_INET; // 地址族：IPv4
addr.sin_port = htons(port + i); // 端口号：起始端口+i（如8888+0=8888，8888+1=8889…）
addr.sin_addr.s_addr = INADDR_ANY; // 绑定所有网卡的IP（0.0.0.0）

// 绑定socket到指定端口（将sockfd与addr关联）
if (bind(sockfd, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)) < 0)
{
perror("bind failed"); // 打印错误原因（如端口被占用）
close(sockfd); // 关闭已创建的socket，避免资源泄漏
return 2;
}

// 监听socket：进入被动连接状态，backlog=5（未完成连接队列的最大长度）
if (listen(sockfd, 5) < 0)
{
perror("listen failed");
close(sockfd);
return 3;
}
// 打印监听信息：提示当前监听的端口号
printf("tcp server listen on port : %d\\n", port + i);

// 将监听fd加入epoll：关注"读事件"（EPOLLIN，有新连接时触发）
struct epoll_event ev; // epoll事件结构
ev.events = EPOLLIN; // 监听的事件类型：读事件（新连接请求）
ev.data.fd = sockfd; // 绑定当前监听fd到事件结构
// epoll控制：EPOLL_CTL_ADD（添加事件）、epfd（epoll实例）、sockfd（目标fd）、&ev（事件配置）
epoll_ctl(epfd, EPOLL_CTL_ADD, sockfd, &ev);

// 将当前监听fd存入数组，供后续islistenfd函数判断
sockfds[i] = sockfd;
}

// 3. epoll主循环：持续等待并处理就绪事件（新连接/客户端数据）
struct epoll_event events[EPOLL_SIZE] = {0}; // 存储就绪事件的数组
while (1) // 无限循环（服务器常驻）
{
// 等待epoll事件：epfd（epoll实例）、events（就绪事件数组）、EPOLL_SIZE（数组最大容量）、5（超时时间，单位ms，5ms无事件则返回0）
int nready = epoll_wait(epfd, events, EPOLL_SIZE, 5);
if (nready == -1) { // 容错：epoll_wait出错（如被信号中断），跳过本次循环
continue;
}

// 遍历所有就绪事件（nready为就绪事件数量）
int i = 0;
for (i = 0; i < nready; i++)
{
// 3.1 处理监听fd的事件（新连接请求）
// 判断当前就绪fd是否为监听fd（调用islistenfd函数）
int sockfd = islistenfd(events[i].data.fd, sockfds);
if (sockfd) // 是监听fd：有新客户端连接请求
{
// 初始化客户端地址结构：用于存储客户端的IP和端口
struct sockaddr_in client_addr;
memset(&client_addr, 0, sizeof(struct sockaddr_in));
socklen_t client_len = sizeof(client_addr); // 地址长度（传入传出参数）

// 接受新连接：从监听队列中取出一个连接，返回客户端fd（与客户端通信的句柄）
int clientfd = accept(sockfd, (struct sockaddr *)&client_addr, &client_len);
if (clientfd < 0) { // 容错：accept失败（如连接队列空）
perror("accept failed");
continue;
}

// 设置客户端fd为非阻塞模式：避免recv/send阻塞导致服务器卡死
fcntl(clientfd, F_SETFL, O_NONBLOCK);

// 设置socket选项：SO_REUSEADDR（端口复用），避免连接断开后端口处于TIME_WAIT状态无法立即复用
int reuse = 1;
setsockopt(clientfd, SOL_SOCKET, SO_REUSEADDR, (char *)&reuse, sizeof(reuse));

// 将客户端fd加入epoll：关注"读事件+边缘触发"（EPOLLET，高并发场景常用，减少事件触发次数）
struct epoll_event ev;
ev.events = EPOLLIN | EPOLLET; // 边缘触发（仅在状态变化时触发一次）
ev.data.fd = clientfd;
epoll_ctl(epfd, EPOLL_CTL_ADD, clientfd, &ev);

// 连接数+1，并统计耗时（每1000个连接或达到100万连接时打印）
connections++;
if (connections % 1000 == 999 || connections >= 1000000)
{
struct timeval tv_cur;
memcpy(&tv_cur, &tv_begin, sizeof(struct timeval)); // 保存上一次统计的起始时间
gettimeofday(&tv_begin, NULL); // 更新当前时间为新的起始时间
int time_used = TIME_SUB_MS(tv_begin, tv_cur); // 计算这1000个连接的建立耗时（ms）
printf("connections: %d, time_used:%d ms\\n", connections, time_used);
}
}
// 3.2 处理客户端fd的事件（客户端发送数据/断开连接）
else
{
int clientfd = events[i].data.fd; // 获取就绪的客户端fd

// 接收客户端数据：buffer（接收缓冲区）、BUFFER_LENGTH（缓冲区大小）、0（默认标志）
char buffer[BUFFER_LENGTH] = {0};
int len = recv(clientfd, buffer, BUFFER_LENGTH, 0);

// 处理recv返回值：三种情况
if (len < 0) // 情况1：接收错误（如客户端强制断开）
{
close(clientfd); // 关闭客户端fd，释放资源
// 从epoll中删除该客户端fd（避免后续再监听该fd的事件）
struct epoll_event ev;
ev.events = EPOLLIN;
ev.data.fd = clientfd;
epoll_ctl(epfd, EPOLL_CTL_DEL, clientfd, &ev);
connections–; // 连接数-1
}
else if (len == 0) // 情况2：客户端正常断开（发送FIN包）
{
close(clientfd);
epoll_ctl(epfd, EPOLL_CTL_DEL, clientfd, NULL); // 删除epoll事件（结构体可传NULL）
connections–;
}
else // 情况3：成功接收数据（len为接收的字节数）
{
// 注释说明：本代码为高并发连接测试，暂不处理数据回显（避免打印/发送影响性能）
// printf("Recv: %s, %d byte(s), clientfd: %d\\n", buffer, len, clientfd);
// send(clientfd, buffer, len, 0); // 数据回显（客户端发什么，服务器回什么）
}
}
}
}

// 程序理论上不会走到这里，若退出需关闭所有监听fd和epoll实例（避免资源泄漏）
for (i = 0; i < MAX_PORT; i++) {
close(sockfds[i]);
}
close(epfd);
return 0;
}

2. 客户端代码

#include <stdio.h> // 标准输入输出库（printf、perror等）
#include <string.h> // 字符串处理库（memset、strcpy、strcmp等）
#include <stdlib.h> // 标准库（exit、atoi等）

#include <sys/types.h> // 系统基础类型定义（如socket相关类型）
#include <sys/socket.h> // socket核心库（socket、connect、send、recv等）
#include <sys/epoll.h> // epoll IO多路复用库（epoll_create、epoll_wait、epoll_ctl）
#include <errno.h> // 错误处理库（errno变量、strerror等）
#include <netinet/tcp.h> // TCP协议相关定义（如TCP选项）
#include <arpa/inet.h> // 网络地址转换库（inet_addr、htons等）
#include <netdb.h> // 网络主机相关（本代码未实际使用，仅包含）
#include <fcntl.h> // 文件控制库（fcntl设置非阻塞IO）
#include <sys/time.h> // 时间库（gettimeofday获取系统时间，统计耗时）
#include <unistd.h> // 系统调用库（close、usleep等）

// 宏定义：全局常量配置
#define MAX_BUFFER128 // 接收/发送数据的缓冲区大小（128字节）
#define MAX_EPOLLSIZE(384*1024) // epoll事件数组最大容量（支持最多384*1024个连接事件）
#define MAX_PORT100 // 客户端连接的端口范围（对应服务器的100个监听端口）
// 宏定义：计算两个timeval结构体的时间差（单位：毫秒）
#define TIME_SUB_MS(tv1, tv2) ((tv1.tv_sec – tv2.tv_sec) * 1000 + (tv1.tv_usec – tv2.tv_usec) / 1000)

// 全局标志：控制是否继续建立新连接（收到服务器"quit"指令后设为0，停止建连）
int isContinue = 0;

/**
* @brief 设置文件描述符（fd）为非阻塞模式
* @param fd 待设置的文件描述符（如socket fd）
* @return 0：设置成功；-1：设置失败
*/
static int ntySetNonblock(int fd) {
int flags; // 存储fd当前的文件状态标志

// 1. 获取fd当前的状态标志（F_GETFL：Get File Status Flags）
flags = fcntl(fd, F_GETFL, 0);
if (flags < 0) return flags; // 获取失败，返回错误码

// 2. 给标志添加"非阻塞"位（O_NONBLOCK）
flags |= O_NONBLOCK;
// 3. 设置新的状态标志（F_SETFL：Set File Status Flags）
if (fcntl(fd, F_SETFL, flags) < 0) return -1; // 设置失败返回-1

return 0; // 设置成功
}

/**
* @brief 设置socket的SO_REUSEADDR选项（允许端口复用）
* @param fd 待设置的socket文件描述符
* @return 0：设置成功；-1：设置失败（返回setsockopt的错误码）
*/
static int ntySetReUseAddr(int fd) {
int reuse = 1; // 启用端口复用（1：启用，0：禁用）
// setsockopt参数说明：
// fd：目标socket；SOL_SOCKET：操作socket层选项；SO_REUSEADDR：选项名；
// &reuse：选项值地址；sizeof(reuse)：选项值长度
return setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&reuse, sizeof(reuse));
}

/**
* @brief 主函数：高并发TCP客户端逻辑（建立大量连接到服务器，用epoll管理连接）
* @param argc 命令行参数个数
* @param argv 命令行参数数组（argv[1]：服务器IP，argv[2]：服务器起始端口）
* @return 0：正常退出；非0：异常退出
*/
int main(int argc, char **argv) {
// 1. 命令行参数校验：需传入服务器IP和起始端口（argc至少为3）
if (argc <= 2) {
printf("Usage: %s ip port\\n", argv[0]); // 提示正确用法（如./client 127.0.0.1 8888）
exit(0); // 退出程序
}

// 初始化核心变量
const char *ip = argv[1]; // 服务器IP地址（从命令行获取）
int port = atoi(argv[2]); // 服务器起始端口（字符串转整数）
int connections = 0; // 统计当前与服务器的总连接数
char buffer[128] = {0}; // 发送数据的缓冲区
int i = 0, index = 0; // 循环索引（index用于切换连接的端口）

struct epoll_event events[MAX_EPOLLSIZE]; // 存储epoll就绪事件的数组
// 创建epoll实例：参数为最大事件数（已废弃，仅需传入大于0的值，这里用MAX_EPOLLSIZE）
int epoll_fd = epoll_create(MAX_EPOLLSIZE);
if (epoll_fd < 0) { // 容错：epoll创建失败
perror("epoll_create failed");
exit(1);
}

// 初始化发送缓冲区（默认填充测试数据，可后续覆盖）
strcpy(buffer, " Data From MulClient\\n");

// 2. 初始化服务器地址结构（IPv4）
struct sockaddr_in addr;
memset(&addr, 0, sizeof(struct sockaddr_in)); // 内存清零（避免脏数据）
addr.sin_family = AF_INET; // 地址族：IPv4
addr.sin_addr.s_addr = inet_addr(ip); // 服务器IP（将字符串IP转为网络字节序）

// 初始化时间统计：记录连接建立的起始时间（用于计算每1000个连接的耗时）
struct timeval tv_begin;
gettimeofday(&tv_begin, NULL);

// 3. 主循环：持续建立连接 + 处理epoll事件（服务器常驻）
while (1) {
// 切换连接的端口：循环使用0~MAX_PORT-1（对应服务器的100个监听端口）
if (++index >= MAX_PORT) index = 0;

struct epoll_event ev; // epoll事件结构（用于添加连接到epoll）
int sockfd = 0; // 当前创建的socket fd（与服务器的单个连接）

// 3.1 建立新连接：连接数未达上限（34万）且允许继续建连（isContinue=0）
if (connections < 340000 && !isContinue) {
// 创建TCP socket：AF_INET（IPv4）、SOCK_STREAM（流式TCP）、0（默认协议）
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd == -1) { // 容错：socket创建失败
perror("socket");
goto err; // 跳转到错误处理标签
}

// （可选注释）设置端口复用（注释掉不影响，按需启用）
// ntySetReUseAddr(sockfd);
// 设置当前连接的服务器端口：起始端口 + 循环索引（如8888+0=8888，8888+1=8889…）
addr.sin_port = htons(port + index);

// 连接服务器：非阻塞socket的connect会立即返回（后续通过epoll的EPOLLOUT判断连接是否成功）
if (connect(sockfd, (struct sockaddr*)&addr, sizeof(struct sockaddr_in)) < 0) {
// 非阻塞connect失败可能是正常的（如连接在建立中），仅打印错误不退出
perror("connect");
goto err;
}

// 设置socket为非阻塞模式（避免send/recv阻塞导致客户端卡死）
ntySetNonblock(sockfd);
// 启用端口复用（避免连接断开后端口处于TIME_WAIT状态无法立即复用）
ntySetReUseAddr(sockfd);

// 构造发送数据（包含当前连接数，用于标识客户端）
sprintf(buffer, "Hello Server: client –> %d\\n", connections);
// （可选注释）发送数据到服务器（注释掉不影响连接建立，仅用于测试数据交互）
// send(sockfd, buffer, strlen(buffer), 0);

// 将当前socket添加到epoll：关注读事件（EPOLLIN，服务器发数据）和写事件（EPOLLOUT，可发送数据）
ev.data.fd = sockfd;
ev.events = EPOLLIN | EPOLLOUT;
epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sockfd, &ev);

connections ++; // 连接数+1
}

// 3.2 统计连接耗时 + 处理epoll就绪事件
// 条件：每建立1000个连接（connections%1000==999）或连接数达上限（34万）
if (connections % 1000 == 999 || connections >= 340000) {
struct timeval tv_cur;
memcpy(&tv_cur, &tv_begin, sizeof(struct timeval)); // 保存上一次统计的起始时间
gettimeofday(&tv_begin, NULL); // 更新当前时间为新的起始时间
int time_used = TIME_SUB_MS(tv_begin, tv_cur); // 计算这1000个连接的建立耗时（毫秒）
// 打印统计信息：当前连接数、当前socket fd、耗时
printf("connections: %d, sockfd:%d, time_used:%d ms\\n", connections, sockfd, time_used);

// 等待epoll事件：最多等待100ms，返回就绪事件数（nfds）
int nfds = epoll_wait(epoll_fd, events, connections, 100);
// 遍历所有就绪事件，处理每个连接的读写需求
for (i = 0; i < nfds; i++) {
int clientfd = events[i].data.fd; // 当前就绪的socket fd

// 3.2.1 处理写事件（EPOLLOUT：socket可写，可发送数据）
if (events[i].events & EPOLLOUT) {
// 构造发送数据（包含当前socket fd，标识发送方）
sprintf(buffer, "data from client fd: %d\\n", clientfd);
// （可选注释）发送数据到服务器（注释掉不影响事件处理）
// send(clientfd, buffer, strlen(buffer), 0);
}
// 3.2.2 处理读事件（EPOLLIN：socket可读，服务器发来了数据）
else if (events[i].events & EPOLLIN) {
char rBuffer[MAX_BUFFER] = {0}; // 接收数据的缓冲区
// 接收服务器数据：非阻塞recv，返回接收的字节数
ssize_t length = recv(clientfd, rBuffer, MAX_BUFFER, 0);

if (length > 0) { // 接收成功（length为接收的字节数）
printf("Recv from server: %s\\n", rBuffer); // 打印接收的数据

// 若收到服务器的"quit"指令，设置标志停止建立新连接
if (!strcmp(rBuffer, "quit")) {
isContinue = 0;
}
}
else if (length == 0) { // 服务器正常断开连接（发送FIN包）
printf("Server disconnected, clientfd:%d\\n", clientfd);
connections –; // 连接数-1
close(clientfd); // 关闭socket，释放资源
}
else { // 接收错误（length < 0）
if (errno == EINTR) continue; // 被信号中断（如Ctrl+C），跳过本次处理

// 其他错误（如客户端强制断开），打印错误信息并关闭socket
printf("Recv error, clientfd:%d, errno:%d\\n", clientfd, errno);
close(clientfd);
}
}
// 3.2.3 处理其他事件（如错误事件）
else {
printf("Unexpected event, clientfd:%d, errno:%d\\n", clientfd, errno);
close(clientfd); // 关闭异常socket，避免资源泄漏
}
}
}

// 每次循环休眠1毫秒：降低CPU占用率（避免空循环过度消耗CPU）
usleep(1 * 1000);
}

return 0; // 程序理论上不会走到这里（主循环无限）

// 错误处理标签：处理socket/connect创建失败的情况
err:
printf("Error: %s\\n", strerror(errno)); // 打印具体错误原因（如端口被占用、连接超时）
return 0;
}