日志器基類+同步日志器的實(shí)現(xiàn)：

先來(lái)實(shí)現(xiàn)日志器基類和同步日志器并進(jìn)行功能測(cè)試

實(shí)現(xiàn)代碼：logger.hpp

#ifndef __M_LOGGER_H__
#define __M_LOGGER_H__
#include"util.hpp"
#include"level.hpp"
#include"formatter.hpp"
#include"sink.hpp"
#include"message.hpp"
#include<atomic>
#include<mutex>
#include<stdio.h>
#include<stdarg.h>
#include<stdlib.h>

namespace wz_logs
{
    class Logger
    {
        public:
        Logger( const std::string &logger_name,
               Formatter::ptr &formatter,
               std::vector<LogSink::ptr> &sinks,
               LogLevel::value &level):
               _logger_name(logger_name),
               _formatter(formatter),
               _limit_level(level),
               _sinks(sinks.begin(),sinks.end()) {}
        //需要向外提供的是一系列對(duì)不同等級(jí)日志消息輸出的方法

        using ptr=std::shared_ptr<Logger>;
        void debug(const std::string &file,size_t line,const char* fmt,...)
        {
            //通過(guò)傳入的參數(shù)構(gòu)造出一個(gè)日志消息對(duì)象，進(jìn)行格式化，最終落地
            //1.判斷當(dāng)前的日志輸出等級(jí)是否達(dá)到輸出等級(jí)
            if(LogLevel::value::DEBUG<_limit_level) {return ;}
            //對(duì)fmt格式化字符串和不定參進(jìn)行字符串組織，得到日志消息字符串
             va_list ap;
             va_start(ap,fmt);
             char* res;
             int ret=vasprintf(&res,fmt,ap);
            if(ret==-1)
            {
               std::cout<<"vasprintf failed!\n";
               return;
            }
              va_end(ap);
              serialize(LogLevel::value::DEBUG,file,line,res);
              free(res);
        }
        void info(const std::string &file,size_t line,const char*fmt,...)
        {
             //通過(guò)傳入的參數(shù)構(gòu)造出一個(gè)日志消息對(duì)象，進(jìn)行格式化，最終落地
            //1.判斷當(dāng)前的日志輸出等級(jí)是否達(dá)到輸出等級(jí)
            if(LogLevel::value::INFO<_limit_level) {return ;}
            //對(duì)fmt格式化字符串和不定參進(jìn)行字符串組織，得到日志消息字符串
             va_list ap;
             va_start(ap,fmt);
             char* res;
             int ret=vasprintf(&res,fmt,ap);
            if(ret==-1)
            {
               std::cout<<"vasprintf failed!\n";
               return;
            }
              va_end(ap);
              serialize(LogLevel::value::INFO,file,line,res);
              free(res);
        }
        void warn(const std::string &file,size_t line,const char*fmt,...)
        {
             //通過(guò)傳入的參數(shù)構(gòu)造出一個(gè)日志消息對(duì)象，進(jìn)行格式化，最終落地
            //1.判斷當(dāng)前的日志輸出等級(jí)是否達(dá)到輸出等級(jí)
            if(LogLevel::value::WARN<_limit_level) {return ;}
            //對(duì)fmt格式化字符串和不定參進(jìn)行字符串組織，得到日志消息字符串
             va_list ap;
             va_start(ap,fmt);
             char* res;
             int ret=vasprintf(&res,fmt,ap);
            if(ret==-1)
            {
               std::cout<<"vasprintf failed!\n";
               return;
            }
              va_end(ap);
              serialize(LogLevel::value::WARN,file,line,res);
              free(res);
        }
        void error(const std::string &file,size_t line,const char*fmt,...)
        {
             //通過(guò)傳入的參數(shù)構(gòu)造出一個(gè)日志消息對(duì)象，進(jìn)行格式化，最終落地
            //1.判斷當(dāng)前的日志輸出等級(jí)是否達(dá)到輸出等級(jí)
            if(LogLevel::value::ERROR<_limit_level) {return ;}
            //對(duì)fmt格式化字符串和不定參進(jìn)行字符串組織，得到日志消息字符串
             va_list ap;
             va_start(ap,fmt);
             char* res;
             int ret=vasprintf(&res,fmt,ap);
            if(ret==-1)
            {
               std::cout<<"vasprintf failed!\n";
               return;
            }
              va_end(ap);
              serialize(LogLevel::value::ERROR,file,line,res);
              free(res);
        }
        void fatal(const std::string &file,size_t line,const char*fmt,...)
        {
             //通過(guò)傳入的參數(shù)構(gòu)造出一個(gè)日志消息對(duì)象，進(jìn)行格式化，最終落地
            //1.判斷當(dāng)前的日志輸出等級(jí)是否達(dá)到輸出等級(jí)
            if(LogLevel::value::FATAL<_limit_level) {return ;}
            //對(duì)fmt格式化字符串和不定參進(jìn)行字符串組織，得到日志消息字符串
             va_list ap;
             va_start(ap,fmt);
             char* res;
             int ret=vasprintf(&res,fmt,ap);
            if(ret==-1)
            {
               std::cout<<"vasprintf failed!\n";
               return;
            }
              va_end(ap);
              serialize(LogLevel::value::FATAL,file,line,res);
              free(res);
        }
        protected:
        void serialize(LogLevel::value level,const std::string &file,size_t line,char*str)
        {
            //1.構(gòu)造LogMsg對(duì)象
            LogMsg msg(level,line,file,_logger_name,str);
            //2.通過(guò)格式化工具對(duì)LogMsg進(jìn)行格式化，得到格式化后的日志字符串
            std::string ss=_formatter->format(msg);
            //3.進(jìn)行日志落地
            log(ss.c_str(),ss.size());
        }
        //抽象接口完成實(shí)際的落地輸出--不同的日志器會(huì)有不同的落地方式
        virtual void log(const char* data,size_t len)=0;
        protected:
        std::mutex _mutex;
        std::string _logger_name;
        Formatter::ptr _formatter;
        std::vector<LogSink::ptr> _sinks;
        std::atomic<LogLevel::value> _limit_level;
    };

    class SyncLogger:public Logger{
    public:
     SyncLogger( const std::string &logger_name,
    Formatter::ptr &formatter,
    std::vector<LogSink::ptr> &sinks,
    LogLevel::value &level):
    Logger(logger_name,
          formatter,
          sinks,
          level) {}
     void log(const char* data,size_t len)
     {
        //同步日志器，是將日志直接通過(guò)落地模塊句柄進(jìn)行日志落地
        std::unique_lock<std::mutex> lock(_mutex);
        if(_sinks.empty()) return;
        for(auto &sink:_sinks)
        {
            sink->sink(data,len); 
        }
     }
    };
}

#endif

測(cè)試代碼：test.cpp

//logger.cpp同步日志器測(cè)試
#include"logger.hpp"
int main()
{
    std::string logger_name="synclogger";
    wz_logs::LogLevel::value limit=wz_logs::LogLevel::value::WARN;
    wz_logs::Formatter::ptr fmt(new wz_logs::Formatter("[%d{%H:%M:%S}][%c][%f:%l][%p]%T%m%n"));
     wz_logs::LogSink::ptr stdout_lsp=wz_logs::SinkFactory::creat<wz_logs::StdoutSink>();
     wz_logs::LogSink::ptr file_lsp=wz_logs::SinkFactory::creat<wz_logs::FileSink>("./logfile/test.log");
     wz_logs::LogSink::ptr roll_lsp=wz_logs::SinkFactory::creat<wz_logs::RollBySizeSink>("./logfile/roll-",1024*1024);
     std::vector<wz_logs::LogSink::ptr> sinks={stdout_lsp,file_lsp,roll_lsp};
     wz_logs::Logger::ptr logger(new wz_logs::SyncLogger(logger_name,fmt,sinks,limit));
     logger->debug(__FILE__,__LINE__,"%s","測(cè)試日志");
     logger->info(__FILE__,__LINE__,"%s","測(cè)試日志");
     logger->warn(__FILE__,__LINE__,"%s","測(cè)試日志");
     logger->error(__FILE__,__LINE__,"%s","測(cè)試日志");
     logger->fatal(__FILE__,__LINE__,"%s","測(cè)試日志");
     size_t cursize=0,count=0;
     while(cursize<1024*1024*10)
     {
        logger->fatal(__FILE__,__LINE__,"測(cè)試日志-%d",count++);
        cursize+=20;
     }
    return 0;
}

本測(cè)試用例實(shí)現(xiàn)同時(shí)向三個(gè)落地方向進(jìn)行輸出，測(cè)試結(jié)果如下：

建造者設(shè)計(jì)思想的引入：

我們?cè)谑褂萌罩酒髂K進(jìn)行日志打印之前，要進(jìn)行日志消息模塊、格式化器模塊等的大量的零部件構(gòu)造，如下圖：

也就是說(shuō)用戶真正使用到我們的日志器模塊之前還要自己承擔(dān)構(gòu)造各個(gè)零件的任務(wù)，顯然，這對(duì)于用戶來(lái)說(shuō)，體驗(yàn)感并不好，因此我們使用建造者模式來(lái)建造日志器，而不要讓用戶直接建造，簡(jiǎn)化用戶使用的復(fù)雜度，實(shí)現(xiàn)思想如下：

1.抽象一個(gè)日志器建造者基類：設(shè)置日志器類性、將所有的日志器創(chuàng)建放在同一個(gè)建造者類中完成；

2.派生出具體的建造者類--局部日志器的建造者、全局日志器的建造者

建造者模式初步實(shí)現(xiàn)：

這部分代碼也在logger.hpp中：

enum LoggerType{
LOGGER_SYNC,
LOGGER_ASYNC
};
//1.抽象一個(gè)日志器建造者基類：設(shè)置日志器類性、將所有的日志器創(chuàng)建放在同一個(gè)建造者類中完成；
class LoggerBuilder
{
  public:
  LoggerBuilder():_logger_type(LoggerType::LOGGER_SYNC),
  _limit_level(wz_logs::LogLevel::value::DEBUG) {}
  void buildLoggerType(LoggerType type){_logger_type=type;}
  void buildLoggerName(const std::string &name){_logger_name=name;}
  void buildLoggerLevel(wz_logs::LogLevel::value level){_limit_level=level;}
  void buildFormatter(const std::string &pattern)
  {
   _formatter=std::make_shared<wz_logs::Formatter>(pattern);
  }
  template <typename SinkType,typename...Args>
  void buildSink(Args &&...args)
  {
   wz_logs::LogSink::ptr psink=SinkFactory::creat<SinkType>(std::forward<Args>(args)...);
   _sinks.push_back(psink);
  }
  virtual Logger::ptr build()=0;

  protected:
   LoggerType _logger_type;
   std::string _logger_name;
   wz_logs::Formatter::ptr _formatter;
   wz_logs::LogLevel::value _limit_level;
   std::vector<wz_logs::LogSink::ptr> _sinks;
};

//2.派生出具體的建造者類--局部日志器的建造者、全局日志器的建造者  
class LocalLoggerBuilder:public LoggerBuilder{
   public:
   Logger::ptr build() override
   {
      assert(!_logger_name.empty());//日志器名稱是使用日志器的唯一標(biāo)識(shí)，即必須有
      if(_formatter.get()==nullptr)
      {
         _formatter=std::make_shared<Formatter>();
      }
      if(_sinks.empty())
      {
         buildSink<StdoutSink>();
      }
      if(_logger_type==LoggerType::LOGGER_ASYNC)
      {

      }
      return std::make_shared<SyncLogger>(_logger_name,_formatter,_sinks,_limit_level);
   }
};

? ? ? ? 看得出來(lái)調(diào)用接口來(lái)實(shí)現(xiàn)零件構(gòu)造明顯比上面直接構(gòu)造方便很多，由于我們對(duì)各個(gè)模塊構(gòu)建的順序不會(huì)影響到最后的落地情況，因此這里不需要再生成指揮者類。

測(cè)試代碼：test.cpp

//logger.cpp建造者模式下同步日志器測(cè)試
#include"logger.hpp"
int main()
{
     std::unique_ptr<wz_logs::LoggerBuilder> builder(new wz_logs::LocalLoggerBuilder());
     builder->buildLoggerName("sync_logger");
     builder->buildLoggerLevel(wz_logs::LogLevel::value::WARN);
     builder->buildFormatter("%m%n");
     builder->buildLoggerType(wz_logs::LoggerType::LOGGER_SYNC);
     builder->buildSink<wz_logs::FileSink>("./logfile/test.log");
     builder->buildSink<wz_logs::StdoutSink>();
     wz_logs::Logger::ptr logger=builder->build();
     logger->debug(__FILE__,__LINE__,"%s","測(cè)試日志");
     logger->info(__FILE__,__LINE__,"%s","測(cè)試日志");
     logger->warn(__FILE__,__LINE__,"%s","測(cè)試日志");
     logger->error(__FILE__,__LINE__,"%s","測(cè)試日志");
     logger->fatal(__FILE__,__LINE__,"%s","測(cè)試日志");
     size_t cursize=0,count=0;
     while(cursize<1024*1024*10)
     {
        logger->fatal(__FILE__,__LINE__,"測(cè)試日志-%d",count++);
        cursize+=20;
     }
    return 0;
}

測(cè)試結(jié)果：

異步日志器：

異步緩沖區(qū)類--概念：

? ? ? ? 之前完成的同步日志器是直接將日志消息進(jìn)行格式化然后寫入文件，接下來(lái)的異步日志器實(shí)現(xiàn)思想如下：

? ? ? ?有了之前的鋪墊，我們知道，異步日志器的實(shí)現(xiàn)是為了避免因?yàn)閷懭罩镜倪^(guò)程阻塞，導(dǎo)致業(yè)務(wù)線程在寫日志的時(shí)候影響效率，我們的實(shí)現(xiàn)思想就是不讓業(yè)務(wù)線程進(jìn)行日志的實(shí)際落地操作，而是將日志消息放到緩沖區(qū)（一塊指定的內(nèi)存），接下來(lái)有一個(gè)專門的異步線程，去針對(duì)緩沖區(qū)中的數(shù)據(jù)進(jìn)行處理（實(shí)際的落地操作），如下圖：

那么我們要實(shí)現(xiàn)一個(gè)異步日志器，首先要有一個(gè)線程安全的緩沖區(qū)，其次要有一個(gè)處理消息實(shí)際落地的異步工作線程，線程安全是靠對(duì)緩沖區(qū)的讀寫加鎖實(shí)現(xiàn)的。

緩沖區(qū)設(shè)計(jì)：

1.使用隊(duì)列，緩存日志消息，逐條處理

? ? ? ?考慮到效率問(wèn)題，這個(gè)隊(duì)列不能涉及到空間的頻繁申請(qǐng)和釋放，否則會(huì)降低效率，那就可以設(shè)計(jì)一個(gè)環(huán)形隊(duì)列（提前將空間申請(qǐng)好，然后對(duì)空間進(jìn)行循環(huán)利用），但是這種方式會(huì)遇到嚴(yán)重的鎖沖突問(wèn)題，生產(chǎn)者與生產(chǎn)者的互斥，生產(chǎn)者與消費(fèi)者的互斥【因?yàn)閷懭罩静僮髟趯?shí)際開發(fā)過(guò)程中，并不會(huì)分配太多資源，所以工作線程只需要一個(gè)日志器就行，一般不考慮消費(fèi)者與消費(fèi)者之間的沖突】，為解決這一問(wèn)題，我們采用雙緩沖區(qū)的方式，思想如下：

? ? ? ? 雙緩沖區(qū)是處理器將一個(gè)緩沖區(qū)中的任務(wù)全部處理完，然后交換兩個(gè)緩沖區(qū)，重新對(duì)新的緩沖區(qū)中的任務(wù)進(jìn)行處理，雖然同時(shí)多線程輸入也會(huì)沖突，但是沖突并不會(huì)像每次只處理一條的時(shí)候頻繁（主要是減少了生產(chǎn)者和消費(fèi)者之間的鎖沖突），且不涉及到空間的頻繁申請(qǐng)和釋放所帶來(lái)的消耗，結(jié)構(gòu)圖如下：

接下來(lái)我們對(duì)單個(gè)緩沖區(qū)進(jìn)行進(jìn)一步設(shè)計(jì)：

? ? ? ? 生產(chǎn)者消費(fèi)者緩沖區(qū)我們用共同的一個(gè)緩沖區(qū)類來(lái)同時(shí)實(shí)現(xiàn)，這個(gè)緩沖區(qū)類構(gòu)造后可以直接存放格式化后的日志消息字符串（這樣既可以減少LogsMsg對(duì)象的頻繁構(gòu)造，又可以針對(duì)緩沖區(qū)的日志消息，一次性進(jìn)行IO操作，減少IO次數(shù)，提高效率），因此我們?cè)O(shè)計(jì)的緩沖區(qū)類應(yīng)該管理的成員以及需要提供的接口如下：

成員變量：

1.一個(gè)存放字符串?dāng)?shù)據(jù)的緩沖區(qū)（使用管理 ）

2.當(dāng)前的寫入數(shù)據(jù)位置的指針（指向可寫區(qū)域的起始位置，避免數(shù)據(jù)寫入覆蓋）

3.當(dāng)前的讀取數(shù)據(jù)位置的指針（指向可讀數(shù)據(jù)區(qū)域的起始位置，當(dāng)讀取指針與寫入指針指向位置相同表示數(shù)據(jù)讀取完了）

成員函數(shù)：

1.向緩沖區(qū)寫入數(shù)據(jù)

2.獲取可讀、可寫數(shù)據(jù)起始地址的接口

3.獲取可讀數(shù)據(jù)長(zhǎng)度的接口

4.移動(dòng)讀寫位置的接口

5.初始化緩沖區(qū)的操作（將一個(gè)緩沖區(qū)所有數(shù)據(jù)處理完畢之后，讀寫位置初始化）

6.交換緩沖區(qū)的操作

異步緩沖區(qū)類--實(shí)現(xiàn)：

buffer.hpp?

#ifndef __M_BUF_H__
#define __M_BUF_H__
#include<vector>
#include<cassert>
#include<iostream>
namespace wz_logs
{
    #define DEFAULT_BUFFER_SIZE (1*1024*1024) //默認(rèn)緩沖區(qū)大小1M
    #define THRESHOLD_BUFFER_SIZE (10*1024*1024)//緩沖區(qū)閾值
    #define INCREMENT_BUFFER_SIZE (1*1024*1024)//線性增量大小
        class Buffer
        {
            public:
            Buffer():_buffer(DEFAULT_BUFFER_SIZE),_writer(0),_reader(0) {}
            //將數(shù)據(jù)push進(jìn)緩沖區(qū)
            void push(const char* data,size_t len)
            {
                //1.判斷容量，這里提供兩種處理方式，應(yīng)用于不同的場(chǎng)景
                  //1'數(shù)量達(dá)到設(shè)定好的大小，就阻塞/返回false---應(yīng)用于實(shí)際場(chǎng)景，因?yàn)楝F(xiàn)實(shí)中資源不可能是無(wú)限使用的
       //           if(_buffer.writeAblesize()<len) return;
                  //2'數(shù)量按照一定的規(guī)則來(lái)擴(kuò)容，不設(shè)上限---應(yīng)用于測(cè)試場(chǎng)景
                  if(writeAblesize()<len)
                  {
                     containerReset(len);
                  }
                //2.將數(shù)據(jù)拷貝到緩沖區(qū)可寫入起始地址處
                std::copy(data,data+len,&_buffer[_writer]);
                //3.可寫入地址向后偏移
                writemov(len);
            }
            //讀位置向后偏移
            void readmov(size_t len)
            {
                assert(len<=_buffer.size());
                _reader+=len;

            }
            //返回可讀位置起始地址
            const char* begin()
            {
                return &_buffer[_reader];
            }
            //重置緩沖區(qū)，初始化緩沖區(qū)
            void reset()
            {
                _reader=0;
                _writer=0;
            }
            //返回緩沖區(qū)可讀取數(shù)據(jù)長(zhǎng)度
            size_t readAblesize()
            {
                return _writer-_reader;
            }
            //返回緩沖區(qū)可寫入數(shù)據(jù)長(zhǎng)度
            size_t writeAblesize()
            {
                return _buffer.size()-_writer;
            }
            //交換讀寫緩沖區(qū)
            void swap(Buffer &buf)
            {
              _buffer.swap(buf._buffer);
              std::swap(_writer,buf._writer);
              std::swap(_reader,buf._reader);
            }
            //判斷緩沖區(qū)是否為空
            bool empty()
            {
                return _writer==_reader;
            }

            private:
            //寫指針向后偏移
            void writemov(size_t len)
            {
                assert((len+_writer)<=_buffer.size());
                _writer+=len;
            }
            //擴(kuò)容
           void containerReset(const size_t &len)
            {
                //為保證合理性，我們采用閾值的方式來(lái)劃分?jǐn)U容方式
                //設(shè)定一個(gè)閾值，沒(méi)達(dá)到閾值之間，2倍擴(kuò)容，達(dá)到閾值后，線性擴(kuò)容
                size_t newsize=0;
                if(_buffer.size()<THRESHOLD_BUFFER_SIZE)
                {
                    newsize=_buffer.size()*2+len;//+len是因?yàn)閿U(kuò)容后可能容量依舊不夠，即newsize<len
                }
                else
                {
                    newsize=_buffer.size()+INCREMENT_BUFFER_SIZE+len;//日志一般不會(huì)存在擴(kuò)容后空間仍然不夠的問(wèn)題，但是也要考慮到異常的處理
                }
                _buffer.resize(newsize);
            }
            private:
            std::vector<char> _buffer;
            size_t _writer;//本質(zhì)是當(dāng)前可寫位置的下標(biāo)
            size_t _reader;//本質(zhì)是當(dāng)前可讀位置的下標(biāo)
        };
}
#endif

測(cè)試代碼：test.cpp

//buffer.hpp的測(cè)試
//由于在此環(huán)境下，不好去查看內(nèi)存空間值的情況
//因此為了方便，我們和文件讀取寫入配合的操作來(lái)測(cè)試，具體思想如下：
//讀取文件數(shù)據(jù)，逐字節(jié)寫入緩沖區(qū)，最終將緩沖區(qū)數(shù)據(jù)寫入文件，判斷生成的新文件與源文件是否一致
#include "buffer.hpp"
#include <fstream>
int main()
{
   //ifstream：該數(shù)據(jù)類型表示輸入文件流，用于從文件讀取信息。
   std::ifstream ifs("./logfile/test.log",std::ios::binary);
   if(ifs.is_open()==false) return -1;
   ifs.seekg(0,std::ios::end);//讀寫位置跳轉(zhuǎn)至文件末尾
   size_t fsize=ifs.tellg();//獲取當(dāng)前讀寫位置相對(duì)于起始位置的偏移量
   ifs.seekg(0,std::ios::beg);//重新跳轉(zhuǎn)至起始位置
   std::string body;
   body.resize(fsize);
   ifs.read(&body[0],fsize);
   if(ifs.good()==false)
   {
      std::cout<<"read error\n";
      return -1;
   }
   ifs.close();
    std::cout<<fsize<<std::endl;

    wz_logs::Buffer buffer;
    for(int i=0; i<body.size();i++)
    {
      buffer.push(&body[i],1);
    }
    std::ofstream ofs("./logfile/tmp.log",std::ios::binary);//測(cè)試時(shí)，一定要保證這個(gè)文件是存在的，否則運(yùn)行時(shí)找不到會(huì)報(bào)錯(cuò)
    size_t bsize=buffer.readAblesize(); 
    for(int i=0;i<bsize;i++)
    {
    ofs.write(buffer.begin(),1);
    if(ofs.good()==false) {std::cout<<"write error\n";return -1;}
    buffer.readmov(1);
    }
    ofs.close();
    return 0;
}

測(cè)試結(jié)果：

補(bǔ)充知識(shí)：MD5算法常常被用來(lái)驗(yàn)證網(wǎng)絡(luò)文件傳輸?shù)耐暾?，防止文件被人篡改。MD5 全稱是報(bào)文摘要算法（Message-Digest Algorithm 5），此算法對(duì)任意長(zhǎng)度的信息逐位進(jìn)行計(jì)算，產(chǎn)生一個(gè)二進(jìn)制長(zhǎng)度為128位（十六進(jìn)制長(zhǎng)度就是32位）的“指紋”（或“報(bào)文摘要”），不同的文件產(chǎn)生相同的報(bào)文摘要的可能性是非常非常之小的，常用來(lái)驗(yàn)證兩文件內(nèi)容是否完全一致。

異步工作器--概念：

設(shè)計(jì)思想：異步處理器+數(shù)據(jù)池（雙緩沖區(qū)）

? ? ? ? 使用者將需要完成的任務(wù)添加到任務(wù)池中，由異步線程來(lái)完成任務(wù)的實(shí)際執(zhí)行操作。

由此異步工作器需要管理的成員變量及提供的操作就很清楚了，如下：

私有成員變量：

1.雙緩沖區(qū)（生產(chǎn)、消費(fèi)）

2.互斥鎖（保證線程安全）

3.條件變量--生產(chǎn)+ 消費(fèi)（生產(chǎn)緩沖區(qū)沒(méi)有數(shù)據(jù)，處理完消費(fèi)緩沖區(qū)數(shù)據(jù)后就休眠）

4.回調(diào)函數(shù)（針對(duì)緩沖區(qū)中數(shù)據(jù)的處理接口-外部傳入一個(gè)函數(shù)，告訴異步工作器數(shù)據(jù)該如何處理）

提供的操作接口：

1.停止異步工作器

2.添加數(shù)據(jù)到緩沖區(qū)

私有操作接口：

創(chuàng)建線程，線程入口函數(shù)中，交換緩沖區(qū)，對(duì)消費(fèi)緩沖區(qū)數(shù)據(jù)使用回調(diào)函數(shù)進(jìn)行處理，處理完后再次交換

異步工作器--實(shí)現(xiàn)：?

looper.hpp

#ifndef __M_LOOPER_H__
#define __M_LOOPER_H__

#include"buffer.hpp"
#include<thread>
#include<mutex>
#include<condition_variable>
#include<atomic>
#include<functional>
#include<memory>

namespace wz_logs
{
    using  Functor=std::function<void(Buffer &)>;
    enum class Looper_Type
  {
    ASYNC_SAFE,//安全狀態(tài)，緩沖區(qū)滿了則阻塞，避免資源耗盡的風(fēng)險(xiǎn)，用于實(shí)踐
    ASYNC_UNSAFE//非安全，不考慮資源耗盡問(wèn)題，無(wú)限擴(kuò)容，常用于測(cè)試
  };
    class AsyncLooper
    {
      public:
      using ptr=std::shared_ptr<AsyncLooper>;
      AsyncLooper(const Functor &cb,Looper_Type loop_type=Looper_Type::ASYNC_SAFE)
      :_stop(false)
      ,_thread(std::thread(&AsyncLooper::threadEntry,this))
      ,_callBack(cb)
      ,_looper_type(loop_type)
      {}

      ~AsyncLooper()
      {
        stop();
      }
      void stop()
      {
        _stop=true;//將退出標(biāo)志設(shè)置為true
        _cond_con.notify_all();//喚醒所有的工作線程
      }
      void push(const char* data,size_t len)
      {
        //1.無(wú)限擴(kuò)容是不安全的；2.固定大小生產(chǎn)緩沖區(qū)滿了就阻塞
        std::unique_lock<std::mutex> lock(_mutex);
        //2.條件變量控制，若緩沖區(qū)剩余空間大小大于數(shù)據(jù)長(zhǎng)度，則可以添加數(shù)據(jù)
        if(_looper_type==Looper_Type::ASYNC_SAFE)
        _cond_pro.wait(lock,[&](){return _pro_buf.writeAblesize()>=len; });
        //3.能夠走下來(lái)說(shuō)明條件滿足，可以向緩沖區(qū)添加數(shù)據(jù)
        _pro_buf.push(data,len);
        //4.喚醒消費(fèi)者對(duì)緩沖區(qū)進(jìn)行數(shù)據(jù)處理
        _cond_con.notify_one();
      }
      private:
      //線程入口函數(shù)
      //對(duì)消費(fèi)緩沖區(qū)中的數(shù)據(jù)進(jìn)行處理，處理完成后，初始化緩沖區(qū)，交換緩沖區(qū)
      void threadEntry()
      {
        while(1)
        {
           {
             //1.判斷生產(chǎn)緩沖區(qū)有沒(méi)有數(shù)據(jù)，有則交換，無(wú)則阻塞
             //為互斥鎖設(shè)置一個(gè)生命周期，當(dāng)緩沖區(qū)交換完畢后就解鎖
             std::unique_lock<std::mutex> lock(_mutex);
             if(_stop&&_pro_buf.empty()) break;
             //若當(dāng)前是退出前被喚醒，或者所有數(shù)據(jù)被喚醒，則返回真，繼續(xù)向下運(yùn)行，否則重新進(jìn)入休眠
             _cond_con.wait(lock,[&](){return _stop||!_pro_buf.empty();});//這里是為了需要等退出標(biāo)志置為true且生產(chǎn)緩沖區(qū)數(shù)據(jù)已經(jīng)全被處理完了，才進(jìn)行阻塞
             _con_buf.swap(_pro_buf);
             //2.交換完了，就喚醒生產(chǎn)者
              if(_looper_type==Looper_Type::ASYNC_SAFE)
             _cond_pro.notify_all();
           }
        //3.被喚醒后，對(duì)消費(fèi)緩沖區(qū)進(jìn)行數(shù)據(jù)處理
        _callBack(_con_buf);
        //4.初始化消費(fèi)緩沖區(qū)
        _con_buf.reset();
      }
         
      }
      Functor _callBack;//具體對(duì)緩沖區(qū)數(shù)據(jù)進(jìn)行處理的回調(diào)函數(shù)，由異步工作器使用者傳入
      private:
      Looper_Type _looper_type;
      std::atomic<bool> _stop;//工作器停止標(biāo)志
      Buffer _pro_buf;//生產(chǎn)者緩沖區(qū)
      Buffer _con_buf;//消費(fèi)者緩沖區(qū)
      std::mutex _mutex;
      std::condition_variable _cond_pro;
      std::condition_variable _cond_con;
      std::thread _thread;//異步工作器對(duì)應(yīng)的工作線程
    };
}

#endif

測(cè)試代碼：test.cpp

//?。。。?！這個(gè)有問(wèn)題，有待測(cè)試?。。。。?/
//總會(huì)有如下報(bào)錯(cuò)，應(yīng)該是線程異常退出的問(wèn)題//
//terminate called without an active exception Aborted//
//logger.cpp建造者模式下異步日志器測(cè)試
#include"logger.hpp"
int main()
{
     std::unique_ptr<wz_logs::LoggerBuilder> builder(new wz_logs::LocalLoggerBuilder());
     builder->buildLoggerName("async_logger");
     builder->buildLoggerLevel(wz_logs::LogLevel::value::WARN);
     builder->buildFormatter("[%c]%m%n");
     builder->buildLoggerType(wz_logs::LoggerType::LOGGER_ASYNC);
     //builder->buildEnableUnSafeAsync();
     builder->buildSink<wz_logs::FileSink>("./logfile/async.log");
     builder->buildSink<wz_logs::StdoutSink>();
     wz_logs::Logger::ptr logger=builder->build();
     logger->debug(__FILE__,__LINE__,"%s","測(cè)試日志");
     logger->info(__FILE__,__LINE__,"%s","測(cè)試日志");
     logger->warn(__FILE__,__LINE__,"%s","測(cè)試日志");
     logger->error(__FILE__,__LINE__,"%s","測(cè)試日志");
     logger->fatal(__FILE__,__LINE__,"%s","測(cè)試日志");
     size_t cursize=0,count=0;
     while(cursize<1024*1024*10)
     {
        logger->fatal(__FILE__,__LINE__,"測(cè)試日志-%d",count++);
        cursize+=20;
     }
    return 0;
}

測(cè)試等將異步日志器寫完，即完整的日志器模塊基本實(shí)現(xiàn)再來(lái)測(cè)試功能。

日志器模塊完善--異步日志器的實(shí)現(xiàn) ：

logger.hpp

    class AsyncLogger:public Logger{
    public:
     AsyncLogger( const std::string &logger_name,
    Formatter::ptr &formatter,
    std::vector<LogSink::ptr> &sinks,
    LogLevel::value &level,
    Looper_Type looper_type):
    Logger(logger_name,
          formatter,
          sinks,
          level) ,
   _looper(std::make_shared<AsyncLooper>(std::bind(&AsyncLogger::realLog,this,std::placeholders::_1),looper_type)){}
    //將數(shù)據(jù)寫入緩沖區(qū)
     void log(const char* data,size_t len)
     {
      _looper->push(data,len);
     }
     //設(shè)計(jì)一個(gè)實(shí)際落地函數(shù)（將緩沖區(qū)中的數(shù)據(jù)落地）
     void realLog(Buffer &buf)
     {
      if(_sinks.empty()) return;
      for(auto &sink:_sinks)
      {
         sink->sink(buf.begin(),buf.readAblesize());
      }
     }

     private:
     AsyncLooper::ptr _looper;//要管理一個(gè)異步工作器
    };

此時(shí)，同步日志器和異步日志器我們就基本都實(shí)現(xiàn)了，接下來(lái)我們用之前測(cè)試同步日志器的代碼來(lái)對(duì)異步日志器的功能進(jìn)行測(cè)試。

?測(cè)試代碼：test.cpp

//?。。。?！這個(gè)有問(wèn)題，有待測(cè)試?。。。。?/
//總會(huì)有如下報(bào)錯(cuò)，應(yīng)該是線程異常退出的問(wèn)題//
//terminate called without an active exception Aborted//
//logger.cpp建造者模式下異步日志器測(cè)試
#include"logger.hpp"
int main()
{
     std::unique_ptr<wz_logs::LoggerBuilder> builder(new wz_logs::LocalLoggerBuilder());
     builder->buildLoggerName("async_logger");
     builder->buildLoggerLevel(wz_logs::LogLevel::value::WARN);
     builder->buildFormatter("[%c]%m%n");
     builder->buildLoggerType(wz_logs::LoggerType::LOGGER_ASYNC);
     //builder->buildEnableUnSafeAsync();
     builder->buildSink<wz_logs::FileSink>("./logfile/async.log");
     builder->buildSink<wz_logs::StdoutSink>();
     wz_logs::Logger::ptr logger=builder->build();
     logger->debug(__FILE__,__LINE__,"%s","測(cè)試日志");
     logger->info(__FILE__,__LINE__,"%s","測(cè)試日志");
     logger->warn(__FILE__,__LINE__,"%s","測(cè)試日志");
     logger->error(__FILE__,__LINE__,"%s","測(cè)試日志");
     logger->fatal(__FILE__,__LINE__,"%s","測(cè)試日志");
     size_t cursize=0,count=0;
     while(cursize<1024*1024*10)
     {
        logger->fatal(__FILE__,__LINE__,"測(cè)試日志-%d",count++);
        cursize+=20;
     }
    return 0;
}

測(cè)試結(jié)果：

?可見，我們內(nèi)部的實(shí)現(xiàn)有一些問(wèn)題，測(cè)試結(jié)果如下,具體原因尚未排查出來(lái)：

建造者模式進(jìn)一步實(shí)現(xiàn) ：

logger.hpp

//注釋處多為完善增加的內(nèi)容
enum LoggerType{
LOGGER_SYNC,
LOGGER_ASYNC
};
class LoggerBuilder
{
  public:
  LoggerBuilder():_logger_type(LoggerType::LOGGER_SYNC),
  _limit_level(wz_logs::LogLevel::value::DEBUG) {}
  void buildLoggerType(LoggerType type){_logger_type=type;}
  void buildLoggerName(const std::string &name){_logger_name=name;}
  void buildLoggerLevel(wz_logs::LogLevel::value level){_limit_level=level;}
  //新增接口--設(shè)置異步日志器的工作模式，一般極限測(cè)試性能時(shí)，調(diào)用此接口即可設(shè)置日志器工作模式
  void buildEnableUnSafeAsync()
  {
   _looper_type=Looper_Type::ASYNC_UNSAFE;
  }
  void buildFormatter(const std::string &pattern)
  {
   _formatter=std::make_shared<wz_logs::Formatter>(pattern);
  }
  template <typename SinkType,typename...Args>
  void buildSink(Args &&...args)
  {
   wz_logs::LogSink::ptr psink=SinkFactory::creat<SinkType>(std::forward<Args>(args)...);
   _sinks.push_back(psink);
  }
  virtual Logger::ptr build()=0;

  protected:
  //新增成員變量--異步工作器工作模式
   LoggerType _logger_type;//針對(duì)異步日志器提供的
   std::string _logger_name;
   wz_logs::Formatter::ptr _formatter;
   wz_logs::LogLevel::value _limit_level;
   std::vector<wz_logs::LogSink::ptr> _sinks;
   Looper_Type _looper_type;
};
class LocalLoggerBuilder:public LoggerBuilder{
   public:
   Logger::ptr build() override
   {
      assert(!_logger_name.empty());//日志器名稱是使用日志器的唯一標(biāo)識(shí)，即必須有
      if(_formatter.get()==nullptr)
      {
         _formatter=std::make_shared<Formatter>();
      }
      if(_sinks.empty())
      {
         buildSink<StdoutSink>();
      }
      //完善構(gòu)建異步日志器智能指針對(duì)象
      if(_logger_type==LoggerType::LOGGER_ASYNC)
      {
         //記得異步日志器還多一個(gè)參數(shù)【用來(lái)設(shè)置異步日志器的工作模式】
          return std::make_shared<AsyncLogger>(_logger_name,_formatter,_sinks,_limit_level,_looper_type);
      }
      return std::make_shared<SyncLogger>(_logger_name,_formatter,_sinks,_limit_level);
   }
};

日志器管理器模塊

概念：

作用：對(duì)所有創(chuàng)建的日志器統(tǒng)一進(jìn)行管理。

特性：以單例模式來(lái)實(shí)現(xiàn)日志器管理器，這樣我們就可以在程序的任意位置，獲取相同的單例對(duì)象，獲取其中的日志器進(jìn)行日志輸出。

擴(kuò)展：?jiǎn)卫芾砥鲃?chuàng)建時(shí)，默認(rèn)先創(chuàng)建一個(gè)日志器（用于進(jìn)行標(biāo)準(zhǔn)輸出打印，方便用戶使用）

綜上，我們要實(shí)現(xiàn)的單例模式管理器應(yīng)包含以下內(nèi)容：

管理的成員：

1.默認(rèn)日志器

2.管理的日志器數(shù)據(jù)結(jié)構(gòu)

3.互斥鎖

提供的接口：

1.添加日志器管理

2.判斷是否管理了指定名稱的日志器

3.獲取指定名稱的日志器

4。獲取默認(rèn)日志器

實(shí)現(xiàn)：

logger.hpp

//設(shè)置一個(gè)單例模式的日志器管理類
class LoggerManager{
   public:
   static LoggerManager& getInstance()
   {
      //C++11后的新特性，針對(duì)靜態(tài)局部變量，編譯器實(shí)現(xiàn)了線程安全
      //也就是說(shuō)，在靜態(tài)局部變量沒(méi)有構(gòu)造完成之前，其他線程就會(huì)進(jìn)入阻塞
      static LoggerManager eton;
      return eton;
   }
   void addLogger(Logger::ptr &logger)
   {
      if(hasLogger(logger->name())) return;
      std::unique_lock<std::mutex> lock(_mutex);
      _loggers.insert(std::make_pair(logger->name(),logger));
   }
   bool hasLogger(const std::string &name)
   {
      std::unique_lock<std::mutex> lock(_mutex);
      auto it=_loggers.find(name);
      if(it==_loggers.end()) return false;
      return true;
   }
   Logger::ptr getLogger(const std::string &name)
   {
      std::unique_lock<std::mutex> lock(_mutex);
      auto it=_loggers.find(name);
      if(it==_loggers.end())
      {
         return Logger::ptr();
      }
      return it->second;
   }
   Logger::ptr rootLogger()
   {
      return _root_logger; 
   }
   private:
   LoggerManager() {
      //構(gòu)造默認(rèn)日志器
      std::unique_ptr<wz_logs::LoggerBuilder> builder(new wz_logs::LocalLoggerBuilder());
       builder->buildLoggerName("root");
       _root_logger=builder->build();
       _loggers.insert(std::make_pair("root",_root_logger));
   }
   private:
   std::mutex _mutex;
   Logger::ptr _root_logger;
   std::unordered_map<std::string,Logger::ptr> _loggers;
};

? ? ? ?實(shí)現(xiàn)之后，結(jié)合實(shí)際情況思考，我們發(fā)現(xiàn)，當(dāng)我們用戶在創(chuàng)建了一個(gè)日志器后想要進(jìn)行全局的管理時(shí)，就要把這個(gè)日志器添加到我們的單例對(duì)象中，然而我們發(fā)現(xiàn)，用戶自己添加的過(guò)程是比較麻煩的，需要?jiǎng)佑肔oggerManager：：getInstence().addLooger()才能完成添加，無(wú)疑增加了用戶的使用復(fù)雜度，這個(gè)時(shí)候我們就要繼續(xù)完善我們的建造者類，我們之前實(shí)現(xiàn)的LocalLoggerBuilder可以看做是本地建造者，哪里創(chuàng)建哪里使用，接下來(lái)我們就要再實(shí)現(xiàn)一個(gè)全局建造者，GlobalLoggerBuilder,這個(gè)類同樣繼承于LoggerBuilder,但其中在創(chuàng)建好日志器后，直接將日志器添加到管理器中，因此，以后用戶想要?jiǎng)?chuàng)建一個(gè)全局的日志器就只需要使用GlobalLoggerBuilder進(jìn)行構(gòu)建即可，構(gòu)建好的日志器天然就在管理器中。

全局建造者：GlobalLoggerBuilder的實(shí)現(xiàn)：

logger.hpp

class GlobalLoggerBuilder:public LoggerBuilder{
   public:
   Logger::ptr build() override
   {
      assert(!_logger_name.empty());//日志器名稱是使用日志器的唯一標(biāo)識(shí)，即必須有
      if(_formatter.get()==nullptr)
      {
         _formatter=std::make_shared<Formatter>();
      }
      if(_sinks.empty())
      {
         buildSink<StdoutSink>();
      }
      Logger::ptr logger;
      if(_logger_type==LoggerType::LOGGER_ASYNC)
      {
          logger=std::make_shared<AsyncLogger>(_logger_name,_formatter,_sinks,_limit_level,_looper_type);
      }
      else{
         logger=std::make_shared<SyncLogger>(_logger_name,_formatter,_sinks,_limit_level);
      }
      //構(gòu)建好的日志器直接在內(nèi)部添加到單例對(duì)象中
      LoggerManager::getInstance().addLogger(logger);
      return logger;
   }
};

接下來(lái)我們就可以對(duì)管理器模塊以及全局建造者模塊來(lái)進(jìn)行統(tǒng)一的測(cè)試：

測(cè)試代碼：test.cpp

//日志器管理類及全局建造者類測(cè)試
#include"logger.hpp"

void test_log()
{
    wz_logs::Logger::ptr logger=wz_logs::LoggerManager::getInstance().getLogger("sync_logger");
     logger->debug(__FILE__,__LINE__,"%s","測(cè)試日志");
     logger->info(__FILE__,__LINE__,"%s","測(cè)試日志");
     logger->warn(__FILE__,__LINE__,"%s","測(cè)試日志");
     logger->error(__FILE__,__LINE__,"%s","測(cè)試日志");
     logger->fatal(__FILE__,__LINE__,"%s","測(cè)試日志");
     size_t cursize=0,count=0;
     while(cursize<1024*1024*10)
     {
        logger->fatal(__FILE__,__LINE__,"測(cè)試日志-%d",count++);
        cursize+=20;
     }
}
int main()
{
//創(chuàng)建管理全局建造者對(duì)象的智能指針
     std::unique_ptr<wz_logs::LoggerBuilder> builder(new wz_logs::GlobalLoggerBuilder());
     builder->buildLoggerName("sync_logger");
     builder->buildLoggerLevel(wz_logs::LogLevel::value::WARN);
     builder->buildFormatter("%m%n");
     builder->buildLoggerType(wz_logs::LoggerType::LOGGER_SYNC);
     builder->buildSink<wz_logs::FileSink>("./logfile/test.log");
     builder->buildSink<wz_logs::StdoutSink>();
     builder->build();
    test_log();
    return 0;
}

全局建造者創(chuàng)建的同步日志器落地方向?yàn)闃?biāo)準(zhǔn)輸出及指定文件，測(cè)試結(jié)果如下：

目錄文件生成正常，輸出等級(jí)判斷正常：

7.全局接口的設(shè)計(jì)

概念：

? ? ? ?上面在test.cpp中測(cè)試各個(gè)模塊的功能時(shí)，大多都是從我們?cè)O(shè)計(jì)者的角度去測(cè)試的，對(duì)于用戶來(lái)講顯然是不合理的，比如開始用全局建造者構(gòu)建單例對(duì)象管理的日志器，用戶怎么知道你有單例模式，還有在調(diào)用不同等級(jí)的日志輸出方法時(shí)，又怎么知道要傳__LINE__和__FILE__兩個(gè)宏，還有用戶在使用時(shí)，一般只需要有一個(gè)封裝好的頭文件即可，手動(dòng)去包含一大堆頭文件也是不合理的，因此為了對(duì)日志系統(tǒng)接口的使用便捷性進(jìn)行優(yōu)化，我們需要提供全局接口&宏函數(shù)。

思想：

1.提供獲取指定日志器的全局接口（避免用戶自己操作單例對(duì)象）

2.使用宏函數(shù)對(duì)日志器的接口進(jìn)行代理（代理模式）

3.提供宏函數(shù)，直接通過(guò)默認(rèn)日志器進(jìn)行標(biāo)準(zhǔn)輸出打印，不用獲取日志器了

實(shí)現(xiàn)：?

wz_log.hpp

#ifndef __M_WZLOG_H__
#define __M_WZLOG_H__
#include"logger.hpp"

namespace wz_logs{

// 1.提供獲取指定日志器的全局接口（避免用戶自己操作單例對(duì)象）
Logger::ptr getLogger(const std::string &name)
{
    return wz_logs::LoggerManager::getInstance().getLogger(name);
}
Logger::ptr rootLogger()
{
    return wz_logs::LoggerManager::getInstance().rootLogger();
}
// 2.使用宏函數(shù)對(duì)日志器的接口進(jìn)行代理（代理模式）
#define debug(fmt,...) debug(__FILE__,__LINE__,fmt,##__VA_ARGS__)
#define info(fmt,...) info(__FILE__,__LINE__,fmt,##__VA_ARGS__)
#define warn(fmt,...) warn(__FILE__,__LINE__,fmt,##__VA_ARGS__)
#define error(fmt,...) error(__FILE__,__LINE__,fmt,##__VA_ARGS__)
#define fatal(fmt,...) fatal(__FILE__,__LINE__,fmt,##__VA_ARGS__)
// 3.提供宏函數(shù)，直接通過(guò)默認(rèn)日志器進(jìn)行標(biāo)準(zhǔn)輸出打印，不用獲取日志器了
#define DEBUG(fmt,...) wz_logs::rootLogger()->debug(fmt,##__VA_ARGS__)
#define INFO(fmt,...) wz_logs::rootLogger()->info(fmt,##__VA_ARGS__)
#define WARN(fmt,...) wz_logs::rootLogger()->warn(fmt,##__VA_ARGS__)
#define ERROR(fmt,...) wz_logs::rootLogger()->error(fmt,##__VA_ARGS__)
#define FATAL(fmt,...) wz_logs::rootLogger()->fatal(fmt,##__VA_ARGS__)


}
#endif

測(cè)試代碼：test.cpp

//全局接口測(cè)試
//提供封裝全局接口的頭文件之后，測(cè)試就可以只包含這個(gè)頭文件，符合用戶使用習(xí)慣
#include"wz_log.hpp"
 void test_log()
{
    //1.調(diào)用封裝好的接口來(lái)獲取日志器
    //wz_logs::Logger::ptr logger =wz_logs::getLogger("sync_logger");
    wz_logs::Logger::ptr logger=wz_logs::LoggerManager::getInstance().getLogger("sync_logger");
     
     logger->debug("%s","測(cè)試日志");
     logger->info("%s","測(cè)試日志");
     logger->warn("%s","測(cè)試日志");
     logger->error("%s","測(cè)試日志");
     logger->fatal("%s","測(cè)試日志");
     size_t count=0;
     while(count<500000)
     {
        logger->fatal("測(cè)試日志-%d",count++);
     }
    
    //2.不用獲取日志器，直接用封裝好了默認(rèn)日志器的操作
    //  DEBUG("%s","測(cè)試日志");
    //  INFO("%s","測(cè)試日志");
    //  WARN("%s","測(cè)試日志");
    //  ERROR("%s","測(cè)試日志");
    //  FATAL("%s","測(cè)試日志");
    //  size_t count=0;
    //  while(count<500000)
    //  {
    //     FATAL("測(cè)試日志-%d",count++);
    //  }
}
int main()
{
     std::unique_ptr<wz_logs::LoggerBuilder> builder(new wz_logs::GlobalLoggerBuilder());//創(chuàng)建管理全局建造者對(duì)象的智能指針
     builder->buildLoggerName("sync_logger");
     builder->buildLoggerLevel(wz_logs::LogLevel::value::WARN);
     builder->buildFormatter("[%c][%f:%l]%m%n");
     builder->buildLoggerType(wz_logs::LoggerType::LOGGER_SYNC);
     builder->buildSink<wz_logs::FileSink>("./logfile/test.log");
     builder->buildSink<wz_logs::StdoutSink>();
     builder->build();
     test_log();
    return 0;
}

六、項(xiàng)目目錄結(jié)構(gòu)梳理

? ? ? ?考慮到我們項(xiàng)目的用戶層面實(shí)用性，我們要對(duì)整個(gè)項(xiàng)目的目錄結(jié)構(gòu)進(jìn)行梳理，最終用戶只需要拿到一個(gè)logs文件（里面包含實(shí)現(xiàn)各個(gè)模塊的頭文件），使用時(shí)只包含其中的一個(gè)提供全局接口的頭文件wz_log.hpp即可使用；同時(shí)還要有一個(gè)存放測(cè)試用例example文件（里面存放一些重要的測(cè)試用例，主要用于讓用戶快速熟悉這套系統(tǒng)的用法），另外還要有一個(gè)包含細(xì)碎知識(shí)點(diǎn)測(cè)試的practice文件（本項(xiàng)目中存放的是一些前置知識(shí)的測(cè)試代碼），最后再創(chuàng)建一個(gè)extend文件用來(lái)保存擴(kuò)展部分的代碼（本項(xiàng)目中擴(kuò)展的是落地方向，落地到以時(shí)間為劃分標(biāo)準(zhǔn)的滾動(dòng)文件）整理好的目錄結(jié)構(gòu)如下：

1.測(cè)試用例模塊功能檢測(cè)：

代碼：./example/test.cpp

//全局接口測(cè)試
#include"../logs/wz_log.hpp"
#include<unistd.h>
 void test_log(const std::string &name)
{
     INFO("%s","測(cè)試開始");
     wz_logs::Logger::ptr logger =wz_logs::getLogger("sync_logger");
     logger->debug("%s","測(cè)試日志");
     logger->info("%s","測(cè)試日志");
     logger->warn("%s","測(cè)試日志");
     logger->error("%s","測(cè)試日志");
     logger->fatal("%s","測(cè)試日志");
     INFO("%s","測(cè)試結(jié)束");
    
}
int main()
{
     std::unique_ptr<wz_logs::LoggerBuilder> builder(new wz_logs::GlobalLoggerBuilder());//創(chuàng)建管理全局建造者對(duì)象的智能指針
     builder->buildLoggerName("sync_logger");
     builder->buildLoggerLevel(wz_logs::LogLevel::value::DEBUG);
     builder->buildFormatter("[%c][%f:%l]%m%n");
     builder->buildLoggerType(wz_logs::LoggerType::LOGGER_SYNC);
     builder->buildSink<wz_logs::FileSink>("./logfile/test.log");
     builder->buildSink<wz_logs::StdoutSink>();
     builder->buildSink<wz_logs::RollBySizeSink>("./logfile/rool-sync-by-size",1024*1024);
     builder->build();
     test_log("sync_logger");
    return 0;
}

測(cè)試結(jié)果：

2.拓展模塊功能檢測(cè)：

實(shí)現(xiàn)+測(cè)試?代碼：./extend/test.cpp

#include"../logs/wz_log.hpp"
#include<unistd.h>

//擴(kuò)展模塊測(cè)試：模擬用戶自定義落地派生類模塊
//定義一個(gè)枚舉類，用戶使用時(shí)只需要傳入想要的枚舉變量即可，方便用戶使用
enum class TIMEGAP
{
    GAP_SEC,
    GAP_MIN,
    GAP_HOUR,
    GAP_DAY
};
 //擴(kuò)展一個(gè)落地方向?yàn)橐詴r(shí)間為切換條件的滾動(dòng)文件的派生類
    class RollByTimeSink:public wz_logs::LogSink
    {
       public:
       RollByTimeSink(const std::string &basename,TIMEGAP gap_type)
       :_basename(basename),_cur_gap(0)
       {
        switch(gap_type)
        {
            case TIMEGAP::GAP_SEC: _gap_size=1; break;
            case TIMEGAP::GAP_MIN: _gap_size=60; break;
            case TIMEGAP::GAP_HOUR: _gap_size=3600; break;
            case TIMEGAP::GAP_DAY: _gap_size=3600*24; break;
        }
        _cur_gap=_gap_size==1?wz_logs::util::Time::GetTime():wz_logs::util::Time::GetTime()%_gap_size;
        //1.創(chuàng)建文件及文件所在的目錄
        std::string pathname=CreatNewFile(); 
        wz_logs::util::File::CreatDirectory(wz_logs::util::File::Path(pathname));
        //2.打開文件，以二進(jìn)制可追加的形式打開，符合文件寫入的條件
        _ofs.open(pathname,std::ios::binary|std::ios::app);
        //文件打開才能進(jìn)行后續(xù)寫入，因此加個(gè)斷言
        assert(_ofs.is_open());
       }
       //判斷當(dāng)前文件的_cur_gap是否是當(dāng)前時(shí)間段，若不是，則要切換文件
       void sink(const char *data,size_t len)
       {
        time_t cur=wz_logs::util::Time::GetTime();
        if((cur%_gap_size)!=_cur_gap)
        {
            _ofs.close();//關(guān)閉原來(lái)打開的文件
            std::string pathname=CreatNewFile();
            _ofs.open(pathname,std::ios::binary|std::ios::app);
            assert(_ofs.is_open());
        }
        _ofs.write(data,len);
        assert(_ofs.good());
       }
       private:
       //進(jìn)行大小判斷，超過(guò)指定大小，創(chuàng)建新文件
       std::string CreatNewFile()
       {
        //獲取系統(tǒng)時(shí)間，以時(shí)間來(lái)構(gòu)造文件拓展名
        time_t t=wz_logs::util::Time::GetTime();
        struct tm lt;
        localtime_r(&t,&lt);
        std::stringstream filename;
        filename<<_basename.c_str();
        filename<<lt.tm_year+1900;
        filename<<lt.tm_mon+1;
        filename<<lt.tm_mday;
        filename<<lt.tm_hour;
        filename<<lt.tm_min;
        filename<<lt.tm_sec;
        filename<<".log";
        return filename.str();

       }
       private:
       //文件基礎(chǔ)名，一個(gè)系列的滾動(dòng)文件擁有共同的基礎(chǔ)名+各自的擴(kuò)展名
       std::string _basename;
       std::ofstream _ofs;
       //用于記錄當(dāng)前的時(shí)間段
       size_t _cur_gap;
       //用于記錄規(guī)定文件切換的時(shí)間段長(zhǎng)度，讓用戶自定義傳入
       size_t _gap_size;
    
    };


//RollByTimeSink測(cè)試
int main()
{
    
     std::unique_ptr<wz_logs::LoggerBuilder> builder(new wz_logs::GlobalLoggerBuilder());//創(chuàng)建管理全局建造者對(duì)象的智能指針
     builder->buildLoggerName("sync_logger");
     builder->buildLoggerLevel(wz_logs::LogLevel::value::WARN);
     builder->buildFormatter("[%c][%f:%l]%m%n");
     builder->buildLoggerType(wz_logs::LoggerType::LOGGER_SYNC);
     builder->buildSink<RollByTimeSink>("./logfile/rool-sync-by-size",TIMEGAP::GAP_SEC);
     wz_logs::Logger::ptr logger=builder->build();
     time_t old=wz_logs::util::Time::GetTime();
     while(wz_logs::util::Time::GetTime()<old+5)
     {
        logger->fatal("這是一條測(cè)試日志");
        usleep(1000);
     }
     return 0;
}

測(cè)試結(jié)果：

七、項(xiàng)目性能測(cè)試工具的設(shè)計(jì)?

? ? ? ?在我們完成一個(gè)項(xiàng)目之后，還有一步重要的步驟是不能忽略的，那就是進(jìn)行性能測(cè)試，項(xiàng)目作者需要設(shè)計(jì)出項(xiàng)目的性能測(cè)試工具，同時(shí)還要說(shuō)明當(dāng)前測(cè)試環(huán)境下的測(cè)試結(jié)果，也就是整個(gè)測(cè)試模塊需要包含測(cè)試三要素：測(cè)試環(huán)境、測(cè)試方法、測(cè)試結(jié)果，接下來(lái)我會(huì)基于我本人的環(huán)境依次對(duì)本項(xiàng)目進(jìn)行測(cè)試方法的提供以及測(cè)試結(jié)果的分析。

1.測(cè)試環(huán)境說(shuō)明

CPU：Intel(R) Xeon(R) Platinum 8269CY CPU @ 2.50GHz

RAM：2GB

ROM：50GB

OS：CentOS7.6

2.測(cè)試方法編寫

? ? ? ?我們要測(cè)試的內(nèi)容是分別在同步日志器和異步日志器下，單線程寫日志的性能和多線程寫日志的性能，即我們的測(cè)試工具要求可以控制寫日志的數(shù)量以及寫日志所用線程的總數(shù)量，實(shí)現(xiàn)思想如下：

1.封裝一個(gè)接口，傳入日志器名稱，日志數(shù)量、線程數(shù)量、單條日志消息的大小

在接口內(nèi)：

創(chuàng)建一個(gè)（批）線程，分別負(fù)責(zé)一部分日志的輸出；

在輸出之前開始計(jì)時(shí)，輸出完畢結(jié)束計(jì)時(shí)，所耗時(shí)間=結(jié)束時(shí)間-起始時(shí)間；

每秒日志輸出量=日志數(shù)量/所耗時(shí)間；

每秒輸出大小=日志數(shù)量*單條日志大小/所耗時(shí)間；

需要注意：在測(cè)試異步輸入時(shí)，我們啟動(dòng)非安全模式，純內(nèi)存寫入（不考慮實(shí)際落地時(shí)間）。

測(cè)試工具的實(shí)現(xiàn)：bench.cc

#include"../logs/wz_log.hpp"
#include<vector>
#include<chrono>
#include<thread>
void bench(const std::string &loggername,size_t thr_num,size_t msg_num,size_t msg_len)
{
   //獲取日志器
   wz_logs::Logger::ptr logger=wz_logs::getLogger(loggername);
   if(logger.get()==nullptr)
   {
    return;
   }
   std::cout<<"測(cè)試日志："<<msg_num<<"條，總大?。?<<(msg_num*msg_len)/1024<<"KB\n";
   //2.組織指定長(zhǎng)度的日志消息
   std::string msg(msg_len-1,'w');//-1是想要在每條日志消息最后填一個(gè)換行
   //3.創(chuàng)建指定數(shù)量的線程
   std::vector<std::thread> threads;
   std::vector<double> cost_arry(thr_num);//用來(lái)記錄每條線程處理日志消息的所用時(shí)間
   size_t msg_per_thr=msg_num/thr_num;//每個(gè)線程需要輸出的日志數(shù)量=日志總量/線程總量,這里不準(zhǔn)確，存在不能整除，這里只為觀察現(xiàn)象，因此不作為重點(diǎn)處理，
   for(int i=0;i<thr_num;i++)
   {
    //emplace_back是vector提供的操作，功能是在vector已有的空間基礎(chǔ)上直接構(gòu)造并尾插
    threads.emplace_back([&,i](){
     //線程函數(shù)內(nèi)部開始計(jì)時(shí)
     auto start =std::chrono::high_resolution_clock::now();
     //開始循環(huán)寫日志
    for(int j=0;j<msg_per_thr;j++){
        logger->fatal("%s",msg.c_str());
    }
    //線程內(nèi)部結(jié)束計(jì)時(shí)
    auto end=std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> cost=end-start;
    cost_arry[i]=cost.count();
    std::cout<<"線程"<<i<<":"<<"\t輸出數(shù)量"<<msg_per_thr<<"耗時(shí):"<<cost.count()<<"s\n";
    });
   }
   for(int i=0;i<thr_num;i++)
   {
    threads[i].join();
   }
   //4.計(jì)算總耗時(shí)：在多線程中，每個(gè)線程都會(huì)耗費(fèi)時(shí)間，但是線程是并發(fā)處理的，因此耗時(shí)最高的那個(gè)就是總時(shí)間
   double max_cost=cost_arry[0];
   for(int i=0;i<thr_num;i++)
   {
    max_cost=max_cost<cost_arry[i]?cost_arry[i]:max_cost;
   }
   size_t msg_per_sec=msg_num/max_cost;//每秒處理的日志消息數(shù)量
    size_t size_per_sec=(msg_num*msg_len)/(max_cost*1024);//每秒處理的日志總大小
   //打印測(cè)試結(jié)果
   std::cout<<"每秒輸出日志數(shù)量："<<msg_per_sec<<"條\n";
   std::cout<<"每秒輸出日志大?。?<<size_per_sec<<"KB\n";
}

測(cè)試代碼：

void sync_bench()
{
     std::unique_ptr<wz_logs::LoggerBuilder> builder(new wz_logs::GlobalLoggerBuilder());//創(chuàng)建管理全局建造者對(duì)象的智能指針
     builder->buildLoggerName("sync_logger");
     builder->buildLoggerLevel(wz_logs::LogLevel::value::DEBUG);
     builder->buildFormatter("%m%n");
     builder->buildLoggerType(wz_logs::LoggerType::LOGGER_SYNC);
     builder->buildSink<wz_logs::FileSink>("./logfile/test.log");
     builder->build();
     bench("sync_logger",1,1000000,100);
     //bench("sync_logger",3,1000000,100);
}
void async_bench()
{
     std::unique_ptr<wz_logs::LoggerBuilder> builder(new wz_logs::GlobalLoggerBuilder());//創(chuàng)建管理全局建造者對(duì)象的智能指針
     builder->buildLoggerName("sync_logger");
     builder->buildLoggerLevel(wz_logs::LogLevel::value::DEBUG);
     builder->buildFormatter("%m%n");
     builder->buildLoggerType(wz_logs::LoggerType::LOGGER_ASYNC);
     builder->buildSink<wz_logs::FileSink>("./logfile/test.log");
     builder->build();
    bench("async_logger",1,1000000,100);
     //bench("async_logger",3,1000000,100);
}

int main()
{
    sync_bench();
    //async_bench();
    return 0;
}

測(cè)試結(jié)果：

同步日志器下單線程測(cè)試結(jié)果：bench("sync_logger",1,1000000,100);

同步日志器下多線程測(cè)試結(jié)果：bench("sync_logger",3,1000000,100);

異步日志器下單線程測(cè)試結(jié)果：bench("async_logger",1,1000000,100);

異步日志器的實(shí)現(xiàn)有些問(wèn)題，還在排查中，后續(xù)會(huì)更新。。。

異步日志器下多線程測(cè)試結(jié)果：bench("async_logger",3,1000000,100);

異步日志器的實(shí)現(xiàn)有些問(wèn)題，還在排查中，后續(xù)會(huì)更新。。。

? ? 到此，一個(gè)支持多落地方向，且支持同步日志器和異步日志器的日志系統(tǒng)就完成了，異步日志器還存在一些問(wèn)題?，后續(xù)會(huì)排查并更正。文章來(lái)源地址http://www.zghlxwxcb.cn/news/detail-702659.html

到了這里，關(guān)于【實(shí)例項(xiàng)目：基于多設(shè)計(jì)模式下的日志系統(tǒng)（同步&異步）】的文章就介紹完了。如果您還想了解更多內(nèi)容，請(qǐng)?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！