生产者消费者问题c++

这是一个常见的操作系统同步问题，主要涉及资源的竞争和互斥。在多个线程或进程同时访问共享资源时，需要进行同步控制，确保资源在同一时间只能被一个线程或进程访问，从而避免资源竞争的问题。一种经典的解决方案是使用信号量。生产者将生产的数据存入缓冲区，然后发送一个信号，消费者接收到信号后从缓冲区中取出数据进行消费，然后也发送一个信号给生产者，表示缓冲区又可以继续生产数据了。

相关问题

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

多生产者消费者问题是一个经典的并发编程问题，即多个生产者线程同时向一个共享的缓冲区中生产数据，多个消费者线程同时从缓冲区中消费数据。以下是一个使用C++语言实现的多生产者消费者问题的示例代码：

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

using namespace std;

const int BUFFER_SIZE = 10;
queue<int> buffer;
mutex mtx;
condition_variable not_full;
condition_variable not_empty;

void producer(int id) {
    while (true) {
        unique_lock<mutex> lock(mtx);
        while (buffer.size() == BUFFER_SIZE) {
            not_full.wait(lock);
        }
        int item = rand() % 100;
        buffer.push(item);
        cout << "Producer " << id << " produces item " << item << endl;
        not_empty.notify_all();
    }
}

void consumer(int id) {
    while (true) {
        unique_lock<mutex> lock(mtx);
        while (buffer.empty()) {
            not_empty.wait(lock);
        }
        int item = buffer.front();
        buffer.pop();
        cout << "Consumer " << id << " consumes item " << item << endl;
        not_full.notify_all();
    }
}

int main() {
    thread p1(producer, 1);
    thread p2(producer, 2);
    thread c1(consumer, 1);
    thread c2(consumer, 2);
    p1.join();
    p2.join();
    c1.join();
    c2.join();
    return 0;
}

在上面的代码中，我们使用了一个互斥量`mtx`来保证对共享缓冲区的访问是线程安全的。当缓冲区满时，生产者线程会调用`not_full.wait(lock)`等待缓冲区非满；当缓冲区为空时，消费者线程会调用`not_empty.wait(lock)`等待缓冲区非空。当生产者线程向缓冲区中添加数据后，会通过`not_empty.notify_all()`通知所有等待的消费者线程；当消费者线程从缓冲区中取出数据后，会通过`not_full.notify_all()`通知所有等待的生产者线程。

生产者消费者问题c++代码

以下是一个简单的生产者消费者问题的C代码：

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

#define BUFFER_SIZE 10

pthread_mutex_t mutex;
pthread_cond_t buffer_not_full;
pthread_cond_t buffer_not_empty;

int buffer[BUFFER_SIZE];
int counter;

void *producer(void *arg) {
    int item = 0;
    while (1) {
        pthread_mutex_lock(&mutex);
        while (counter == BUFFER_SIZE) {
            pthread_cond_wait(&buffer_not_full, &mutex);
        }
        buffer[counter++] = item;
        printf("Producer produced %d\n", item++);
        pthread_cond_signal(&buffer_not_empty);
        pthread_mutex_unlock(&mutex);
        sleep(1);
    }
}

void *consumer(void *arg) {
    int item;
    while (1) {
        pthread_mutex_lock(&mutex);
        while (counter == 0) {
            pthread_cond_wait(&buffer_not_empty, &mutex);
        }
        item = buffer[--counter];
        printf("Consumer consumed %d\n", item);
        pthread_cond_signal(&buffer_not_full);
        pthread_mutex_unlock(&mutex);
        sleep(1);
    }
}

int main() {
    pthread_t producer_thread, consumer_thread;

    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&buffer_not_full, NULL);
    pthread_cond_init(&buffer_not_empty, NULL);

    pthread_create(&producer_thread, NULL, producer, NULL);
    pthread_create(&consumer_thread, NULL, consumer, NULL);

    pthread_join(producer_thread, NULL);
    pthread_join(consumer_thread, NULL);

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&buffer_not_full);
    pthread_cond_destroy(&buffer_not_empty);

    return 0;
}