（1） 设计进程同步算法，使用P/V（wait/signal）操作模拟解决进程中经典同步问题。假设有一个生产者和一个消费者，缓冲区可以存放产品，生产者不断生产产品并存入缓冲区，消费者不断从缓冲区中取出产品并消费，设计代码并运行实现结果。 （2） 编制时间片轮转调度算法，可自定义时间片的大小。 （3） 编制静态优先级调度算法，优先级高低可自定义

（1）生产者-消费者问题的P/V解决方案已经在上一个问题中提到了，这里再提供一份代码实现：

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

#define N 10 // 缓冲区大小
#define P 20 // 生产者需要生产的产品数量
#define C 20 // 消费者需要消费的产品数量

sem_t mutex; // 互斥信号量
sem_t empty; // 空闲信号量
sem_t full; // 满信号量

int buffer[N]; // 缓冲区
int in = 0; // 生产者写入位置
int out = 0; // 消费者读取位置

void *producer(void *arg) {
    for (int i = 0; i < P; i++) {
        int item = rand() % 100; // 生产一个产品
        sem_wait(&empty); // 等待空闲缓冲区
        sem_wait(&mutex); // 申请互斥访问缓冲区
        buffer[in] = item; // 将产品存入缓冲区
        in = (in + 1) % N; // 更新写入位置
        printf("producer produced item %d\n", item);
        sem_post(&mutex); // 释放互斥访问缓冲区
        sem_post(&full); // 通知有新的产品可供消费
    }
    return NULL;
}

void *consumer(void *arg) {
    for (int i = 0; i < C; i++) {
        sem_wait(&full); // 等待满缓冲区
        sem_wait(&mutex); // 申请互斥访问缓冲区
        int item = buffer[out]; // 从缓冲区取出产品
        out = (out + 1) % N; // 更新读取位置
        printf("consumer consumed item %d\n", item);
        sem_post(&mutex); // 释放互斥访问缓冲区
        sem_post(&empty); // 通知已释放一个空闲缓冲区
    }
    return NULL;
}

int main() {
    // 初始化信号量
    sem_init(&mutex, 0, 1);
    sem_init(&empty, 0, N);
    sem_init(&full, 0, 0);

    // 创建生产者和消费者线程
    pthread_t producer_thread, consumer_thread;
    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(&mutex);
    sem_destroy(&empty);
    sem_destroy(&full);

    return 0;
}

（2）时间片轮转调度算法的代码实现如下：

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

#define MAX_PROCESS_NUM 10 // 最大进程数量
#define TIME_SLICE 2 // 时间片大小

int process_num = 0; // 进程数量
int current_time = 0; // 当前时间
int current_process = 0; // 当前进程
int remaining_time[MAX_PROCESS_NUM]; // 进程剩余执行时间
int arrival_time[MAX_PROCESS_NUM]; // 进程到达时间
int completion_time[MAX_PROCESS_NUM]; // 进程完成时间
int turnaround_time[MAX_PROCESS_NUM]; // 进程周转时间
int waiting_time[MAX_PROCESS_NUM]; // 进程等待时间

void input_process() {
    printf("请输入进程数量：");
    scanf("%d", &process_num);
    printf("请输入进程信息（到达时间 执行时间）：\n");
    for (int i = 0; i < process_num; i++) {
        scanf("%d %d", &arrival_time[i], &remaining_time[i]);
    }
}

void output_process() {
    printf("进程信息如下：\n");
    printf("进程编号 到达时间 执行时间 完成时间 周转时间 等待时间\n");
    for (int i = 0; i < process_num; i++) {
        printf("%d %11d %8d %10d %8d %8d\n", i, arrival_time[i], remaining_time[i], completion_time[i], turnaround_time[i], waiting_time[i]);
    }
}

void schedule_process() {
    printf("时间片大小为%d，进程轮转调度如下：\n", TIME_SLICE);
    while (1) {
        int flag = 1;
        for (int i = 0; i < process_num; i++) {
            if (remaining_time[i] > 0) {
                flag = 0;
                if (remaining_time[i] > TIME_SLICE) {
                    current_time += TIME_SLICE;
                    remaining_time[i] -= TIME_SLICE;
                } else {
                    current_time += remaining_time[i];
                    remaining_time[i] = 0;
                    completion_time[i] = current_time;
                    turnaround_time[i] = completion_time[i] - arrival_time[i];
                    waiting_time[i] = turnaround_time[i] - remaining_time[i];
                }
            }
        }
        if (flag) {
            break;
        }
    }
}

int main() {
    input_process();
    schedule_process();
    output_process();
    return 0;
}

（3）静态优先级调度算法的代码实现如下：

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

#define MAX_PROCESS_NUM 10 // 最大进程数量

int process_num = 0; // 进程数量
int current_time = 0; // 当前时间
int current_process = 0; // 当前进程
int priority[MAX_PROCESS_NUM]; // 进程优先级
int remaining_time[MAX_PROCESS_NUM]; // 进程剩余执行时间
int arrival_time[MAX_PROCESS_NUM]; // 进程到达时间
int completion_time[MAX_PROCESS_NUM]; // 进程完成时间
int turnaround_time[MAX_PROCESS_NUM]; // 进程周转时间
int waiting_time[MAX_PROCESS_NUM]; // 进程等待时间

void input_process() {
    printf("请输入进程数量：");
    scanf("%d", &process_num);
    printf("请输入进程信息（到达时间 执行时间 优先级）：\n");
    for (int i = 0; i < process_num; i++) {
        scanf("%d %d %d", &arrival_time[i], &remaining_time[i], &priority[i]);
    }
}

void output_process() {
    printf("进程信息如下：\n");
    printf("进程编号 到达时间 执行时间 优先级 完成时间 周转时间 等待时间\n");
    for (int i = 0; i < process_num; i++) {
        printf("%d %11d %8d %6d %10d %8d %8d\n", i, arrival_time[i], remaining_time[i], priority[i], completion_time[i], turnaround_time[i], waiting_time[i]);
    }
}

void schedule_process() {
    printf("进程静态优先级调度如下：\n");
    while (1) {
        int next_process = -1;
        int max_priority = -1;
        for (int i = 0; i < process_num; i++) {
            if (arrival_time[i] <= current_time && remaining_time[i] > 0 && priority[i] > max_priority) {
                next_process = i;
                max_priority = priority[i];
            }
        }
        if (next_process == -1) {
            break;
        }
        current_process = next_process;
        current_time += remaining_time[current_process];
        remaining_time[current_process] = 0;
        completion_time[current_process] = current_time;
        turnaround_time[current_process] = completion_time[current_process] - arrival_time[current_process];
        waiting_time[current_process] = turnaround_time[current_process] - remaining_time[current_process];
    }
}

int main() {
    input_process();
    schedule_process();
    output_process();
    return 0;
}