操作系统模拟生产者和消费者问题c++

操作系统模拟生产者和消费者问题是经典的并发控制问题，通常通过队列（Queue）数据结构来解决。在这个场景中，有两个角色：生产者（Producer）和消费者（Consumer）。生产者负责生成产品并放入队列，而消费者则从队列中取出产品进行处理。

在 C++ 中，可以使用互斥量（Mutex）、条件变量（Condition Variable）以及队列（如 `std::queue` 或 `boost::queue`）来实现这个模式：

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

class Queue {
public:
    std::queue<int> data;
    mutable std::mutex mutex; // 保护队列
    std::condition_variable cond; // 等待信号

    void produce(int item) {
        std::unique_lock<std::mutex> lock(mutex);
        data.push(item);
        notify_cond(); // 唤醒等待的消费者
        lock.unlock();
    }

    void consume() {
        std::unique_lock<std::mutex> lock(mutex);
        while (data.empty()) { // 队列为空，等待
            cond.wait(lock); // 当有新数据时唤醒
        }
        int item = data.front();
        data.pop();
        process_item(item); // 消费商品
    }

private:
    void notify_cond() {
        cond.notify_one(); // 唤醒一个等待线程
    }
};

// 示例中假设process_item是一个函数，用于处理消费的商品
void process_item(int item) {
    // ...
}

int main() {
    Queue queue;
    std::thread producer(producer_thread, &queue);
    std::thread consumer(consumer_thread, &queue);

    producer.join();
    consumer.join();

    return 0;
}

// 生产者线程函数
void producer_thread(Queue* q) {
    for (int i = 0; i < 10; ++i) {
        q->produce(i);
        std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟生产时间
    }
}

// 消费者线程函数
void consumer_thread(Queue* q) {
    while (true) {
        q->consume();
        std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟消费时间
    }
}