进程同步与互斥生产者消费者c语言代码

以下是一个使用信号量实现进程同步与互斥的生产者消费者问题的C语言代码：

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

#define BUFFER_SIZE 10
#define NUM_PRODUCERS 2
#define NUM_CONSUMERS 2

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

sem_t empty, full, mutex;

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

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

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

        buffer[in] = item;
        printf("Producer %d produced item %d\n", id, item);
        in = (in + 1) % BUFFER_SIZE;

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

        sleep(rand() % 3);
    }

    return NULL;
}

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

    while (1) {
        sem_wait(&full);
        sem_wait(&mutex);

        int item = buffer[out];
        printf("Consumer %d consumed item %d\n", id, item);
        out = (out + 1) % BUFFER_SIZE;

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

        sleep(rand() % 3);
    }

    return NULL;
}

int main() {
    srand(time(NULL));

    sem_init(&empty, 0, BUFFER_SIZE);
    sem_init(&full, 0, 0);
    sem_init(&mutex, 0, 1);

    pthread_t producers[NUM_PRODUCERS], consumers[NUM_CONSUMERS];
    int producer_ids[NUM_PRODUCERS], consumer_ids[NUM_CONSUMERS];

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

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

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

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

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

    return 0;
}

在这个代码中，我们使用了三个信号量来实现进程同步与互斥。其中：

- `empty` 用来表示缓冲区中空闲的位置数目。
- `full` 用来表示缓冲区中已有的数据项数目。
- `mutex` 用来实现互斥访问缓冲区。

生产者进程在每次生产完一项数据后，都会将 `empty` 减 1，表示缓冲区中空闲的位置数目减少了一个；然后获取 `mutex` 的锁，将数据存放在缓冲区中，更新 `in` 的值，并释放 `mutex` 的锁；最后将 `full` 加 1，表示缓冲区中已有的数据项数目增加了一个。

消费者进程在每次消费一项数据后，都会将 `full` 减 1，表示缓冲区中已有的数据项数目减少了一个；然后获取 `mutex` 的锁，从缓冲区中取出数据，更新 `out` 的值，并释放 `mutex` 的锁；最后将 `empty` 加 1，表示缓冲区中空闲的位置数目增加了一个。

这样，生产者进程和消费者进程之间就实现了进程同步与互斥。其中，`empty` 和 `full` 信号量用来实现进程同步，保证生产者进程只在缓冲区中有空闲位置时才生产数据，而消费者进程只在缓冲区中有数据项时才消费数据；`mutex` 信号量用来实现互斥，保证在任意时刻只有一个进程能够访问缓冲区。