（1）编程实现生产者-消费者问题的模拟（建议用C语言编写源代码）。 基本要求： （1）生产者消费者对缓冲区进行互斥操作。 （2）缓冲区大小为10，缓冲区满则不允许生产者生产数据，缓冲区空则不允许消费者消费数据。 （3）生产者消费者各循环操作10次。

以下是使用C语言编写的源代码，实现生产者-消费者问题的模拟：

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

#define BUFFER_SIZE 10
#define PRODUCER_TIMES 10
#define CONSUMER_TIMES 10

typedef struct {
    int buffer[BUFFER_SIZE]; // 缓冲区
    int in; // 生产者指针
    int out; // 消费者指针
    sem_t empty; // 空缓冲区信号量
    sem_t full; // 满缓冲区信号量
    pthread_mutex_t mutex; // 互斥锁
} buffer_t;

void *producer(void *arg) {
    buffer_t *buffer = (buffer_t*)arg;
    int i, item;
    for (i = 0; i < PRODUCER_TIMES; i++) {
        item = rand() % 100; // 产生随机数作为生产的数据项
        sem_wait(&buffer->empty); // 等待空缓冲区
        pthread_mutex_lock(&buffer->mutex); // 获取互斥锁
        buffer->buffer[buffer->in] = item; // 将数据项放入缓冲区
        buffer->in = (buffer->in + 1) % BUFFER_SIZE; // 生产者指针后移
        printf("Producer put item %d into buffer.\n", item);
        pthread_mutex_unlock(&buffer->mutex); // 释放互斥锁
        sem_post(&buffer->full); // 发送满缓冲区信号
    }
    return NULL;
}

void *consumer(void *arg) {
    buffer_t *buffer = (buffer_t*)arg;
    int i, item;
    for (i = 0; i < CONSUMER_TIMES; i++) {
        sem_wait(&buffer->full); // 等待满缓冲区
        pthread_mutex_lock(&buffer->mutex); // 获取互斥锁
        item = buffer->buffer[buffer->out]; // 从缓冲区取出数据项
        buffer->out = (buffer->out + 1) % BUFFER_SIZE; // 消费者指针后移
        printf("Consumer get item %d from buffer.\n", item);
        pthread_mutex_unlock(&buffer->mutex); // 释放互斥锁
        sem_post(&buffer->empty); // 发送空缓冲区信号
    }
    return NULL;
}

int main() {
    buffer_t buffer;
    pthread_t producer_tid, consumer_tid;
    int ret;

    // 初始化缓冲区、指针、信号量和互斥锁
    buffer.in = 0;
    buffer.out = 0;
    sem_init(&buffer.empty, 0, BUFFER_SIZE);
    sem_init(&buffer.full, 0, 0);
    pthread_mutex_init(&buffer.mutex, NULL);

    // 创建生产者和消费者线程
    ret = pthread_create(&producer_tid, NULL, producer, &buffer);
    if (ret != 0) {
        perror("pthread_create producer error");
        exit(EXIT_FAILURE);
    }
    ret = pthread_create(&consumer_tid, NULL, consumer, &buffer);
    if (ret != 0) {
        perror("pthread_create consumer error");
        exit(EXIT_FAILURE);
    }

    // 等待线程结束
    ret = pthread_join(producer_tid, NULL);
    if (ret != 0) {
        perror("pthread_join producer error");
        exit(EXIT_FAILURE);
    }
    ret = pthread_join(consumer_tid, NULL);
    if (ret != 0) {
        perror("pthread_join consumer error");
        exit(EXIT_FAILURE);
    }

    // 销毁信号量和互斥锁
    sem_destroy(&buffer.empty);
    sem_destroy(&buffer.full);
    pthread_mutex_destroy(&buffer.mutex);

    return 0;
}

在代码中，我们通过定义结构体 `buffer_t` 来实现生产者-消费者问题中的共享缓冲区，包括 `buffer` 数组表示缓冲区、`in` 和 `out` 表示生产者和消费者指针、`empty` 和 `full` 表示空缓冲区和满缓冲区的信号量以及 `mutex` 表示互斥锁。

我们分别定义了生产者和消费者线程的函数 `producer` 和 `consumer`，它们分别完成了生产者和消费者的操作。在 `producer` 函数中，生产者产生随机数作为数据项，等待空缓冲区信号量，获取互斥锁后将数据项放入缓冲区，生产者指针后移，并向满缓冲区发送信号量。在 `consumer` 函数中，消费者等待满缓冲区信号量，获取互斥锁后从缓冲区取出数据项，消费者指针后移，并向空缓冲区发送信号量。

在 `main` 函数中，我们使用 `pthread_create` 函数创建生产者和消费者线程，使用 `pthread_join` 函数等待线程结束。在程序结束时，我们使用 `sem_destroy` 和 `pthread_mutex_destroy` 函数销毁信号量和互斥锁。