生产者消费者问题c++

生产者-消费者问题是一个经典的同步问题，其中有一组生产者进程将数据放入缓冲区，一组消费者进程从缓冲区中取出数据。缓冲区是一个有限的共享数据结构。如果缓冲区已满，则生产者必须等待，直到缓冲区中有空间可用。如果缓冲区为空，则消费者必须等待，直到缓冲区中有数据可用。

下面是一个使用 C++ 的实现：

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

std::mutex mu;
std::condition_variable cv;
std::queue<int> buffer;
const int maxSize = 10;

void producer(int id) {
    for (int i = 0; i < 20; ++i) {
        std::unique_lock<std::mutex> locker(mu);
        cv.wait(locker, [] { return buffer.size() < maxSize; });
        buffer.push(i);
        std::cout << "Producer " << id << " produced " << i << std::endl;
        locker.unlock();
        cv.notify_all();
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

void consumer(int id) {
    for (int i = 0; i < 20; ++i) {
        std::unique_lock<std::mutex> locker(mu);
        cv.wait(locker, [] { return !buffer.empty(); });
        int val = buffer.front();
        buffer.pop();
        std::cout << "Consumer " << id << " consumed " << val << std::endl;
        locker.unlock();
        cv.notify_all();
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

int main() {
    std::thread producer1(producer, 1);
    std::thread producer2(producer, 2);
    std::thread consumer1(consumer, 1);
    std::thread consumer2(consumer, 2);
    producer1.join();
    producer2.join();
    consumer1.join();
    consumer2.join();
    return 0;
}

在这个实现中，我们使用了条件变量来实现线程的等待和唤醒。当缓冲区已满时，生产者线程会等待，直到消费者线程取走了一些数据时，才会继续生产。当缓冲区为空时，消费者线程会等待，直到生产者线程放入了一些数据时，才会继续消费。同时，我们使用了互斥锁来保护缓冲区的访问，以避免多线程同时访问缓冲区时出现的竞态条件问题。