用C++实现生产者消费者问题

在C++中，生产者消费者问题是一个经典的并发控制问题，通常使用互斥量、条件变量等同步原语来解决。以下是简单的一个基于C++11的线程池实现：

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

std::queue<int> queue_buffer;
std::mutex buffer_mutex; // 互斥量用于保护队列
std::condition_variable not_empty; // 条件变量，当队列非空时唤醒等待者
std::condition_variable not_full; // 当队列不满时唤醒生产者

void producer(int id) {
    for (int i = 0; i < 10; ++i) {
        std::unique_lock<std::mutex> lock(buffer_mutex);
        while (queue_buffer.size() == MAX_QUEUE_SIZE) { // 队满，生产者等待
            not_full.wait(lock);
        }
        queue_buffer.push(i); // 生产元素
        std::cout << "Producer " << id << " produced item " << i << "\n";
        lock.unlock();
        not_empty.notify_one(); // 队列非空，通知消费者
    }
}

void consumer(int id) {
    for (int i = 0; i < 10; ++i) {
        std::unique_lock<std::mutex> lock(buffer_mutex);
        while (queue_buffer.empty()) { // 队空，消费者等待
            not_empty.wait(lock);
        }
        int item = queue_buffer.front(); // 消费元素
        queue_buffer.pop();
        std::cout << "Consumer " << id << " consumed item " << item << "\n";
        lock.unlock();
        not_full.notify_one(); // 队列不满，通知生产者
    }
}

int main() {
    const int num_consumers = 2;
    const int num_producers = 3;
    std::vector<std::thread> threads;

    // 创建并启动生产者线程
    for (int i = 0; i < num_producers; ++i) {
        threads.emplace_back(producer, i);
    }

    // 创建并启动消费者线程
    for (int i = 0; i < num_consumers; ++i) {
        threads.emplace_back(consumer, i);
    }

    // 等待所有线程完成
    for (auto& t : threads) {
        t.join();
    }

    return 0;
}

在这个例子中，`producer`负责生成数据放入队列，而`consumer`从队列中取出数据处理。通过互斥量`buffer_mutex`保证了对队列操作的原子性，条件变量则实现了生产者和消费者的同步。