用C语言写出完整的代码，要求如下：用时间片轮转调度算法与进程同步（以生产者消费者问题为例）结合，设计一种时间片轮转调度算法从进程就绪队列（可以假定队列中只有生产者和消费者）中选择一个生产者进程或消费者进程进行相关生产或者消费活动。

以下是一份基于时间片轮转调度算法和进程同步的生产者消费者问题的C语言代码，仅供参考。

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

#define MAX_BUFFER_SIZE 10
#define MAX_PRODUCER_NUM 3
#define MAX_CONSUMER_NUM 3
#define MAX_PRODUCER_TIME 5
#define MAX_CONSUMER_TIME 5
#define TIME_QUANTUM 1

typedef struct PCB {
    int pid;
    int state;
    int priority;
    int time_slice;
    pthread_t thread;
} PCB;

typedef struct Buffer {
    int data[MAX_BUFFER_SIZE];
    int front;
    int rear;
    int count;
} Buffer;

PCB producer[MAX_PRODUCER_NUM];
PCB consumer[MAX_CONSUMER_NUM];
Buffer buffer;
sem_t empty, full, mutex;
int last_pid = -1;

// 初始化缓冲区
void init_buffer() {
    buffer.front = 0;
    buffer.rear = -1;
    buffer.count = 0;
}

// 向缓冲区中插入一个数据项
void insert_item(int item) {
    buffer.rear = (buffer.rear + 1) % MAX_BUFFER_SIZE;
    buffer.data[buffer.rear] = item;
    buffer.count++;
}

// 从缓冲区中取出一个数据项
int remove_item() {
    int item = buffer.data[buffer.front];
    buffer.front = (buffer.front + 1) % MAX_BUFFER_SIZE;
    buffer.count--;
    return item;
}

// 初始化生产者进程
void init_producer(int pid) {
    producer[pid].pid = pid;
    producer[pid].state = 0; // 0代表就绪态
    producer[pid].priority = 1; // 生产者优先级为1
    producer[pid].time_slice = TIME_QUANTUM;
}

// 初始化消费者进程
void init_consumer(int pid) {
    consumer[pid].pid = pid;
    consumer[pid].state = 0; // 0代表就绪态
    consumer[pid].priority = 2; // 消费者优先级为2
    consumer[pid].time_slice = TIME_QUANTUM;
}

// 生产者进程
void *produce(void *arg) {
    int pid = *(int *)arg;
    while (1) {
        sleep(rand() % MAX_PRODUCER_TIME + 1); // 生产一个数据项
        sem_wait(&empty); // 如果缓冲区已满，则等待
        sem_wait(&mutex); // 进入临界区
        insert_item(rand() % 100 + 1); // 插入数据项
        printf("Producer %d produced an item.\n", pid);
        sem_post(&mutex);
        sem_post(&full); // 发出信号，通知消费者进程
    }
    pthread_exit(NULL);
}

// 消费者进程
void *consume(void *arg) {
    int pid = *(int *)arg;
    while (1) {
        sem_wait(&full); // 如果缓冲区为空，则等待
        sem_wait(&mutex); // 进入临界区
        int item = remove_item(); // 取出数据项
        printf("Consumer %d consumed an item: %d.\n", pid, item);
        sem_post(&mutex);
        sem_post(&empty); // 发出信号，通知生产者进程
        sleep(rand() % MAX_CONSUMER_TIME + 1); // 消费一个数据项
    }
    pthread_exit(NULL);
}

// 选择下一个进程
int select_next_process() {
    int i, next_pid = -1;
    for (i = 0; i < MAX_PRODUCER_NUM; i++) {
        if (producer[i].state == 0 && producer[i].pid > last_pid) {
            next_pid = producer[i].pid;
            break;
        }
    }
    if (next_pid == -1) {
        for (i = 0; i < MAX_CONSUMER_NUM; i++) {
            if (consumer[i].state == 0 && consumer[i].pid > last_pid) {
                next_pid = consumer[i].pid;
                break;
            }
        }
    }
    return next_pid;
}

// 时间片轮转调度算法
void *scheduler(void *arg) {
    int next_pid = -1;
    while (1) {
        next_pid = select_next_process();
        if (next_pid == -1) {
            break;
        }
        last_pid = next_pid;
        if (producer[next_pid].state == 0) {
            producer[next_pid].state = 1; // 1代表运行态
            pthread_kill(producer[next_pid].thread, SIGCONT);
            sleep(TIME_QUANTUM);
            producer[next_pid].time_slice -= TIME_QUANTUM;
            if (producer[next_pid].time_slice <= 0) {
                producer[next_pid].state = 0; // 0代表就绪态
                producer[next_pid].time_slice = TIME_QUANTUM;
            }
        } else if (consumer[next_pid].state == 0) {
            consumer[next_pid].state = 1; // 1代表运行态
            pthread_kill(consumer[next_pid].thread, SIGCONT);
            sleep(TIME_QUANTUM);
            consumer[next_pid].time_slice -= TIME_QUANTUM;
            if (consumer[next_pid].time_slice <= 0) {
                consumer[next_pid].state = 0; // 0代表就绪态
                consumer[next_pid].time_slice = TIME_QUANTUM;
            }
        }
    }
    pthread_exit(NULL);
}

int main() {
    int i, pid[MAX_PRODUCER_NUM + MAX_CONSUMER_NUM];
    for (i = 0; i < MAX_PRODUCER_NUM + MAX_CONSUMER_NUM; i++) {
        pid[i] = i;
    }
    init_buffer();
    sem_init(&empty, 0, MAX_BUFFER_SIZE); // 缓冲区空槽数量为MAX_BUFFER_SIZE
    sem_init(&full, 0, 0); // 缓冲区满槽数量为0
    sem_init(&mutex, 0, 1); // 互斥信号量初始化为1
    for (i = 0; i < MAX_PRODUCER_NUM; i++) {
        init_producer(i);
        pthread_create(&producer[i].thread, NULL, produce, &pid[i]);
    }
    for (i = 0; i < MAX_CONSUMER_NUM; i++) {
        init_consumer(i);
        pthread_create(&consumer[i].thread, NULL, consume, &pid[MAX_PRODUCER_NUM + i]);
    }
    pthread_t scheduler_thread;
    pthread_create(&scheduler_thread, NULL, scheduler, NULL);
    pthread_join(scheduler_thread, NULL);
    sem_destroy(&empty);
    sem_destroy(&full);
    sem_destroy(&mutex);
    return 0;
}

上述代码中，我们使用了多个线程模拟多个进程的并发执行，使用了信号量机制实现了进程同步，使用了时间片轮转调度算法实现了进程调度。在生产者进程中，我们使用了随机数模拟了生产数据的过程，在消费者进程中，我们使用了随机数模拟了消费数据的过程。在调度器中，我们使用了select_next_process函数选择下一个要运行的进程，并在进程的时间片用完后将其放回就绪队列的末尾。