生产者消费者模型c++11

生产者消费者模型是一种并发编程模型，用于解决生产者和消费者之间的数据交换问题。在这个模型中，生产者负责生产数据，消费者负责消费数据。

模型的实现通常涉及到共享资源（如队列）和同步机制（如锁、条件变量）。生产者和消费者通过共享的队列进行通信。当队列为空时，消费者将等待，直到有数据可供消费。当队列满时，生产者将等待，直到有空间可供生产。

在你提供的引用中，生产者线程和消费者线程使用了互斥锁和条件变量来实现同步。当消费者线程获取锁后，如果队列为空，则会进入等待状态，并释放锁。此时生产者线程可以获取锁，并判断队列是否为空，如果为空，则进入等待状态并释放锁。当生产者线程生产了产品后，会通过条件变量通知消费者线程可以消费了。消费者线程收到通知后，需要获取锁才能进行消费。

总结一下生产者消费者模型的步骤：
1. 定义共享队列作为生产者和消费者之间的数据交换通道。
2. 定义互斥锁，确保同时只有一个线程能够访问共享资源（即队列）。
3. 定义条件变量，用于线程间的通信。
4. 生产者线程获取互斥锁，判断队列是否已满，如果满则等待，否则生产数据并将其放入队列。
5. 如果消费者线程获取互斥锁，判断队列是否为空，如果为空则等待，否则消费数据并从队列中移除。
6. 在适当的时候，使用条件变量通知等待中的线程继续执行。

相关问题

写一个 c++ 生产者消费者模型

以下是一个简单的 C 生产者消费者模型：

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#define BUFFER_SIZE 10

int buffer[BUFFER_SIZE]; // 缓冲区数组
int count = 0; // 缓冲区计数器

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; // 互斥锁
pthread_cond_t  cond  = PTHREAD_COND_INITIALIZER;  // 条件变量

void *producer(void *arg)
{
    int i;
    for (i = 0; i < BUFFER_SIZE; i++) {
        pthread_mutex_lock(&mutex);
        while (count == BUFFER_SIZE) { // 缓冲区满了
            pthread_cond_wait(&cond, &mutex); // 等待消费者消费
        }
        buffer[count++] = i; // 生产物品并放入缓冲区
        printf("producer produced %d\n", i);
        pthread_cond_signal(&cond); // 通知消费者可以消费了
        pthread_mutex_unlock(&mutex);
    }
    pthread_exit(NULL);
}

void *consumer(void *arg)
{
    int i;
    for (i = 0; i < BUFFER_SIZE; i++) {
        pthread_mutex_lock(&mutex);
        while (count == 0) { // 缓冲区空了
            pthread_cond_wait(&cond, &mutex); // 等待生产者生产
        }
        int item = buffer[--count]; // 从缓冲区取出物品并消费
        printf("consumer consumed %d\n", item);
        pthread_cond_signal(&cond); // 通知生产者可以生产了
        pthread_mutex_unlock(&mutex);
    }
    pthread_exit(NULL);
}

int main()
{
    pthread_t producer_thread, consumer_thread;

    // 创建生产者和消费者线程
    pthread_create(&producer_thread, NULL, producer, NULL);
    pthread_create(&consumer_thread, NULL, consumer, NULL);

    // 等待线程结束
    pthread_join(producer_thread, NULL);
    pthread_join(consumer_thread, NULL);

    return 0;
}

在上面的代码中，生产者线程和消费者线程共享一个缓冲区数组和一个计数器。生产者向缓冲区中添加物品，并将计数器加一；消费者从缓冲区中取出物品，并将计数器减一。如果缓冲区已满，生产者就会等待消费者消费；如果缓冲区已空，消费者就会等待生产者生产。在等待过程中，线程会释放互斥锁，以允许其他线程访问缓冲区。当条件变量发生变化时，线程会重新获取互斥锁并继续执行。

c++写一个生产者消费者模型

下面是一个基于 C++11 的生产者消费者模型的实现：

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

const int kBufferSize = 10;
std::queue<int> buffer;
std::mutex buffer_mutex;
std::condition_variable buffer_not_empty;
std::condition_variable buffer_not_full;

void Producer() {
  for (int i = 0; i < 100; ++i) {
    std::unique_lock<std::mutex> lock(buffer_mutex);
    buffer_not_full.wait(lock, []{ return buffer.size() < kBufferSize; });
    buffer.push(i);
    std::cout << "Producer produced " << i << ".\n";
    buffer_not_empty.notify_one();
  }
}

void Consumer() {
  for (int i = 0; i < 100; ++i) {
    std::unique_lock<std::mutex> lock(buffer_mutex);
    buffer_not_empty.wait(lock, []{ return !buffer.empty(); });
    int value = buffer.front();
    buffer.pop();
    std::cout << "Consumer consumed " << value << ".\n";
    buffer_not_full.notify_one();
  }
}

int main() {
  std::thread producer(Producer);
  std::thread consumer(Consumer);
  producer.join();
  consumer.join();
  return 0;
}

这个例子中，生产者不断地往 buffer 中添加数据，当 buffer 已满时就等待消费者取走数据，消费者不断地从 buffer 中取出数据，当 buffer 已空时就等待生产者添加数据。

其中，buffer_mutex 是用来保护 buffer 的互斥锁，buffer_not_empty 和 buffer_not_full 分别是用来通知消费者和生产者的条件变量。当 buffer_not_empty.wait() 被调用时，线程会等待直到 buffer 不为空，buffer_not_full.wait() 同理。notify_one() 则是用来通知等待线程有新的数据或者空间可用。