c++ 实现的BlockingQueue

#include "thread/Critical.h"
#include "thread/Codition.h"
#include "thread/Lock.h"
#include <vector>
using namespace std;

const unsigned int DEFAULT_MAX_SIZE = 100;

template<class T>
class BlockingQueue
{
public:
BlockingQueue(unsigned int uMaxSize = DEFAULT_MAX_SIZE);
~BlockingQueue(void);

public:
bool Add( T item);
bool Put( T item);
T Take();//获取不到数据，一直阻塞
bool Poll(unsigned long time, T& item);//time单位ms，time时间内获取不到队列数据，返回NULL

private:
vector<T> m_vecQueue;
CCodition m_oGetCondition;
CCodition m_oSetCondition;
CCritical m_oCriticalSection;

unsigned int m_uMaxSize;

};

template<class T>
BlockingQueue<T>::BlockingQueue( unsigned int uMaxSize )
:m_uMaxSize(uMaxSize)
{
}

template<class T>
BlockingQueue<T>::~BlockingQueue( void )
{
m_vecQueue.clear();
}

template<class T>
bool BlockingQueue<T>::Add( T item )
{
CLock oLock(&m_oCriticalSection);

if (m_vecQueue.size() < m_uMaxSize)
{
m_vecQueue.push_back(item);
m_oGetCondition.Signal();
return true;
}

return false;

}

template<class T>
bool BlockingQueue<T>::Put( T item )
{

CLock oLock(&m_oCriticalSection);

while (true)
{
if (m_vecQueue.size() < m_uMaxSize)
{
m_vecQueue.push_back(item);
m_oGetCondition.Signal();
return true;
}

if (WAIT_FAILED == m_oSetCondition.Wait(INFINITE))
{
return false;
}

}
}

template<class T>
bool BlockingQueue<T>::Poll( unsigned long time, T& item )
{
while (true)
{
if (!m_vecQueue.empty())
{
CLock oLock(&m_oCriticalSection);

vector<T>::iterator it = m_vecQueue.begin();
item = *it;
m_vecQueue.erase(it);

m_oSetCondition.Signal();
return true;
}

DWORD dwWaitResult = m_oGetCondition.Wait(time);

if (WAIT_TIMEOUT == dwWaitResult || WAIT_FAILED == dwWaitResult)
{
return false;
}

}
}

template<class T>
T BlockingQueue<T>::Take()
{
while (true)
{
if (!m_vecQueue.empty())
{
CLock oLock(&m_oCriticalSection);

vector<T>::iterator it = m_vecQueue.begin();
T item = *it;
m_vecQueue.erase(it);

m_oSetCondition.Signal();
return item;
}

m_oGetCondition.Wait();
}
}

#include <Windows.h>

class CCodition
{
public:
CCodition(void);
~CCodition(void);

public:
void Signal();//发送信号
DWORD Wait(unsigned long time = INFINITE);//等待信号
private:
HANDLE m_hSignalEvent;
};

#include "StdAfx.h"
#include "Codition.h"

CCodition::CCodition(void)
{
m_hSignalEvent = ::CreateEvent(NULL, false, false, NULL);
}

CCodition::~CCodition(void)
{
if (NULL != m_hSignalEvent)
{
::CloseHandle(m_hSignalEvent);
}
}

void CCodition::Signal()
{
if (NULL == m_hSignalEvent)
{
return;
}
::SetEvent(m_hSignalEvent);

}

DWORD CCodition::Wait(unsigned long time)
{
if (NULL == m_hSignalEvent)
{
return WAIT_FAILED;
}
return ::WaitForSingleObject(m_hSignalEvent, time);
}

#include "Critical.h"

class CLock
{
public:
CLock(CCritical* pCritical);
~CLock(void);

private:
CLock(void);

private:
CCritical* m_pCritical;

};

#include "StdAfx.h"
#include "Lock.h"

CLock::CLock(void)
{
}

CLock::CLock( CCritical* pCritical )
{
if (NULL != pCritical)
{
m_pCritical = pCritical;
m_pCritical->Lock();
}

}

CLock::~CLock(void)
{
if (NULL != m_pCritical)
{
m_pCritical->Unlock();
}

}

#include <Windows.h>

class CCritical
{
public:
CCritical(void);
~CCritical(void);

public:
void Lock();
void Unlock();

private:
CRITICAL_SECTION m_oCriticalSection;

};

#include "StdAfx.h"
#include "Critical.h"

CCritical::CCritical(void)
{
::InitializeCriticalSection(&m_oCriticalSection);
}

CCritical::~CCritical(void)
{
::DeleteCriticalSection(&m_oCriticalSection);
}

void CCritical::Lock()
{
::EnterCriticalSection(&m_oCriticalSection);
}

void CCritical::Unlock()
{
::LeaveCriticalSection(&m_oCriticalSection);
}