c语言简单实现生产者消费者问题【生产者-消费者问题】有3个生产者A、B、C和2个消费者D、E，共享一段容量为2的缓冲区，随机选取A~E进行生产或消费，通过信号量解决进程同步

好的，下面是一个简单的C语言实现生产者消费者问题的代码：

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

#define BUFFER_SIZE 2
#define MAX_PRODUCER 3
#define MAX_CONSUMER 2
#define MAX_ITEMS 20

int buffer[BUFFER_SIZE];
int in = 0, out = 0;
int num_items = 0;

sem_t empty, full;
pthread_mutex_t mutex;

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

    while (num_items < MAX_ITEMS) {
        item = rand() % 100;

        sem_wait(&empty);
        pthread_mutex_lock(&mutex);

        if (num_items < MAX_ITEMS) {
            buffer[in] = item;
            in = (in + 1) % BUFFER_SIZE;
            num_items++;
            printf("Producer %d produced item %d, total %d items in buffer\n", id, item, num_items);
        }

        pthread_mutex_unlock(&mutex);
        sem_post(&full);

        sleep(rand() % 3 + 1);
    }

    pthread_exit(NULL);
}

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

    while (num_items > 0) {
        sem_wait(&full);
        pthread_mutex_lock(&mutex);

        if (num_items > 0) {
            item = buffer[out];
            out = (out + 1) % BUFFER_SIZE;
            num_items--;
            printf("Consumer %d consumed item %d, total %d items in buffer\n", id, item, num_items);
        }

        pthread_mutex_unlock(&mutex);
        sem_post(&empty);

        sleep(rand() % 3 + 1);
    }

    pthread_exit(NULL);
}

int main() {
    pthread_t producer_thread[MAX_PRODUCER], consumer_thread[MAX_CONSUMER];
    int producer_id[MAX_PRODUCER], consumer_id[MAX_CONSUMER];
    int i;

    sem_init(&empty, 0, BUFFER_SIZE);
    sem_init(&full, 0, 0);
    pthread_mutex_init(&mutex, NULL);

    for (i = 0; i < MAX_PRODUCER; i++) {
        producer_id[i] = i + 1;
        pthread_create(&producer_thread[i], NULL, producer, &producer_id[i]);
    }

    for (i = 0; i < MAX_CONSUMER; i++) {
        consumer_id[i] = i + 1;
        pthread_create(&consumer_thread[i], NULL, consumer, &consumer_id[i]);
    }

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

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

    sem_destroy(&empty);
    sem_destroy(&full);
    pthread_mutex_destroy(&mutex);

    return 0;
}

在代码中，我们使用了信号量和互斥锁来实现进程之间的同步。

信号量 `empty` 表示空缓冲区的数量，初始值为 `BUFFER_SIZE`。当生产者向缓冲区中写入一个数据时，要将 `empty` 减一，表示空缓冲区数量减少了一个。当 `empty` 的值为0时，生产者需要等待，直到有消费者使用了一个缓冲区。

信号量 `full` 表示满缓冲区的数量，初始值为0。当消费者从缓冲区中读取一个数据时，要将 `full` 加一，表示满缓冲区数量增加了一个。当 `full` 的值为0时，消费者需要等待，直到有生产者向缓冲区中写入了一个数据。

互斥锁 `mutex` 用于保护共享资源 `num_items`、`in` 和 `out`。每个线程在访问这些共享资源时需要先获取互斥锁，然后在修改完共享资源后释放互斥锁，以防止多个线程同时修改共享资源而导致数据不一致的问题。

在主函数中，我们创建了多个生产者和消费者线程，并且等待它们执行完毕。当所有生产者都生产了 `MAX_ITEMS` 个数据并退出线程后，程序结束。

希望能够帮助到你！