生产者/消费者，消费者线程从未执行过

Question

Created a program having a producer thread and a consumer thread.

The producer thread continuously pushes to a stack every one second, which is protected by a mutex.

The consumer thread continuously pops from the stack.

The unexpected behavior is that, the producer thread is constantly running, while the consumer thread never gets a chance to pop the stack.

How could I proceed to investigate this problem? Many thanks.

#include <stack>
#include <chrono>

#include <thread>
#include <mutex>
#include <condition_variable>
#include <iostream>


std::mutex mtx;
std::stack<int> the_stack;

void producer(const int id)
{
  while(1)
  {
    mtx.lock();
    the_stack.push(0);
    std::cout << "Producer " << id << " push" << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    mtx.unlock();
  }
}//producer


void consumer(const int id)
{
  while(1)
  {
    mtx.lock();
    if (!the_stack.empty())
    {
      std::cout << "Consumer " << id << " pop" << std::endl;
      the_stack.pop();
    }
    mtx.unlock();
  }
}//consumer


int main()
{
  std::thread thread_0(producer, 0);
  std::thread consum_0(consumer, 0);

  thread_0.join();
  consum_0.join();

  return 0;
}//main;

Answer 1

The producer is spending its sleeping time while holding the mutex. This hardly gives the consumer a chance to lock the mutex.

If you put the sleep statement outside the mutex protected area, it will work as expected..

void producer(const int id)
{
  while(1)
  {
    ....
    mtx.unlock();
    std::this_thread::sleep_for(std::chrono::seconds(1)); // below the unlock operation
  }