编写程序， 使用Linux操作系统中的信号量机制模拟 实现生产者-消费者问题。设有一个生产者可以生产 水果并放入缓冲区（最多只能放10个水果） ，有一 个消费者， 不断从缓冲区中取出水果，并吃掉水 果

编写程序， 使用Linux操作系统中的信号量机制模拟 实现生产者-消费者问题。设有一个生产者可以生产 水果并放入缓冲区（最多只能放10个水果） ，有一 个消费者， 不断从缓冲区中取出水果，并吃掉水 果。

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

#define BUFFER_SIZE 10

typedef struct {
    sem_t empty;  //缓冲区为空的信号量
    sem_t full;   //缓冲区为满的信号量
    sem_t mutex;  //互斥信号量，用于保护缓冲区
    int buffer[BUFFER_SIZE]; //缓冲区
    int in;       //生产者的下标
    int out;      //消费者的下标
} buffer_t;

void *producer(void *arg) {
    buffer_t *buffer = (buffer_t *)arg;

    while (1) {
        // 生产水果
        int fruit = rand() % 100;

        // 如果缓冲区已满，等待空闲位置
        sem_wait(&buffer->empty);

        // 保护缓冲区
        sem_wait(&buffer->mutex);

        // 将水果放入缓冲区
        buffer->buffer[buffer->in] = fruit;
        printf("Produced fruit: %d\n", fruit);
        buffer->in = (buffer->in + 1) % BUFFER_SIZE;

        // 释放缓冲区的互斥锁
        sem_post(&buffer->mutex);

        // 发送满缓冲区信号
        sem_post(&buffer->full);
    }
}

void *consumer(void *arg) {
    buffer_t *buffer = (buffer_t *)arg;

    while (1) {
        // 如果缓冲区为空，等待水果生产完成
        sem_wait(&buffer->full);

        // 保护缓冲区
        sem_wait(&buffer->mutex);

        // 取出缓冲区中的水果
        int fruit = buffer->buffer[buffer->out];
        printf("Consumed fruit: %d\n", fruit);
        buffer->out = (buffer->out + 1) % BUFFER_SIZE;

        // 释放缓冲区的互斥锁
        sem_post(&buffer->mutex);

        // 发送缓冲区空信号
        sem_post(&buffer->empty);
    }
}

int main(int argc, char *argv[]) {
    buffer_t buffer;
    pthread_t producer_thread, consumer_thread;

    // 初始化信号量
    sem_init(&buffer.empty, 0, BUFFER_SIZE);
    sem_init(&buffer.full, 0, 0);
    sem_init(&buffer.mutex, 0, 1);

    // 初始化下标
    buffer.in = 0;
    buffer.out = 0;

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

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

    // 销毁信号量
    sem_destroy(&buffer.empty);
    sem_destroy(&buffer.full);
    sem_destroy(&buffer.mutex);

    return 0;
}