C语言实现时间片轮转和生产者消费者问题的简易代码，并注释

下面是一个简单的时间片轮转和生产者消费者问题的C语言代码实现，注释在代码中：

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

#define BUFFER_SIZE 10  // 缓冲区大小
#define PRODUCER_NUM 2  // 生产者数量
#define CONSUMER_NUM 2  // 消费者数量
#define ITEM_NUM 20     // 生产者生产的总数

int buffer[BUFFER_SIZE];   // 缓冲区
int in = 0, out = 0;       // 缓冲区的读写指针
int item_counter = 0;      // 生产者已经生产的数量

sem_t empty, full, mutex;  // 信号量

void* producer(void* arg) {
    int p_id = *(int*)arg;
    while (item_counter < ITEM_NUM) {
        sleep(1);
        sem_wait(&empty);   // 请求一个空槽位
        sem_wait(&mutex);   // 互斥访问缓冲区
        buffer[in] = p_id * ITEM_NUM + item_counter;  // 生产者生产
        in = (in + 1) % BUFFER_SIZE;
        item_counter++;
        printf("Producer %d produced item %d\n", p_id, buffer[in-1]);
        sem_post(&mutex);   // 释放互斥锁
        sem_post(&full);    // 增加一个产品
    }
    pthread_exit(NULL);
}

void* consumer(void* arg) {
    int c_id = *(int*)arg;
    while (1) {
        sleep(2);
        sem_wait(&full);    // 请求一个产品
        sem_wait(&mutex);   // 互斥访问缓冲区
        int item = buffer[out];  // 消费者消费
        out = (out + 1) % BUFFER_SIZE;
        printf("Consumer %d consumed item %d\n", c_id, item);
        sem_post(&mutex);   // 释放互斥锁
        sem_post(&empty);   // 增加一个空槽位
    }
    pthread_exit(NULL);
}

int main() {
    pthread_t producers[PRODUCER_NUM], consumers[CONSUMER_NUM];
    sem_init(&empty, 0, BUFFER_SIZE);  // 初始化信号量：空槽位数量为缓冲区大小
    sem_init(&full, 0, 0);            // 初始化信号量：产品数量为0
    sem_init(&mutex, 0, 1);           // 初始化信号量：互斥锁
    int p_id[PRODUCER_NUM], c_id[CONSUMER_NUM];
    for (int i = 0; i < PRODUCER_NUM; i++) {
        p_id[i] = i;
        pthread_create(&producers[i], NULL, producer, &p_id[i]);
    }
    for (int i = 0; i < CONSUMER_NUM; i++) {
        c_id[i] = i;
        pthread_create(&consumers[i], NULL, consumer, &c_id[i]);
    }
    for (int i = 0; i < PRODUCER_NUM; i++) {
        pthread_join(producers[i], NULL);
    }
    for (int i = 0; i < CONSUMER_NUM; i++) {
        pthread_join(consumers[i], NULL);
    }
    sem_destroy(&empty);
    sem_destroy(&full);
    sem_destroy(&mutex);
    return 0;
}

上述代码实现了一个生产者-消费者模型，其中生产者和消费者通过缓冲区进行交互。生产者每次生产一个数字，消费者每次消费一个数字。当缓冲区已满时，生产者会等待直到有空槽位。当缓冲区为空时，消费者会等待直到有产品。为了防止多个线程同时访问缓冲区，我们使用互斥锁来保护缓冲区的访问。同时，我们使用信号量来控制缓冲区的状态。`empty`表示空槽位的数量，`full`表示产品的数量，`mutex`表示互斥锁。