C++ 阻塞队列隔离错误带提升

我需要C++具有超时功能的阻塞队列offer()。该队列适用于多个生产者，一个使用者。当我实现时，我没有找到任何适合此需求的现有队列，所以我自己编写了代码。

我看到队列上的take()方法出现段错误，但它们是间歇性的。我一直在查看代码中的问题，但我没有看到任何看起来有问题的东西。

我想知道是否：

• 有一个现有的库可以可靠地做到这一点，我应该使用（首选升压或仅标头）。
• 任何人都会在我的代码中看到我需要修复的任何明显缺陷。

这是标题：

class BlockingQueue
{
    public:
        BlockingQueue(unsigned int capacity) : capacity(capacity) { };
        bool offer(const MyType & myType, unsigned int timeoutMillis);
        MyType take();
        void put(const MyType & myType);
        unsigned int getCapacity();
        unsigned int getCount();
    private:
         std::deque<MyType> queue;
         unsigned int capacity;
};

以及相关的实现：

boost::condition_variable cond;
boost::mutex mut;
bool BlockingQueue::offer(const MyType & myType, unsigned int timeoutMillis)
{
    Timer timer;
    // boost::unique_lock is a scoped lock - its destructor will call unlock().
    // So no need for us to make that call here.
    boost::unique_lock<boost::mutex> lock(mut);
    // We use a while loop here because the monitor may have woken up because
    // another producer did a PulseAll. In that case, the queue may not have
    // room, so we need to re-check and re-wait if that is the case.
    // We use an external stopwatch to stop the madness if we have taken too long.
    while (queue.size() >= this->capacity)
    {
        int monitorTimeout = timeoutMillis - ((unsigned int) timer.getElapsedMilliSeconds());
        if (monitorTimeout <= 0)
        {
            return false;
        }
        if (!cond.timed_wait(lock, boost::posix_time::milliseconds(timeoutMillis)))
        {
            return false;
        }
    }
    cond.notify_all();
    queue.push_back(myType);
    return true;
}
void BlockingQueue::put(const MyType & myType)
{
    // boost::unique_lock is a scoped lock - its destructor will call unlock().
    // So no need for us to make that call here.
    boost::unique_lock<boost::mutex> lock(mut);
    // We use a while loop here because the monitor may have woken up because
    // another producer did a PulseAll. In that case, the queue may not have
    // room, so we need to re-check and re-wait if that is the case.
    // We use an external stopwatch to stop the madness if we have taken too long.
    while (queue.size() >= this->capacity)
    {
        cond.wait(lock);
    }
    cond.notify_all();
    queue.push_back(myType);
}
MyType BlockingQueue::take()
{
    // boost::unique_lock is a scoped lock - its destructor will call unlock().
    // So no need for us to make that call here.
    boost::unique_lock<boost::mutex> lock(mut);
    while (queue.size() == 0)
    {
        cond.wait(lock);
    }
    cond.notify_one();
    MyType myType = this->queue.front();
    this->queue.pop_front();
    return myType;
}
unsigned int BlockingQueue::getCapacity()
{
    return this->capacity;
}
unsigned int BlockingQueue::getCount()
{
    return this->queue.size();
}

是的，我没有使用模板实现该类 - 这是列表中的下一个:)

任何帮助将不胜感激。线程问题可能真的很难确定。

-本