基于Boost 的线程安全队列

   在实际的项目应用中，涉及到很多队列，但是队列的实际使用却受到多线程安全的影响，为了屏蔽这些影响，需要使用到互斥锁，如下是自己实现的一个线程安全队列

template<typename T>
class CRequestQueue
{

public:
    CRequestQueue() {}
    ~CRequestQueue() 
    {
        if (!theQueue_.empty())
        {
            theQueue_.clear();
        }

    }

    int QueuePush(const T &pt) 
    {
        boost::mutex::scoped_lock oLock(m_oMutex);
        theQueue_.push_back(pt);
        return theQueue_.size();
    }

    T QueuePop() 
    {
        boost::mutex::scoped_lock oLock(m_oMutex);
        if (theQueue_.size() > 0) 
        {
            T oThread = theQueue_.front();
            theQueue_.pop_front();
            return oThread;
        }

        return m_nullObject;
    }

    void QueueErase(T &Object) 
    {
        boost::mutex::scoped_lock oLock(m_oMutex);
        typedef typename list<T>::iterator iter_thread;
        for (iter_thread it = theQueue_.begin(); it != theQueue_.end();) 
        {
            if (Object == *it) 
            {
                theQueue_.erase(it++);
                break;
            }
            else 
            {
                ++it;
            }
        }
    }

    void QueueClean()
    {    
        boost::mutex::scoped_lock oLock(m_oMutex);
        if (!theQueue_.empty())
        {
            theQueue_.clear();
        }

        return;
    }

    int QueueLength() 
    {
        boost::mutex::scoped_lock oLock(m_oMutex);
        return theQueue_.size();
    }

    bool IsQueueEmpty()
    {
        boost::mutex::scoped_lock oLock(m_oMutex);
        return theQueue_.empty();
    }

public:
    boost::mutex m_oMutex;

private:
    std::list<T> theQueue_;
    T m_nullObject;
};