log.cpp日志服务

参考学习：从零开始实现 C++ TinyWebServer 异步日志系统 Log类详解_tiny webserver-CSDN博客

本文用于强化学习记忆，原文讲解很清晰。

 

log.cpp:

构造函数：

Log::Log():is_async_(false), today_(0),line_count_(0),fp_(nullptr),
deque_(nullptr), write_thread_(nullptr){}

• 作用：初始化日志类的成员变量，设置初始状态。
• 初始化列表解析：
  • is_async_(false)：默认使用同步模式（日志直接写入文件）。
  • today_(0)：当前日期（初始化为 0，后续由 Init 函数设置）。
  • line_count_(0)：当前日志文件的行数（从 0 开始计数）。
  • fp_(nullptr)：日志文件指针（初始未打开）。
  • deque_(nullptr)：阻塞队列（异步模式用，初始未创建）。
  • write_thread_(nullptr)：异步写日志的线程（初始未创建）。

析构函数：

Log::~Log(){
    while(!deque_->empty())deque_->flush();//唤醒消费者处理剩下数据
    deque_->close();
    write_thread_->join();  //等待线程退出
    if(fp_){
        std::lock_guard<std::mutex> locker(mtx_);
        Flush();
        fclose(fp_);
    }
}

• 作用：程序退出时清理资源，确保日志数据不丢失。
• 步骤解析：
  1. 处理剩余日志：如果是异步模式（deque_ 存在），循环判断队列是否为空，调用 deque_->flush() 唤醒阻塞的写线程，处理队列中剩余的日志数据。
  2. 关闭队列：deque_->close() 通知队列 “不再接受新数据”，让写线程可以退出循环。
  3. 等待线程结束：write_thread_->join() 等待异步写线程完成，避免线程未结束就销毁资源。
  4. 关闭文件：如果文件指针 fp_ 已打开，加锁后刷新缓存（Flush()），再关闭文件（fclose(fp_)），确保数据写入磁盘。

　　　　

初始化函数Init():

//初始化
void Log::Init(int level, const char* path, const char* suffix, int max_capacity){
    is_open_ = true;// 标记日志模块已开启（后续可通过IsOpen()判断）
    level_ = level;// 设置日志等级（0=DEBUG,1=INFO,...,4=FATAL）
    path_ = path; // 记录日志文件存放路径（如"./log"）
    suffix_ = suffix;// 记录日志文件后缀（如".log"）

    if(max_capacity){   // 若max_capacity>0，启用异步模式（需创建队列和线程）
        is_async_= true;    // 标记为异步模式
        if(!deque_){    // 如果阻塞队列还未创建（首次初始化）
            // 1. 创建阻塞队列（用于缓存待写日志，生产者-消费者模型）
            std::unique_ptr<BlockQueue<string>> new_deque(new BlockQueue<string>);
            deque_ = std::move(new_deque);  //所有权转移    // 用移动语义转移队列所有权（避免拷贝）
            
            // 2. 创建异步写日志线程（线程函数为FlushLogThread）
            std::unique_ptr<thread> new_thread(new thread(FlushLogThread));
            write_thread_ = std::move(new_thread);   // 转移线程所有权
        }
    }else {
        // 若max_capacity=0，启用同步模式（直接写文件，无需队列和线程）
        is_async_ = false;
    }
    line_count_ = 0;    // 重置当前日志文件的行数计数器（从0开始）
    path_ = path;    // 冗余：重复设置path_（和前面第3行重复，可删除）
    suffix_ = suffix;   // 冗余：重复设置suffix_（和前面第4行重复，可删除）
    time_t timer = time(nullptr);   // 获取当前时间（秒级，从1970年开始计算）
    struct tm* sys_time = localtime(&timer);    // 转换为本地时间（年/月/日/时/分/秒）
    struct tm t = *sys_time;    // 拷贝一份本地时间（避免后续操作修改原结构体）
    char filename[Log_NAME_LENGTH] = {0};    // 定义文件名数组（长度为Log_NAME_LENGTH=256），初始化为0
    // 格式化文件名：路径+年_月_日+后缀（例如："./log2024_07_26.log"）
    snprintf(filename, Log_NAME_LENGTH - 1, "%s%04d_%02d_%02d%s", path_, t.tm_year + 1900, t.tm_mon + 1, t.tm_mday, suffix_);
    today_ = t.tm_mday; // 记录当前日期的“日”（如26号），用于后续判断是否跨天（需切分文件）

    {   // 作用域：限制lock_guard的生命周期（自动加锁/解锁）
        std::lock_guard<std::mutex> locker(mtx_);   // 加锁，确保文件操作线程安全（多线程下不冲突）
        if(fp_){    // 如果之前已经打开了日志文件
            Flush();    // 先刷新缓存（将内存中的数据写入磁盘）
            fclose(fp_);    // 关闭旧文件
        }
        fp_ = fopen(filename, "a"); // 以“追加模式”打开新日志文件（新内容加在文件末尾）
        if(fp_ == nullptr){ // 如果文件打开失败（可能是路径不存在）
            mkdir(path_, 0777); //777最大权限   // 创建日志目录（0777表示最大权限）
            fp_ = fopen(filename, "a"); // 再次尝试打开文件
        }
        assert(fp_ != nullptr); // 断言：如果文件仍未打开，则程序终止（避免后续操作出错）
    }
}

这里的std::unique_ptr表示智能指针类型，是C++11引入的独占所有权智能指针，它的核心作用是：自动管理动态资源的生命周期，再执政超出作用域时自动调用delete释放内存，避免手动new/delete导致的内存泄露(比如忘记delete,或在异常场景下delete未执行)。

这里说涉及到程序中堆和栈的问题，在栈上创建对象只要出了作用域就会自动销毁，在堆上创建对象需要手动进行销毁。

这两的区分方式主要是看作用域，创建方式，生命周期；一般栈上的创建时直接声名，不需要使用new、malloc等动态分配关键字。堆则是使用new这类的关键字。栈上创建的生命周期严格绑定作用域，出了作用域就自动销毁了。

 

根据日志等级，向日志缓冲区添加对应的等级前缀AppendLogLevel

void Log::AppendLogLevel(int level){
    //定义一个存储 “日志等级前缀字符串” 的数组，每个元素对应一个等级的标识。
    const char* level_title[] = { "[DEBUG]:","[INFO]:", "[WARN]:", "[ERROR]:", "[FATAL]:"};
    //校验并修正日志等级
    int valid_level = (level >= 0 && level <=4 ) ? level : 1;
    //将等级前缀添加到缓冲区
    buff_.Append(level_title[valid_level], 9);
}

 

日志核心写入函数Write：

void Log::Write(int level, const char* format, ...){
    struct timeval now = {0, 0};    // 1. 初始化时间结构体（包含秒和微秒）
    gettimeofday(&now, nullptr);     // 2. 获取当前时间（精确到微秒），存到now中
    time_t time_second = now.tv_sec; // 3. 提取秒级时间（从1970年开始的秒数）
    struct tm* sys_time = localtime(&time_second);   // 4. 将秒级时间转换为本地时间（年/月/日/时/分/秒）
    struct tm t = *sys_time;    // 5. 拷贝本地时间到结构体t（避免sys_time被其他线程修改，确保线程安全）

    //日期不对或行数满了
    // 6. 判断是否需要切换文件：① 日期变化（跨天）；② 行数达到上限（当前文件满了）
    if(today_ != t.tm_mday || (line_count_ && (line_count_ % MAX_LINES == 0))){
        // 7. 加锁后立即解锁：暂时占用锁防止其他线程同时修改文件，随后释放减少阻塞
        std::unique_lock<std::mutex> locker(mtx_);
        locker.unlock();

        // 8. 定义新文件名和日期后缀的缓冲区
        char new_file[Log_NAME_LENGTH]; // 新日志文件名（长度由Log_NAME_LENGTH宏定义，如256）
        char tail[36];  // 日期后缀（如"2024_07_26"）

        // 9. 格式化日期后缀为"年_月_日"（如2024_07_26）
        snprintf(tail, 36, "%04d_%02d_%02d", t.tm_year + 1900, t.tm_mon + 1, t.tm_mday);

        // 10. 分支1：日期变化（跨天，如从25日到26日）
        if(today_ != t.tm_mday)
        {
            // 11. 新文件名格式：路径+日期+后缀（如"./log/2024_07_26.log"）
            snprintf(new_file, Log_NAME_LENGTH - 72, "%s%s%s", path_, tail, suffix_);
            today_ = t.tm_mday; // 更新当前日期为新的"日"（如26）
        }else{
            // 12. 分支2：行数满了（当前文件达到MAX_LINES行）
            int num = line_count_ / MAX_LINES;   // 计算序号（第几个文件，如1、2、3...）
            // 13. 新文件名格式：路径+日期-序号+后缀（如"./log/2024_07_26-1.log"）
            snprintf(new_file, Log_NAME_LENGTH, "%s%s-%d%s", path_, tail, num, suffix_);
        }

        // 14. 加锁处理文件切换（确保线程安全）
        {
            std::lock_guard<std::mutex> locker(mtx_);   // 加锁，防止多线程同时操作文件指针
            Flush();    // 15. 刷新旧文件的缓存（将内存数据写入磁盘）
            fclose(fp_);    // 16. 关闭旧文件
            fp_ = fopen(new_file, "a"); // 17. 以追加模式打开新文件
            assert(fp_ != nullptr); // 18. 断言：确保文件打开成功（失败则程序终止）
        }
    }
    // 19. 加锁：确保日志内容格式化和写入的原子性（线程安全）
    {
        std::lock_guard<std::mutex> locker(mtx_);
        line_count_++;  // 20. 当前文件行数+1（用于判断是否达到切换阈值）

        // 21. 格式化时间戳到缓冲区："年-月-日 时:分:秒.微秒"（如2024-07-26 15:30:20.123456）
        int n = snprintf(buff_.WriteBegin(), 128, "%d-%02d-%02d %02d:%02d:%02d.%06ld",
            t.tm_year + 1900, t.tm_mon + 1, t.tm_mday,  // 年（+1900）、月（+1）、日
            t.tm_hour, t.tm_min, t.tm_sec, now.tv_usec);    // 时、分、秒、微秒
        buff_.HasWritten(n);    // 22. 更新缓冲区已写入的长度（n字节）
        AppendLogLevel(level);  // 23. 向缓冲区添加日志等级前缀（如[DEBUG]:，调用之前分析的函数）

        // 24. 处理用户传入的可变参数（如LOG_DEBUG("fd=%d", fd)中的"fd=%d"和fd）
        va_list vaList; // 定义可变参数列表
        va_start(vaList, format);   // 初始化参数列表（绑定到format后面的参数）
        // 25. 将格式化的日志内容写入缓冲区（如"fd=5"）
        int m = vsnprintf(buff_.WriteBegin(), buff_.WritableBytes(), format, vaList);
        va_end(vaList); // 26. 结束可变参数处理（释放资源）
        buff_.HasWritten(m);    // 27. 更新缓冲区已写入的长度（m字节）
        buff_.Append("\n\0", 2);    // 28. 向缓冲区添加换行符和字符串终止符（每个日志占一行）

        // 29. 根据模式写入：异步模式放入队列，同步模式直接写入文件
        if( is_async_ && deque_)
            deque_->push_back(buff_.RetrieveAllAsString()); // 异步：缓冲区内容转字符串入队
        else
            fputs(buff_.ReadBegin(), fp_);  // 同步：直接将缓冲区内容写入当前文件
        buff_.RetrieveAll();    // 30. 清空缓冲区，准备下次写入
    }   

}

Write 函数的完整流程是：

1. 获取精确时间 → 2. 判断是否需要切换日志文件（按日期 / 行数）→ 3. 线程安全地切换文件 → 4. 格式化日志内容（时间 + 等级 + 用户信息）→ 5. 按模式写入（同步写文件 / 异步入队列）→ 6. 清空缓冲区。

 

GetInstance单例模式

//单例模式之饿汉模式
// 定义一个静态成员函数GetInstance，返回Log类的指针
Log* Log::GetInstance(){
    //静态局部变量的初始化是线程安全的
    // 定义一个静态局部变量log：属于Log类的唯一实例
    static Log log;
    // 返回这个唯一实例的地址
    return &log;
}

关键 1：static Log log; —— 静态局部变量的 “唯一性”

• 静态局部变量的生命周期：与程序一致（从第一次初始化到程序结束），而不是像普通局部变量那样随函数调用结束而销毁。
• 初始化特性：静态局部变量只会被初始化一次（第一次调用 GetInstance() 时），后续调用该函数时，不会再创建新的 Log 对象，直接使用已有的 log 实例。

这就保证了：整个程序运行期间，Log 类只有一个实例（就是这个 static log）。

关键 2：static 成员函数 —— 全局访问点

GetInstance() 是 Log 类的静态成员函数，意味着：

• 不需要创建 Log 类的实例，就可以直接通过 Log::GetInstance() 调用（比如 Log::GetInstance()->Write(...)）。
• 整个程序的任何地方，都能通过这个函数获取到 Log 的唯一实例，实现了 “全局访问”。

关键 3：线程安全（C++11 及以上）

代码注释提到 “静态局部变量的初始化是线程安全的”，这是 C++11 标准后的特性：

• 当多个线程同时第一次调用 GetInstance() 时，编译器会保证 static Log log; 这行代码只执行一次（不会因为并发导致创建多个实例）。
• 这避免了 “懒汉模式” 中需要手动加锁（如 std::mutex）才能保证线程安全的麻烦，简化了实现。

 

 

异步日志的写线程函数FlushLogThread

//异步日志的写线程函数
void Log::FlushLogThread(){
    Log::GetInstance()->AsyncWrite();   // 核心逻辑：调用单例的AsyncWrite方法
}

//写线程真正的执行函数
void Log::AsyncWrite(){
    string str = "";    // 用于临时存储从队列中取出的单条日志内容
    while (deque_->pop(str)){   // 循环条件：从队列中成功取出日志（队列未关闭且有数据）
        //异步模式-消费者
        std::lock_guard<std::mutex> locker(mtx_);   // 加锁，确保文件操作线程安全
        fputs(str.c_str(), fp_);        // 将日志内容写入当前打开的文件
    }
}

 

 

剩下一些函数很容易就看懂

//唤醒消费者，开始写日志
void Log::Flush(){
    if(is_async_){   // 判断当前是否为异步日志模式
        deque_->flush();    // 唤醒阻塞队列中的消费者，强制处理剩余日志
    }
    fflush(fp_);    // 刷新文件指针fp_对应的流缓冲区，将内存数据写入磁盘
}

int Log::GetLevel(){
    std::lock_guard<std::mutex> lock(mtx_);
    return level_;
}

void Log::SetLevel(int level){
    std::lock_guard<std::mutex> lock(mtx_);
    level_ = level;
}

bool Log::IsOpen(){
    return is_open_;
}

 

 

log.cpp

#include "Log/log.h"

Log::Log():is_async_(false), today_(0),line_count_(0),fp_(nullptr),
deque_(nullptr), write_thread_(nullptr){}

Log::~Log(){
    while(!deque_->empty())deque_->flush();//唤醒消费者处理剩下数据
    deque_->close();
    write_thread_->join();  //等待线程退出
    if(fp_){
        std::lock_guard<std::mutex> locker(mtx_);
        Flush();
        fclose(fp_);
    }
}

//初始化
void Log::Init(int level, const char* path, const char* suffix, int max_capacity){
    is_open_ = true;// 标记日志模块已开启（后续可通过IsOpen()判断）
    level_ = level;// 设置日志等级（0=DEBUG,1=INFO,...,4=FATAL）
    path_ = path; // 记录日志文件存放路径（如"./log"）
    suffix_ = suffix;// 记录日志文件后缀（如".log"）

    if(max_capacity){   // 若max_capacity>0，启用异步模式（需创建队列和线程）
        is_async_= true;    // 标记为异步模式
        if(!deque_){    // 如果阻塞队列还未创建（首次初始化）
            // 1. 创建阻塞队列（用于缓存待写日志，生产者-消费者模型）
            std::unique_ptr<BlockQueue<string>> new_deque(new BlockQueue<string>);
            deque_ = std::move(new_deque);  //所有权转移    // 用移动语义转移队列所有权（避免拷贝）
            
            // 2. 创建异步写日志线程（线程函数为FlushLogThread）
            std::unique_ptr<thread> new_thread(new thread(FlushLogThread));
            write_thread_ = std::move(new_thread);   // 转移线程所有权
        }
    }else {
        // 若max_capacity=0，启用同步模式（直接写文件，无需队列和线程）
        is_async_ = false;
    }
    line_count_ = 0;    // 重置当前日志文件的行数计数器（从0开始）
    path_ = path;    // 冗余：重复设置path_（和前面第3行重复，可删除）
    suffix_ = suffix;   // 冗余：重复设置suffix_（和前面第4行重复，可删除）
    time_t timer = time(nullptr);   // 获取当前时间（秒级，从1970年开始计算）
    struct tm* sys_time = localtime(&timer);    // 转换为本地时间（年/月/日/时/分/秒）
    struct tm t = *sys_time;    // 拷贝一份本地时间（避免后续操作修改原结构体）
    char filename[Log_NAME_LENGTH] = {0};    // 定义文件名数组（长度为Log_NAME_LENGTH=256），初始化为0
    // 格式化文件名：路径+年_月_日+后缀（例如："./log2024_07_26.log"）
    snprintf(filename, Log_NAME_LENGTH - 1, "%s%04d_%02d_%02d%s", path_, t.tm_year + 1900, t.tm_mon + 1, t.tm_mday, suffix_);
    today_ = t.tm_mday; // 记录当前日期的“日”（如26号），用于后续判断是否跨天（需切分文件）

    {   // 作用域：限制lock_guard的生命周期（自动加锁/解锁）
        std::lock_guard<std::mutex> locker(mtx_);   // 加锁，确保文件操作线程安全（多线程下不冲突）
        if(fp_){    // 如果之前已经打开了日志文件
            Flush();    // 先刷新缓存（将内存中的数据写入磁盘）
            fclose(fp_);    // 关闭旧文件
        }
        fp_ = fopen(filename, "a"); // 以“追加模式”打开新日志文件（新内容加在文件末尾）
        if(fp_ == nullptr){ // 如果文件打开失败（可能是路径不存在）
            mkdir(path_, 0777); //777最大权限   // 创建日志目录（0777表示最大权限）
            fp_ = fopen(filename, "a"); // 再次尝试打开文件
        }
        assert(fp_ != nullptr); // 断言：如果文件仍未打开，则程序终止（避免后续操作出错）
    }
}


void Log::AppendLogLevel(int level){
    //定义一个存储 “日志等级前缀字符串” 的数组，每个元素对应一个等级的标识。
    const char* level_title[] = { "[DEBUG]:","[INFO]:", "[WARN]:", "[ERROR]:", "[FATAL]:"};
    //校验并修正日志等级
    int valid_level = (level >= 0 && level <=4 ) ? level : 1;
    //将等级前缀添加到缓冲区
    buff_.Append(level_title[valid_level], 9);
}

void Log::Write(int level, const char* format, ...){
    struct timeval now = {0, 0};    // 1. 初始化时间结构体（包含秒和微秒）
    gettimeofday(&now, nullptr);     // 2. 获取当前时间（精确到微秒），存到now中
    time_t time_second = now.tv_sec; // 3. 提取秒级时间（从1970年开始的秒数）
    struct tm* sys_time = localtime(&time_second);   // 4. 将秒级时间转换为本地时间（年/月/日/时/分/秒）
    struct tm t = *sys_time;    // 5. 拷贝本地时间到结构体t（避免sys_time被其他线程修改，确保线程安全）

    //日期不对或行数满了
    // 6. 判断是否需要切换文件：① 日期变化（跨天）；② 行数达到上限（当前文件满了）
    if(today_ != t.tm_mday || (line_count_ && (line_count_ % MAX_LINES == 0))){
        // 7. 加锁后立即解锁：暂时占用锁防止其他线程同时修改文件，随后释放减少阻塞
        std::unique_lock<std::mutex> locker(mtx_);
        locker.unlock();

        // 8. 定义新文件名和日期后缀的缓冲区
        char new_file[Log_NAME_LENGTH]; // 新日志文件名（长度由Log_NAME_LENGTH宏定义，如256）
        char tail[36];  // 日期后缀（如"2024_07_26"）

        // 9. 格式化日期后缀为"年_月_日"（如2024_07_26）
        snprintf(tail, 36, "%04d_%02d_%02d", t.tm_year + 1900, t.tm_mon + 1, t.tm_mday);

        // 10. 分支1：日期变化（跨天，如从25日到26日）
        if(today_ != t.tm_mday)
        {
            // 11. 新文件名格式：路径+日期+后缀（如"./log/2024_07_26.log"）
            snprintf(new_file, Log_NAME_LENGTH - 72, "%s%s%s", path_, tail, suffix_);
            today_ = t.tm_mday; // 更新当前日期为新的"日"（如26）
        }else{
            // 12. 分支2：行数满了（当前文件达到MAX_LINES行）
            int num = line_count_ / MAX_LINES;   // 计算序号（第几个文件，如1、2、3...）
            // 13. 新文件名格式：路径+日期-序号+后缀（如"./log/2024_07_26-1.log"）
            snprintf(new_file, Log_NAME_LENGTH, "%s%s-%d%s", path_, tail, num, suffix_);
        }

        // 14. 加锁处理文件切换（确保线程安全）
        {
            std::lock_guard<std::mutex> locker(mtx_);   // 加锁，防止多线程同时操作文件指针
            Flush();    // 15. 刷新旧文件的缓存（将内存数据写入磁盘）
            fclose(fp_);    // 16. 关闭旧文件
            fp_ = fopen(new_file, "a"); // 17. 以追加模式打开新文件
            assert(fp_ != nullptr); // 18. 断言：确保文件打开成功（失败则程序终止）
        }
    }
    // 19. 加锁：确保日志内容格式化和写入的原子性（线程安全）
    {
        std::lock_guard<std::mutex> locker(mtx_);
        line_count_++;  // 20. 当前文件行数+1（用于判断是否达到切换阈值）

        // 21. 格式化时间戳到缓冲区："年-月-日 时:分:秒.微秒"（如2024-07-26 15:30:20.123456）
        int n = snprintf(buff_.WriteBegin(), 128, "%d-%02d-%02d %02d:%02d:%02d.%06ld",
            t.tm_year + 1900, t.tm_mon + 1, t.tm_mday,  // 年（+1900）、月（+1）、日
            t.tm_hour, t.tm_min, t.tm_sec, now.tv_usec);    // 时、分、秒、微秒
        buff_.HasWritten(n);    // 22. 更新缓冲区已写入的长度（n字节）
        AppendLogLevel(level);  // 23. 向缓冲区添加日志等级前缀（如[DEBUG]:，调用之前分析的函数）

        // 24. 处理用户传入的可变参数（如LOG_DEBUG("fd=%d", fd)中的"fd=%d"和fd）
        va_list vaList; // 定义可变参数列表
        va_start(vaList, format);   // 初始化参数列表（绑定到format后面的参数）
        // 25. 将格式化的日志内容写入缓冲区（如"fd=5"）
        int m = vsnprintf(buff_.WriteBegin(), buff_.WritableBytes(), format, vaList);
        va_end(vaList); // 26. 结束可变参数处理（释放资源）
        buff_.HasWritten(m);    // 27. 更新缓冲区已写入的长度（m字节）
        buff_.Append("\n\0", 2);    // 28. 向缓冲区添加换行符和字符串终止符（每个日志占一行）

        // 29. 根据模式写入：异步模式放入队列，同步模式直接写入文件
        if( is_async_ && deque_)
            deque_->push_back(buff_.RetrieveAllAsString()); // 异步：缓冲区内容转字符串入队
        else
            fputs(buff_.ReadBegin(), fp_);  // 同步：直接将缓冲区内容写入当前文件
        buff_.RetrieveAll();    // 30. 清空缓冲区，准备下次写入
    }   

}


//单例模式之饿汉模式
// 定义一个静态成员函数GetInstance，返回Log类的指针
Log* Log::GetInstance(){
    //静态局部变量的初始化是线程安全的
    // 定义一个静态局部变量log：属于Log类的唯一实例
    static Log log;
    // 返回这个唯一实例的地址
    return &log;
}



//异步日志的写线程函数
void Log::FlushLogThread(){
    Log::GetInstance()->AsyncWrite();   // 核心逻辑：调用单例的AsyncWrite方法
}

//写线程真正的执行函数
void Log::AsyncWrite(){
    string str = "";    // 用于临时存储从队列中取出的单条日志内容
    while (deque_->pop(str)){   // 循环条件：从队列中成功取出日志（队列未关闭且有数据）
        //异步模式-消费者
        std::lock_guard<std::mutex> locker(mtx_);   // 加锁，确保文件操作线程安全
        fputs(str.c_str(), fp_);        // 将日志内容写入当前打开的文件
    }
}

//唤醒消费者，开始写日志
void Log::Flush(){
    if(is_async_){   // 判断当前是否为异步日志模式
        deque_->flush();    // 唤醒阻塞队列中的消费者，强制处理剩余日志
    }
    fflush(fp_);    // 刷新文件指针fp_对应的流缓冲区，将内存数据写入磁盘
}

int Log::GetLevel(){
    std::lock_guard<std::mutex> lock(mtx_);
    return level_;
}

void Log::SetLevel(int level){
    std::lock_guard<std::mutex> lock(mtx_);
    level_ = level;
}

bool Log::IsOpen(){
    return is_open_;
}

 

 

还有对于log.cpp的测试源文件，这里不详细剖析了：

#include "Log/log.h"
#include <iostream>

int main(){
    //获取Log类的单例实例
    Log* logger = Log::GetInstance();

    //初始化日志系统
    logger->Init(0, "./logs/", ".log", 1024);

    //输出不同级别的日志信息
    LOG_DEBUG("This is a debug message.");
    LOG_INFO("This is an info message.");
    LOG_WARN("This is a warning message.");
    LOG_ERROR("This is an error message.");
    LOG_FATAL("This is an fatal message.");

    //输出日志级别
    std::cout << "Current log level: " << logger->GetLevel() << std::endl;

    //修改日志级别
    logger->SetLevel(2);
    std::cout << "New log level: " << logger->GetLevel() << std::endl;

    //再次输出不同级别的日志信息
    LOG_DEBUG("This debug message should not be logged.");
    LOG_INFO("This info message should not be logged.");
    LOG_WARN("This is a new warning message.");
    LOG_ERROR("This is a new error message.");
    LOG_FATAL("This is a new fatal message.");

    //可变参数
    logger->SetLevel(0);
    LOG_DEBUG("%s %d %d", "log info", 123, 666);

    //大量日志
    for(int i = 0; i < 100000; ++i)
    LOG_DEBUG("This is the %d-th errpr message.", i);

    return 0;
}