操作系统实验：分别用非抢占式静态优先权调度策略，时间片轮转调度策略

非抢占式静态优先权调度策略是指在系统中，每个进程都被赋予一个固定的优先级，当进程就绪时，调度程序会根据进程的优先级决定执行哪个进程，优先级高的进程先执行。该调度策略的优点是简单，容易实现，但是存在优先级反转和饥饿现象。

时间片轮转调度策略是指在系统中，每个进程被分配一个时间片，当进程就绪时，调度程序会将其插入到就绪队列尾部，每个进程执行的时间片到后，就会被挂起，插入到就绪队列的尾部，等待下一轮调度。该调度策略的优点是公平，能够避免优先级反转和饥饿现象，但是会存在上下文切换的开销。

在实验中，我们可以通过编写不同的调度算法，来实现不同的调度策略。以非抢占式静态优先权调度策略为例，我们可以编写一个优先级队列，每个进程的优先级为其固定的优先级，当进程就绪时，将其插入到队列中。调度程序会选择队列中优先级最高的进程执行。在进程执行过程中，如果有更高优先级的进程就绪，则当前进程被挂起，等待下一轮调度。

以时间片轮转调度策略为例，我们可以编写一个循环队列，每个进程被分配一个固定的时间片。当进程就绪时，将其插入到队列尾部。调度程序会选择队列中的头部进程执行，执行过程中，如果时间片用完，将其挂起，插入到队列尾部，等待下一轮调度。如果有更高优先级的进程就绪，则当前进程被挂起，插入到队列尾部，等待下一轮调度。

相关问题

操作系统实验：分别用非抢占式静态优先权调度策略，时间片轮转调度策略实现，写出代码并执行。

非抢占式静态优先权调度策略：

#include<stdio.h>

struct process
{
    int pid;
    int priority;
    int burst_time;
    int waiting_time;
    int turnaround_time;
};

void main()
{
    int n, i, j;
    printf("Enter the number of processes: ");
    scanf("%d", &n);
    struct process p[n], temp;
    for(i=0; i<n; i++)
    {
        printf("\nEnter the details of process %d:\n", i+1);
        printf("Process ID: ");
        scanf("%d", &p[i].pid);
        printf("Priority: ");
        scanf("%d", &p[i].priority);
        printf("Burst Time: ");
        scanf("%d", &p[i].burst_time);
    }
    for(i=0; i<n-1; i++)
    {
        for(j=i+1; j<n; j++)
        {
            if(p[i].priority < p[j].priority)
            {
                temp = p[i];
                p[i] = p[j];
                p[j] = temp;
            }
        }
    }
    p[0].waiting_time = 0;
    p[0].turnaround_time = p[0].burst_time;
    for(i=1; i<n; i++)
    {
        p[i].waiting_time = p[i-1].waiting_time + p[i-1].burst_time;
        p[i].turnaround_time = p[i].waiting_time + p[i].burst_time;
    }
    printf("\nProcess\tPriority\tBurst Time\tWaiting Time\tTurnaround Time\n");
    for(i=0; i<n; i++)
    {
        printf("%d\t%d\t\t%d\t\t%d\t\t%d\n", p[i].pid, p[i].priority, p[i].burst_time, p[i].waiting_time, p[i].turnaround_time);
    }
}

时间片轮转调度策略：

#include<stdio.h>

struct process
{
    int pid;
    int burst_time;
    int remaining_time;
    int waiting_time;
    int turnaround_time;
};

void main()
{
    int n, i, quantum, time=0, flag=0, total_waiting_time=0, total_turnaround_time=0;
    printf("Enter the number of processes: ");
    scanf("%d", &n);
    struct process p[n];
    for(i=0; i<n; i++)
    {
        printf("\nEnter the details of process %d:\n", i+1);
        printf("Process ID: ");
        scanf("%d", &p[i].pid);
        printf("Burst Time: ");
        scanf("%d", &p[i].burst_time);
        p[i].remaining_time = p[i].burst_time;
    }
    printf("Enter the time quantum: ");
    scanf("%d", &quantum);
    while(1)
    {
        flag = 0;
        for(i=0; i<n; i++)
        {
            if(p[i].remaining_time > 0)
            {
                flag = 1;
                if(p[i].remaining_time > quantum)
                {
                    time += quantum;
                    p[i].remaining_time -= quantum;
                }
                else
                {
                    time += p[i].remaining_time;
                    p[i].waiting_time = time - p[i].burst_time;
                    p[i].remaining_time = 0;
                }
            }
        }
        if(flag == 0)
            break;
    }
    for(i=0; i<n; i++)
    {
        p[i].turnaround_time = p[i].burst_time + p[i].waiting_time;
        total_waiting_time += p[i].waiting_time;
        total_turnaround_time += p[i].turnaround_time;
    }
    printf("\nProcess\tBurst Time\tWaiting Time\tTurnaround Time\n");
    for(i=0; i<n; i++)
    {
        printf("%d\t%d\t\t%d\t\t%d\n", p[i].pid, p[i].burst_time, p[i].waiting_time, p[i].turnaround_time);
    }
    printf("\nAverage Waiting Time: %f\n", (float)total_waiting_time/n);
    printf("Average Turnaround Time: %f\n", (float)total_turnaround_time/n);
}

用C++语言实现操作系统实验：分别用非抢占式静态优先权调度策略，时间片轮转调度策略实现，写出代码并执行。

由于操作系统是一个非常复杂的系统，我们无法在这里完整地给出一个操作系统的实现代码。但是，我们可以给出一个简单的示例程序，它演示了如何使用非抢占式静态优先权调度策略和时间片轮转调度策略来实现一个简单的多任务操作系统。

下面是一个使用C++语言实现的简单的多任务操作系统的示例程序：

#include <iostream>
#include <vector>

using namespace std;

// 进程结构体
struct Process {
    int pid; // 进程ID
    int priority; // 进程优先级
    int burst_time; // 进程运行时间
    int remaining_time; // 进程剩余运行时间
};

// 非抢占式静态优先权调度策略
void non_preemptive_priority_scheduling(vector<Process>& processes) {
    int n = processes.size();

    // 对进程按照优先级进行排序
    sort(processes.begin(), processes.end(), [](const Process& a, const Process& b) {
        return a.priority < b.priority;
    });

    // 执行进程
    for (int i = 0; i < n; i++) {
        Process& p = processes[i];
        cout << "Running process #" << p.pid << endl;
        for (int j = 0; j < p.burst_time; j++) {
            p.remaining_time--;
            cout << "Process #" << p.pid << " is running (" << p.remaining_time << "s remaining)" << endl;
        }
    }
}

// 时间片轮转调度策略
void round_robin_scheduling(vector<Process>& processes, int time_slice) {
    int n = processes.size();

    // 执行进程
    int i = 0;
    while (true) {
        Process& p = processes[i];
        cout << "Running process #" << p.pid << endl;
        for (int j = 0; j < time_slice; j++) {
            if (p.remaining_time == 0) {
                break;
            }
            p.remaining_time--;
            cout << "Process #" << p.pid << " is running (" << p.remaining_time << "s remaining)" << endl;
        }
        if (p.remaining_time == 0) {
            i++;
        }
        if (i == n) {
            i = 0;
        }
        if (all_of(processes.begin(), processes.end(), [](const Process& p) {
            return p.remaining_time == 0;
        })) {
            break;
        }
    }
}

int main() {
    // 创建进程
    vector<Process> processes = {
        {1, 2, 5, 5},
        {2, 1, 4, 4},
        {3, 3, 2, 2},
        {4, 4, 1, 1}
    };

    // 非抢占式静态优先权调度策略
    cout << "Non-preemptive priority scheduling:" << endl;
    non_preemptive_priority_scheduling(processes);

    // 时间片轮转调度策略
    cout << "Round-robin scheduling:" << endl;
    round_robin_scheduling(processes, 2);

    return 0;
}

在上面的示例程序中，我们定义了一个`Process`结构体来表示进程。`Process`结构体包含`pid`（进程ID）、`priority`（进程优先级）、`burst_time`（进程运行时间）和`remaining_time`（进程剩余运行时间）等成员变量。

我们还定义了两个函数`non_preemptive_priority_scheduling`和`round_robin_scheduling`，分别对应非抢占式静态优先权调度策略和时间片轮转调度策略。这两个函数都接受一个指向进程数组的指针，并按照不同的调度策略执行这些进程。

在`non_preemptive_priority_scheduling`函数中，我们首先对进程按照优先级进行排序，然后依次执行这些进程。在执行进程时，我们使用一个简单的循环来模拟进程的运行，每次循环中让进程的`remaining_time`减1，并输出一条运行信息。

在`round_robin_scheduling`函数中，我们采用时间片轮转调度策略来执行进程。具体来说，我们使用一个循环来依次执行每个进程。每个进程执行一个时间片（即`time_slice`），然后切换到下一个进程。当所有进程都执行完毕时，循环结束。

最后，在`main`函数中，我们创建了一个包含4个进程的进程数组。我们首先使用非抢占式静态优先权调度策略来执行这些进程，然后使用时间片轮转调度策略来执行这些进程。在执行每个进程时，我们输出一些信息，以便观察调度过程。

注意：上面的示例程序只是一个简单的示例，它并不能完整地演示操作系统的实现过程。如果你想深入学习操作系统，建议阅读相关的教材和资料，以了解更多的内容。