C++轻量级日志系统实现：策略模式与线程安全设计

今忱

1. 项目概述

在Linux系统开发中，日志系统是每个开发者都绕不开的基础设施。一个设计良好的日志系统不仅能帮助我们快速定位问题，还能记录系统运行状态，为后续的性能分析和优化提供数据支持。今天我要分享的是如何从零开始实现一个轻量级但功能完备的日志系统。

这个日志系统采用了策略模式设计，支持两种日志输出方式：控制台输出和文件输出。它具备以下特点：

线程安全，支持多线程环境下的日志记录
支持不同日志级别（DEBUG、INFO、WARNING等）
自动记录时间戳、进程ID、文件名和行号
使用C++17标准实现，代码简洁高效

2. 设计思路与架构

2.1 策略模式的应用

策略模式是我们这个日志系统的核心设计模式。它的主要思想是将算法（在这里是日志的输出策略）封装成独立的类，使得它们可以相互替换而不影响客户端代码。

在我们的实现中：

LogStrategy是抽象基类，定义了日志同步的接口
ConsoleLogStrategy实现了向控制台输出的策略
FileLogStrategy实现了向文件输出的策略

这种设计带来的好处是：

新增输出策略（比如网络输出）时，不需要修改现有代码
可以在运行时动态切换输出策略
每种策略的实现细节被封装在各自类中，降低了耦合度

2.2 日志格式设计

一个良好的日志格式应该包含足够的信息，同时保持可读性。我们设计的日志格式如下：

code复制[2024-08-04 12:27:03] [DEBUG] [202938] [main.cc] [16] - hello world

各字段说明：

时间戳：精确到秒的本地时间
日志级别：DEBUG/INFO/WARNING等
进程ID：记录日志的进程
文件名：记录日志的源文件
行号：记录日志的代码行
消息内容：实际的日志信息

提示：在实际项目中，可以根据需要调整日志格式，比如添加线程ID、模块名等信息。

3. 核心实现细节

3.1 线程安全保证

在多线程环境下，日志系统必须是线程安全的。我们使用互斥锁来保证这一点：

cpp复制class Mutex {
public:
    Mutex() { pthread_mutex_init(&mutex, nullptr); }
    ~Mutex() { pthread_mutex_destroy(&mutex); }
    void Lock() { pthread_mutex_lock(&mutex); }
    void Unlock() { pthread_mutex_unlock(&mutex); }
private:
    pthread_mutex_t mutex;
};

class LockGuard {
public:
    LockGuard(Mutex &mutex) : _Mutex(mutex) { _Mutex.Lock(); }
    ~LockGuard() { _Mutex.Unlock(); }
private:
    Mutex &_Mutex;
};

使用RAII技术的LockGuard确保在任何情况下锁都会被正确释放，避免了死锁问题。

3.2 日志策略实现

3.2.1 控制台输出策略

cpp复制class ConsoleLogStrategy : public LogStrategy {
public:
    void SyncLog(const string &message) override {
        LockGuard lockguard(_mutex);
        cout << message << "\r\n";
    }
private:
    Mutex _mutex;
};

注意：即使是向控制台输出也需要加锁，因为多个线程同时输出会导致日志信息交错。

3.2.2 文件输出策略

文件输出策略稍微复杂一些，需要处理文件路径的创建和文件的打开：

cpp复制class FileLogStrategy : public LogStrategy {
public:
    FileLogStrategy(const string &path = "./log", const string &file = "my.log")
        : _path(path), _file(file) {
        LockGuard lockguard(_mutex);
        if (!filesystem::exists(_path))
            filesystem::create_directories(_path);
    }

    void SyncLog(const string &message) override {
        string fullPath = _path + (_path.back() == '/' ? "" : "/") + _file;
        ofstream out(fullPath, ios::app);
        out << message << "\r\n";
    }
private:
    string _path;
    string _file;
    Mutex _mutex;
};

这里使用了C++17的filesystem库来处理路径操作，比传统的C函数更加安全和方便。

3.3 日志消息构建

日志消息的构建使用了流式接口，通过重载<<运算符实现：

cpp复制class LogMessage {
public:
    template <class T>
    LogMessage &operator<<(const T &message) {
        stringstream ss;
        ss << message;
        _loginfo += ss.str();
        return *this;
    }
    
    ~LogMessage() {
        _logger.Strategy->SyncLog(_loginfo);
    }
private:
    string _loginfo;
    Logger &_logger;
};

这种设计使得日志记录可以像使用标准输出流一样自然：

cpp复制LOG(LogLevel::DEBUG) << "User " << username << " logged in from " << ip;

4. 实用技巧与优化建议

4.1 日志级别管理

我们定义了5种日志级别：

cpp复制enum class LogLevel {
    DEBUG,   // 调试信息
    INFO,    // 普通信息
    WARNING, // 警告
    ERROR,   // 错误
    FATAL    // 致命错误
};

在实际项目中，可以通过编译时宏定义来控制哪些级别的日志会被实际输出，这在发布版本中可以减少不必要的日志开销。

4.2 性能优化

日志系统虽然不应该是性能瓶颈，但也需要注意以下几点：

避免频繁的文件打开关闭：可以考虑在FileLogStrategy中保持文件句柄打开
批量写入：对于高频日志，可以实现缓冲机制，定期批量写入
异步日志：将日志写入操作放到单独的线程中执行

4.3 日志轮转

生产环境中还需要考虑日志轮转（log rotation）的问题，防止日志文件无限增长。可以通过以下方式实现：

按文件大小轮转：当日志文件达到一定大小时，创建新文件
按时间轮转：每天/每小时创建一个新的日志文件
结合压缩：对旧的日志文件进行压缩归档

5. 完整代码实现

以下是完整的日志系统实现，分为两个头文件：

5.1 Mutex.hpp

cpp复制#pragma once
#include <pthread.h>

class Mutex {
public:
    Mutex() { pthread_mutex_init(&mutex, nullptr); }
    ~Mutex() { pthread_mutex_destroy(&mutex); }
    void Lock() { pthread_mutex_lock(&mutex); }
    void Unlock() { pthread_mutex_unlock(&mutex); }
private:
    pthread_mutex_t mutex;
};

class LockGuard {
public:
    LockGuard(Mutex &mutex) : _Mutex(mutex) { _Mutex.Lock(); }
    ~LockGuard() { _Mutex.Unlock(); }
private:
    Mutex &_Mutex;
};

5.2 Log.hpp

cpp复制#pragma once
#include <iostream>
#include <sstream>
#include <filesystem>
#include <fstream>
#include <sys/types.h>
#include <unistd.h>
#include "Mutex.hpp"
using namespace std;

namespace LogModule {
    // 日志等级
    enum class LogLevel {
        DEBUG, INFO, WARNING, ERROR, FATAL
    };

    string LevelToStr(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";
        }
    }

    string GetTime() {
        time_t curr = time(nullptr);
        struct tm curr_time;
        localtime_r(&curr, &curr_time);
        char buffer[128];
        snprintf(buffer, sizeof(buffer), "%04d-%02d-%02d %02d:%02d:%02d",
                curr_time.tm_year + 1900,
                curr_time.tm_mon + 1,
                curr_time.tm_mday,
                curr_time.tm_hour,
                curr_time.tm_min,
                curr_time.tm_sec);
        return buffer;
    }

    class LogStrategy {
    public:
        virtual void SyncLog(const string &message) = 0;
    };

    class ConsoleLogStrategy : public LogStrategy {
    public:
        void SyncLog(const string &message) override {
            LockGuard lockguard(_mutex);
            cout << message << "\r\n";
        }
    private:
        Mutex _mutex;
    };

    class FileLogStrategy : public LogStrategy {
    public:
        FileLogStrategy(const string &path = "./log", const string &file = "my.log")
            : _path(path), _file(file) {
            LockGuard lockguard(_mutex);
            if (!filesystem::exists(_path))
                filesystem::create_directories(_path);
        }

        void SyncLog(const string &message) override {
            string fullPath = _path + (_path.back() == '/' ? "" : "/") + _file;
            ofstream out(fullPath, ios::app);
            out << message << "\r\n";
        }
    private:
        string _path;
        string _file;
        Mutex _mutex;
    };

    class Logger {
    public:
        Logger() {
            Strategy = make_unique<ConsoleLogStrategy>();
        }

        void EnableConsoleLogStrategy() {
            Strategy = make_unique<ConsoleLogStrategy>();
        }

        void EnableFileLogStrategy() {
            Strategy = make_unique<FileLogStrategy>();
        }

        class LogMessage {
        public:
            LogMessage(const LogLevel &level, const string &name, const int &line, Logger &logger)
                : _level(level), _name(name), _logger(logger), _line(line) {
                _pid = getpid();
                _time = GetTime();
                stringstream ss;
                ss << "[" << _time << "] "
                   << "[" << LevelToStr(_level) << "] "
                   << "[" << _pid << "] "
                   << "[" << _name << "] "
                   << "[" << _line << "] - ";
                _loginfo = ss.str();
            }

            template <class T>
            LogMessage &operator<<(const T &message) {
                stringstream ss;
                ss << message;
                _loginfo += ss.str();
                return *this;
            }

            ~LogMessage() {
                _logger.Strategy->SyncLog(_loginfo);
            }
        private:
            string _time;
            LogLevel _level;
            pid_t _pid;
            string _name;
            int _line;
            string _loginfo;
            Logger &_logger;
        };

        LogMessage operator()(const LogLevel &level, const string &name, const int &line) {
            return LogMessage(level, name, line, *this);
        }
    private:
        unique_ptr<LogStrategy> Strategy;
    };

    extern Logger logger;

    #define LOG(level) logger(level, __FILE__, __LINE__)
    #define ENABLE_CONSOLE_LOG() logger.EnableConsoleLogStrategy()
    #define ENABLE_FILE_LOG() logger.EnableFileLogStrategy()
}

6. 使用示例

6.1 基本使用

cpp复制#include "Log.hpp"
using namespace LogModule;

int main() {
    // 默认输出到控制台
    LOG(LogLevel::INFO) << "Application started";
    
    // 切换到文件输出
    ENABLE_FILE_LOG();
    LOG(LogLevel::DEBUG) << "Debug information";
    LOG(LogLevel::ERROR) << "Something went wrong";
    
    return 0;
}

6.2 多线程环境测试

cpp复制#include <thread>
#include <vector>
#include "Log.hpp"
using namespace LogModule;

void worker(int id) {
    for (int i = 0; i < 10; ++i) {
        LOG(LogLevel::INFO) << "Thread " << id << " count " << i;
    }
}

int main() {
    ENABLE_FILE_LOG();
    
    vector<thread> threads;
    for (int i = 0; i < 5; ++i) {
        threads.emplace_back(worker, i);
    }
    
    for (auto &t : threads) {
        t.join();
    }
    
    return 0;
}