恋恋风辰的官方博客

场景

公司有成熟的日志库，但是打印日志的功能是在调用线程里触发的，简而言之就是哪个线程调用了日志库的打印功能，就在哪个线程里输出，如果打印功能频繁，可能会影响该线程的逻辑处理。目前公司的软件界面显示和计算等逻辑很频繁，考虑用异步的方式实现打印。
<!--more-->

思路

1 需要把要写的参数封装成一个数据结构然后投递到异步队列里。
2 因为参数类型多变，需要用模板实现写日志的函数。参数个数也不确定，就需要用可变参数模板。
3 需要另一个线程从队列中取数据并打印日志，也可调用第三饭日志库打印。为减少线程调度开销，在队列为空时，需要将队列挂起。

具体实现

日志等级定义为几个级别

    enum LogLv {
        DEBUGS = 0,
        INFO = 1,
        WARN = 2,
        ERRORS = 3,
    };

定义要投递给队列的任务结构

    class  LogTask {
    public:
        LogTask(){}
        LogTask(const LogTask& src):_level(src._level), _logdatas(src._logdatas){}
        LogTask(const LogTask&& src):_level(src._level),
            _logdatas(std::move(src._logdatas)){}
        LogLv _level;
        QQueue<QVariant> _logdatas;
    };

定义异步处理的日志类，先给出全部代码

   class  AsyncLog : public QThread {
    public:
        static AsyncLog& Instance(){
            static AsyncLog instance;
            return instance;
        }
        //如果不支持C++17,可采用如下函数入队
        template<typename Arg, typename ...Args>
        void TaskEnque(std::shared_ptr<LogTask> task, Arg&& arg, Args&&... args){
            task->_logdatas.enqueue(QVariant(std::forward<Arg>(arg)));
            qDebug() << "enque task data is " << arg << endl;
            TaskEnque(task,std::forward<Args>(args)...);
        }
        template<typename Arg>
        void TaskEnque(std::shared_ptr<LogTask> task, Arg&& arg){
            task->_logdatas.enqueue(QVariant(std::forward<Arg>(arg)));
            qDebug() << "enque task data is " << arg << endl;
        }
        //可变参数列表，异步写
        template<typename...  Args>
        void AsyncWrite(LogLv level, Args&&... args) {
            auto task = std::make_shared<LogTask>();
            //折叠表达式依次将可变参数写入队列,需C++17版本支持
            (task->_logdatas.enqueue(QVariant(std::forward<Args>(args))), ...);
            //如不支持C++17 请用这个版本入队
            //TaskEnque(task, args...);
            task->_level = level;
            std::unique_lock<std::mutex> lock(_mtx);
            _queue.enqueue(task);
            bool notify = (_queue.size() == 1)?true:false;
            lock.unlock();
            // 通知等待的线程有新的任务可处理
            if(notify){
                 _empty_cond.notify_one();
            }
        }
        void Stop(){
            _b_stop = true;
            _empty_cond.notify_one();
        }
    private:
        AsyncLog(const AsyncLog&) = delete;
        AsyncLog& operator = (const AsyncLog&) = delete;
        AsyncLog(QObject* parent = nullptr):QThread(parent),_b_stop(false){
        }
        void run(){
            for(;;){
                std::unique_lock<std::mutex> lock(_mtx);
                while(_queue.empty() && !_b_stop){
                    _empty_cond.wait(lock);
                }
                if(_b_stop){
                    return;
                }
                auto logtask = _queue.dequeue();
                lock.unlock();
                processTask(logtask);
            }
        }
        void processTask(std::shared_ptr<LogTask> task){
            qDebug() << "log level is " << task->_level << endl;
            if(task->_logdatas.empty()){
                return;
            }
            // 队列首元素
            auto head = task->_logdatas.dequeue();
            auto formatstr = head.toString().toStdString();
            for(;!(task->_logdatas.empty());){
                auto data = task->_logdatas.dequeue();
                qDebug() << "deque task data is " << data;
                formatstr=formatString(formatstr, data);
            }
            qDebug() << "formatstr is " << QString::fromStdString(formatstr) << endl;
        }
        template<typename... Args>
        std::string formatString(const std::string& format, Args&&... args) {
               std::string result = format;
               size_t pos = 0;
                //lambda表达式查找并替换字符串
               auto replacePlaceholder = [&](const std::string& placeholder, const std::string& replacement) {
                       size_t placeholderPos = result.find(placeholder, pos);
                       if (placeholderPos != std::string::npos) {
                           result.replace(placeholderPos, placeholder.length(), replacement);
                           pos = placeholderPos + replacement.length();
                       }else{
                            result = result + " " + replacement;
                       }
                   };
              (replacePlaceholder("{}", QVariant(std::forward<Args>(args)).toString().toStdString()), ...);
               qDebug() << "result is : " << QString::fromStdString(result) << endl;
               return result;
           }
        std::condition_variable _empty_cond;
        QQueue<std::shared_ptr<LogTask> >  _queue;
        bool _b_stop;
        std::mutex _mtx;
    };

下面分别解释每段含义
我们先定义了一个单例类

       static AsyncLog& Instance(){
            static AsyncLog instance;
            return instance;
        }

通过可变参数列表，实现异步写功能

    //可变参数列表，异步写
    template<typename...  Args>
    void AsyncWrite(LogLv level, Args&&... args) {
    auto task = std::make_shared<LogTask>();
    //折叠表达式依次将可变参数写入队列,需C++17版本支持
    (task->_logdatas.enqueue(QVariant(std::forward<Args>(args))), ...);
    //如不支持C++17 请用这个版本入队
    //TaskEnque(task, args...);
    task->_level = level;
    std::unique_lock<std::mutex> lock(_mtx);
    _queue.enqueue(task);
    bool notify = (_queue.size() == 1)?true:false;
    lock.unlock();
    // 通知等待的线程有新的任务可处理
    if(notify){
        _empty_cond.notify_one();
    }
}

AsyncWrite用到了可变参数模板，类型为模板类型的右值引用，这被称作万能引用，使用该引用有几个好处
1 支持右值传递
2 支持完美转发
函数内用到了折叠表达式，折叠表达式基本语法如下

(表达式, ...)

折叠表达式会循环执行表达式，直到参数列表用完。
AsyncWrite主要实现了将可变参数封装为task然后投递到队列里，如果队列由空到满则需激活消费者线程取消费队列。
如果你的编译器不支持C++17， 可以改为实现两个模板函数TaskEnque入队。

接下来的run函数重载了QThread的run函数，意在启动一个线程处理任务。

processTask 是处理打印日志的功能。
formatString 为多参数模板函数，意在模拟将多个参数匹配和拼接的功能，当然这个函数可替代为你使用的第三方库。

测试和使用

我们在主函数内初始化日志类，然后启动一个界面阻塞主线程，点击关闭界面后，会销毁日志类开辟的线程。

int main(int argc, char *argv[])
{
    QApplication  a(argc, argv);
    auto & instance =  AsyncLog::AsyncLog::Instance();
    instance.AsyncWrite(AsyncLog::LogLv::ERRORS, "hello", "world !",
                        "my name is {} ", "zack {}", "fair");
    instance.start();
    MainWindow main;
    main.show();
    a.exec();
    qDebug() << "Application Quitting, Please Wait...";
    AsyncLog::AsyncLog::Instance().Stop();
    // 暂停执行500毫秒（0.5秒）
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
    qDebug() << "Application exited...";
    return 0;
}

函数运行后输出如下

formatstr is  "hello world ! my name is zack fair " 
Application Quitting, Please Wait...
Application exited...

总结

本文介绍了如何用模板和可变参数构造一个异步打印功能的类，是基于QT实现的，之后又实现了C++标准版本的。源码链接如下

QT版本

C++版本