基于多设计模式下的同步&异步日志系统测试报告

石油人单挑所有2026-04-25 10:23

1、项目概述

2、测试环境

操作系统

硬件资源信息

内核信息

CPU信息

内存信息

磁盘信息

显卡信息

网络设备信息

编译器

测试工具

GDB

Vim

make（makefile文件）

VsCode

C++标准

C++11及以上版本

3、测试目的

4、测试用例设计与执行

功能测试

单元测试

系统测试

性能测试

兼容性测试

界面测试

安全测试

易用性测试

回归测试

本云服务器CPU详情

本云服务器内存详情

5、问题与优化

问题

优化

6、测试总结

1、项目概述

本项目是基于C++11开发、融合多设计模式实现的同步&异步日志系统，无第三方库依赖，面向高并发服务场景设计。系统支持多级别日志输出、多线程安全写入、日志落地控制台/固定文件/滚动文件，可灵活拓展输出目标，采用生产-消费模型与双缓冲区实现异步日志，使用单例、工厂、建造者、代理模式提升代码可维护性与拓展性，适用于服务端程序问题定位、运行状态监控与分布式系统日志管理。

2、测试环境

操作系统

Linux Centos 7

硬件资源信息

内核信息

CPU信息

内存信息

磁盘信息

显卡信息

网络设备信息

实时监控硬件资源

编译器

g++

测试工具

GDB、Vim、VsCode、Makefile

GDB

Vim

make（makefile文件）

VsCode

C++标准

C++11及以上标准

cppreference.cn - C++参考手册

3、测试目的

  1. 验证日志系统功能完整性，确认所有设计功能正常可用
  2. 验证多线程并发安全性，无日志丢失、乱序、交叉写入、死锁等问题
  3. 测试同步/异步模式性能差异，评估吞吐量与写入效率
  4. 验证异常场景健壮性，确保目录缺失、格式错误、权限异常等场景不崩溃，不丢数据
  5. 确保架构可拓展性，模块解耦、拓展Sink与日志器符合设计预期
  6. 输出客观测试结论，评估系统是否符合使用上线标准

4、测试用例设计与执行

与高并发内存池的测试报告中的一致，这里我对从功能测试、性能测试、界面测试、易用性测试、兼容性测试、安全测试、回归测试这七大角度对该日志系统编写测试用例，从思维导图中可得知编写的测试用例非常多，为了方便读者查阅，每个方面选取最典型的测试用例进行执行，验证预期结果是否与实际结果一致。

功能测试

单元测试

验证日志消息是否可以有效过滤

cpp 复制代码 
#include "../logs/lcglog.h"
#include <unistd.h>

void test_log(const std::string& name){
    INFO("%s", "测试开始");
    lcglog::Logger::ptr logger = lcglog::LoggerManger::getInstance().getLogger(name);
    logger->debug("%s", "测试日志");
    logger->info("%s", "测试日志");
    logger->warn("%s", "测试日志");
    logger->error("%s", "测试日志");
    logger->fatal("%s", "测试日志");
    INFO("%s", "测试完毕");

}
int main()
{

    std::unique_ptr<lcglog::LoggerBuilder> builder(new lcglog::GlobalLoggerBuilder());
    builder->buildLoggerName("sync_logger");

    // 只有日志输出等级大于等于ERROR的日志才可以输出
    builder->buildLoggerLevel(lcglog::LogLevel::value::ERROR);
    builder->buildLoggerFormatter("[%c][%f:%l][%p]%m%n");
    builder->buildLoggerType(lcglog::LoggerType::LOGGER_SYNC);
    builder->buildSink<lcglog::FileSink>("./logfile/sync.log");
    builder->buildSink<lcglog::StdoutSink>();
    builder->buildSink<lcglog::RollBySizeSink>("./logfile/sync-roll-by-size", 1024*1024);
    builder->build();
    test_log("sync_logger");
    
    return 0;
}
  • 预期结果：只有当日志输出等级高于设置的等级时，日志才可输出
  • 实际结果：只有当日志输出等级高于设置的等级时，日志才可输出，符合预期

验证日志消息是否可以有效落地至控制台/固定文件/滚动文件

cpp 复制代码 
#include "../logs/lcglog.h"
#include <unistd.h>

void test_log(const std::string& name){
    INFO("%s", "测试开始");
    lcglog::Logger::ptr logger = lcglog::LoggerManger::getInstance().getLogger(name);
    logger->debug("%s", "测试日志");
    logger->info("%s", "测试日志");
    logger->warn("%s", "测试日志");
    logger->error("%s", "测试日志");
    logger->fatal("%s", "测试日志");
    INFO("%s", "测试完毕");

}
int main()
{

    std::unique_ptr<lcglog::LoggerBuilder> builder(new lcglog::GlobalLoggerBuilder());
    builder->buildLoggerName("sync_logger");
    builder->buildLoggerLevel(lcglog::LogLevel::value::ERROR);
    builder->buildLoggerFormatter("[%c][%f:%l][%p]%m%n");
    builder->buildLoggerType(lcglog::LoggerType::LOGGER_SYNC);
    // 落地至指定文件
    builder->buildSink<lcglog::FileSink>("./logfile/sync.log");
    // 落地至控制台
    builder->buildSink<lcglog::StdoutSink>();
    // 落地至滚动文件
    builder->buildSink<lcglog::RollBySizeSink>("./logfile/sync-roll-by-size", 1024*1024);
    builder->build();
    test_log("sync_logger");
    
    return 0;
}
  • 预期结果：当落地方式为控制台/指定文件/滚动文件时，日志消息均可顺利输出落地，日志消息内容完整、无乱码/截断
  • 实际结果：当落地方式为控制台/指定文件/滚动文件时，日志消息均可顺利输出落地，日志消息内容完整、无乱码/截断，符合预期

落地至控制台

落地至指定文件

落地至滚动文件

验证多线程使用同步模式进行海量日志数据输出时，此时日志消息是否可以全部落地

cpp 复制代码 
#include "../logs/lcglog.h"
#include <vector>
#include <thread>
#include <chrono>
/*参数：日志器名称，线程总数量，日志总数量，单条日志大小*/
void bench(const std::string& name, size_t thr_count, size_t msg_count, size_t msg_len){
    //1.获取日志器
    lcglog::Logger::ptr logger = lcglog::getLogger(name);
    if(logger.get() == nullptr){
        return;
    }
    std::cout << "测试日志：" << msg_count << " 条, 总大小:" << msg_count * msg_len / 1024 <<
        "KB" << std::endl;

    //2.组织指定长度的日志消息
    std::string msg ("my name is lihua");//最后一个字节是换行符，以便于输出打印
    //3.创建指定数量的线程
    size_t msg_per_thr = msg_count / thr_count;//一个线程要写的日志数量--每个线程输出的日志条目
    std::vector<std::thread> threads;
    std::vector<double> cost_array(thr_count);
    for(int i=0; i<thr_count; i++){
        threads.emplace_back([&, i](){
            //4.线程函数内部开始计时
            auto start = std::chrono::high_resolution_clock::now();
            //5.开始循环写日志
            for(int j=0; j<msg_per_thr; j++){
                logger->fatal("%s", msg.c_str());
            }
            //6.线程函数内部结束计时
            auto end = std::chrono::high_resolution_clock::now();
            std::chrono::duration<double> cost = end - start;
            cost_array[i] = cost.count();
            std::cout << "\t线程[" << i << "]: " << "  输出日志数量:" << msg_per_thr << ", 耗时:" << 
                cost.count()  << "s" << std::endl;
        });
    }
    for(int i=0; i<thr_count; i++){
        threads[i].join();
    }
    //7.计算总耗时-所有写线程中所耗时间最多的那个线程
    /*多线程中每个线程都有自己的运行时间，但线程是并发处理的，因此耗时最多的那个才是总时间*/
    double cost_max = cost_array[0];
    for(int i=0; i<thr_count; i++){
        cost_max = cost_max < cost_array[i] ? cost_array[i] : cost_max;
    }
    size_t msg_per_sec = msg_count / cost_max;
    size_t size_per_sec = (msg_count * msg_len) / (cost_max*1024);
    //8.进行输出打印
    std::cout << "\t总耗时: " << cost_max << "s" << std::endl;
    std::cout << "\t每秒输出日志数量: " << msg_per_sec  << " 条"  << std::endl;
    std::cout << "\t每秒输出日志大小: " << size_per_sec << " KB" << std::endl; 
}

void async_bench(){
    std::unique_ptr<lcglog::LoggerBuilder> builder(new lcglog::GlobalLoggerBuilder());
    builder->buildLoggerName("async_logger");
    builder->buildLoggerLevel(lcglog::LogLevel::value::DEBUG);
    builder->buildLoggerFormatter("%m%n");
    builder->buildLoggerType(lcglog::LoggerType::LOGGER_ASYNC);
    builder->buildEnableUnsafeAsync();//开启非安全模式-主要是将实际落地时间排除在外
    builder->buildSink<lcglog::FileSink>("./logfile/async.log");
    builder->build();

    /*参数：日志器名称，线程总数量，日志总数量，单条日志大小*/
    bench("async_logger", 5, 1000, 100);
}

int main(){
    async_bench();
    return 0;
}
  • 预期结果：在多线程场景下，海量日志可全部落地，无死锁、数据不一致性问题，日志输出无交叉/截断/乱码等问题，程序不崩溃
  • 实际结果：在多线程场景下，海量日志可全部落地，无死锁、数据不一致性问题，日志输出无交叉/截断/乱码等问题，程序不崩溃，符合预期

验证获取不存在的日志器时，是否返回空指针

cpp 复制代码 
#include "../logs/lcglog.h"
#include <vector>
#include <thread>
#include <chrono>
/*参数：日志器名称，线程总数量，日志总数量，单条日志大小*/
void bench(const std::string& name, size_t thr_count, size_t msg_count, size_t msg_len){
    //1.获取日志器
    lcglog::Logger::ptr logger = lcglog::getLogger(name);
    if(logger.get() == nullptr){
        return;
    }
    std::cout << "测试日志：" << msg_count << " 条, 总大小:" << msg_count * msg_len / 1024 <<
        "KB" << std::endl;

    //2.组织指定长度的日志消息
    std::string msg ("my name is lihua");//最后一个字节是换行符，以便于输出打印
    //3.创建指定数量的线程
    size_t msg_per_thr = msg_count / thr_count;//一个线程要写的日志数量--每个线程输出的日志条目
    std::vector<std::thread> threads;
    std::vector<double> cost_array(thr_count);
    for(int i=0; i<thr_count; i++){
        threads.emplace_back([&, i](){
            //4.线程函数内部开始计时
            auto start = std::chrono::high_resolution_clock::now();
            //5.开始循环写日志
            for(int j=0; j<msg_per_thr; j++){
                logger->fatal("%s", msg.c_str());
            }
            //6.线程函数内部结束计时
            auto end = std::chrono::high_resolution_clock::now();
            std::chrono::duration<double> cost = end - start;
            cost_array[i] = cost.count();
            std::cout << "\t线程[" << i << "]: " << "  输出日志数量:" << msg_per_thr << ", 耗时:" << 
                cost.count()  << "s" << std::endl;
        });
    }
    for(int i=0; i<thr_count; i++){
        threads[i].join();
    }
    //7.计算总耗时-所有写线程中所耗时间最多的那个线程
    /*多线程中每个线程都有自己的运行时间，但线程是并发处理的，因此耗时最多的那个才是总时间*/
    double cost_max = cost_array[0];
    for(int i=0; i<thr_count; i++){
        cost_max = cost_max < cost_array[i] ? cost_array[i] : cost_max;
    }
    size_t msg_per_sec = msg_count / cost_max;
    size_t size_per_sec = (msg_count * msg_len) / (cost_max*1024);
    //8.进行输出打印
    std::cout << "\t总耗时: " << cost_max << "s" << std::endl;
    std::cout << "\t每秒输出日志数量: " << msg_per_sec  << " 条"  << std::endl;
    std::cout << "\t每秒输出日志大小: " << size_per_sec << " KB" << std::endl; 
}

void async_bench(){
    std::unique_ptr<lcglog::LoggerBuilder> builder(new lcglog::GlobalLoggerBuilder());
    builder->buildLoggerName("async_logger");
    builder->buildLoggerLevel(lcglog::LogLevel::value::DEBUG);
    builder->buildLoggerFormatter("%m%n");
    builder->buildLoggerType(lcglog::LoggerType::LOGGER_ASYNC);
    builder->buildEnableUnsafeAsync();//开启非安全模式-主要是将实际落地时间排除在外
    builder->buildSink<lcglog::FileSink>("./logfile/async.log");
    builder->build();

    /*参数：日志器名称，线程总数量，日志总数量，单条日志大小*/

    // 这里无Async_logger名称的日志器，日志无法输出
    bench("Async_logger", 5, 1000, 100);
}

int main(){
    async_bench();
    return 0;
}
  • 预期结果：输入不存在的日志器名称时，获取不到对应的日志器，返回空指针；程序不崩溃；日志无法完成落地操作；查看不到输出的日志消息
  • 实际结果：输入不存在的日志器名称时，获取不到对应的日志器，返回空指针；程序不崩溃；日志无法完成落地操作；查看不到输出的日志消息，符合预期

系统测试

验证使用同步模式多线程输出少量的日志时，日志是否可以顺利输出，日志内容是否完整符合预期

cpp 复制代码 
#include "../logs/lcglog.h"
#include <vector>
#include <thread>
#include <chrono>

/*参数：日志器名称，线程总数量，日志总数量，单条日志大小*/
void bench(const std::string& name, size_t thr_count, size_t msg_count, size_t msg_len){
    //1.获取日志器
    lcglog::Logger::ptr logger = lcglog::getLogger(name);
    if(logger.get() == nullptr){
        return;
    }
    std::cout << "测试日志：" << msg_count << " 条, 总大小:" << msg_count * msg_len / 1024 <<
        "KB" << std::endl;

    //2.组织指定长度的日志消息
    std::string msg ("my name is lihua");//最后一个字节是换行符，以便于输出打印
    //3.创建指定数量的线程
    size_t msg_per_thr = msg_count / thr_count;//一个线程要写的日志数量--每个线程输出的日志条目
    std::vector<std::thread> threads;
    std::vector<double> cost_array(thr_count);
    for(int i=0; i<thr_count; i++){
        threads.emplace_back([&, i](){
            //4.线程函数内部开始计时
            auto start = std::chrono::high_resolution_clock::now();
            //5.开始循环写日志
            for(int j=0; j<msg_per_thr; j++){
                logger->fatal("%s", msg.c_str());
            }
            //6.线程函数内部结束计时
            auto end = std::chrono::high_resolution_clock::now();
            std::chrono::duration<double> cost = end - start;
            cost_array[i] = cost.count();
            std::cout << "\t线程[" << i << "]: " << "  输出日志数量:" << msg_per_thr << ", 耗时:" << 
                cost.count()  << "s" << std::endl;
        });
    }
    for(int i=0; i<thr_count; i++){
        threads[i].join();
    }
    //7.计算总耗时-所有写线程中所耗时间最多的那个线程
    /*多线程中每个线程都有自己的运行时间，但线程是并发处理的，因此耗时最多的那个才是总时间*/
    double cost_max = cost_array[0];
    for(int i=0; i<thr_count; i++){
        cost_max = cost_max < cost_array[i] ? cost_array[i] : cost_max;
    }
    size_t msg_per_sec = msg_count / cost_max;
    size_t size_per_sec = (msg_count * msg_len) / (cost_max*1024);
    //8.进行输出打印
    std::cout << "\t总耗时: " << cost_max << "s" << std::endl;
    std::cout << "\t每秒输出日志数量: " << msg_per_sec  << " 条"  << std::endl;
    std::cout << "\t每秒输出日志大小: " << size_per_sec << " KB" << std::endl; 
}


/*参数：日志器名称，线程总数量，日志总数量，单条日志大小*/
void async_bench(){
    std::unique_ptr<lcglog::LoggerBuilder> builder(new lcglog::GlobalLoggerBuilder());
    builder->buildLoggerName("async_logger");
    builder->buildLoggerLevel(lcglog::LogLevel::value::DEBUG);
    builder->buildLoggerFormatter("%m%n");
    builder->buildLoggerType(lcglog::LoggerType::LOGGER_ASYNC);
    builder->buildEnableUnsafeAsync();//开启非安全模式-主要是将实际落地时间排除在外
    builder->buildSink<lcglog::FileSink>("./logfile/async.log");
    builder->build();

    /*参数：日志器名称，线程总数量，日志总数量，单条日志大小*/
    bench("Async_logger", 5, 10000, 100);
}

int main(){
    async_bench();
    return 0;
}
  • 预期结果：当使用同步模式进行多线程日志输出时，日志可顺利输出；日志内容完整，无乱码/截断；程序不崩溃
  • 实际结果：当使用同步模式进行多线程日志输出时，日志可顺利输出；日志内容完整，无乱码/截断；程序不崩溃，符合预期

验证使用异步模式，多线程输出少量的日志时，日志是否可以顺利输出，日志内容是否完整符合预期

cpp 复制代码 
#include "../logs/lcglog.h"
#include <vector>
#include <thread>
#include <chrono>

/*参数：日志器名称，线程总数量，日志总数量，单条日志大小*/
void bench(const std::string& name, size_t thr_count, size_t msg_count, size_t msg_len){
    //1.获取日志器
    lcglog::Logger::ptr logger = lcglog::getLogger(name);
    if(logger.get() == nullptr){
        return;
    }
    std::cout << "测试日志：" << msg_count << " 条, 总大小:" << msg_count * msg_len / 1024 <<
        "KB" << std::endl;

    //2.组织指定长度的日志消息
    std::string msg ("my name is lihua");//最后一个字节是换行符，以便于输出打印
    //3.创建指定数量的线程
    size_t msg_per_thr = msg_count / thr_count;//一个线程要写的日志数量--每个线程输出的日志条目
    std::vector<std::thread> threads;
    std::vector<double> cost_array(thr_count);
    for(int i=0; i<thr_count; i++){
        threads.emplace_back([&, i](){
            //4.线程函数内部开始计时
            auto start = std::chrono::high_resolution_clock::now();
            //5.开始循环写日志
            for(int j=0; j<msg_per_thr; j++){
                logger->fatal("%s", msg.c_str());
            }
            //6.线程函数内部结束计时
            auto end = std::chrono::high_resolution_clock::now();
            std::chrono::duration<double> cost = end - start;
            cost_array[i] = cost.count();
            std::cout << "\t线程[" << i << "]: " << "  输出日志数量:" << msg_per_thr << ", 耗时:" << 
                cost.count()  << "s" << std::endl;
        });
    }
    for(int i=0; i<thr_count; i++){
        threads[i].join();
    }
    //7.计算总耗时-所有写线程中所耗时间最多的那个线程
    /*多线程中每个线程都有自己的运行时间，但线程是并发处理的，因此耗时最多的那个才是总时间*/
    double cost_max = cost_array[0];
    for(int i=0; i<thr_count; i++){
        cost_max = cost_max < cost_array[i] ? cost_array[i] : cost_max;
    }
    size_t msg_per_sec = msg_count / cost_max;
    size_t size_per_sec = (msg_count * msg_len) / (cost_max*1024);
    //8.进行输出打印
    std::cout << "\t总耗时: " << cost_max << "s" << std::endl;
    std::cout << "\t每秒输出日志数量: " << msg_per_sec  << " 条"  << std::endl;
    std::cout << "\t每秒输出日志大小: " << size_per_sec << " KB" << std::endl; 
}


/*参数：日志器名称，线程总数量，日志总数量，单条日志大小*/
void sync_bench(){
    std::unique_ptr<lcglog::LoggerBuilder> builder(new lcglog::GlobalLoggerBuilder());
    builder->buildLoggerName("sync_logger");
    builder->buildLoggerLevel(lcglog::LogLevel::value::DEBUG);
    builder->buildLoggerFormatter("%m%n");
    builder->buildLoggerType(lcglog::LoggerType::LOGGER_SYNC);
    builder->buildSink<lcglog::FileSink>("./logfile/sync.log");
    builder->build();
    bench("sync_logger", 5, 10000, 100);
}

int main(){
    sync_bench();
    return 0;
}
  • 预期结果：当使用异步模式进行多线程日志输出时，日志可顺利输出；日志内容完整，无乱码/截断；程序不崩溃
  • 实际结果：当使用异步模式进行多线程日志输出时，日志可顺利输出；日志内容完整，无乱码/截断；程序不崩溃，符合预期

性能测试

cpp 复制代码 
#include "../logs/lcglog.h"
#include <vector>
#include <thread>
#include <chrono>
/*参数：日志器名称，线程总数量，日志总数量，单条日志大小*/
void bench(const std::string& name, size_t thr_count, size_t msg_count, size_t msg_len){
    //1.获取日志器
    lcglog::Logger::ptr logger = lcglog::getLogger(name);
    if(logger.get() == nullptr){
        return;
    }
    std::cout << "测试日志：" << msg_count << " 条, 总大小:" << msg_count * msg_len / 1024 <<
        "KB" << std::endl;

    //2.组织指定长度的日志消息
    std::string msg ("my name is lihua");//最后一个字节是换行符，以便于输出打印
    //3.创建指定数量的线程
    size_t msg_per_thr = msg_count / thr_count;//一个线程要写的日志数量--每个线程输出的日志条目
    std::vector<std::thread> threads;
    std::vector<double> cost_array(thr_count);
    for(int i=0; i<thr_count; i++){
        threads.emplace_back([&, i](){
            //4.线程函数内部开始计时
            auto start = std::chrono::high_resolution_clock::now();
            //5.开始循环写日志
            for(int j=0; j<msg_per_thr; j++){
                logger->fatal("%s", msg.c_str());
            }
            //6.线程函数内部结束计时
            auto end = std::chrono::high_resolution_clock::now();
            std::chrono::duration<double> cost = end - start;
            cost_array[i] = cost.count();
            std::cout << "\t线程[" << i << "]: " << "  输出日志数量:" << msg_per_thr << ", 耗时:" << 
                cost.count()  << "s" << std::endl;
        });
    }
    for(int i=0; i<thr_count; i++){
        threads[i].join();
    }
    //7.计算总耗时-所有写线程中所耗时间最多的那个线程
    /*多线程中每个线程都有自己的运行时间，但线程是并发处理的，因此耗时最多的那个才是总时间*/
    double cost_max = cost_array[0];
    for(int i=0; i<thr_count; i++){
        cost_max = cost_max < cost_array[i] ? cost_array[i] : cost_max;
    }
    size_t msg_per_sec = msg_count / cost_max;
    size_t size_per_sec = (msg_count * msg_len) / (cost_max*1024);
    //8.进行输出打印
    std::cout << "\t总耗时: " << cost_max << "s" << std::endl;
    std::cout << "\t每秒输出日志数量: " << msg_per_sec  << " 条"  << std::endl;
    std::cout << "\t每秒输出日志大小: " << size_per_sec << " KB" << std::endl; 
}


/*参数：日志器名称，线程总数量，日志总数量，单条日志大小*/
void sync_bench(){
    std::unique_ptr<lcglog::LoggerBuilder> builder(new lcglog::GlobalLoggerBuilder());
    builder->buildLoggerName("sync_logger");
    builder->buildLoggerLevel(lcglog::LogLevel::value::DEBUG);
    builder->buildLoggerFormatter("%m%n");
    builder->buildLoggerType(lcglog::LoggerType::LOGGER_SYNC);
    builder->buildSink<lcglog::FileSink>("./logfile/sync.log");
    builder->build();
    bench("sync_logger", 5, 10000, 100);
}

void async_bench(){
    std::unique_ptr<lcglog::LoggerBuilder> builder(new lcglog::GlobalLoggerBuilder());
    builder->buildLoggerName("async_logger");
    builder->buildLoggerLevel(lcglog::LogLevel::value::DEBUG);
    builder->buildLoggerFormatter("%m%n");
    builder->buildLoggerType(lcglog::LoggerType::LOGGER_ASYNC);
    builder->buildEnableUnsafeAsync();//开启非安全模式-主要是将实际落地时间排除在外
    builder->buildSink<lcglog::FileSink>("./logfile/async.log");
    builder->build();

    /*参数：日志器名称，线程总数量，日志总数量，单条日志大小*/
    bench("async_logger", 5, 10000, 100);
}

int main(){
    async_bench();
    return 0;
}

验证使用同步模式单线程输出大量日志消息，并将日志消息落地至普通文件时，系统总耗时、每秒输出日志数量、每秒输出日志大小三个指标是否符合预期

  • 预期结果：使用同步模式单线程输出大量日志消息，并将日志消息落地至普通文件时，系统总耗时、每秒输出日志数量、每秒输出日志大小等指标优于使用异步模式单线程输出大量日志时的指标；日志消息完整；程序正常运行不崩溃
  • 实际结果：使用同步模式单线程输出大量日志消息，并将日志消息落地至普通文件时，系统总耗时、每秒输出日志数量、每秒输出日志大小等指标优于使用异步模式单线程输出大量日志时的指标；日志消息完整；程序正常运行不崩溃，符合预期

输出日志数量为1百万时：

输出日志数量为1千万时：

验证使用同步模式多线程输出大量日志消息，并将日志消息落地至普通文件时，系统总耗时、每秒输出日志数量、每秒输出日志大小三个指标是否符合预期

  • 预期结果：使用同步模式多线程输出大量日志消息，并将日志消息落地至普通文件时，系统总耗时、每秒输出日志数量、每秒输出日志大小等指标差于使用异步模式多线程输出大量日志时的指标；日志消息完整；程序正常运行不崩溃；无日志消息交叉输出情况；无线程安全等问题；无死锁/死循环等问题
  • 实际结果：使用同步模式多线程输出大量日志消息，并将日志消息落地至普通文件时，系统总耗时、每秒输出日志数量、每秒输出日志大小等指标差于使用异步模式多线程输出大量日志时的指标；日志消息完整；程序正常运行不崩溃；无日志消息交叉输出情况；无线程安全等问题；无死锁/死循环等问题，符合预期

输出日志数量为1百万时：

输出日志数量为1千万时：

验证使用异步模式单线程输出大量日志消息，并将日志消息落地至普通文件时，系统总耗时、每秒输出日志数量、每秒输出日志大小三个指标是否符合预期

  • 预期结果：使用异步模式单线程输出大量日志消息，并将日志消息落地至普通文件时，系统总耗时、每秒输出日志数量、每秒输出日志大小等指标差于使用同步模式单线程输出大量日志时的指标；日志消息完整；程序正常运行不崩溃
  • 实际结果：使用异步模式单线程输出大量日志消息，并将日志消息落地至普通文件时，系统总耗时、每秒输出日志数量、每秒输出日志大小等指标差于使用同步模式单线程输出大量日志时的指标；日志消息完整；程序正常运行不崩溃，符合预期

输出日志数为1百万时：

输出日志数为1千万时：

验证使用异步模式多线程输出大量日志消息时，日志消息落地至普通文件总耗时、每秒输出日志数量、每秒输出日志大小三个指标是否符合预期

  • 预期结果：使用异步模式多线程输出大量日志消息，并将日志消息落地至普通文件时，系统总耗时、每秒输出日志数量、每秒输出日志大小等指标优于使用同步模式多线程输出大量日志时的指标；日志消息完整；程序正常运行不崩溃；无日志消息交叉输出情况；无线程安全等问题；无死锁/死循环等问题
  • 实际结果：使用异步模式多线程输出大量日志消息，并将日志消息落地至普通文件时，系统总耗时、每秒输出日志数量、每秒输出日志大小等指标优于使用同步模式多线程输出大量日志时的指标；日志消息完整；程序正常运行不崩溃；无日志消息交叉输出情况；无线程安全等问题；无死锁/死循环等问题，符合预期

输出日志数为1百万时：

输出日志数为1千万时：

兼容性测试

验证在CentOs 7系统环境下，系统是否可以编译运行通过、是否可以正常输出日志消息

cpp 复制代码 
#include "../logs/lcglog.h"
#include <unistd.h>

void test_log(const std::string& name){
    INFO("%s", "测试开始");
    lcglog::Logger::ptr logger = lcglog::LoggerManger::getInstance().getLogger(name);
    logger->debug("%s", "测试日志");
    logger->info("%s", "测试日志");
    logger->warn("%s", "测试日志");
    logger->error("%s", "测试日志");
    logger->fatal("%s", "测试日志");
    INFO("%s", "测试完毕");

}

int main()
{

    std::unique_ptr<lcglog::LoggerBuilder> builder(new lcglog::GlobalLoggerBuilder());
    builder->buildLoggerName("sync_logger");
    builder->buildLoggerLevel(lcglog::LogLevel::value::ERROR);
    builder->buildLoggerFormatter("[%c][%f:%l][%p]%m%n");
    builder->buildLoggerType(lcglog::LoggerType::LOGGER_SYNC);
    builder->buildSink<lcglog::FileSink>("./logfile/sync.log");
    builder->buildSink<lcglog::StdoutSink>();
    builder->buildSink<lcglog::RollBySizeSink>("./logfile/sync-roll-by-size", 1024*1024);
    builder->build();
    test_log("sync_logger");
    
    return 0;
}
  • 预期结果：系统可顺利编译运行通过；可正常输出日志消息
  • 实际结果：系统可顺利编译运行通过；可正常输出日志消息，符合预期

界面测试

验证多等级日志输出时，日志输出是否排版整洁

  • 预期结果：多等级日志输出时，日志消息输出排版整洁、清晰、易懂
  • 实际结果：多等级日志输出时，日志消息输出排版整洁、清晰、易懂，符合预期

安全测试

验证多线程使用同步模式进行日志输出时，是否存在线程安全问题

  • 预期结果：无日志输出错乱、数据丢失/重复、线程/程序崩溃
  • 实际结果：无日志输出错乱、数据丢失/重复、线程/程序崩溃，符合预期

易用性测试

验证使用空文件名、非法格式化串时，控制台是否明确输出错误提示

cpp 复制代码 
void async_bench(){
    std::unique_ptr<lcglog::LoggerBuilder> builder(new lcglog::GlobalLoggerBuilder());
    builder->buildLoggerName("async_logger");
    builder->buildLoggerLevel(lcglog::LogLevel::value::DEBUG);

    // 这里没有与之匹配的%M的字符，应当报错提示
    builder->buildLoggerFormatter("%M%n");
    builder->buildLoggerType(lcglog::LoggerType::LOGGER_ASYNC);
    builder->buildEnableUnsafeAsync();//开启非安全模式-主要是将实际落地时间排除在外
    builder->buildSink<lcglog::FileSink>("./logfile/async.log");
    builder->build();

    /*参数：日志器名称，线程总数量，日志总数量，单条日志大小*/
    bench("async_logger", 5, 10000, 100);
}
  • 预期结果：当格式化字符串非法运行程序时，控制台明确提示错误消息
  • 实际结果：当格式化字符串非法运行程序时，控制台明确提示错误消息，符合预期

回归测试

验证同步日志全功能是否正常，进行回归测试

cpp 复制代码 
// ...
void async_bench(){
    std::unique_ptr<lcglog::LoggerBuilder> builder(new lcglog::GlobalLoggerBuilder());
    builder->buildLoggerName("async_logger");
    builder->buildLoggerLevel(lcglog::LogLevel::value::DEBUG);
    builder->buildLoggerFormatter("%m%n");
    builder->buildLoggerType(lcglog::LoggerType::LOGGER_ASYNC);
    builder->buildEnableUnsafeAsync();//开启非安全模式-主要是将实际落地时间排除在外
    builder->buildSink<lcglog::FileSink>("./logfile/async.log");
    builder->build();

    /*参数：日志器名称，线程总数量，日志总数量，单条日志大小*/
    bench("async_logger", 5, 10000, 100);
}
  • 预期结果：使用同步模式输出日志时，可顺利完成日志落地操作
  • 实际结果：使用同步模式输出日志时，可顺利完成日志落地操作，符合预期

本云服务器CPU详情

（注：CPU详细信息保存在 /proc/cpuinfo 中）

本云服务器内存详情

（注：内存详细信息保存在 /proc/meminfo 中）

由上图可知本云服务器的核心与内存是比较小的，只有仅仅2核4G；那么在输出海量日志数据时，系统是吃不消的，这就导致异步模式多线程输出海量数据时的指标与同步模式多线程输出海量数据时的指标不是非常准确，这是受硬件资源的影响；但在虚拟机上异步模式多线程输出海量数据时的指标优于同步模式多线程输出海量数据时的指标。

5、问题与优化

问题

  • 异步单线程性能低于同步模式，存在锁竞争开销
  • 控制台输出无颜色等级区分，问题定位不够直观
  • 异常提示信息较简单，缺少可配置的错误处理策略
  • 无配置文件支持，等级、格式、输出目标需硬编码

优化

  • 滚动文件仅支持按文件大小滚动，可拓展为按时间滚动/天/月/年滚动
  • 优化双缓冲区锁机制，降低单线程异步场景锁冲突
  • 增加控制台颜色渲染，按等级高亮输出
  • 增加配置文件解析功能，支持动态调整日志参数
  • 拓展落地方式，支持网络输出、数据库落地、远超日志服务
  • 完善异常处理与监控，支持日志写入失败告警与提示

6、测试总结

本次测试从功能、性能、界面、兼容性、易用性、安全、回归测试七大角度对该项目进行测试，可以得出以下结论：

  1. 日志系统功能完整，所有设计目标均实现，多级日志、同步/异步切换、多目标落地、格式化等功能正常
  2. 并发安全可靠，多线程场景无死锁、无日志丢失/乱序/交叉写入，满足高并发服务使用要求
  3. 性能表现符合预期，单线程同步效率更高，多线程异步优势明显，但还是会受CPU性能限制
  4. 健壮性良好，异常场景处理合适，程序稳定不崩溃，具备生产环境使用条件
  5. 架构设计合理，模块化程度高、拓展方便，设计模式运用得当

总结：本日志系统测试通过，功能、性能、稳定性均达标，可打包成库给第三方使用

相关推荐
学Linux的语莫1 小时前
langgraph实操
服务器·数据库·mysql
.千余1 小时前
【Linux】开发工具1
linux·运维·服务器·c语言·学习
Ops菜鸟(Xu JieHao)1 小时前
Linux Rear系统热备份 【详细教程】
linux·运维·服务器·linux备份·系统备份·rear·热备份
TBrL7UtdTELTTdut4BAL1 小时前
XG-140G-TF 极简 OpenWrt | 修复2.5G | NPU硬件加速
服务器·智能路由器·openwrt·光猫·xg-140g-tf
乐飞鱼～万维网2 小时前
vscode 调试xdebug 配置问题
ide·vscode·编辑器
сокол2 小时前
【网安-Web渗透测试-Linux提权】CVE-2023-22809
linux·服务器·网络安全
小此方2 小时前
Re：从零开始的 C++ 进阶篇（四）工业级 C++ 编程：如何构建异常安全的健壮系统？（含案例分析）
运维·开发语言·c++·安全
电商API_180079052472 小时前
如何实现批量化自动化获取淘宝商品详情数据？爬虫orAPI？
大数据·c++·爬虫·自动化
爱学习的小囧2 小时前
VMware ESXi 双管理网口配置全教程：新增 vmk1 端口 + 主备冗余 / 负载均衡双模式实操
运维·服务器·网络·windows·负载均衡·虚拟化
热门推荐
012026年4月技术前沿：AI大模型爆发、智能体革命与量子安全新纪元02GitHub 镜像站点03近期有什么ai的新消息，新动态？ 2026.4月042026年4月AI大事件深度解读：大模型竞争进入“深水区“05codex app每次打开重连5次Reconnecting问题解决06AI Weekly | 2026年4月第二周 · GitHub热门项目与AI发展趋势深度解析072026年AI前瞻：量子AI、具身智能与科学发现的新纪元08CC-Switch & Claude 基于 Linux 服务器安装使用指南092026 年 AI 编程助手全面对比评测：Cursor vs Copilot vs Claude Code vs GitHub Copilot Free10从限购到畅通：GLM-5.1 Coding Plan接入攻略