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 < 20; i++) {  // 总共运行20个时间片
        if (i % 2 == 0) {
            printf("Switch to producer thread\n");
            for (int j = 0; j < PRODUCER_NUM; j++) {
                pthread_kill(producers[j], SIGUSR1);  // 发送信号给生产者线程
            }
        } else {
            printf("Switch to consumer thread\n");
            for (int j = 0; j < CONSUMER_NUM; j++) {
                pthread_kill(consumers[j], SIGUSR1);  // 发送信号给消费者线程
            }
        }
        sleep(1);  // 时间片长度为1秒
    }
    
    for (int i = 0; i < PRODUCER_NUM; i++) {
        pthread_kill(producers[i], SIGTERM);  // 终止生产者线程
    }
    for (int i = 0; i < CONSUMER_NUM; i++) {
        pthread_kill(consumers[i], SIGTERM);  // 终止消费者线程
    }
    sem_destroy(&empty);
    sem_destroy(&full);
    sem_destroy(&mutex);
    return 0;
}

void sig_handler(int signo) {
    // 空函数，用于接收信号
}

上述代码实现了一个生产者-消费者模型，同时使用了时间片轮转调度算法来调度生产者和消费者线程。在主线程中，每隔1秒钟就会进行一次调度，总共进行20个时间片。在每个时间片中，如果是偶数时间片就调度生产者线程，如果是奇数时间片就调度消费者线程。为了实现这个调度过程，我们使用了`pthread_kill`函数向生产者和消费者线程发送信号。同时，我们需要在生产者和消费者线程中注册一个信号处理函数，用来接收信号。在本例中，我们使用了SIGUSR1信号来表示调度信号，使用SIGTERM信号来表示线程终止信号。