C++ 手写线程池：基于策略模式实现日志模块

刷新策略

日志的刷新策略采用策略模式设计。先创建一个日志刷新基类，然后根据日志具体往哪刷新写具体的派生类函数，例如往显示器中写、往文件中写、往网络中写等。

以往文件中写为例，注意事项及步骤如下：

1. 当把日志内容刷新到文件中时，需要在当前工作目录下新建一个文件夹，因为日志需要根据不同的日志等级把日志内容写到不同的文件里。
2. 新建文件夹可以使用 C++17 提供的文件操作接口 <filesystem>。在派生类 FileLogStrategy 的构造函数里需要先判断在当前工作目录下指定目录文件存不存在，若存在直接返回，若不存在则新建该指定目录文件。创建目录时需要 try-catch 捕获异常。
3. 实现 SyncLog 往日志文件中刷新日志内容。拼接目标文件路径，然后使用 C++ 风格的文件操作对指定文件写入日志内容。

源码及测试代码：

// logger.hpp
// 策略模式，策略接口
class LogStrategy {
public:
    virtual ~LogStrategy() = default;
    // 纯虚函数，强制派生类重写该函数
    virtual void SyncLog(const std::string &logmessage) = 0;
};

// 控制台日志策略，就是日志只向显示器打印，方便我们 debug
class ConsoleLogStrategy : public LogStrategy {
public:
    ~ConsoleLogStrategy() {}
    void SyncLog(const std::string &logmessage) override {
        // 显示器是共享资源，需要加锁保护
        { LockGuard lockguard(&_lock);
            std::cout << logmessage << std::endl;
        }
    }
private:
    Mutex _lock;
};

// 日志向文件打印
const std::string logdefaultpath = "log";
const static std::string logdefaultfilename = "test.log";

class FileLogStrategy : public LogStrategy {
public:
    FileLogStrategy(const std::string &dir = logdefaultpath, const std::string &filename = logdefaultfilename)
        : _dir_path_name(dir), _filename(filename) {
        // 有可能多个线程都在新建目录，所以最好对新建目录也进行加锁
        {
            LockGuard lockguard(&_lock);
            if (std::filesystem::exists(_dir_path_name)) {
                // 当前工作路径下目录存在，不用新建目录，直接返回
                return;
            }
            try {
                std::filesystem::create_directories(_dir_path_name);
            } catch (const std::filesystem::filesystem_error &e) {
                std::cerr << e.what() << '\n';
            }
        }
    }

    void SyncLog(const std::string &logmessage) override {
        // 显示器是共享资源，需要加锁保护
        {
            LockGuard lockguard(&_lock);
            // 拼接目标文件路径
            std::string target = _dir_path_name; target += "/"; target += _filename;
            std::ofstream out(target.c_str(), std::ios::app); // app 追加模式
            if (!out.is_open()) {
                // 打开文件失败
                return;
            }
            out << logmessage << "\n"; // 等价于 out.write()
            out.close();
        }
    }
    ~FileLogStrategy() {}
private:
    std::string _dir_path_name; // 要写入的目录路径名 // log
    std::string _filename;      // 形成日志文件的文件名 // hello.log
    // 例子：先创建一个 log 目录，再在 log 路径下形成 hello.log 文件，并把日志内容写到该文件中
    Mutex _lock;
};

// main.cc
#include "Logger.hpp"
int main() {
    std::string test = "hello logger";
    // 测试策略 2，文件写入
    // 智能指针，本质就是对 LogStrategy * 原生指针做了封装
    std::unique_ptr<LogStrategy> logger_ptr = std::make_unique<FileLogStrategy>();
    logger_ptr->SyncLog(test);
    logger_ptr->SyncLog(test);
    logger_ptr->SyncLog(test);
    logger_ptr->SyncLog(test);
    logger_ptr->SyncLog(test);
    return 0;
}

获取日志时间

1. 首先需要获取时间戳，利用 time 系统调用。参数传递 nullptr，返回值类型本质是对 long int 类型做的封装，返回值具体是 1970-01-01 午夜到现在的秒数。
2. 然后根据时间戳，转化成可读性较强的时间信息，例如 1970-01-01 00:00:00。实现该功能需要利用 localtime 函数，推荐使用带 _r 后缀的版本，表示该函数可被重入。 它会将时间戳转化为 struct tm 结构体，第一个是输入型参数，传递时间戳，第二个是输出型参数，将结果通过指针带出，成功返回结构体指针，失败返回 nullptr。
3. 把年月日时分秒转化为字符串，使用 snprintf。需要注意 struct tm 中的年减掉了 1900，月是 0-11，需要手动把年加 1900，把月加 1。

// 根据时间戳，获取可读性较强的时间信息
std::string GetCurrentTime() {
    // 1、获取时间戳
    time_t curtime = time(nullptr);
    // 2、把时间戳转化为年月日时分秒
    struct tm currtm;
    localtime_r(&curtime, &currtm);
    // 3、把年月日时分秒转化为字符串
    char timebuffer[64];
    snprintf(timebuffer, sizeof(timebuffer), "%4d-%02d-%02d %02d:%02d:%02d", 
             currtm.tm_year + 1900, currtm.tm_mon + 1, currtm.tm_mday, 
             currtm.tm_hour, currtm.tm_min, currtm.tm_sec);
    return timebuffer;
}

logger 类实现

现在所有零件都已加工完成，接下来需要把它们拼接成一个完整的日志类，供我们使用。

首先需要激活策略，要开启什么策略，就把策略对应的派生类对象创建出来，并把派生类成员指针变量指向该对象。

class Logger {
public:
    Logger() {}
    // 激活策略
    void EnableConsoleLogStrategy() { _strategy = std::make_unique<ConsoleLogStrategy>(); }
    void EnableFileLogStrategy() { _strategy = std::make_unique<FileLogStrategy>(); }
    ~Logger() {}
private:
    std::unique_ptr<LogStrategy> _strategy;
};

现在我们还缺形成一条完整日志的方式，这里利用内部类来实现，在 logger 内部定义一个 LogMessage 的内部类，利用 LogMessage 将各种日志信息拼接成一个字符串，在 LogMessage 的析构函数中调用 logger 成员变量 _strategy 的刷新函数将字符串刷新出去，这也是 RAII 风格的设计思路，所以内部类还需要定义一个对外部类引用的成员变量。

形成一条完整日志后就需要将日志信息信息刷新出去，这里通过重载括号运算符实现，比定义一个具体 writelog 函数更优雅。

内部类 LogMessage 实现

LogMessage 的构造函数： 首先将成员变量利用初始化列表初始化，然后用 stringstream 类对象 ss 将各种类型的成员变量格式化为字符串，接着调用对象 ss 的 str 接口，将其赋给 _loginfo，构成日志信息的左半部分。 stringstream 需要包 <sstream> 头文件，它是 C++ 提供的格式化方案，前面用的 snprintf 是 C 语言提供的方案。

LogMessage 的 operator<<： 然后拼接 _loginfo 右半部分。右半部分是参数是可变的，并且参数类型也不确定，所以处理思路是在内部类中对输出运算符做重载，并且参数类型设置成模板，这样任意类型参数都可以输出。

LogMessage 的析构函数： 当 LogMessage 调用 operator<< 完毕后，_loginfo 也就拼接完毕了，此时 LogMessage 要析构了，我们就可以在 LogMessage 的析构函数中将 _loginfo 的日志信息刷新出去。

日志刷新流程图及源码

[图片：日志刷新流程图]

// logger.hpp
#pragma once
#include <iostream>
#include <filesystem> // C++17
#include <fstream>
#include <string>
#include <sstream>
#include <ctime>
#include <memory>
#include <unistd.h>
#include "Mutex.hpp"

// C++11 支持的强枚举，访问成员需指定作用域，不易出现命名冲突
enum class LogLevel {
    DEBUG,
    INFO,      // 正常消息
    WARNING,   // 出现错误，但不影响程序运行
    ERROR,     // 导致程序退出的错误
    FATAL      // 重大错误
};

std::string Level_to_string(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";
    }
}

// 根据时间戳，获取可读性较强的时间信息
std::string GetCurrentTime() {
    // 1、获取时间戳
    time_t curtime = time(nullptr);
    // 2、把时间戳转化为年月日时分秒
    struct tm currtm;
    localtime_r(&curtime, &currtm);
    // 3、把年月日时分秒转化为字符串
    char timebuffer[64];
    snprintf(timebuffer, sizeof(timebuffer), "%4d-%02d-%02d %02d:%02d:%02d", 
             currtm.tm_year + 1900, currtm.tm_mon + 1, currtm.tm_mday, 
             currtm.tm_hour, currtm.tm_min, currtm.tm_sec);
    return timebuffer;
}

///////////////////////////////////////////////////////////////
// 策略模式，策略接口
class LogStrategy {
public:
    virtual ~LogStrategy() = default;
    // 纯虚函数，强制派生类重写该函数
    virtual void SyncLog(const std::string &logmessage) = 0;
};

// 控制台日志策略，就是日志只向显示器打印，方便我们 debug
class ConsoleLogStrategy : public LogStrategy {
public:
    ~ConsoleLogStrategy() {}
    void SyncLog(const std::string &logmessage) override {
        // 显示器是共享资源，需要加锁保护
        {
            LockGuard lockguard(&_lock);
            std::cout << logmessage << std::endl;
        }
    }
private:
    Mutex _lock;
};

// 日志向文件打印
const std::string logdefaultpath = "log";
const static std::string logdefaultfilename = "test.log";

class FileLogStrategy : public LogStrategy {
public:
    FileLogStrategy(const std::string &dir = logdefaultpath, const std::string &filename = logdefaultfilename)
        : _dir_path_name(dir), _filename(filename) {
        // 有可能多个线程都在新建目录，所以最好对新建目录也进行加锁
        {
            LockGuard lockguard(&_lock);
            if (std::filesystem::exists(_dir_path_name)) {
                // 当前工作路径下目录存在，不用新建目录，直接返回
                return;
            }
            try {
                std::filesystem::create_directories(_dir_path_name);
            } catch (const std::filesystem::filesystem_error &e) {
                std::cerr << e.what() << '\n';
            }
        }
    }

    void SyncLog(const std::string &logmessage) override {
        // 显示器是共享资源，需要加锁保护
        {
            LockGuard lockguard(&_lock);
            // 拼接目标文件路径
            std::string target = _dir_path_name; target += "/"; target += _filename;
            std::ofstream out(target.c_str(), std::ios::app); // app 追加模式
            if (!out.is_open()) {
                // 打开文件失败
                return;
            }
            out << logmessage << "\n"; // 等价于 out.write()
            out.close();
        }
    }
    ~FileLogStrategy() {}
private:
    std::string _dir_path_name; // 要写入的目录路径名 // log
    std::string _filename;      // 形成日志文件的文件名 // hello.log
    // 例子：先创建一个 log 目录，再在 log 路径下形成 hello.log 文件，并把日志内容写到该文件中
    Mutex _lock;
};

////////////////////////////////////////////////////////////
class Logger {
public:
    Logger() {}
    // 激活策略
    void EnableConsoleLogStrategy() { _strategy = std::make_unique<ConsoleLogStrategy>(); }
    void EnableFileLogStrategy() { _strategy = std::make_unique<FileLogStrategy>(); }

    // 形成一条完整的日志信息，利用内部类 LogMessage
    class LogMessage {
    public:
        LogMessage(LogLevel level, std::string filename, int line, Logger &logger)
            : _curr_time(GetCurrentTime()), _level(level), _pid(getpid()),
              _filename(filename), _line(line), _logger(logger) {
            std::stringstream ss;
            ss << "[" << _curr_time << "] "
               << "[" << Level_to_string(_level) << "] "
               << "[" << _pid << "] "
               << "[" << _filename << "] "
               << "[" << _line << "] ";
            _loginfo = ss.str();
        }

        template<typename T>
        LogMessage &operator<<(const T &info) {
            std::stringstream ss;
            ss << info;
            _loginfo += ss.str();
            return *this;
        }

        ~LogMessage() {
            // 如果外部类的_strategy 的成员变量不为空，就可以将_loginfo 的内容通过_strategy 刷新出去
            if (_logger._strategy) {
                _logger._strategy->SyncLog(_loginfo);
            }
        }
    private:
        std::string _curr_time;   // 日志时间
        LogLevel _level;          // 日志等级
        pid_t _pid;               // 进程 pid
        std::string _filename;    // 对应的文件名
        int _line;                // 对应的文件行号
        std::string _loginfo;     // 一条合并完成的，完整的日志信息
        Logger &_logger;          // 对外部类引用，利用 Logger 为 LogMessage 提供刷新策略
    };

    // Logger 提供的写日志方法
    LogMessage operator()(LogLevel level, std::string filename, int line) {
        // 返回 LogMessage 的匿名对象
        return LogMessage(level, filename, line, *this);
    }
    // 上面 LogMessage operator() 实现引出的一些知识点：
    // 1、直接返回 LogMessage 临时对象，和先显式创建对象再返回的写法
    // 在绝大多数场景下效果完全一致，返回临时对象的写法
    // 编译器会直接在'接收返回值的位置'构造 LogMessage 对象，无任何拷贝/移动
    // 先显式创建对象再返回的写法编译器会触发 RVO 优化，同样省略 log_msg 的拷贝 / 移动，
    // 最终效果和写法 1 完全一致；即使关闭优化，C++11 也会通过移动构造函数
    // （LogMessage 无自定义移动构造时，编译器自动生成）完成返回，性能损耗可忽略。
    // 2、的生命周期并非简单的'只有一行'，它的存活时间会根据上下文被编译器延长，
    // 尤其是在函数返回的场景下，例如上面代码的 LogMessage 匿名对象
    // 3、这里写日志方法完全可以不重载括号运算符，而是写成一个具体函数如 WriteLog，
    // 这样就只在：#define LOG(level) logger.WriteLog(level, __FILE__, __LINE__)
    // 需要修改一下调用方法，而重载括号运算符的会更优雅，推荐~

    ~Logger() {}
private:
    std::unique_ptr<LogStrategy> _strategy;
};

// 先定义一个 Logger 对象，后面定义宏会用到
Logger logger;
// 定义调用日志的宏
#define LOG(level) logger(level, __FILE__, __LINE__)
// 定义选择日志模式的宏（也就是选择日志刷新策略）
#define EnableConsoleLogStrategy() logger.EnableConsoleLogStrategy()
#define EnableFileLogStrategy() logger.EnableFileLogStrategy()

// main.cc
#include "Logger.hpp"
#include <unistd.h>

int main() {
    // 预处理阶段时 EnableConsoleLogStrategy() 会被宏替换为 logger.EnableConsoleLogStrategy()
    EnableConsoleLogStrategy();
    // EnableFileLogStrategy();
    LOG(LogLevel::ERROR) << "hello world" << 1234 << ", 3.14 " << 'c';
    LOG(LogLevel::WARNING) << "hello world" << 1234 << ", 3.14 " << 'c';
    LOG(LogLevel::ERROR) << "hello world" << 1234 << ", 3.14 " << 'c';
    LOG(LogLevel::ERROR) << "hello world" << 1234 << ", 3.14 " << 'c';
    return 0;
}