生产者-消费者问题用C++编写代码

生产者-消费者问题是经典的同步问题，它的场景通常是一个有界缓冲区，生产者往缓冲区生产数据，消费者从缓冲区取数据消费。如果缓冲区已满，生产者需要等待；如果缓冲区已空，消费者需要等待。下面是用C++编写的生产者-消费者问题代码：

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

const int BufferSize = 10;
std::queue<int> buffer;
std::mutex mu;
std::condition_variable cond_prod;
std::condition_variable cond_cons;

void producer(int id)
{
    for (int i = 0; i < 20; i++)
    {
        std::unique_lock<std::mutex> lock(mu);
        while (buffer.size() >= BufferSize)
        {
            cond_prod.wait(lock);
        }
        buffer.push(i);
        std::cout << "Producer " << id << " produced: " << i << std::endl;
        lock.unlock();
        cond_cons.notify_one();
    }
}

void consumer(int id)
{
    for (int i = 0; i < 20; i++)
    {
        std::unique_lock<std::mutex> lock(mu);
        while (buffer.empty())
        {
            cond_cons.wait(lock);
        }
        int value = buffer.front();
        buffer.pop();
        std::cout << "Consumer " << id << " consumed: " << value << std::endl;
        lock.unlock();
        cond_prod.notify_one();
    }
}

int main()
{
    std::thread t1(producer, 1);
    std::thread t2(consumer, 1);
    std::thread t3(producer, 2);
    std::thread t4(consumer, 2);

    t1.join();
    t2.join();
    t3.join();
    t4.join();

    return 0;
}

以上代码中，我们定义了一个有界缓冲区，大小为10，使用std::queue来实现。我们还定义了一个std::mutex锁来保护缓冲区的访问，并定义了两个std::condition_variable条件变量来实现生产者和消费者之间的同步。

在producer函数中，我们首先获取锁，然后判断缓冲区是否已满，如果已满则等待。当缓冲区有空闲位置时，我们将数据加入缓冲区，并通知消费者线程。最后释放锁。

在consumer函数中，我们也首先获取锁，然后判断缓冲区是否为空，如果为空则等待。当缓冲区有数据时，我们取出数据并从缓冲区中删除，并通知生产者线程。最后释放锁。

在main函数中，我们创建了两个生产者线程和两个消费者线程，并分别启动它们。最后等待所有线程执行完毕。