mprpc框架的日志系统的设计实现——异步日志缓冲队列

设计想法

一般情况在做项目时，都要有一个日志模块，由于写日志是磁盘I/O，我们不能把这个操作算在业务的执行里，那样效率太低了。

所以我们的思路就是，将写日志信息这部操作，放到一个缓冲队列中，然后有一个单独的写日志线程，来做磁盘I/O。

然后要考虑的问题是：由于我Rpc服务发布方，采用的是muduo网络库，即epoll + 多线程机制，同一时间可能有多个请求，所以要保证该队列的线程安全。

异步缓冲队列的实现

这里直接使用C++的队列queue，为了保证线程安全，引入C++自身封装的互斥量和条件变量。

#pragma once
#include <queue>
#include <thread>
#include <mutex>    // pthread_mutex_t
#include <condition_variable>   // pthread_condition_t

// 异步写日志的日志队列

template<typename T>
class LockQueue
{
public:
    // 入队 多个worker线程都会写日志queue
    void Push(const T& data)
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_queue.push(data);
        m_condvariable.notify_one();
    }

    // 出队 一个线程读日志queue
    T Pop()
    {
        std::unique_lock<std::mutex> lock(m_mutex);
        while (m_queue.empty())
        {
            // 日志队列为空，线程进入wait状态，并释放锁
            m_condvariable.wait(lock);
        }

        T data = m_queue.front();
        m_queue.pop();
        return data;
    }

private:
    std::queue<T> m_queue;
    std::mutex m_mutex;
    std::condition_variable m_condvariable;

};

logger.h

设计的比较简单，目前只有普通日志和错误日志，实例化利用单例模式，除了最基本的方法外，还
定义了一个可变参的宏

#pragma once

#include "lockQueue.h"
#include <string>

enum LogLevel
{
    INFO,   // 普通信息
    ERROR,  // 错误信息
};

// Mprpc框架提供的日志系统
class Logger
{
public:
    // 获取日志的单例
    static Logger& GetInstance();
    // 设置日志级别
    void SetLogLevel(LogLevel level);
    // 写日志
    void Log(std::string msg);

private:
    Logger();
    Logger(const Logger&) = delete;
    Logger(Logger&&) = delete;


    int m_loglevel; // 记录日志级别
    LockQueue<std::string> m_lckQue; // 日志缓冲队列
};

// 定义宏 LOG_INFO
#define LOG_INFO(logmsgformat, ...) \
    do \
    {  \
        Logger& logger = Logger::GetInstance(); \
        logger.SetLogLevel(INFO); \
        char c[1024] = {0}; \
        snprintf(c, 1024, logmsgformat, ##__VA_ARGS__); \
        logger.Log(c); \
    } while (0)

#define LOG_ERR(logmsgformat, ...) \
    do \
    {  \
        Logger& logger = Logger::GetInstance(); \
        logger.SetLogLevel(ERROR); \
        char c[1024] = {0}; \
        snprintf(c, 1024, logmsgformat, ##__VA_ARGS__); \
        logger.Log(c); \
    } while (0)

logger.cc

#include "logger.h"
#include <time.h>
#include <iostream>

// 获取日志的单例
Logger& Logger::GetInstance()
{
    static Logger logger;
    return logger;
}

Logger::Logger()
{
    // 启动专门的写日志线程
    std::thread writeLogTask([&](){
        for (; ;)
        {
            // 获取当前的日期，然后取日志信息，写入相应的日志文件当中 a+
            time_t now = time(nullptr); // 秒数
            tm* nowtm = localtime(&now); // 结构体

            char file_name[128] = {0};
            sprintf(file_name, "%d-%d-%d-log.txt", nowtm->tm_year + 1900, nowtm->tm_mon + 1, nowtm->tm_mday);

            FILE* fp = fopen(file_name, "a+");
            if (fp == nullptr)
            {
                std::cout << "logger file: " << file_name << " open error!" << std::endl;
                exit(EXIT_FAILURE);
            }

            std::string msg = m_lckQue.Pop();

            char time_buf[128] = {0};
            sprintf(time_buf, "%d:%d:%d => [%s]",
                    nowtm->tm_hour,
                    nowtm->tm_min,
                    nowtm->tm_sec,
                    (m_loglevel == INFO ? "info" : "error"));
            msg.insert(0, time_buf);
            msg.append("\n");

            fputs(msg.c_str(), fp);
            fclose(fp);
        }
    });

    // 设置分离线程，守护线程
    writeLogTask.detach();
}

// 设置日志级别
void Logger::SetLogLevel(LogLevel level)
{
    m_loglevel = level;
}

// 写日志，把日志信息写入lockqueue缓冲区中
void Logger::Log(std::string msg)
{
    m_lckQue.Push(msg);
}