操作系统生产者——消费者问题算法代码

生产者-消费者问题是一个经典的同步问题，涉及到两个或多个进程之间的协作。以下是基于信号量实现的生产者-消费者问题的算法代码：

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

#define BUFFER_SIZE 10

int buffer[BUFFER_SIZE];
int nextIn = 0, nextOut = 0;
sem_t full, empty, mutex;

void *producer(void *arg) {
    int item;
    while (1) {
        item = rand() % 100;
        sem_wait(&empty);
        sem_wait(&mutex);
        buffer[nextIn] = item;
        nextIn = (nextIn + 1) % BUFFER_SIZE;
        printf("Producer produced item %d\n", item);
        sem_post(&mutex);
        sem_post(&full);
    }
    pthread_exit(NULL);
}

void *consumer(void *arg) {
    int item;
    while (1) {
        sem_wait(&full);
        sem_wait(&mutex);
        item = buffer[nextOut];
        nextOut = (nextOut + 1) % BUFFER_SIZE;
        printf("Consumer consumed item %d\n", item);
        sem_post(&mutex);
        sem_post(&empty);
    }
    pthread_exit(NULL);
}

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

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

    pthread_create(&producer_thread, NULL, producer, NULL);
    pthread_create(&consumer_thread, NULL, consumer, NULL);

    pthread_join(producer_thread, NULL);
    pthread_join(consumer_thread, NULL);

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

    return 0;
}

在这个代码中，我们使用了三个信号量：`full`、`empty` 和 `mutex`。`full` 信号量表示缓冲区中已经有的数据项的数量，`empty` 信号量表示缓冲区中还可以存放的数据项的数量，`mutex` 信号量用于实现互斥访问缓冲区。

在生产者线程中，我们生成一个随机的数据项，然后在获取到 `empty` 和 `mutex` 信号量之后，将该数据项放入缓冲区中，并更新下一个数据项的位置。最后释放 `mutex` 和 `full` 信号量。

在消费者线程中，我们首先获取 `full` 和 `mutex` 信号量，然后从缓冲区中取出一个数据项，并更新下一个数据项的位置。最后释放 `mutex` 和 `empty` 信号量。

在 `main` 函数中，我们初始化三个信号量，创建一个生产者线程和一个消费者线程。在两个线程结束后，我们释放这三个信号量。

以上就是基于信号量实现的生产者-消费者问题的算法代码。