【Linux系统编程】（四十五）线程池基础：日志系统设计与策略模式的优雅落地

[时间戳] [日志等级] [进程ID] [文件名] [行号] - 日志内容

[2024-08-04 15:09:29] [INFO] [206342] [ThreadPool.hpp] [62] - ThreadPool Construct()
[2024-08-04 15:09:29] [DEBUG] [206342] [ThreadPool.hpp] [109] - 任务入队列成功
[2024-08-04 15:09:39] [ERROR] [206342] [Task.cpp] [36] - 任务执行失败：参数错误

// Log.hpp 基于策略模式的线程池日志系统
#pragma once
#include <iostream>
#include <string>
#include <fstream>
#include <memory>
#include <ctime>
#include <sstream>
#include <filesystem> // C++17 文件系统，需编译参数 -std=c++17
#include <unistd.h>   // getpid() 获取进程ID
#include "Lock.hpp"   // 引入自定义的互斥量封装类

// 日志模块命名空间
namespace LogModule
{
    // 引入锁的命名空间，使用自定义的Mutex和LockGuard
    using namespace LockModule;

    // 日志默认配置：日志目录、日志文件名
    const std::string default_log_path = "./log/";
    const std::string default_log_name = "thread_pool_log.txt";

    // 日志等级：DEBUG(调试) < INFO(信息) < WARNING(警告) < ERROR(错误) < FATAL(致命)
    enum class LogLevel
    {
        DEBUG,
        INFO,
        WARNING,
        ERROR,
        FATAL
    };

    // 工具函数：日志等级转换为字符串，方便日志输出
    std::string LogLevelToString(LogLevel level)
    {
        switch (level)
        {
            case LogLevel::DEBUG:    return "DEBUG";
            case LogLevel::INFO:     return "INFO";
            case LogLevel::WARNING:  return "WARNING";
            case LogLevel::ERROR:    return "ERROR";
            case LogLevel::FATAL:    return "FATAL";
            default:                 return "UNKNOWN";
        }
    }

    // 工具函数：获取格式化的当前时间戳 YYYY-MM-DD HH:MM:SS
    std::string GetCurrentTime()
    {
        // 获取当前时间的时间戳
        time_t now = time(nullptr);
        // 转换为本地时间，使用localtime_r（线程安全），避免localtime（线程不安全）
        struct tm local_tm;
        localtime_r(&now, &local_tm);

        // 格式化时间戳，使用snprintf保证缓冲区安全
        char time_buf[64] = {0};
        snprintf(time_buf, sizeof(time_buf),
                 "%4d-%02d-%02d %02d:%02d:%02d",
                 local_tm.tm_year + 1900,  // 年份从1900开始，需加1900
                 local_tm.tm_mon + 1,      // 月份从0开始，需加1
                 local_tm.tm_mday,
                 local_tm.tm_hour,
                 local_tm.tm_min,
                 local_tm.tm_sec);

        return std::string(time_buf);
    }

    // 策略模式：日志策略接口，声明统一的日志输出方法
    class LogStrategy
    {
    public:
        // 虚析构函数：保证子类析构时能正确调用自身的析构函数
        virtual ~LogStrategy() = default;

        // 纯虚方法：同步输出日志，子类必须实现
        // 参数：格式化后的完整日志字符串
        virtual void SyncLog(const std::string& log_msg) = 0;
    };

    // 具体策略1：控制台日志策略 - 日志输出到控制台，方便调试
    class ConsoleLogStrategy : public LogStrategy
    {
    public:
        // 实现策略接口的SyncLog方法：控制台输出日志
        void SyncLog(const std::string& log_msg) override
        {
            // RAII风格的锁：自动加锁，析构时自动解锁，保证线程安全
            LockGuard lock(_mutex);
            // 输出到标准错误流，实时刷新，无缓冲
            std::cerr << log_msg << std::endl;
        }

    private:
        Mutex _mutex; // 互斥量，保证多线程控制台输出的线程安全
    };

    // 具体策略2：文件日志策略 - 日志持久化到文件，线上环境使用
    class FileLogStrategy : public LogStrategy
    {
    public:
        // 构造函数：初始化日志路径和文件名，自动创建日志目录
        FileLogStrategy(const std::string& log_path = default_log_path,
                        const std::string& log_name = default_log_name)
            : _log_path(log_path), _log_name(log_name)
        {
            // 加锁保证目录创建的线程安全
            LockGuard lock(_mutex);
            // 判断日志目录是否存在，不存在则创建（递归创建，支持多级目录）
            if (!std::filesystem::exists(_log_path))
            {
                try
                {
                    std::filesystem::create_directories(_log_path);
                }
                catch (const std::filesystem::filesystem_error& e)
                {
                    // 目录创建失败，输出错误信息到控制台
                    std::cerr << "创建日志目录失败：" << e.what() << std::endl;
                }
            }
        }

        // 实现策略接口的SyncLog方法：将日志追加写入文件
        void SyncLog(const std::string& log_msg) override
        {
            // RAII风格的锁：保证多线程文件写入的线程安全
            LockGuard lock(_mutex);
            // 拼接完整的日志文件路径
            std::string log_file = _log_path + _log_name;
            // 以追加模式打开文件：std::ios::app，不存在则创建，存在则追加
            std::ofstream log_fs(log_file, std::ios::app);
            if (!log_fs.is_open())
            {
                std::cerr << "打开日志文件失败：" << log_file << std::endl;
                return;
            }
            // 写入日志并换行
            log_fs << log_msg << std::endl;
            // 手动刷新缓冲区，保证日志实时写入文件
            log_fs.flush();
        }

    private:
        std::string _log_path;  // 日志目录
        std::string _log_name;  // 日志文件名
        Mutex _mutex;           // 互斥量，保证多线程文件操作的线程安全
    };

    // 日志核心类：策略模式的客户端，持有策略接口，管理策略切换，创建日志对象
    class Logger
    {
    public:
        // 构造函数：默认使用控制台日志策略，方便开发调试
        Logger()
        {
            UseConsoleStrategy();
        }

        // 析构函数：默认即可，智能指针自动释放策略对象
        ~Logger() = default;

        // 切换策略：使用控制台日志
        void UseConsoleStrategy()
        {
            _log_strategy = std::make_unique<ConsoleLogStrategy>();
        }

        // 切换策略：使用文件日志，支持自定义日志路径和文件名
        void UseFileStrategy(const std::string& log_path = default_log_path,
                             const std::string& log_name = default_log_name)
        {
            _log_strategy = std::make_unique<FileLogStrategy>(log_path, log_name);
        }

        // 内部类：RAII风格的日志格式化类，下文实现
        class LogMessage;

        // 创建日志格式化对象，作为日志输出的入口
        // 参数：日志等级、文件名、行号（后续通过宏自动传入）
        LogMessage operator()(LogLevel level, const std::string& file_name, int line_num);

    private:
        // 持有日志策略接口的智能指针，支持动态切换策略
        // std::unique_ptr：独占所有权，避免策略对象被多次拷贝
        std::unique_ptr<LogStrategy> _log_strategy;
    };

    // 内部类：RAII风格的日志格式化类 - 构造格式化头部，析构自动输出日志
    class Logger::LogMessage
    {
    private:
        LogLevel _level;          // 日志等级
        std::string _time;        // 格式化后的时间戳
        pid_t _pid;               // 进程ID
        std::string _file_name;   // 日志打印的文件名
        int _line_num;            // 日志打印的行号
        Logger& _logger;          // 引用外部的Logger对象，用于调用策略的SyncLog
        std::string _log_msg;     // 格式化后的完整日志字符串

    public:
        // 构造函数：自动格式化日志头部信息
        LogMessage(LogLevel level, const std::string& file_name, int line_num, Logger& logger)
            : _level(level), _file_name(file_name), _line_num(line_num), _logger(logger)
        {
            // 初始化基础信息
            _time = GetCurrentTime();
            _pid = getpid(); // 获取当前进程ID

            // 格式化日志头部：[时间] [等级] [PID] [文件] [行号] - 
            std::stringstream ss;
            ss << "[" << _time << "] "
               << "[" << LogLevelToString(_level) << "] "
               << "[" << _pid << "] "
               << "[" << _file_name << "] "
               << "[" << _line_num << "] - ";
            // 将头部信息存入完整日志字符串
            _log_msg = ss.str();
        }

        // 重载<<运算符：支持任意类型的日志内容拼接，返回自身引用支持链式调用
        template <typename T>
        LogMessage& operator<<(const T& content)
        {
            std::stringstream ss;
            ss << content;
            _log_msg += ss.str();
            return *this;
        }

        // 析构函数：RAII核心 - 自动调用策略的SyncLog方法，输出完整日志
        ~LogMessage()
        {
            if (_logger._log_strategy) // 策略对象不为空时才输出
            {
                _logger._log_strategy->SyncLog(_log_msg);
            }
        }
    };

    // 实现Logger的operator()方法：创建LogMessage对象
    inline Logger::LogMessage Logger::operator()(LogLevel level, const std::string& file_name, int line_num)
    {
        // 返回LogMessage临时对象，RAII风格
        return LogMessage(level, file_name, line_num, *this);
    }

    // 定义全局的Logger对象，整个线程池共用一个日志实例
    Logger g_logger;

    // 日志宏：自动获取文件名(__FILE__)和行号(__LINE__)，简化调用
    // 用法：LOG(LogLevel::INFO) << "线程池启动成功，线程数：" << 10;
    #define LOG(level) g_logger(level, __FILE__, __LINE__)

    // 策略切换宏：一键启用控制台日志/文件日志
    #define ENABLE_CONSOLE_LOG() g_logger.UseConsoleStrategy()
    #define ENABLE_FILE_LOG(path, name) g_logger.UseFileStrategy(path, name)
    // 重载：使用默认路径和文件名的文件日志
    #define ENABLE_FILE_LOG_DEFAULT() g_logger.UseFileStrategy()

} // end of namespace LogModule

LOG(LogLevel::INFO) << "线程池初始化完成，核心线程数：" << 10;
LOG(LogLevel::DEBUG) << "任务入队成功，任务ID：" << 1001;
LOG(LogLevel::ERROR) << "任务执行失败，原因：" << "参数为空";

// Lock.hpp 互斥量封装类，RAII风格，保证线程安全
#pragma once
#include <iostream>
#include <pthread.h>

namespace LockModule
{
    // 互斥量封装类
    class Mutex
    {
    public:
        // 禁用拷贝和赋值：互斥量不能被拷贝
        Mutex(const Mutex&) = delete;
        Mutex& operator=(const Mutex&) = delete;

        // 构造函数：初始化互斥量
        Mutex()
        {
            if (pthread_mutex_init(&_mutex, nullptr) != 0)
            {
                std::cerr << "互斥量初始化失败！" << std::endl;
                exit(EXIT_FAILURE);
            }
        }

        // 加锁
        void Lock()
        {
            if (pthread_mutex_lock(&_mutex) != 0)
            {
                std::cerr << "互斥量加锁失败！" << std::endl;
                exit(EXIT_FAILURE);
            }
        }

        // 解锁
        void Unlock()
        {
            if (pthread_mutex_unlock(&_mutex) != 0)
            {
                std::cerr << "互斥量解锁失败！" << std::endl;
                exit(EXIT_FAILURE);
            }
        }

        // 析构函数：销毁互斥量
        ~Mutex()
        {
            pthread_mutex_destroy(&_mutex);
        }

    private:
        pthread_mutex_t _mutex; // 原生POSIX互斥量
    };

    // RAII风格的锁守卫：构造加锁，析构解锁，避免忘记解锁
    class LockGuard
    {
    public:
        // 禁用拷贝和赋值
        LockGuard(const LockGuard&) = delete;
        LockGuard& operator=(const LockGuard&) = delete;

        // 构造函数：传入互斥量引用，加锁
        explicit LockGuard(Mutex& mutex) : _mutex(mutex)
        {
            _mutex.Lock();
        }

        // 析构函数：解锁
        ~LockGuard()
        {
            _mutex.Unlock();
        }

    private:
        Mutex& _mutex; // 互斥量引用，避免拷贝
    };
} // end of namespace LockModule

// log_test.cpp 日志系统测试程序
#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include "Log.hpp"
#include "Lock.hpp"

using namespace LogModule;
using namespace LockModule;

// 多线程测试函数：多个线程同时打印日志，测试线程安全
void* log_thread_func(void* arg)
{
    std::string thread_name = (char*)arg;
    for (int i = 0; i < 5; ++i)
    {
        LOG(LogLevel::DEBUG) << thread_name << " 打印调试日志，次数：" << i;
        LOG(LogLevel::INFO) << thread_name << " 打印信息日志，次数：" << i;
        usleep(100000); // 休眠100ms，模拟业务逻辑
    }
    return nullptr;
}

int main()
{
    // 1. 默认使用控制台日志，打印测试日志
    std::cout << "===== 控制台日志测试 =====" << std::endl;
    LOG(LogLevel::INFO) << "日志系统启动成功，默认使用控制台日志";
    LOG(LogLevel::WARNING) << "这是一条警告日志，测试等级输出";
    LOG(LogLevel::ERROR) << "这是一条错误日志，测试内容拼接：" << 123 << " " << 3.14 << " " << 'c';
    LOG(LogLevel::FATAL) << "这是一条致命错误日志，测试进程ID：" << getpid();

    // 2. 切换为文件日志（默认路径./log/，文件名thread_pool_log.txt）
    std::cout << "\n===== 切换为文件日志 =====" << std::endl;
    ENABLE_FILE_LOG_DEFAULT();
    LOG(LogLevel::INFO) << "成功切换为文件日志，日志文件路径：./log/thread_pool_log.txt";

    // 3. 多线程日志测试，创建3个线程同时打印日志，测试线程安全
    std::cout << "\n===== 多线程日志测试 =====" << std::endl;
    pthread_t t1, t2, t3;
    pthread_create(&t1, nullptr, log_thread_func, (void*)"Thread-1");
    pthread_create(&t2, nullptr, log_thread_func, (void*)"Thread-2");
    pthread_create(&t3, nullptr, log_thread_func, (void*)"Thread-3");

    // 等待线程结束
    pthread_join(t1, nullptr);
    pthread_join(t2, nullptr);
    pthread_join(t3, nullptr);

    // 4. 切换回控制台日志
    std::cout << "\n===== 切换回控制台日志 =====" << std::endl;
    ENABLE_CONSOLE_LOG();
    LOG(LogLevel::INFO) << "日志系统测试完成，所有日志打印正常";

    return 0;
}

# 编译命令
g++ log_test.cpp Lock.hpp Log.hpp -o log_test -std=c++17 -lpthread

# 运行程序
./log_test

// ThreadPool.hpp 线程池中集成日志系统
#include "Log.hpp"
using namespace LogModule;

// 线程池构造函数
ThreadPool(int thread_num = 10) : _thread_num(thread_num)
{
    LOG(LogLevel::INFO) << "ThreadPool 构造，核心线程数：" << _thread_num;
    // 初始化线程...
}

// 线程任务处理函数
void HandlerTask()
{
    std::string thread_name = "Thread-" + std::to_string(pthread_self() % 100);
    LOG(LogLevel::INFO) << thread_name << " 开始运行，等待任务";
    while (true)
    {
        // 加锁获取任务...
        LOG(LogLevel::DEBUG) << thread_name << " 获取到任务，开始执行";
        // 执行任务...
    }
}

// 任务入队函数
bool Enqueue(Task& task)
{
    // 加锁入队...
    LOG(LogLevel::DEBUG) << "任务入队成功，当前任务队列大小：" << _task_queue.size();
    return true;
}