加上就能顺利结束，这是什么原因呢。
//头文件
#pragma once
#include <boost/thread/condition.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/recursive_mutex.hpp>
#include <boost/thread/thread.hpp>
#include <boost/filesystem.hpp>
#include <queue>
#include <fstream>
namespace MutithreadLog
{
template <typename V>
class SafeQueue
{
public:
typedef typename boost::recursive_mutex::scoped_lock scoped_lock;
SafeQueue(int nCount)
: _limit(nCount)
{
}
void add(V v)
{
scoped_lock lk(_mutex);
while (_limit <= _queue.size())
{
_cond.wait(lk);
}
_queue.push(v);
_cond.notify_one();
}
V pop()
{
scoped_lock lk(_mutex);
while (_queue.size() == 0)
{
_cond.wait(lk);
}
V vRet = _queue.front();
_queue.pop();
_cond.notify_one();
return vRet;
}
int size()
{
scoped_lock lk(_mutex);
return static_cast<int>(_queue.size());
}
bool is_full()
{
scoped_lock lk(_mutex);
if (_limit <= _queue.size())
{
return true;
}
return false;
}
void clearall()
{
scoped_lock lk(_mutex);
while (_queue.size() > 0)
{
_queue.pop();
}
_cond.notify_one();
}
private:
boost::recursive_mutex _mutex;
boost::condition _cond;
std::queue<V> _queue;
unsigned int _limit;
};
enum eLogLevel
{
eNormal = 0,
eWarning,
eError,
eFatal
};
class CLogInfo
{
public:
CLogInfo(const std::string& strLog, const eLogLevel level)
: m_strLog(strLog), m_level(level) {}
~CLogInfo() {}
const std::string& GetLog() const { return m_strLog; }
const eLogLevel GetLogLevel() const { return m_level; }
private:
std::string m_strLog;
eLogLevel m_level;
};
typedef boost::shared_ptr<CLogInfo> CLogInfoPtr;
class CLogger
{
public:
static bool Initialize(const std::string& strPath = "D:\\MyLog\\");
static void UnInitialize();
static bool WriteLog(const std::string& strLog, const eLogLevel level = eNormal);
static void Run();
private:
static SafeQueue<CLogInfoPtr> m_logQueue;
static boost::thread_group m_threadGroup;
static std::ofstream m_ofstream;
};
};
// 源文件
#include "Logger.h"
#include <Windows.h>
#include <sstream>
#include <boost/date_time/posix_time/posix_time.hpp>
using namespace MutithreadLog;
using namespace std;
SafeQueue<CLogInfoPtr> CLogger::m_logQueue = SafeQueue<CLogInfoPtr>(1000);
boost::thread_group CLogger::m_threadGroup;
std::ofstream CLogger::m_ofstream;
bool CLogger::Initialize(const std::string& strPath)
{
if (!boost::filesystem::exists(strPath))
boost::filesystem::create_directory(strPath);
string strFileName = strPath + "ImportMonitorLog.txt";
m_ofstream.open(strFileName.c_str(), ios::app);
if (m_ofstream.is_open())
{
m_threadGroup.create_thread(boost::bind(&CLogger::Run));
return true;
}
return false;
}
void CLogger::UnInitialize()
{
m_logQueue.add(CLogInfoPtr());
}
bool CLogger::WriteLog(const std::string& strLog, const eLogLevel level)
{
if (m_ofstream.is_open())
{
m_logQueue.add(CLogInfoPtr(new CLogInfo(strLog, level)));
return true;
}
return false;
}
void CLogger::Run()
{
while(true)
{
CLogInfoPtr logPtr = m_logQueue.pop();
if (logPtr)
m_ofstream << "level:" << logPtr->GetLogLevel() << " " << logPtr->GetLog() << endl;
else
{
m_ofstream.close();
break;
}
}
}
// test code...
void test()
{
int nThreadID = ::GetCurrentThreadId();
while (true)
{
stringstream sstream;
string strTime = boost::posix_time::to_iso_string(boost::posix_time::second_clock::local_time());
int pos = strTime.find('T');
strTime.replace(pos,1,std::string("-"));
strTime.replace(pos + 3,0,std::string(":"));
strTime.replace(pos + 6,0,std::string(":"));
sstream << strTime << " " << nThreadID;
if (!CLogger::WriteLog(sstream.str() , eNormal))
break;
//::Sleep(100);
}
}
int main(void)
{
CLogger::Initialize();
boost::thread_group threads;
for (int i = 0; i < 30; i++)
threads.create_thread(boost::bind(&test));
::Sleep(1000);
CLogger::UnInitialize();
threads.join_all();
getchar();
}
