封装一个简单的池操作

 

//临界区同步类
class CMRThreadLock
{
 //变量定义
private:
 CRITICAL_SECTION     m_csLock;     //临界变量

 //函数定义
public:
 //构造函数
 inline CMRThreadLock() { ::InitializeCriticalSection(&m_csLock); }
 //析构函数
 inline ~CMRThreadLock() { ::DeleteCriticalSection(&m_csLock); }

 //功能函数
public:
 //锁定函数
 virtual inline void Lock() { ::EnterCriticalSection(&m_csLock); }
 //解锁函数
 virtual inline void UnLock() { ::LeaveCriticalSection(&m_csLock); }
};

 

 

class CMRPoolObject
{
public:
 //must deep copy
 virtual CMRPoolObject* Copy()=NULL;
};

class CMRPool
{
public:
 CMRPool(DWORD initSize, DWORD maxSize, CMRPoolObject* po)
 {
  ASSERT(maxSize > initSize && initSize);

  m_MaxSize = maxSize;
  for (DWORD i = 0; i < initSize - 1; i++)
  {
   try
   {
    m_IdleObjects.push_back(po->Copy());
   }
   catch (...)
   {
    break;
   }  
  }
  m_IdleObjects.push_back(po);
 }
 
 virtual ~CMRPool()
 {
  m_Lock.Lock();
  for (list<CMRPoolObject*>::iterator it = m_IdleObjects.begin(); it != m_IdleObjects.end(); it++)
   delete *it;
  m_IdleObjects.clear();
  
  for (list<CMRPoolObject*>::iterator it = m_BusyObjects.begin(); it != m_BusyObjects.end(); it++)
   delete *it;
  m_BusyObjects.clear();
  m_Lock.UnLock();

 }

 CMRPoolObject* GetObject()
 {
  CMRPoolObject* result = NULL;
  m_Lock.Lock();

  if (m_IdleObjects.size())
  {
   result = m_IdleObjects.front();
   m_BusyObjects.push_back(result);
   m_IdleObjects.pop_front();
  }
  else if (ObjectCount() < m_MaxSize)
  {
   try
   {
    result = m_BusyObjects.back()->Copy();
    m_BusyObjects.push_back(result);
   }
   catch (...)
   {
    result = NULL;
   }   
  }

  m_Lock.UnLock();
  return result;
 }

 void ReleaseObject(CMRPoolObject* po)
 {
  m_Lock.Lock();
  for (list<CMRPoolObject*>::iterator it = m_BusyObjects.begin(); it != m_BusyObjects.end();)
  {
   if (*it == po)
   {
    m_BusyObjects.erase(it++);
    break;
   }
   else
    ++it;
  }
  m_IdleObjects.push_back(po);
  
  m_Lock.UnLock();
 }

 DWORD ObjectCount() { return m_BusyObjects.size() + m_IdleObjects.size(); }
 
 void Lock(){ m_Lock.Lock(); }
 void UnLock(){ m_Lock.UnLock(); }

 const list<CMRPoolObject*>& BusyObjects(){ return m_BusyObjects; }
 const list<CMRPoolObject*>& IdleObjects(){ return m_IdleObjects; }
private:
 list<CMRPoolObject*> m_BusyObjects;
 list<CMRPoolObject*> m_IdleObjects;
 DWORD m_MaxSize;
 CMRThreadLock m_Lock;
 
};