非抢占式时间片轮转调度算法

非抢占式时间片轮转调度算法是指操作系统按顺序将每个进程分配一个时间片，时间片用完后将进程挂起并将CPU分配给下一个进程。 当所有进程均已运行完一个时间片后，进程列表重新排序，并开始新的一轮时间片。这种算法适用于多个进程并发执行的情况，能够保证每个进程得到一定的时间片，从而避免了某个进程独占系统资源的情况。

相关问题

抢占式时间片轮转调度算法

抢占式时间片轮转调度算法是一种常见的CPU调度算法。它将每个进程分配一个固定时间片，当一个进程的时间片用完后，它会被移动到就绪队列的末尾，并给下一个进程分配时间片。在每个时间片结束时，进程会被强制切换，并移动到就绪队列末尾。这个算法可以在多个进程之间公平地分配CPU时间，并且可以防止任何一个进程独占CPU资源。

非抢占式时间片轮转调度法的c语言代码

下面是一个简单的非抢占式时间片轮转调度算法的 C 语言代码：

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

struct Process {
int pid;
int burst_time;
int arrival_time;
int waiting_time;
int turn_around_time;
int remaining_time;
};

// 计算等待时间和周转时间
void calculate_time(struct Process p[], int n) {

int i, t = 0, total_wt = 0, total_tat = 0;
float avg_wt, avg_tat;

// 计算每个进程的等待时间和周转时间
for (i = 0; i < n; i++) {
p[i].remaining_time = p[i].burst_time;
}

while (1) {
int done = 1;

for (i = 0; i < n; i++) {
if (p[i].remaining_time > 0) {
done = 0;

if (p[i].remaining_time > t) {
t = p[i].arrival_time + t;
} else {
t = t + p[i].remaining_time;

p[i].turn_around_time = t - p[i].arrival_time;
p[i].waiting_time = p[i].turn_around_time - p[i].burst_time;

total_wt = total_wt + p[i].waiting_time;
total_tat = total_tat + p[i].turn_around_time;

p[i].remaining_time = 0;
}
}
}

if (done == 1) break;
}

// 计算平均等待时间和平均周转时间
avg_wt = (float) total_wt / n;
avg_tat = (float) total_tat / n;

// 输出结果
printf("\n%s\t%s\t%s\t%s\t%s\n", "Process", "Burst time", "Arrival time", "Waiting time", "Turnaround time");

for (i = 0; i < n; i++) {
printf("P%d\t%d\t\t%d\t\t%d\t\t%d\n", p[i].pid, p[i].burst_time, p[i].arrival_time, p[i].waiting_time, p[i].turn_around_time);
}

printf("\nAverage waiting time: %f\n", avg_wt);
printf("Average turnaround time: %f\n", avg_tat);
}

int main() {
int n, i;
printf("Enter number of processes:\n");
scanf("%d", &n);

struct Process p[n];

printf("Enter process details:\n");
printf("Pid, Burst time, Arrival time\n");

for (i = 0; i < n; i++) {
scanf("%d %d %d", &p[i].pid, &p[i].burst_time, &p[i].arrival_time);
}

calculate_time(p, n);

return 0;
}