生产者消费者问题临界区代码是哪儿C++

生产者消费者问题的典型解决方案涉及使用互斥量（mutex）、条件变量（condition_variable）以及读写锁（std::shared_mutex 或 std::atomic）。以下是C++的一个简单示例，展示了一个基于互斥量和条件变量的基本临界区（critical section）代码，用于保护生产者和消费者共同访问的缓冲区：

#include <mutex>
#include <queue>
#include <thread>
#include <condition_variable>

// 定义生产者消费者结构体
struct Item {
    int value;
};

// 互斥量和条件变量
std::mutex mtx; // 互斥锁
std::condition_variable cv_prod; // 用于唤醒生产者
std::condition_variable cv_cons; // 用于唤醒消费者
std::queue<Item> buffer; // 共享缓冲区

void producer(int id) {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        // 生产者检查缓冲区是否已满
        while (buffer.size() == MAX_SIZE) {
            cv_prod.wait(lock); // 阻塞直到有空位
        }
        
        // 生产并添加到缓冲区
        Item item;
        item.value = id++;
        buffer.push(item);
        std::cout << "Producer " << id << " produced item: " << item.value << std::endl;

        // 解锁并通知消费者
        lock.unlock();
        cv_cons.notify_one(); // 唤醒一个消费者
    }
}

void consumer(int id) {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        // 消费者检查缓冲区是否为空
        while (buffer.empty()) {
            cv_cons.wait(lock); // 等待直到有新的物品
        }

        // 从缓冲区取走并消费
        Item item = buffer.front();
        buffer.pop();
        std::cout << "Consumer " << id << " consumed item: " << item.value << std::endl;

        // 解锁并通知生产者
        lock.unlock();
        cv_prod.notify_one(); // 唤醒一个生产者
    }
}

int main() {
    const int num_producers = 2, num_consumers = 5;
    std::vector<std::thread> producers(num_producers), consumers(num_consumers);

    for (int i = 0; i < num_producers; ++i)
        producers[i] = std::thread(producer, i + 1);
    
    for (int i = 0; i < num_consumers; ++i)
        consumers[i] = std::thread(consumer, i + 1);

    for (auto& t : producers)
        t.join();

    for (auto& t : consumers)
        t.join();

    return 0;
}

这个例子中，`cv_prod.wait(lock)` 和 `cv_cons.wait(lock)` 用于线程间的协作，当某个条件满足时，它们会解除当前线程的睡眠，并继续执行。请注意，这只是一个基础版本，实际应用中可能需要更复杂的错误处理和线程管理。