C++ 多线程程序在等待条件下挂起

我有下面的代码。我正在使用c++11线程编写一个简单的多线程生产者-消费者问题

class W
{
public:
    explicit W();
    void p();
    void c();
private:
    std::deque<std::uint64_t> q;
    std::shared_ptr<std::mutex> m;
    std::shared_ptr<std::condition_variable> cvQEmpty;
    std::shared_ptr<std::condition_variable> cvQFull;
    const std::size_t queue_size;
};

W::W()
: m(std::make_shared<std::mutex>()), 
cvQEmpty(std::make_shared<std::condition_variable>()),
cvQFull(std::make_shared<std::condition_variable>()),
queue_size(3)  
{
}

void
W::p()
{
    while(1)    
    {
        std::unique_lock<std::mutex> lk(*m.get());
        if (q.size() >= queue_size)
        {
            cvQFull->wait(lk, [this] { return q.size() < queue_size; });
        }
        q.push_back(q.size());
        std::cout << "Pushed " << q[q.size() - 1] << std::endl;
        lk.unlock();
        cvQEmpty->notify_one();
    }
}

void
W::c()
{
  while (1)
  {
    std::unique_lock<std::mutex> lk(*m.get());
    if (q.empty())
    {
        cvQEmpty->wait(lk, [this] { return !q.empty(); });
    }
    while(!q.empty())
    {
      const std::uint64_t val = q[0];
      std::cout << "Output : " << val << std::endl;
      q.pop_back();
    }
    lk.unlock();
    cvQFull->notify_one();
  }
}

void 
foo()
{
    W w;
    std::thread p(&W::p, w);
    std::thread c(&W::c, w);
    c.join();
    p.join();
} 

W类
{
公众：
显式W（）；
void p（）；
无效c（）；
私人：
标准：德克q；
std：：共享的ptr m；
std:：shared_ptr cvQEmpty；
std：：共享_ptr cvQFull；
const std:：size\u t queue\u size；
};
W：：W（）
：m（std:：make_shared（）），
cvQEmpty（std:：make_shared（）），
cvQFull（std:：make_shared（）），
队列大小（3）
{
}
无效的
W：：p（）
{
而(1)
{
std:：unique_lock lk（*m.get（））；
if（q.size（）>=队列大小）
{
cvQFull->wait（lk，[this]{return q.size（）std:：cout非常简单。您正在将
w
参数复制到两个线程，调用复制构造函数。这些线程最终使用两个独立队列

解决方案：


将您的队列设置为类似互斥体的
共享\u ptr
（更好）将您的论点包含在
std:：ref
中

（另一方面，
explicit W（）
什么也不给你，只是语法噪音）
非常简单。你正在将
W
参数复制到两个线程，调用复制构造函数。这些线程最终使用两个独立队列

解决方案：


将您的队列设置为类似互斥体的
共享\u ptr
（更好）将您的论点包含在
std:：ref
中

（另一方面，
explicit W（）
什么都不给，只是语法噪音）
您是否有日志？如Push1、Push2..当队列已满时它是否挂起？因为生产者锁定互斥锁并等待队列大小减小，但消费者将等待获得生产者锁定的互斥锁以消费..因此死锁..您不需要任何共享的PTR，没有什么可共享的。请使用普通
std:：互斥锁
和
std:：condition\u variable
是否有任何日志？如push1、push2..当队列已满时它是否挂起？因为生产者锁定互斥锁并等待队列大小减小，但消费者将等待获得生产者锁定的互斥锁以消费..因此死锁..您不需要任何共享的PTR，只有无需共享。请使用普通的
std:：mutex
和
std:：condition\u变量
。