使用C语言 写出生产者-消费者进程的同步与互斥的代码

好的，下面是使用 C 语言实现生产者-消费者进程同步与互斥的代码：

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

#define BUFFER_SIZE 5 // 缓冲区大小
#define NUM_ITEMS 10 // 生产者和消费者需要处理的总数量

int buffer[BUFFER_SIZE]; // 缓冲区数组
int in = 0; // 生产者插入元素的位置
int out = 0; // 消费者取出元素的位置

pthread_mutex_t mutex; // 互斥锁
pthread_cond_t cond_full; // 条件变量，表示缓冲区已满
pthread_cond_t cond_empty; // 条件变量，表示缓冲区已空

// 生产者线程函数
void *producer(void *arg) {
    int item;

    for (int i = 0; i < NUM_ITEMS; i++) {
        item = rand() % 100; // 随机生成一个元素

        pthread_mutex_lock(&mutex); // 获取互斥锁
        while ((in + 1) % BUFFER_SIZE == out) {
            pthread_cond_wait(&cond_full, &mutex); // 等待条件变量
        }

        buffer[in] = item;
        in = (in + 1) % BUFFER_SIZE;

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

        pthread_cond_signal(&cond_empty); // 发送条件变量信号
        pthread_mutex_unlock(&mutex); // 释放互斥锁
    }

    return NULL;
}

// 消费者线程函数
void *consumer(void *arg) {
    int item;

    for (int i = 0; i < NUM_ITEMS; i++) {
        pthread_mutex_lock(&mutex); // 获取互斥锁
        while (in == out) {
            pthread_cond_wait(&cond_empty, &mutex); // 等待条件变量
        }

        item = buffer[out];
        out = (out + 1) % BUFFER_SIZE;

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

        pthread_cond_signal(&cond_full); // 发送条件变量信号
        pthread_mutex_unlock(&mutex); // 释放互斥锁
    }

    return NULL;
}

int main() {
    pthread_t producer_thread, consumer_thread;

    // 初始化互斥锁和条件变量
    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond_full, NULL);
    pthread_cond_init(&cond_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(&cond_full);
    pthread_cond_destroy(&cond_empty);

    return 0;
}

上面的代码中，我们使用 pthread 库中的线程函数来实现生产者-消费者进程的同步与互斥。我们定义了一个缓冲区数组 `buffer`，以及两个变量 `in` 和 `out` 分别表示生产者插入元素的位置和消费者取出元素的位置。

我们使用 `pthread_mutex_t` 类型的变量 `mutex` 来实现互斥锁，使用 `pthread_cond_t` 类型的变量 `cond_full` 和 `cond_empty` 分别表示缓冲区已满和已空的条件变量。

在生产者线程函数中，我们随机生成一个元素，并使用 `pthread_mutex_lock` 函数获取互斥锁。如果缓冲区已满，我们使用 `pthread_cond_wait` 函数等待条件变量 `cond_full`，直到缓冲区不再满。然后我们将元素插入缓冲区，释放互斥锁，并使用 `pthread_cond_signal` 函数发送条件变量信号 `cond_empty`。

在消费者线程函数中，我们使用 `pthread_mutex_lock` 函数获取互斥锁。如果缓冲区已空，我们使用 `pthread_cond_wait` 函数等待条件变量 `cond_empty`，直到缓冲区不再空。然后我们从缓冲区取出一个元素，释放互斥锁，并使用 `pthread_cond_signal` 函数发送条件变量信号 `cond_full`。

在 `main` 函数中，我们初始化互斥锁和条件变量，并创建生产者和消费者线程。然后我们使用 `pthread_join` 函数等待线程结束，并在程序结束时销毁互斥锁和条件变量。