多个生产者消费者问题c++

多个生产者消费者问题可以使用多线程和同步机制来实现。

下面是一个使用C++11中的线程库和互斥锁（mutex）和条件变量（condition_variable）来解决多个生产者消费者问题的示例代码：

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

using namespace std;

// 生产者消费者问题中的缓冲区
queue<int> buffer;

// 互斥锁和条件变量
mutex mtx;
condition_variable cv;

// 生产者线程函数
void producer(int id) {
    for (int i = 0; i < 10; ++i) {
        // 生产一个任务
        int task = i + id * 10;

        {
            // 加锁
            unique_lock<mutex> lock(mtx);

            // 如果缓冲区已满，等待
            while (buffer.size() == 10) {
                cv.wait(lock);
            }

            // 将任务放入缓冲区
            buffer.push(task);
            cout << "Producer " << id << " produces task " << task << endl;

            // 通知等待的消费者线程
            cv.notify_all();
        }
    }
}

// 消费者线程函数
void consumer(int id) {
    while (true) {
        {
            // 加锁
            unique_lock<mutex> lock(mtx);

            // 如果缓冲区为空，等待
            while (buffer.empty()) {
                cv.wait(lock);
            }

            // 从缓冲区取出一个任务
            int task = buffer.front();
            buffer.pop();
            cout << "Consumer " << id << " consumes task " << task << endl;

            // 通知等待的生产者线程
            cv.notify_all();
        }

        // 模拟消费任务的过程
        this_thread::sleep_for(chrono::milliseconds(100));
    }
}

int main() {
    // 创建两个生产者线程和三个消费者线程
    vector<thread> producers, consumers;
    for (int i = 0; i < 2; ++i) {
        producers.emplace_back(producer, i);
    }
    for (int i = 0; i < 3; ++i) {
        consumers.emplace_back(consumer, i);
    }

    // 等待所有线程结束
    for (auto& t : producers) {
        t.join();
    }
    for (auto& t : consumers) {
        t.join();
    }

    return 0;
}

在上面的示例代码中，生产者线程每次生产一个任务并将其放入缓冲区，消费者线程每次从缓冲区取出一个任务并消费。如果缓冲区已满，生产者线程会等待，直到缓冲区有空闲位置；如果缓冲区为空，消费者线程会等待，直到缓冲区有任务。在等待时，线程会释放互斥锁，直到条件变量通知它继续执行。同时，生产者线程在将任务放入缓冲区后会通知等待的消费者线程，消费者线程在消费任务后会通知等待的生产者线程。这样就可以保证生产者和消费者的同步和互斥。