cqueue.h

一个简单的队列类

#ifndef _CYQueueSyn_H
#define _CYQueueSyn_H


#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000 

#include <list>

using namespace std;

class CYException
{
public:
	CString sMsg;
	int nError;
	CYException(int nErr,char* sErrMsg){
		nError = nErr;
		sMsg  = sErrMsg;
	}
	virtual ~CYException(){}

};

   
template   <class  T>  
class   CYQueueSyn  
{  
  public:  
	  std::list<T>   queue;  
	  int   m_outtime;  
	  HANDLE   m_readSem;  
	  HANDLE   m_writeSem;  
	  HANDLE   m_synObject;  
	  
  public:  
	  CYQueueSyn(int length,int  outtime = INFINITE);  
	  virtual   ~CYQueueSyn(void);  
  public:  
	  void   inq(T type);  
	  T   outq();  

	  void   free();  	  
};  
   
////////////////////////////////////////////////////////
template<class   T>  
void   CYQueueSyn<T>::free()  
{  
	int   size = (int)queue.size();  
	for(int i = 0; i<size; i++)  
		delete queue.back();  
	queue.clear();  
}  
   
template<class T>  
CYQueueSyn<T>::CYQueueSyn(int   length,int   outtime)  
{  
	m_readSem = CreateSemaphore(NULL,0,length,NULL);  
	m_writeSem = CreateSemaphore(NULL,length,length,NULL);  
	m_synObject = ::CreateMutex(NULL,false,NULL);  

	m_outtime = outtime;
}  
   
template<class T>  
CYQueueSyn<T>::~CYQueueSyn()  
{  
	CloseHandle(m_readSem);  
	CloseHandle(m_writeSem);  
	CloseHandle(m_synObject);  
}  

   
template<class T>  
void   CYQueueSyn<T>::inq(T type)   throw(CYException)  
{  
	int  rVal = WaitForSingleObject(m_writeSem,m_outtime);  
	
	if(rVal == WAIT_OBJECT_0)  
	{  
		if(WaitForSingleObject(m_synObject,INFINITE) == WAIT_OBJECT_0)  
		{  
			queue.push_back(type);  
			ReleaseMutex(m_synObject);  
		}  
	}  
	else if(rVal == WAIT_TIMEOUT)  
	{  
		throw CYException(1,"TIMEOUT");  
	}  
	else if(rVal == WAIT_ABANDONED)  
	{  
		throw CYException(-1, "ERROR");  
	}  
	ReleaseSemaphore(m_readSem,1,NULL);  
}  
   
template<class T>  
T  CYQueueSyn<T>::outq()   throw(CYException)  
{  
	T  value;  
	int rVal = WaitForSingleObject(m_readSem,m_outtime);  
	
	if(rVal == WAIT_OBJECT_0)  
	{  
		if(WaitForSingleObject(m_synObject,INFINITE) == WAIT_OBJECT_0)  
		{  
			value = queue.front();  
			queue.pop_front();  
			ReleaseMutex(m_synObject);  
		}  
	}  
	else if(rVal == WAIT_TIMEOUT)  
	{  
		throw CYException(1,"TIMEOUT");  
	}  
	else if(rVal == WAIT_ABANDONED)  
	{  
		throw CYException(-1,"ERROR");  
	}  

	ReleaseSemaphore(m_writeSem,1,NULL);  
	return   value;  
}  


#endif