The solution to the producer-consumer problem is to use mutex locks and condition variables to achieve thread synchronization. 1. Use std::mutex and std::unique_lock to protect the shared buffer; 2. The producer waits through the condition variable when the buffer is full, and the consumer waits when the buffer is empty and the production has not ended; 3. After the producer generates data, the consumer notifies the producer after the consumer is notified; 4. After all producers complete, set the finished flag and notify the consumer to exit; 5. The consumer terminates the thread when the buffer is empty and the production is finished. This implementation ensures thread safety and correct synchronization, completely solving producer-consumer problems.

In multithreaded programming, the Producer-Consumer Problem is a classic synchronization problem. In C, it can be implemented through std::thread , std::mutex , std::condition_variable and a shared buffer. Here is a simple example using a fixed-size buffer.

? Question description

• Producer thread : Continuously generate data and put it into the buffer.
• Consumer thread : fetches data from the buffer for processing.
• The buffer has a size limit and cannot be stored unlimitedly.
• It is necessary to prevent multiple threads from accessing the buffer (mutex) simultaneously.
• Producers cannot continue to produce when the buffer is full, and consumers cannot continue to consume when the buffer is empty (conditional synchronization).

? C sample code

 #include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>
#include <vector>
#include <chrono>
#include <random>

const int BUFFER_SIZE = 5;
const int TOTAL_ITEMS = 20;

std::queue<int> buffer;
std::mutex mtx;
std::condition_variable cv;

bool finished = false;

// Producer function void producer(int id) {
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(100, 999); // Random number 100~999

    for (int i = 0; i < TOTAL_ITEMS; i) {
        std::this_thread::sleep_for(std::chrono::milliseconds(dis(gen) % 200)); // Simulate production time int item = dis(gen);

        {
            std::unique_lock<std::mutex> lock(mtx);
            cv.wait(lock, []() { return buffer.size() < BUFFER_SIZE; });

            buffer.push(item);
            std::cout << "Producer " << id << " produced: " << item
                      << " (buffer size: " << buffer.size() << ")\n";
        } // Automatically release the lock cv.notify_all(); // Notify consumers who may be blocking}
}

// Consumer function void consumer(int id) {
    while (true) {
        int item;
        {
            std::unique_lock<std::mutex> lock(mtx);

            // Wait: the buffer is not empty, or the production ends cv.wait(lock, []() { return !buffer.empty() || finished; });

            if (buffer.empty() && finished) {
                break; // End consumer}

            item = buffer.front();
            buffer.pop();
            std::cout << "Consumer " << id << " consumed: " << item
                      << " (buffer size: " << buffer.size() << ")\n";
        } // Release the lock cv.notify_all(); // Notify the producer who may be blocking std::this_thread::sleep_for(std::chrono::milliseconds(300)); // Simulate consumption time}
    std::cout << "Consumer " << id << " finished.\n";
}

int main() {
    std::vector<std::thread> producers;
    std::vector<std::thread> consumers;

    // Create 2 producers producers.emplace_back(producer, 1);
    producers.emplace_back(producer, 2);

    // Create 3 consumer consumers.emplace_back(consumer, 1);
    consumers.emplace_back(consumer, 2);
    consumers.emplace_back(consumer, 3);

    // Wait for all producers to complete for (auto& p : producers) {
        p.join();
    }

    // After all producers are finished, set the finished flag {
        std::lock_guard<std::mutex> lock(mtx);
        finished = true;
    }
    cv.notify_all();

    // Wait for all consumers to complete for (auto& c : consumers) {
        c.join();
    }

    std::cout << "All tasks completed.\n";
    return 0;
}

? illustrate

• Buffer : Use std::queue<int> as the shared buffer.
• Mutex mtx : Protect access to buffer .
• Condition variable cv :
  • Producer waits for buffer.size() < BUFFER_SIZE
  • Consumers are waiting !buffer.empty() || finished
• finished logo : Notify consumers that production has ended and avoid unlimited waiting.
• cv.notify_all() : Wake up the waiting thread (although notify_one is sometimes more efficient, all is safer).

? Output example (partial)

 Producer 1 produced: 456 (buffer size: 1)
Consumer 1 consumed: 456 (buffer size: 0)
Producer 2 produced: 789 (buffer size: 1)
Producer 1 produced: 123 (buffer size: 2)
Consumer 2 consumed: 789 (buffer size: 1)
...
Consumer 3 finished.
All tasks completed.

? Key points summary

• Use std::unique_lock with condition_variable::wait() to achieve blocking and waiting.
• Use lambda expressions to avoid false awakening in conditional judgment.
• The finished flag must be set inside the lock to ensure thread safety.
• The consumer exits when it finds finished and the buffer is empty.

Basically that's it. This example shows how to implement a thread-safe producer-consumer model with modern C, suitable for learning multithreaded synchronization mechanisms.

The above is the detailed content of C producer consumer problem example. For more information, please follow other related articles on the PHP Chinese website!