c++ - 两个具有共享缓冲区的等待线程(生产者/消费者)

Question

我试图让一堆生产者线程等到缓冲区有空间容纳一个项目，然后它尽可能地将项目放入缓冲区，如果没有更多空间则返回休眠。

同时应该有一堆消费者线程等待直到缓冲区中有东西，然后它会尽可能地从缓冲区中取出东西，如果它是空的则返回休眠。

在伪代码中，这就是我正在做的，但我得到的只是死锁。

condition_variable cvAdd;
condition_variable cvTake;
mutex smtx;

ProducerThread(){
    while(has something to produce){

         unique_lock<mutex> lock(smtx);
         while(buffer is full){
            cvAdd.wait(lock);
         }
         AddStuffToBuffer();
         cvTake.notify_one();
    }
}

ConsumerThread(){

     while(should be taking data){

        unique_lock<mutex> lock(smtx);
        while( buffer is empty ){
            cvTake.wait(lock);
        }   
        TakeStuffFromBuffer();
        if(BufferIsEmpty)
        cvAdd.notify_one();
     }

}

Answer 1

另一个值得一提的错误是您的消费者仅在缓冲区变空时通知等待中的生产者。

仅当队列已满时通知消费者的最佳方式。

例如:

template<class T, size_t MaxQueueSize>
class Queue
{
    std::condition_variable consumer_, producer_;
    std::mutex mutex_;
    using unique_lock = std::unique_lock<std::mutex>;

    std::queue<T> queue_;

public:
    template<class U>
    void push_back(U&& item) {
        unique_lock lock(mutex_);
        while(MaxQueueSize == queue_.size())
            producer_.wait(lock);
        queue_.push(std::forward<U>(item));
        consumer_.notify_one();
    }

    T pop_front() {
        unique_lock lock(mutex_);
        while(queue_.empty())
            consumer_.wait(lock);
        auto full = MaxQueueSize == queue_.size();
        auto item = queue_.front();
        queue_.pop();
        if(full)
            producer_.notify_all();
        return item;
    }
};