C++ 队列的实现

 /************************************************************************/
 /* 实现一个通用同步队列
    使用链表实现队列 (先入先出)
    使用信号量等待实现同步
 /************************************************************************/
 #pragma once

 #include "lock.h"
 #include <list>

 template <typename Type>
 class Queue
 {
 public:
     inline Queue()
     {
         bInit = true;
         count = ;
         semaphore.Create(0xFFFF);
     }
     inline ~Queue()
     {
         Close();
     }

     inline void Close()
     {
         if(bInit) {
             bInit = false;
             semaphore.Release();            //释放信号 让正在wait的就返回
             semaphore.Close();
         }
     }

     inline int getCount()
     {
         return count;
     }

     inline bool Push(Type* type)
     {
         if(!bInit)
             return false;

         criticalsection.Lock();

         queueList.push_back(type);
         count++;

         criticalsection.Unlock();

         semaphore.Release();                //发出信号 让Pop可以操作了
         return true;
     }
     inline Type* Pop()
     {
         semaphore.Wait(INFINITE);            //等待Push的信号发来后才进行动作
         if(bInit == false)
             return ;

         criticalsection.Lock();

         Type *type = *(queueList.begin());    //取出链表头
         queueList.pop_front();                //从链表弹出
         count--;

         criticalsection.Unlock();
         return type;
     }

 private:
     bool bInit;
     int     count;
     Semaphore    semaphore;
     CriticalSection criticalsection;
     std::list<Type*> queueList;
 };

其中用到了简单包装的Semaphore和CriticalSection

如下：

 //临界区
 class CriticalSection
 {
 public:
     inline CriticalSection()
     {
         InitializeCriticalSection(&m_sect);
     }
     inline ~CriticalSection()
     {
         DeleteCriticalSection(&m_sect);
     }
     inline void Lock()
     {
         EnterCriticalSection(&m_sect);
     }
     inline void Unlock()
     {
         LeaveCriticalSection(&m_sect);
     }
     inline BOOL TryLock()
     {
         return TryEnterCriticalSection(&m_sect);
     }

 private:
     CRITICAL_SECTION m_sect;
 };

 //信号量
 class Semaphore
 {
 public:
     inline Semaphore()
     {
         m_hSem = NULL;
     }
     inline ~Semaphore()
     {
         Close();
     }
     inline BOOL Create(LONG lMaximumCount)
     {
         m_hSem = CreateSemaphore(NULL, , lMaximumCount, NULL);
         return (m_hSem != NULL);
     }
     inline void Close()
     {
         if (m_hSem)
         {
             CloseHandle(m_hSem);
             m_hSem = NULL;
         }
     }
     inline BOOL Release(LONG lReleaseCount)
     {
         return ReleaseSemaphore(m_hSem, lReleaseCount, NULL);
     }
     inline DWORD Wait(DWORD dwMilliseconds)
     {
         return WaitForSingleObject(m_hSem, dwMilliseconds);
     }

 public:
     HANDLE  m_hSem;
 };