操作系统生产者与消费者代码实现C++

在操作系统中，生产者-消费者问题是一个经典的多线程同步问题。它描述了共享缓冲区的生产者（Producer）生成数据放入缓冲区，消费者（Consumer）从缓冲区取出数据进行消费的场景。在这个问题中，需要确保生产者不会在缓冲区满时放入数据，消费者也不会在缓冲区空时尝试取出数据。

以下是使用C++实现的一个简单的生产者与消费者问题的代码示例。这里使用了条件变量和互斥锁来实现线程间的同步。

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

class ProducerConsumerQueue {
public:
    void produce(int value) {
        std::unique_lock<std::mutex> lock(mutex_);
        cond_not_full_.wait(lock, [this] { return !queue_.size() == max_size_; });
        queue_.push(value);
        std::cout << "Produced: " << value << std::endl;
        cond_not_empty_.notify_one();
    }

    int consume() {
        std::unique_lock<std::mutex> lock(mutex_);
        cond_not_empty_.wait(lock, [this] { return !queue_.empty(); });
        int value = queue_.front();
        queue_.pop();
        std::cout << "Consumed: " << value << std::endl;
        cond_not_full_.notify_one();
        return value;
    }

private:
    std::queue<int> queue_;
    const int max_size_ = 10;
    std::mutex mutex_;
    std::condition_variable cond_not_empty_;
    std::condition_variable cond_not_full_;
};

ProducerConsumerQueue q;

void producer() {
    int count = 0;
    while (true) {
        q.produce(count++);
        std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟耗时的生产操作
    }
}

void consumer() {
    while (true) {
        q.consume();
        std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟耗时的消费操作
    }
}

int main() {
    std::thread prod_thread(producer);
    std::thread cons_thread(consumer);

    prod_thread.join();
    cons_thread.join();

    return 0;
}

在这个例子中，我们定义了一个`ProducerConsumerQueue`类来管理生产和消费。该类中有一个队列和两个条件变量`cond_not_empty_`和`cond_not_full_`分别用于通知等待的消费者和生产者。`produce`方法在队列未满时生产数据，`consume`方法在队列非空时消费数据。`main`函数中创建了生产者和消费者的线程。