1、c++异步日志

0、思维导图

日志 - 图1

1、头文件

  1. /** 
  2.  * @desc:   异步日志类，AsyncLog.h
  3.  * @author: zhangyl
  4.  * @date:   2019.04.13
  5.  */
  7. #ifndef __ASYNC_LOG_H__
  8. #define __ASYNC_LOG_H__
  10. #include <stdio.h>
  11. #include <string>
  12. #include <list>
  13. #include <thread>
  14. #include <memory>
  15. #include <mutex>
  16. #include <condition_variable>
  18. //#ifdef LOG_EXPORTS
  19. //#define LOG_API __declspec(dllexport)
  20. //#else
  21. //#define LOG_API __declspec(dllimport)
  22. //#endif
  24. #define LOG_API
  26. enum LOG_LEVEL
  27. {
  28.     LOG_LEVEL_TRACE,
  29.     LOG_LEVEL_DEBUG,
  30.     LOG_LEVEL_INFO,
  31.     LOG_LEVEL_WARNING,
  32.     LOG_LEVEL_ERROR,    //用于业务错误
  33.     LOG_LEVEL_SYSERROR, //用于技术框架本身的错误
  34.     LOG_LEVEL_FATAL,    //FATAL 级别的日志会让在程序输出日志后退出
  35.     LOG_LEVEL_CRITICAL  //CRITICAL 日志不受日志级别控制，总是输出
  36. };
  38. //TODO: 多增加几个策略
  39. //注意：如果打印的日志信息中有中文，则格式化字符串要用_T()宏包裹起来，
  40. //e.g. LOGI(_T("GroupID=%u, GroupName=%s, GroupName=%s."), lpGroupInfo->m_nGroupCode, lpGroupInfo->m_strAccount.c_str(), lpGroupInfo->m_strName.c_str());
  41. #define LOGT(...)    CAsyncLog::output(LOG_LEVEL_TRACE, __FILE__, __LINE__, __VA_ARGS__)
  42. #define LOGD(...)    CAsyncLog::output(LOG_LEVEL_DEBUG, __FILE__, __LINE__, __VA_ARGS__)
  43. #define LOGI(...)    CAsyncLog::output(LOG_LEVEL_INFO, __FILE__, __LINE__, __VA_ARGS__)
  44. #define LOGW(...)    CAsyncLog::output(LOG_LEVEL_WARNING, __FILE__, __LINE__,__VA_ARGS__)
  45. #define LOGE(...)    CAsyncLog::output(LOG_LEVEL_ERROR, __FILE__, __LINE__, __VA_ARGS__)
  46. #define LOGSYSE(...) CAsyncLog::output(LOG_LEVEL_SYSERROR, __FILE__, __LINE__, __VA_ARGS__)
  47. #define LOGF(...)    CAsyncLog::output(LOG_LEVEL_FATAL, __FILE__, __LINE__, __VA_ARGS__)        //为了让FATAL级别的日志能立即crash程序，采取同步写日志的方法
  48. #define LOGC(...)    CAsyncLog::output(LOG_LEVEL_CRITICAL, __FILE__, __LINE__, __VA_ARGS__)     //关键信息，无视日志级别，总是输出
  50. //用于输出数据包的二进制格式
  51. #define LOG_DEBUG_BIN(buf, buflength) CAsyncLog::outputBinary(buf, buflength)
  53. class LOG_API CAsyncLog
  54. {
  55. public:
  56.     static bool init(const char* pszLogFileName = nullptr, bool bTruncateLongLine = false, int64_t nRollSize = 10 * 1024 * 1024);
  57.     static void uninit();
  59.     static void setLevel(LOG_LEVEL nLevel);
  60.     static bool isRunning();
  62.     //不输出线程ID号和所在函数签名、行号
  63.     static bool output(long nLevel, const char* pszFmt, ...);
  64.     //输出线程ID号和所在函数签名、行号    
  65.     static bool output(long nLevel, const char* pszFileName, int nLineNo, const char* pszFmt, ...);
  67.     static bool outputBinary(unsigned char* buffer, size_t size);
  69. private:
  70.     CAsyncLog() = delete;
  71.     ~CAsyncLog() = delete;
  73.     CAsyncLog(const CAsyncLog& rhs) = delete;
  74.     CAsyncLog& operator=(const CAsyncLog& rhs) = delete;
  76.     static void makeLinePrefix(long nLevel, std::string& strPrefix);
  77.     static void getTime(char* pszTime, int nTimeStrLength);
  78.     static bool createNewFile(const char* pszLogFileName);
  79.     static bool writeToFile(const std::string& data);
  80.     //让程序主动崩溃
  81.     static void crash();
  83.     static const char* ullto4Str(int n);
  84.     static char* formLog(int& index, char* szbuf, size_t size_buf, unsigned char* buffer, size_t size);
  86.     static void writeThreadProc();
  88. private:
  89.     static bool                                m_bToFile;                //日志写入文件还是写到控制台  
  90.     static FILE*                            m_hLogFile;
  91.     static std::string                      m_strFileName;          //日志文件名
  92.     static std::string                      m_strFileNamePID;       //文件名中的进程id
  93.     static bool                             m_bTruncateLongLog;     //长日志是否截断
  94.     static LOG_LEVEL                        m_nCurrentLevel;        //当前日志级别
  95.     static int64_t                          m_nFileRollSize;        //单个日志文件的最大字节数
  96.     static int64_t                          m_nCurrentWrittenSize;  //已经写入的字节数目
  97.     static std::list<std::string>           m_listLinesToWrite;     //待写入的日志
  98.     static std::unique_ptr<std::thread>     m_spWriteThread;
  99.     static std::mutex                       m_mutexWrite;
  100.     static std::condition_variable          m_cvWrite;
  101.     static bool                             m_bExit;                //退出标志
  102.     static bool                             m_bRunning;             //运行标志
  103. };
  105. #endif // !__ASYNC_LOG_H__

2、cpp文件

  1. /**
  2.  * @desc:   异步日志类，AsyncLog.cpp
  3.  * @author: zhangyl
  4.  * @date:   2019.04.13
  5.  */
  6. #include "AsyncLog.h"
  7. #include <ctime>
  8. #include <time.h>
  9. #include <sys/timeb.h>
  10. #include <stdio.h>
  11. #include <string.h>
  12. #include <sstream>
  13. #include <iostream>
  14. #include <stdarg.h>
  15. #include "../base/Platform.h"
  17. #define MAX_LINE_LENGTH   256
  18. #define DEFAULT_ROLL_SIZE 10 * 1024 * 1024
  20. bool CAsyncLog::m_bTruncateLongLog = false;
  21. FILE* CAsyncLog::m_hLogFile = NULL;
  22. std::string CAsyncLog::m_strFileName = "default";
  23. std::string CAsyncLog::m_strFileNamePID = "";
  24. LOG_LEVEL CAsyncLog::m_nCurrentLevel = LOG_LEVEL_INFO;
  25. int64_t CAsyncLog::m_nFileRollSize = DEFAULT_ROLL_SIZE;
  26. int64_t CAsyncLog::m_nCurrentWrittenSize = 0;
  27. std::list<std::string> CAsyncLog::m_listLinesToWrite;
  28. std::unique_ptr<std::thread> CAsyncLog::m_spWriteThread;
  29. std::mutex CAsyncLog::m_mutexWrite;
  30. std::condition_variable CAsyncLog::m_cvWrite;
  31. bool CAsyncLog::CAsyncLog::m_bExit = false;
  32. bool CAsyncLog::m_bRunning = false;
  34. bool CAsyncLog::init(const char* pszLogFileName/* = nullptr*/, bool bTruncateLongLine/* = false*/, int64_t nRollSize/* = 10 * 1024 * 1024*/)
  35. {
  36.     m_bTruncateLongLog = bTruncateLongLine;
  37.     m_nFileRollSize = nRollSize;
  39.     if (pszLogFileName == nullptr || pszLogFileName[0] == 0)
  40.     {
  41.         m_strFileName.clear();
  42.     }
  43.     else
  44.         m_strFileName = pszLogFileName;
  46.     //获取进程id，这样快速看到同一个进程的不同日志文件
  47.     char szPID[8];
  48. #ifdef WIN32
  49.     snprintf(szPID, sizeof(szPID), "%05d", (int)::GetCurrentProcessId());  
  50. #else
  51.     snprintf(szPID, sizeof(szPID), "%05d", (int)::getpid());
  52. #endif
  53.     m_strFileNamePID = szPID;
  55.     //TODO：创建文件夹
  57.     m_spWriteThread.reset(new std::thread(writeThreadProc));
  59.     return true;
  60. }
  62. void CAsyncLog::uninit()
  63. {
  64.     m_bExit = true;
  66.     m_cvWrite.notify_one();
  68.     if (m_spWriteThread->joinable())
  69.         m_spWriteThread->join();
  71.     if(m_hLogFile != nullptr)
  72.     {
  73.         fclose(m_hLogFile);
  74.         m_hLogFile = nullptr;
  75.     }
  76. }
  78. void CAsyncLog::setLevel(LOG_LEVEL nLevel)
  79. {
  80.     if (nLevel < LOG_LEVEL_TRACE || nLevel > LOG_LEVEL_FATAL)
  81.         return;
  83.     m_nCurrentLevel = nLevel;
  84. }
  86. bool CAsyncLog::isRunning()
  87. {
  88.     return m_bRunning;
  89. }
  91. bool CAsyncLog::output(long nLevel, const char* pszFmt, ...)
  92. {
  93.     if (nLevel != LOG_LEVEL_CRITICAL)
  94.     {
  95.         if (nLevel < m_nCurrentLevel)
  96.             return false;
  97.     }
  99.     std::string strLine;
  100.     makeLinePrefix(nLevel, strLine);
  102.     //log正文
  103.     std::string strLogMsg;
  105.     //先计算一下不定参数的长度，以便于分配空间
  106.     va_list ap;
  107.     va_start(ap, pszFmt);
  108.     int nLogMsgLength = vsnprintf(NULL, 0, pszFmt, ap);
  109.     va_end(ap);
  111.     //容量必须算上最后一个\0
  112.     if ((int)strLogMsg.capacity() < nLogMsgLength + 1)
  113.     {
  114.         strLogMsg.resize(nLogMsgLength + 1);
  115.     }
  116.     va_list aq;
  117.     va_start(aq, pszFmt);
  118.     vsnprintf((char*)strLogMsg.data(), strLogMsg.capacity(), pszFmt, aq);
  119.     va_end(aq);
  121.     //string内容正确但length不对，恢复一下其length
  122.     std::string strMsgFormal;
  123.     strMsgFormal.append(strLogMsg.c_str(), nLogMsgLength);
  125.     //如果日志开启截断，长日志只取前MAX_LINE_LENGTH个字符
  126.     if (m_bTruncateLongLog)
  127.         strMsgFormal = strMsgFormal.substr(0, MAX_LINE_LENGTH);
  129.     strLine += strMsgFormal;
  131.     //不是输出到控制台才会在每一行末尾加一个换行符
  132.     if (!m_strFileName.empty())
  133.     {
  134.         strLine += "\n";
  135.     }
  137.     if (nLevel != LOG_LEVEL_FATAL)
  138.     {
  139.         std::lock_guard<std::mutex> lock_guard(m_mutexWrite);
  140.         m_listLinesToWrite.push_back(strLine);
  141.         m_cvWrite.notify_one();
  142.     }
  143.     else
  144.     {
  145.         //为了让FATAL级别的日志能立即crash程序，采取同步写日志的方法
  146.         std::cout << strLine << std::endl;
  147. #ifdef _WIN32
  148.         OutputDebugStringA(strLine.c_str());
  149.         OutputDebugStringA("\n");
  150. #endif
  152.         if (!m_strFileName.empty())
  153.         {
  154.             if (m_hLogFile == nullptr)
  155.             {
  156.                 //新建文件
  157.                 char szNow[64];
  158.                 time_t now = time(NULL);
  159.                 tm time;
  160. #ifdef _WIN32
  161.                 localtime_s(&time, &now);
  162. #else
  163.                 localtime_r(&now, &time);
  164. #endif
  165.                 strftime(szNow, sizeof(szNow), "%Y%m%d%H%M%S", &time);
  167.                 std::string strNewFileName(m_strFileName);
  168.                 strNewFileName += ".";
  169.                 strNewFileName += szNow;
  170.                 strNewFileName += ".";
  171.                 strNewFileName += m_strFileNamePID;
  172.                 strNewFileName += ".log";
  173.                 if (!createNewFile(strNewFileName.c_str()))
  174.                     return false;
  175.             }// end inner if 
  177.            writeToFile(strLine);
  179.         }// end outer-if
  181.         //让程序主动crash掉
  182.         crash();
  183.     }
  186.     return true;
  187. }
  189. bool CAsyncLog::output(long nLevel, const char* pszFileName, int nLineNo, const char* pszFmt, ...)
  190. {
  191.     if (nLevel != LOG_LEVEL_CRITICAL)
  192.     {
  193.         if (nLevel < m_nCurrentLevel)
  194.             return false;
  195.     }
  197.     std::string strLine;
  198.     makeLinePrefix(nLevel, strLine);
  200.     //函数签名
  201.     char szFileName[512] = { 0 };
  202.     snprintf(szFileName, sizeof(szFileName), "[%s:%d]", pszFileName, nLineNo);
  203.     strLine += szFileName;
  205.     //日志正文
  206.     std::string strLogMsg;
  208.     //先计算一下不定参数的长度，以便于分配空间
  209.     va_list ap;
  210.     va_start(ap, pszFmt);
  211.     int nLogMsgLength = vsnprintf(NULL, 0, pszFmt, ap);
  212.     va_end(ap);
  214.     //容量必须算上最后一个\0
  215.     if ((int)strLogMsg.capacity() < nLogMsgLength + 1)
  216.     {
  217.         strLogMsg.resize(nLogMsgLength + 1);
  218.     }
  219.     va_list aq;
  220.     va_start(aq, pszFmt);
  221.     vsnprintf((char*)strLogMsg.data(), strLogMsg.capacity(), pszFmt, aq);
  222.     va_end(aq);
  224.     //string内容正确但length不对，恢复一下其length
  225.     std::string strMsgFormal;
  226.     strMsgFormal.append(strLogMsg.c_str(), nLogMsgLength);
  228.     //如果日志开启截断，长日志只取前MAX_LINE_LENGTH个字符
  229.     if (m_bTruncateLongLog)
  230.         strMsgFormal = strMsgFormal.substr(0, MAX_LINE_LENGTH);
  232.     strLine += strMsgFormal;
  234.     //不是输出到控制台才会在每一行末尾加一个换行符
  235.     if (!m_strFileName.empty())
  236.     { 
  237.         strLine += "\n";
  238.     }
  240.     if (nLevel != LOG_LEVEL_FATAL)
  241.     {
  242.         std::lock_guard<std::mutex> lock_guard(m_mutexWrite);
  243.         m_listLinesToWrite.push_back(strLine);
  244.         m_cvWrite.notify_one();
  245.     }
  246.     else
  247.     {
  248.         //为了让FATAL级别的日志能立即crash程序，采取同步写日志的方法
  249.         std::cout << strLine << std::endl;
  250. #ifdef _WIN32
  251.         OutputDebugStringA(strLine.c_str());
  252.         OutputDebugStringA("\n");
  253. #endif
  255.         if (!m_strFileName.empty())
  256.         {
  257.             if (m_hLogFile == nullptr)
  258.             {
  259.                 //新建文件
  260.                 char szNow[64];
  261.                 time_t now = time(NULL);
  262.                 tm time;
  263. #ifdef _WIN32
  264.                 localtime_s(&time, &now);
  265. #else
  266.                 localtime_r(&now, &time);
  267. #endif
  268.                 strftime(szNow, sizeof(szNow), "%Y%m%d%H%M%S", &time);
  270.                 std::string strNewFileName(m_strFileName);
  271.                 strNewFileName += ".";
  272.                 strNewFileName += szNow;
  273.                 strNewFileName += ".";
  274.                 strNewFileName += m_strFileNamePID;
  275.                 strNewFileName += ".log";
  276.                 if (!createNewFile(strNewFileName.c_str()))
  277.                     return false;
  278.             }// end inner if 
  280.             writeToFile(strLine);     
  281.         }// end outer-if
  283.         //让程序主动crash掉
  284.         crash();
  285.     }
  287.     return true;
  288. }
  290. bool CAsyncLog::outputBinary(unsigned char* buffer, size_t size)
  291. {
  292.     //std::string strBinary;
  293.     std::ostringstream os;
  295.     static const size_t PRINTSIZE = 512;
  296.     char szbuf[PRINTSIZE * 3 + 8];
  298.     size_t lsize = 0;
  299.     size_t lprintbufsize = 0;
  300.     int index = 0;
  301.     os << "address[" << (long)buffer << "] size[" << size << "] \n";
  302.     while (true)
  303.     {
  304.         memset(szbuf, 0, sizeof(szbuf));
  305.         if (size > lsize)
  306.         {
  307.             lprintbufsize = (size - lsize);
  308.             lprintbufsize = lprintbufsize > PRINTSIZE ? PRINTSIZE : lprintbufsize;
  309.             formLog(index, szbuf, sizeof(szbuf), buffer + lsize, lprintbufsize);
  310.             size_t len = strlen(szbuf);
  312.             //if (stream().buffer().avail() < static_cast<int>(len))
  313.             //{
  314.             //    stream() << szbuf + (len - stream().buffer().avail());
  315.             //    break;
  316.             //}
  317.             //else
  318.             //{
  319.             os << szbuf;
  320.             //}
  321.             lsize += lprintbufsize;
  322.         }
  323.         else
  324.         {
  325.             break;
  326.         }
  327.     }
  329.     std::lock_guard<std::mutex> lock_guard(m_mutexWrite);
  330.     m_listLinesToWrite.push_back(os.str());
  331.     m_cvWrite.notify_one();
  333.     return true;
  334. }
  336. const char* CAsyncLog::ullto4Str(int n)
  337. {
  338.     static char buf[64 + 1];
  339.     memset(buf, 0, sizeof(buf));
  340.     sprintf(buf, "%06u", n);
  341.     return buf;
  342. }
  344. char* CAsyncLog::formLog(int& index, char* szbuf, size_t size_buf, unsigned char* buffer, size_t size)
  345. {
  346.     size_t len = 0;
  347.     size_t lsize = 0;
  348.     int headlen = 0;
  349.     char szhead[64 + 1] = { 0 };
  350.     char szchar[17] = "0123456789abcdef";
  351.     //memset(szhead, 0, sizeof(szhead));
  352.     while (size > lsize && len + 10 < size_buf)
  353.     {
  354.         if (lsize % 32 == 0)
  355.         {
  356.             if (0 != headlen)
  357.             {
  358.                 szbuf[len++] = '\n';
  359.             }
  361.             memset(szhead, 0, sizeof(szhead));
  362.             strncpy(szhead, ullto4Str(index++), sizeof(szhead) - 1);
  363.             headlen = strlen(szhead);
  364.             szhead[headlen++] = ' ';
  366.             strcat(szbuf, szhead);
  367.             len += headlen;
  369.         }
  370.         if (lsize % 16 == 0 && 0 != headlen)
  371.             szbuf[len++] = ' ';
  372.         szbuf[len++] = szchar[(buffer[lsize] >> 4) & 0xf];
  373.         szbuf[len++] = szchar[(buffer[lsize]) & 0xf];
  374.         lsize++;
  375.     }
  376.     szbuf[len++] = '\n';
  377.     szbuf[len++] = '\0';
  378.     return szbuf;
  379. }
  381. void CAsyncLog::makeLinePrefix(long nLevel, std::string& strPrefix)
  382. {
  383.     //级别
  384.     strPrefix = "[INFO]";
  385.     if (nLevel == LOG_LEVEL_TRACE)
  386.         strPrefix = "[TRACE]";
  387.     else if (nLevel == LOG_LEVEL_DEBUG)
  388.         strPrefix = "[DEBUG]";
  389.     else if (nLevel == LOG_LEVEL_WARNING)
  390.         strPrefix = "[WARN]";
  391.     else if (nLevel == LOG_LEVEL_ERROR)
  392.         strPrefix = "[ERROR]";
  393.     else if (nLevel == LOG_LEVEL_SYSERROR)
  394.         strPrefix = "[SYSE]";
  395.     else if (nLevel == LOG_LEVEL_FATAL)
  396.         strPrefix = "[FATAL]";
  397.     else if (nLevel == LOG_LEVEL_CRITICAL)
  398.         strPrefix = "[CRITICAL]";
  400.     //时间
  401.     char szTime[64] = { 0 };
  402.     getTime(szTime, sizeof(szTime));
  404.     strPrefix += "[";
  405.     strPrefix += szTime;
  406.     strPrefix += "]";
  408.     //当前线程信息
  409.     char szThreadID[32] = { 0 };
  410.     std::ostringstream osThreadID;
  411.     osThreadID << std::this_thread::get_id();
  412.     snprintf(szThreadID, sizeof(szThreadID), "[%s]", osThreadID.str().c_str());
  413.     strPrefix += szThreadID;   
  414. }
  416. void CAsyncLog::getTime(char* pszTime, int nTimeStrLength)
  417. {   
  418.     struct timeb tp;
  419.     ftime(&tp);
  421.     time_t now = tp.time;
  422.     tm time;
  423. #ifdef _WIN32
  424.     localtime_s(&time, &now);
  425. #else
  426.     localtime_r(&now, &time);
  427. #endif
  429.     snprintf(pszTime, nTimeStrLength, "[%04d-%02d-%02d %02d:%02d:%02d:%03d]", time.tm_year + 1900, time.tm_mon + 1, time.tm_mday, time.tm_hour, time.tm_min, time.tm_sec, tp.millitm);
  430.     //strftime(pszTime, nTimeStrLength, "[%Y-%m-%d %H:%M:%S:]", &time);
  431. }
  433. bool CAsyncLog::createNewFile(const char* pszLogFileName)
  434. {
  435.     if (m_hLogFile != nullptr)
  436.     {
  437.         fclose(m_hLogFile);
  438.     }
  440.     //始终新建文件
  441.     m_hLogFile = fopen(pszLogFileName, "w+");
  442.     return m_hLogFile != nullptr;
  443. }
  445. bool CAsyncLog::writeToFile(const std::string& data)
  446. {
  447.     //为了防止长文件一次性写不完，放在一个循环里面分批写
  448.     std::string strLocal(data);
  449.     int ret = 0;
  450.     while (true)
  451.     {
  452.         ret = fwrite(strLocal.c_str(), 1, strLocal.length(), m_hLogFile);
  453.         if (ret <= 0)
  454.             return false;
  455.         else if (ret <= (int)strLocal.length())
  456.         {
  457.             strLocal.erase(0, ret);
  458.         }
  460.         if (strLocal.empty())
  461.             break;
  462.     }
  465.     //::OutputDebugStringA(strDebugInfo.c_str());
  467.     fflush(m_hLogFile);
  469.     return true;
  470. }
  472. void CAsyncLog::crash()
  473. {
  474.     char* p = nullptr;
  475.     *p = 0;
  476. }
  478. void CAsyncLog::writeThreadProc()
  479. {
  480.     m_bRunning = true;
  482.     while (true)
  483.     {        
  484.         if (!m_strFileName.empty())
  485.         {
  486.             if (m_hLogFile == nullptr || m_nCurrentWrittenSize >= m_nFileRollSize)
  487.             {
  488.                 //重置m_nCurrentWrittenSize大小
  489.                 m_nCurrentWrittenSize = 0;
  491.                 //第一次或者文件大小超过rollsize，均新建文件
  492.                 char szNow[64];
  493.                 time_t now = time(NULL);
  494.                 tm time;
  495. #ifdef _WIN32
  496.                 localtime_s(&time, &now);
  497. #else
  498.                 localtime_r(&now, &time);
  499. #endif
  500.                 strftime(szNow, sizeof(szNow), "%Y%m%d%H%M%S", &time);
  502.                 std::string strNewFileName(m_strFileName);
  503.                 strNewFileName += ".";
  504.                 strNewFileName += szNow;
  505.                 strNewFileName += ".";
  506.                 strNewFileName += m_strFileNamePID;
  507.                 strNewFileName += ".log";
  508.                 if (!createNewFile(strNewFileName.c_str()))
  509.                     return;
  510.             }// end inner if        
  511.         }// end outer-if
  514.         std::string strLine;
  515.         {
  516.             std::unique_lock<std::mutex> guard(m_mutexWrite);
  517.             while (m_listLinesToWrite.empty())
  518.             {
  519.                 if (m_bExit)
  520.                     return;
  522.                 m_cvWrite.wait(guard);
  523.             }
  525.             strLine = m_listLinesToWrite.front();
  526.             m_listLinesToWrite.pop_front();
  527.         }
  530.         std::cout << strLine << std::endl;
  532. #ifdef _WIN32
  533.         OutputDebugStringA(strLine.c_str());
  534.         OutputDebugStringA("\n");
  535. #endif
  537.         if (!m_strFileName.empty())
  538.         {
  539.             if (!writeToFile(strLine))
  540.                 return;
  542.             m_nCurrentWrittenSize += strLine.length();
  543.         }     
  544.     }// end outer-while-loop
  546.     m_bRunning = false;
  547. }

3、应用

  1. #ifdef _DEBUG
  2.     CAsyncLog::init();
  3. #else
  4.     CAsyncLog::init(logFileFullPath.c_str());
  5. #endif
  7. LOGI("exit chatserver.");
  8. LOGI("current online user count: %d", (int)m_sessions.size());