进程同步与互斥生产者消费者问题，C++代码实现

进程同步和互斥是在多线程编程中处理并发访问共享资源的关键技术。"生产者-消费者"问题是一个经典的示例，描述了一个生产者负责生成产品放入缓冲区，消费者负责从缓冲区取出并消费产品。

在C++中，我们可以使用`std::mutex`（互斥锁）和`std::condition_variable`（条件变量）来实现这个问题。下面是一个简单的代码框架：

#include <thread>
#include <vector>
#include <mutex>
#include <condition_variable>

// 生产者函数
void producer(std::vector<int>& buffer, std::mutex& mtx, std::condition_variable& cv, int num_items) {
    for (int i = 0; i < num_items; ++i) {
        std::unique_lock<std::mutex> lock(mtx);
        // 生产物品并等待缓冲区满
        while (buffer.size() == MAX_CAPACITY) {
            cv.wait(lock); // 当缓冲区满，唤醒等待的消费者
        }
        buffer.push_back(i);
        lock.unlock();
        cv.notify_one(); // 唤醒一个等待的消费者
    }
}

// 消费者函数
void consumer(std::vector<int>& buffer, std::mutex& mtx, std::condition_variable& cv) {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        // 等待缓冲区有新元素
        cv.wait(lock, [] { return !buffer.empty(); });
        if (buffer.empty()) {
            break; // 如果缓冲区空了，消费者退出
        }
        int item = buffer.front();
        buffer.pop_front();
        lock.unlock();
        cv.notify_one(); // 唤醒一个等待的生产者
        // 消耗物品...
    }
}

int main() {
    const int MAX_CAPACITY = 5;
    std::vector<int> buffer(MAX_CAPACITY);
    std::mutex mtx;
    std::condition_variable cv;

    std::thread producer_thread(producer, std::ref(buffer), std::ref(mtx), std::ref(cv), 10);
    std::thread consumer_thread(consumer, std::ref(buffer), std::ref(mtx), std::ref(cv));

    producer_thread.join();
    consumer_thread.join();

    return 0;
}