Understanding the Producer-Consumer Problem in C++

The Producer-Consumer problem is a classic multi-threading and synchronization problem in computer science. It arises when two or more threads, called producers and consumers, need to communicate with each other by sharing a limited-size buffer. 

The producers generate data and store it in the buffer, while the consumers remove and process the data from the buffer. The challenge lies in ensuring that the producers do not overflow the buffer and the consumers do not consume from an empty buffer, all while maintaining concurrency and avoiding deadlocks.

C++ Concepts Covered in the Solution

This particular C++ implementation of the Producer-Consumer problem covers a range of essential C++ concepts, including:

  1. Threading
  2. Mutexes
  3. Condition variables
  4. Atomic variables
  5. Lambdas
  6. RAII (Resource Acquisition Is Initialization)
  7. Standard Template Library (STL) containers

C++ Functions Utilized in the Program

The program leverages various C++ functions and constructs to solve the Producer-Consumer problem:

  1. std::queue
  2. C++ 11 – Multithreading
  3. std::condition_variable
  4. std::atomic
  5. std::thread
  6. std::unique_lock
  7. std::this_thread::sleep_for
  8. std::thread::join

Code Explanation

The program is below. 

#include <iostream>
#include <queue>
#include <mutex>
#include <thread>
#include <condition_variable>
#include <atomic>
#include <chrono>

constexpr int MAX_BUFFER_SIZE = 10;
constexpr int NUM_PRODUCERS = 2;
constexpr int NUM_CONSUMERS = 2;
constexpr int NUM_ITERATIONS = 10;

std::queue<int> buffer;
std::mutex buffer_mutex;
std::condition_variable buffer_cv;
std::atomic<bool> done{false};

void producer(int id) {
    for (int i = 0; i < NUM_ITERATIONS; ++i) {
        std::unique_lock<std::mutex> lock(buffer_mutex);

        buffer_cv.wait(lock, [] { return buffer.size() < MAX_BUFFER_SIZE; });

        int value = id * NUM_ITERATIONS + i;
        std::cout << "Producer " << id << " produced: " << value << std::endl;



void consumer(int id) {
    while (!done.load() || !buffer.empty()) {
        std::unique_lock<std::mutex> lock(buffer_mutex);

        buffer_cv.wait(lock, [] { return !buffer.empty() || done.load(); });

        if (!buffer.empty()) {
            int value = buffer.front();
            std::cout << "Consumer " << id << " consumed: " << value << std::endl;



int main() {
    std::thread producers[NUM_PRODUCERS];
    std::thread consumers[NUM_CONSUMERS];

    for (int i = 0; i < NUM_PRODUCERS; ++i) {
        producers[i] = std::thread(producer, i);

    for (int i = 0; i < NUM_CONSUMERS; ++i) {
        consumers[i] = std::thread(consumer, i);

    for (auto &producer_thread : producers) {


    for (auto &consumer_thread : consumers) {

    return 0;

The compilation and execution output is below.

$ g++ -o multi_threaded_consumer_producer multi_threaded_consumer_producer.cpp

$ ./multi_threaded_consumer_producer 
Producer 1 produced: 10
Consumer 1 consumed: 10
Producer 0 produced: 0
Consumer 0 consumed: 0
Producer 1 produced: 11
Consumer 1 consumed: 11
Producer 0 produced: 1
Consumer 0 consumed: 1
Producer 1 produced: 12
Consumer 1 consumed: 12
Producer 0 produced: 2
Consumer 0 consumed: 2
Producer 1 produced: 13
Consumer 1 consumed: 13
Producer 0 produced: 3
Consumer 0 consumed: 3
Producer 1 produced: 14
Consumer 1 consumed: 14
Producer 0 produced: 4
Consumer 0 consumed: 4
Producer 1 produced: 15
Consumer 1 consumed: 15
Producer 0 produced: 5
Consumer 0 consumed: 5
Producer 1 produced: 16
Consumer 1 consumed: 16
Producer 0 produced: 6
Consumer 0 consumed: 6
Producer 1 produced: 17
Consumer 1 consumed: 17
Producer 0 produced: 7
Consumer 0 consumed: 7
Producer 1 produced: 18
Consumer 1 consumed: 18
Producer 0 produced: 8
Consumer 0 consumed: 8
Producer 1 produced: 19
Consumer 1 consumed: 19
Producer 0 produced: 9
Consumer 0 consumed: 9

You can download the program at https://github.com/codeversionmaster/cplusplus/blob/cplusplus17/projects/multi_threaded_consumer_producer.cpp.

In the producer function, each producer thread generates data for a fixed number of iterations. The producer first acquires a lock on the buffer using a unique_lock, ensuring mutual exclusion. Then, it waits on a condition variable until space is available in the buffer. The producer pushes the generated data into the buffer, unlocks the mutex, and notifies other waiting threads.

The consumer function is designed as a loop that runs until a “done” flag is set and the buffer is empty. Like the producer, the consumer acquires a lock on the buffer and waits for the condition variable to be signaled. If the buffer is not empty, the consumer retrieves the data, removes it from the buffer, and unlocks the mutex. 

Then, it notifies other waiting threads.

The main function initializes producer and consumer threads, starts them, and waits for them to complete their tasks. Once all producer threads have finished, it sets the “done” flag to true and notifies all waiting threads. Finally, it waits for all consumer threads to join before exiting the program.

Best Practices and Considerations

When working with the Producer-Consumer problem or similar synchronization problems in large projects, keep the following points in mind:

  1. Minimize lock contention: Try to minimize the time a thread holds a lock to reduce the chances of other threads being blocked.
  2. Avoid busy waiting: Utilize condition variables to put threads to sleep when they cannot proceed instead of constantly checking shared data.
  3. Use atomic variables: Atomic variables allow you to perform lock-free operations on shared data, increasing performance in some cases.
  4. Properly handle exceptions: Ensure that locks are released, and resources are properly managed in case of an exception.
  5. Optimize buffer size: Choose an appropriate buffer size that balances memory usage and concurrency.
  6. Prioritize scalability: Design your program to scale well with an increasing number of threads and data.
  7. Test and profile: Regularly test and profile your code to identify bottlenecks and synchronization issues.


The Producer-Consumer problem is a fundamental synchronization problem that arises in many real-world applications. Understanding this solution’s C++ concepts and functions will help you tackle similar issues in your projects. Remember to follow best practices and be mindful of the trade-offs and challenges of multi-threading and synchronization to ensure your code is efficient, scalable, and reliable.