队列生产消费模型 c语言

队列生产消费模型是一种多线程编程模型，用于实现生产者-消费者模式。在该模型中，有两个线程：一个线程是生产者，另一个线程是消费者。生产者向队列中添加元素，而消费者从队列中移除元素。队列是一个共享资源，因此需要使用互斥锁和条件变量来保证线程安全。

以下是使用C语言实现队列生产消费模型的示例代码：

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

#define MAX_QUEUE_SIZE 10
#define NUM_PRODUCERS 2
#define NUM_CONSUMERS 2

int queue[MAX_QUEUE_SIZE];
pthread_mutex_t mutex;
pthread_cond_t cond_var;

int queue_size = 0;
int consumer_index = 0;
int producer_index = 0;

void *producer(void *arg)
{
    int item;

    while (1) {
        item = rand() % 100;

        pthread_mutex_lock(&mutex);

        while (queue_size == MAX_QUEUE_SIZE) {
            pthread_cond_wait(&cond_var, &mutex);
        }

        queue[producer_index] = item;
        producer_index = (producer_index + 1) % MAX_QUEUE_SIZE;
        queue_size++;

        printf("Producer %d produced item %d\n", *((int *)arg), item);

        pthread_cond_broadcast(&cond_var);
        pthread_mutex_unlock(&mutex);
    }

    return NULL;
}

void *consumer(void *arg)
{
    int item;

    while (1) {
        pthread_mutex_lock(&mutex);

        while (queue_size == 0) {
            pthread_cond_wait(&cond_var, &mutex);
        }

        item = queue[consumer_index];
        consumer_index = (consumer_index + 1) % MAX_QUEUE_SIZE;
        queue_size--;

        printf("Consumer %d consumed item %d\n", *((int *)arg), item);

        pthread_cond_broadcast(&cond_var);
        pthread_mutex_unlock(&mutex);
    }

    return NULL;
}

int main()
{
    pthread_t producers[NUM_PRODUCERS];
    pthread_t consumers[NUM_CONSUMERS];

    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond_var, NULL);

    int i, producer_ids[NUM_PRODUCERS], consumer_ids[NUM_CONSUMERS];

    for (i = 0; i < NUM_PRODUCERS; i++) {
        producer_ids[i] = i;
        pthread_create(&producers[i], NULL, producer, (void *)&producer_ids[i]);
    }

    for (i = 0; i < NUM_CONSUMERS; i++) {
        consumer_ids[i] = i;
        pthread_create(&consumers[i], NULL, consumer, (void *)&consumer_ids[i]);
    }

    for (i = 0; i < NUM_PRODUCERS; i++) {
        pthread_join(producers[i], NULL);
    }

    for (i = 0; i < NUM_CONSUMERS; i++) {
        pthread_join(consumers[i], NULL);
    }

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond_var);

    return 0;
}

在上面的代码中，生产者线程调用`producer()`函数，消费者线程调用`consumer()`函数。`producer()`函数随机生成一个整数，并将其添加到队列中。如果队列已满，则等待条件变量`cond_var`。`consumer()`函数从队列中移除一个元素。如果队列为空，则等待条件变量`cond_var`。

在`main()`函数中，创建多个生产者和消费者线程，然后等待它们完成。在生产者和消费者线程之间共享的队列上使用互斥锁和条件变量来保证线程安全。