【仿Mudou库one thread per loop式并发服务器实现】服务器边缘测试+性能测试

LuckyRich12025-04-28 8:27

服务器边缘测试+性能测试

  • [1. 长连接连续请求测试](#1. 长连接连续请求测试)
  • [2. 超时连接释放测试1](#2. 超时连接释放测试1)
  • [3. 超时连接释放测试2](#3. 超时连接释放测试2)
  • [4. 超时连接释放测试3](#4. 超时连接释放测试3)
  • [5. 数据中多条请求处理测试](#5. 数据中多条请求处理测试)
  • [6. PUT大文件上传测试](#6. PUT大文件上传测试)
  • [7. 服务器性能测试](#7. 服务器性能测试)
cpp 复制代码 
#include "httpserver.hpp"
#define WWWROOT "./wwwroot"

std::string RequestStr(const HttpRequest &req) {
    std::stringstream ss;
    ss << req._method << " " << req._path << " " << req._version << "\r\n";
    for (auto &it : req._params) {
        ss << it.first << ": " << it.second << "\r\n";
    }
    for (auto &it : req._headers) {
        ss << it.first << ": " << it.second << "\r\n";
    }
    ss << "\r\n";
    ss << req._body;
    return ss.str();
}
void Hello(const HttpRequest &req, HttpResponse *rsp) 
{
    rsp->SetContent(RequestStr(req), "text/plain");
    //sleep(15);
}
void Login(const HttpRequest &req, HttpResponse *rsp) 
{
    rsp->SetContent(RequestStr(req), "text/plain");
}
void PutFile(const HttpRequest &req, HttpResponse *rsp) 
{
    std::string path = WWWROOT + req._path;
    Until::WriteFile(path,req._body);
    //rsp->SetContent(RequestStr(req), "text/plain");
}
void DelFile(const HttpRequest &req, HttpResponse *rsp) 
{
    rsp->SetContent(RequestStr(req), "text/plain");
}
int main()
{
    HttpServer server(8080);
    server.SetThreadCount(3);
    server.SetBaseDir(WWWROOT);//设置静态资源根目录，告诉服务器有静态资源请求到来，需要到哪里去找资源文件
    server.Get("/hello", Hello);
    server.Post("/login", Login);
    server.Put("/1234.txt", PutFile);
    server.Delete("/1234.txt", DelFile);
    server.Start();
    return 0;
}

1. 长连接连续请求测试

长连接测试1：创建一个客户端持续给服务器发送数据，直到超过超时时间看看是否正常

cpp 复制代码 
#include "../source/server.hpp"

int main()
{
    Socket cli_sock;
    cli_sock.CreateClient(8080, "127.0.0.1");
    std::string req = "GET /hello HTTP/1.1\r\nConnection: keep-alive\r\nContent-Length: 0\r\n\r\n";
    while(1) {
        assert(cli_sock.Send(req.c_str(), req.size()) != -1);
        char buf[1024] = {0};
        assert(cli_sock.Recv(buf, 1023));
       LOG_DEBUG("[%s]", buf);
        sleep(3);
    }
    cli_sock.Close();
    return 0;
}

2. 超时连接释放测试1

超时连接测试1：创建一个客户端，给服务器发送一次数据后，不动了，查看服务器是否会正常的超时关闭连接

cpp 复制代码 
#include "../source/server.hpp"

int main()
{
    Socket cli_sock;
    cli_sock.CreateClient(8080, "127.0.0.1");
    std::string req = "GET /hello HTTP/1.1\r\nConnection: keep-alive\r\nContent-Length: 0\r\n\r\n";
    while(1) {
        assert(cli_sock.Send(req.c_str(), req.size()) != -1);
        char buf[1024] = {0};
        assert(cli_sock.Recv(buf, 1023));
        LOG_DEBUG("[%s]", buf);
        sleep(15);
    }
    cli_sock.Close();
    return 0;
}

3. 超时连接释放测试2

给服务器发送一个数据，告诉服务器要发送1024字节的数据，但是实际发送的数据不足1024，查看服务器处理结果

  1. 如果数据只发送一次，服务器将得不到完整请求，就不会进行业务处理，客户端也就得不到响应，最终超时关闭连接
  2. 连着给服务器发送了多次 小的请求， 服务器会将后边的请求当作前边请求的正文进行处理，而后面处理的时候有可能就会因为处理错误而关闭连接
cpp 复制代码 
#include "../source/server.hpp"

int main()
{
    Socket cli_sock;
    cli_sock.CreateClient(8080, "127.0.0.1");
    std::string req = "GET /hello HTTP/1.1\r\nConnection: keep-alive\r\nContent-Length: 100\r\n\r\nbitejiuyeke";
    while(1) {
        assert(cli_sock.Send(req.c_str(), req.size()) != -1);
        assert(cli_sock.Send(req.c_str(), req.size()) != -1);
        assert(cli_sock.Send(req.c_str(), req.size()) != -1);
        assert(cli_sock.Send(req.c_str(), req.size()) != -1);
        assert(cli_sock.Send(req.c_str(), req.size()) != -1);
        char buf[1024] = {0};
        assert(cli_sock.Recv(buf, 1023));
        LOG_DEBUG("[%s]", buf);
        sleep(3);
    }
    cli_sock.Close();
    return 0;
}

4. 超时连接释放测试3

业务处理超时，查看服务器的处理情况。

当服务器达到了一个性能瓶颈，在一次业务处理中花费了太长的时间（超过了服务器设置的非活跃超时时间）。

在一次业务处理中耗费太长时间，导致其他的连接也被连累超时，其他的连接有可能会被拖累超时释放。

假设现在 12345描述符就绪了， 在处理1的时候花费了30s处理完，超时了，导致2345描述符因为长时间没有刷新活跃度

  1. 如果接下来的2345描述符都是通信连接描述符，如果都就绪了，则并不影响，因为接下来就会进行处理并刷新活跃度
  2. 如果接下来的2号描述符是定时器事件描述符，定时器触发超时，执行定时任务，就会将345描述符给释放掉。这时候一旦345描述符对应的连接被释放，接下来在处理345事件的时候就会导致程序崩溃（内存访问错误。 因此这时候，在本次事件处理中，如果有释放连接的操作，并不能直接对连接进行释放，而应该将释放操作压入到任务池中， 等到事件处理完了执行任务池中的任务的时候，再去释放
cpp 复制代码 
#include "../source/server.hpp"


int main()
{
    signal(SIGCHLD, SIG_IGN);
    for (int i = 0; i < 10; i++) {
        pid_t pid = fork();
        if (pid < 0) {
            LOG_DEBUG("FORK ERROR");
            return -1;
        }else if (pid == 0) {
            Socket cli_sock;
            cli_sock.CreateClient(8080, "127.0.0.1");
            std::string req = "GET /hello HTTP/1.1\r\nConnection: keep-alive\r\nContent-Length: 0\r\n\r\n";
            while(1) {
                assert(cli_sock.Send(req.c_str(), req.size()) != -1);
                char buf[1024] = {0};
                assert(cli_sock.Recv(buf, 1023));
                LOG_DEBUG("[%s]", buf);
            }
            cli_sock.Close();
            exit(0);
        }
    }
    while(1) sleep(1);
    
    return 0;
}

现在把所有事件处理结束了，释放连接的操作都先压入到任务队列中。等到所有就绪时间处理完成后，在去执行任务队列中的任务。因此Channel中Handevent函数内，不用每个事件执行前先去执行任意事件回调。而是在最后执行一次任意事件回调。反正在处理就绪事件不会释放连接，不用担心因为释放连接销毁Connection对象而导致调用任意事件回调导致程序奔溃。

5. 数据中多条请求处理测试

一次性给服务器发送多条数据，然后查看服务器的处理结果

预期结果：每一条请求都应该得到正常处理

cpp 复制代码 
#include "../source/server.hpp"

int main()
{
    Socket cli_sock;
    cli_sock.CreateClient(8080, "127.0.0.1");
    std::string req = "GET /hello HTTP/1.1\r\nConnection: keep-alive\r\nContent-Length: 0\r\n\r\n";
    req += "GET /hello HTTP/1.1\r\nConnection: keep-alive\r\nContent-Length: 0\r\n\r\n";
    req += "GET /hello HTTP/1.1\r\nConnection: keep-alive\r\nContent-Length: 0\r\n\r\n";
    while(1) {
        assert(cli_sock.Send(req.c_str(), req.size()) != -1);
        char buf[1024] = {0};
        assert(cli_sock.Recv(buf, 1023));
        LOG_DEBUG("[%s]", buf);
        sleep(3);
    }
    cli_sock.Close();
    return 0;
}

6. PUT大文件上传测试

大文件传输测试，给服务器上传一个大文件，服务器将文件保存下来，观察处理结果

预期结果： 上传的文件，和服务器保存的文件一致

powershell 复制代码 
dd if=/dev/zero of=./hello.txt bs=100M count=3   #创建一个大小为300M的文件
cpp 复制代码 
#include "../source/http/httpserver.hpp"

int main()
{
    Socket cli_sock;
    cli_sock.CreateClient(8080, "127.0.0.1");
    std::string req = "PUT /1234.txt HTTP/1.1\r\nConnection: keep-alive\r\n";
    std::string body;
    Until::ReadFile("./hello.txt", &body);
    req += "Content-Length: " + std::to_string(body.size()) + "\r\n\r\n";
    assert(cli_sock.Send(req.c_str(), req.size()) != -1);
    assert(cli_sock.Send(body.c_str(), body.size()) != -1);
    char buf[1024] = {0};
    assert(cli_sock.Recv(buf, 1023));
    LOG_DEBUG("[%s]", buf);
    sleep(3);
    cli_sock.Close();
    return 0;
}

7. 服务器性能测试

采用webbench进行服务器性能测试。

Webbench是知名的网站压li测试⼯具，它是由Lionbridge公司（http://www.lionbridge.com）开发。

webbench的标准测试可以向我们展示服务器的两项内容： 每秒钟相应请求数 和 每秒钟传输数据量。

webbench测试原理是，创建指定数量的进程，在每个进程中不断创建套接字向服务器发送请求，并通过管道最终将每个进程的结果返回给主进程进行数据统计。

powershell 复制代码 
./webbench -c 1000 -t 60 http://127.0.0.1:8080/hello

-c: 指定客户端数量

-t：指定时间

性能测试的两个重点衡量标准：并发量 & QPS

并发量：可以同时处理多少客户端的请求而不会出现连接失败

QPS：每秒钟处理的包的数量

抛开环境说性能测试都是无知的！！！

测试环境：

服务器是2核2G带宽4M的云服务器

客户端是ubentu环境

使用webbench以1000并发量，向服务器发送请求，进行了60秒测试

最终得到的结果是：并发量当前是1000包，QPM1分钟处理215188个包，QPS：一秒钟处理3586个包。

相关推荐
IT运维爱好者1 分钟前
Ubuntu 22.04.4操作系统初始化详细配置
linux·运维·服务器·ubuntu
樂50210 分钟前
关于 Web 服务器的五个案例
linux·服务器·经验分享
superior tigre1 小时前
C++学习：六个月从基础到就业——模板编程：模板特化
开发语言·c++·学习
码农新猿类1 小时前
信号量函数
linux·c++·visual studio
·醉挽清风·1 小时前
学习笔记—双指针算法—移动零
c++·笔记·学习·算法
H1346948901 小时前
服务器异地备份，服务器异地备份有哪些方法？
运维·服务器
SQingL1 小时前
解决SSLError: [SSL: DECRYPTION_FAILED_OR_BAD_RECORD_MAC] decryption faile的问题
服务器·网络协议·ssl
Lonwayne2 小时前
Web服务器技术选型指南：主流方案、核心对比与策略选择
运维·服务器·前端·程序那些事
Ayanami_Reii2 小时前
Leetcode837.新21点
c++·笔记·算法
法迪2 小时前
Linux电源管理(2)_常规的电源管理的基本概念和软件架构
linux·运维·服务器·功耗
热门推荐
01西电B测-计算机网络综合实验(含验收问题)02KGG转MP3工具|非KGM文件|解密音频03从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑04YOLOv5改进 | 添加CA注意力机制 + 增加预测层 + 更换损失函数之GIoU05yolov8，yolo11，yolo12 服务器训练到部署全流程 笔记06我决定放弃搞 Java 了07Coze扣子平台完整体验和实践（附国内和国际版对比）08YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】09DeepSeek各版本说明与优缺点分析10yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）