操作系统进程调度C语言代码

先来先服务和优先数调度算法c语言先来先服务和优先数调度算法c语言一、前言操作系统中的进程调度是指在多道程序环境下，按照一定的规则从就绪队列中选择一个进程，将CPU分配给它运行。

常用的进程调度算法有先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）等。

本文将介绍两种常见的进程调度算法：先来先服务和优先数调度算法，并给出相应的C语言实现。

二、先来先服务算法1. 算法原理FCFS即First Come First Served，也称为FIFO（First In First Out），是一种非抢占式的进程调度算法。

按照任务到达时间的顺序进行处理，即谁先到达谁就被处理。

2. 算法流程（1）按照任务到达时间排序；（2）依次执行每个任务，直至所有任务都完成。

3. C语言实现下面是一个简单的FCFS程序：```c#include <stdio.h>struct process {int pid; // 进程IDint arrival_time; // 到达时间int burst_time; // 执行时间int waiting_time; // 等待时间};int main() {struct process p[10];int n, i, j;float avg_waiting_time = 0;printf("请输入进程数：");scanf("%d", &n);for (i = 0; i < n; i++) {printf("请输入第%d个进程的信息：\n", i + 1); printf("进程ID：");scanf("%d", &p[i].pid);printf("到达时间：");scanf("%d", &p[i].arrival_time);printf("执行时间：");scanf("%d", &p[i].burst_time);}for (i = 0; i < n; i++) {for (j = 0; j < i; j++) {if (p[j].arrival_time > p[j + 1].arrival_time) { struct process temp = p[j];p[j] = p[j + 1];p[j + 1] = temp;}}}int current_time = p[0].arrival_time;for (i = 0; i < n; i++) {if (current_time < p[i].arrival_time) {current_time = p[i].arrival_time;}p[i].waiting_time = current_time - p[i].arrival_time;current_time += p[i].burst_time;}printf("进程ID\t到达时间\t执行时间\t等待时间\n");for (i = 0; i < n; i++) {printf("%d\t%d\t%d\t%d\n", p[i].pid, p[i].arrival_time, p[i].burst_time, p[i].waiting_time);avg_waiting_time += (float)p[i].waiting_time / n;}printf("平均等待时间：%f\n", avg_waiting_time);return 0;}```三、优先数调度算法1. 算法原理优先数调度算法是一种非抢占式的进程调度算法。

操作系统实验报告进程调度操作系统实验报告：进程调度引言在计算机科学领域中，操作系统是一个重要的概念，它负责管理和协调计算机系统中的各种资源，包括处理器、内存、输入/输出设备等。

其中，进程调度是操作系统中一个非常重要的组成部分，它负责决定哪个进程在何时获得处理器的使用权，以及如何有效地利用处理器资源。

实验目的本次实验的目的是通过对进程调度算法的实验，深入理解不同的进程调度算法对系统性能的影响，并掌握进程调度算法的实现方法。

实验环境本次实验使用了一台配备了Linux操作系统的计算机作为实验平台。

在该计算机上，我们使用了C语言编写了一些简单的进程调度算法，并通过模拟不同的进程调度场景进行了实验。

实验内容1. 先来先服务调度算法（FCFS）先来先服务调度算法是一种简单的进程调度算法，它按照进程到达的顺序进行调度。

在本次实验中，我们编写了一个简单的FCFS调度算法，并通过模拟多个进程同时到达的情况，观察其对系统性能的影响。

2. 短作业优先调度算法（SJF）短作业优先调度算法是一种根据进程执行时间长度进行调度的算法。

在本次实验中，我们编写了一个简单的SJF调度算法，并通过模拟不同长度的进程，观察其对系统性能的影响。

3. 时间片轮转调度算法（RR）时间片轮转调度算法是一种按照时间片大小进行调度的算法。

在本次实验中，我们编写了一个简单的RR调度算法，并通过模拟不同时间片大小的情况，观察其对系统性能的影响。

实验结果通过实验，我们发现不同的进程调度算法对系统性能有着不同的影响。

在FCFS 算法下，长作业会导致短作业等待时间过长；在SJF算法下，长作业会导致短作业饥饿现象；而RR算法则能够较好地平衡不同进程的执行。

因此，在实际应用中，需要根据具体情况选择合适的进程调度算法。

结论本次实验通过对进程调度算法的实验，深入理解了不同的进程调度算法对系统性能的影响，并掌握了进程调度算法的实现方法。

同时，也加深了对操作系统的理解，为今后的学习和研究打下了良好的基础。

操作系统实验报告——调度算法1. 实验目的本实验旨在探究操作系统中常用的调度算法，通过编写代码模拟不同的调度算法，了解它们的特点和应用场景。

2. 实验环境本次实验使用的操作系统环境为Linux，并采用C语言进行编码。

3. 实验内容3.1 调度算法1：先来先服务（FCFS）FCFS调度算法是一种简单且常见的调度算法。

该算法按照进程到达的先后顺序进行调度。

在本实验中，我们使用C语言编写代码模拟FCFS算法的调度过程，并记录每个进程的等待时间、周转时间和响应时间。

3.2 调度算法2：最短作业优先（SJF）SJF调度算法是一种非抢占式的调度算法，根据进程的执行时间来选择下一个要执行的进程。

在本实验中，我们使用C语言编写代码模拟SJF算法的调度过程，并计算每个进程的等待时间、周转时间和响应时间。

3.3 调度算法3：轮转调度（Round Robin）Round Robin调度算法是一种经典的时间片轮转算法，每个进程在给定的时间片内依次执行一定数量的时间。

如果进程的执行时间超过时间片，进程将被暂时挂起，等待下一次轮转。

在本实验中，我们使用C语言编写代码模拟Round Robin算法的调度过程，并计算每个进程的等待时间、周转时间和响应时间。

4. 实验结果分析通过对不同调度算法的模拟实验结果进行分析，可以得出以下结论：- FCFS算法适用于任务到达的先后顺序不重要的场景，但对于执行时间较长的进程可能会导致下一个进程需要等待较久。

- SJF算法适用于任务的执行时间差异较大的场景，能够提高整体执行效率。

- Round Robin算法适用于时间片相对较小的情况，能够公平地为每个进程提供执行时间。

5. 实验总结本次实验通过模拟不同调度算法的实际执行过程，深入了解了各种调度算法的原理、特点和适用场景。

通过对实验结果的分析，我们可以更好地选择合适的调度算法来满足实际应用的需求。

在后续的学习中，我们将进一步探索更多操作系统相关的实验和算法。

操作系统进程调度实验操作系统进程调度是操作系统中非常重要的一个功能，它决定了多个进程的执行顺序和调度策略。

进程调度的好坏直接影响着系统的性能和资源利用率。

本实验旨在通过实现一个简单的进程调度模拟，了解不同的调度算法，探讨其优劣和适用场景。

一、实验目的和原理本实验的目标是实现进程调度模拟，并探究不同调度算法的性能和适用场景。

通过实验，我们可以了解以下内容：1.进程调度算法的基本原理和实现方式；2.比较不同调度算法的优劣和特点；3.了解不同调度算法在不同场景下的应用。

二、实验环境和工具本实验使用C语言进行实现，可以选择任何一种编程环境和工具，例如Dev-C++、Visual Studio等。

三、实验过程及方法1.实现一个进程控制块（PCB）的数据结构，用来保存进程的相关信息，包括进程ID、进程状态、优先级等。

2.实现一个进程队列，用来保存就绪队列中的进程。

可以使用数组或链表等数据结构实现。

3. 实现不同调度算法的函数，包括先来先服务（FCFS）、最短作业优先（SJF）、优先级调度（Priority Scheduling）和时间片轮转（Round Robin）等。

4.根据实际需求生成一批进程，设置其信息，并根据不同算法进行调度。

5.对比不同算法的运行结果和性能，分析其优劣。

四、实验结果和分析通过实验，我们可以得到每个算法的平均等待时间、平均周转时间和吞吐量等性能指标。

根据这些指标，我们可以对不同算法进行评价和分析。

1.先来先服务（FCFS）算法FCFS算法是最简单的调度算法，按照进程到达的顺序进行调度。

它的主要优点是实现简单、公平性好。

然而，FCFS算法有明显的缺点，会导致长作业等待时间过长，产生"饥饿"现象。

2.最短作业优先（SJF）算法SJF算法是按照进程的执行时间长短进行调度的算法。

它能够最大限度地减少平均等待时间和周转时间，但是需要提前知道所有进程的执行时间，这在实际中是很难做到的。

调度算法C语言实现调度算法是操作系统中的重要内容之一，它决定了进程在系统中的运行方式和顺序。

本文将介绍两种常见的调度算法，先来先服务（FCFS）和最短作业优先（SJF），并用C语言实现它们。

一、先来先服务（FCFS）调度算法先来先服务（FCFS）调度算法是最简单的调度算法之一、它按照进程到达的先后顺序进行调度，即谁先到达就先执行。

实现这个算法的关键是记录进程到达的顺序和每个进程的执行时间。

下面是一个用C语言实现先来先服务调度算法的示例程序：```c#include <stdio.h>//进程控制块结构体typedef structint pid; // 进程IDint arrivalTime; // 到达时间int burstTime; // 执行时间} Process;int maiint n; // 进程数量printf("请输入进程数量：");scanf("%d", &n);//输入每个进程的到达时间和执行时间Process process[n];for (int i = 0; i < n; i++)printf("请输入进程 %d 的到达时间和执行时间：", i);scanf("%d%d", &process[i].arrivalTime,&process[i].burstTime);process[i].pid = i;}//根据到达时间排序进程for (int i = 0; i < n - 1; i++)for (int j = i + 1; j < n; j++)if (process[i].arrivalTime > process[j].arrivalTime) Process temp = process[i];process[i] = process[j];process[j] = temp;}}}//计算平均等待时间和平均周转时间float totalWaitingTime = 0; // 总等待时间float totalTurnaroundTime = 0; // 总周转时间int currentTime = 0; // 当前时间for (int i = 0; i < n; i++)if (currentTime < process[i].arrivalTime)currentTime = process[i].arrivalTime;}totalWaitingTime += currentTime - process[i].arrivalTime;totalTurnaroundTime += (currentTime + process[i].burstTime) - process[i].arrivalTime;currentTime += process[i].burstTime;}//输出结果float avgWaitingTime = totalWaitingTime / n;float avgTurnaroundTime = totalTurnaroundTime / n;printf("平均等待时间：%f\n", avgWaitingTime);printf("平均周转时间：%f\n", avgTurnaroundTime);return 0;```以上程序实现了先来先服务（FCFS）调度算法，首先根据进程的到达时间排序，然后依次执行每个进程，并计算总等待时间和总周转时间。

《计算机操作系统》课程实验报告题目实验一进程调度学院: 计算机学院专业: 计算机科学与技术姓名班级学号2015年10月21日实验一进程调度1.实验目的：通过对进程调度算法的模拟，进一步理解进程的基本概念，加深对进程运行状态和进程调度过程、调度算法的理解。

2.实验内容：用C语言实现对N个进程采用某种进程调度算法先来先服务调度、短作业优先调度的调度。

3.设计实现：要求给出设计源码，设计源码要有详细注释，#include <stdio.h>#include<iostream>using namespace std;struct program{char name; /*进程名*/int atime; /*到达时间*/int stime; /*服务时间*/int ftime; /*完成时间*/int rtime; /*周转时间*/float qrtime; /*带权周转时间*/};void xianshi(struct program a[],int n){int i,j;struct program t;/*将进程按时间排序*/printf("根据到达时间重新排序：\n");printf("*****进程*************到达时间***************服务时间*****\n");for(j=0;j<n-1;j++)for(i=0;i<n-1-j;i++)if(a[i].atime>a[i+1].atime){t.atime=a[i].atime;a[i].atime=a[i+1].atime;a[i+1].atime=t.atime;=a[i].name;a[i].name=a[i+1].name;a[i+1].name=;t.stime=a[i].stime;a[i].stime=a[i+1].stime;a[i+1].stime=t.stime;}for(i=0;i<n;i++)printf(" %c %d %d |\n",a[i].name,a[i].atime,a[i].stime);printf("----------------------------------------------------\n"); }void fcfs(struct program a[],int n){int i;int time=0;for(i=0;i<n;i++){time=time+a[i].stime;a[i].ftime=a[0].atime+time;a[i].rtime=a[i].ftime-a[i].atime;a[i].qrtime=(float)a[i].rtime/a[i].stime;}printf("\nFCFS算法：\n");printf("*****进程****到达时间****完成时间******周转时间*******带权周转时间*****\n");for(i=0;i<n;i++){printf(" %c %d %.2d %.2d %.2f |\n",a[i].name,a[i].atime,a[i].ftime,a[i].rtime,a[i].qrtime);}printf("-----------------------------------------------------------------------\n");}void main(){int i,m;struct program pro[4];/*创建进程 */printf(" ******先来先服务算法****** \n");printf("请输入进程的数目：\n");scanf("%d",&m);i=m;for(i=0;i<m;i++){printf("请输入进程%d的进程名，到达时间，服务时间\n",i+1);cin>>pro[i].name>>pro[i].atime>>pro[i].stime;}xianshi(pro,m);fcfs(pro,m);getchar();}#include <stdio.h>#include<iostream>using namespace std;struct program{char name; /*进程名*/float atime; /*到达时间*/float stime; /*服务时间*/float ftime; /*完成时间*/float rtime; /*周转时间*/float qrtime; /*带权周转时间*/};void xianshi(struct program a[],int n){int i,j;struct program t;/*将进程按时间排序*/printf("重新排序：\n");printf("*****进程*************到达时间***************服务时间*****\n");for(j=0;j<n-1;j++)for(i=1;i<n-1-j;i++)if(a[i].stime>a[i+1].stime){t.atime=a[i].atime;a[i].atime=a[i+1].atime;a[i+1].atime=t.atime;=a[i].name;a[i].name=a[i+1].name;a[i+1].name=;t.stime=a[i].stime;a[i].stime=a[i+1].stime;a[i+1].stime=t.stime;}for(i=0;i<n;i++)printf(" %c %f %f |\n",a[i].name,a[i].atime,a[i].stime);printf("----------------------------------------------------\n"); }void SJF(struct program a[],int n){int i;a[0].ftime=a[0].atime+a[0].stime;a[0].rtime=a[0].ftime-a[0].atime;a[0].qrtime=a[0].rtime/a[0].stime;for(i=1;i<n;i++){a[i].ftime=a[i-1].ftime+a[i].stime;a[i].rtime=a[i].ftime-a[i].atime;a[i].qrtime=a[i].rtime/a[i].stime;}printf("\nSJF算法：\n");printf("*****进程****到达时间****完成时间******周转时间*******带权周转时间*****\n");for(i=0;i<n;i++){printf(" %c %.2f %.2f %.2f %.2f |\n",a[i].name,a[i].atime,a[i].ftime,a[i].rtime,a[i].qrtime);}printf("-----------------------------------------------------------------------\n");}void main(){int i,m;struct program pro[4];/*创建进程 */printf(" ******短作业优先算法****** \n");printf("请输入进程的数目：\n");scanf("%d",&m);i=m;for(i=0;i<m;i++){printf("请输入进程%d的进程名，到达时间，服务时间\n",i+1);cin>>pro[i].name>>pro[i].atime>>pro[i].stime;}xianshi(pro,m);SJF(pro,m); getchar(); }4.实验结果5.实验过程中出现的问题及解决办法先来先服务调度算法就是根据进程达到的时间为依据，哪一个进程先来那么该进程就会先执行；最短进程优先调度算法则是以每个进程执行所需时间长短为依据，某一个进程执行所需花的时间要短些那么该进程就先执行。

操作系统进程调度C语言代码#include <stdio.h>#define MAX 20//进程控制块typedef struct PCBchar name[10]; // 进程名int AT; // 到达时间int BT; // 服务时间int Pri; // 优先数int FT; // 完成时间int WT; //等待时间int RT; // 响应时间int position; // 第几号进程int flag; // 用来判断进程是否执行过}PCB;//进程调度void schedule(PCB a[], int n, int alg)int i, j, k, flag, temp;int count = 0;int pri_max = 0;float ATAT = 0.0;float AWT = 0.0;float ART = 0.0;PCBt;//各种算法的调度if (alg == 1)printf("采用先来先服务调度：\n"); //根据到达时间执行for (i = 0; i < n; i++)for (j = i + 1; j < n; j++)if (a[i].AT > a[j].AT)t=a[i];a[i]=a[j];a[j]=t;}//按到达时间依次执行for (i = 0; count != n; i++)for (j = 0; j < n; j++)//查找第一个到达时间小于等于当前时间的进程if (a[j].AT <= i && a[j].flag == 0)//记录运行时间a[j].BT--;//如果运行完成，记录完成时间、等待时间、响应时间if (a[j].BT == 0)a[j].FT=i+1;a[j].WT = a[j].FT - a[j].AT - a[j].Pri;a[j].RT=a[j].WT;a[j].flag = 1;count++;}elsebreak;}}}else if (alg == 2)printf("采用最短服务时间优先（非抢占）调度：\n");for (i = 0; count != n; i++)//找出服务时间最短的进程，并将其放置到最前面for (j = 0; j < n; j++)。

c语言实现进程调度算法进程调度算法是操作系统中的一个重要组成部分，用于决定在多道程序环境下，选择哪个进程来占用CPU并执行。

C语言是一种通用的编程语言，可以用于实现各种进程调度算法。

这里我将分别介绍三种常见的进程调度算法：先来先服务调度算法（FCFS）、最短作业优先调度算法（SJF）和轮转法调度算法（RR），并给出用C语言实现的示例代码。

首先，我们来看先来先服务调度算法（FCFS）。

此算法根据到达时间的先后顺序，按照先来后到的顺序进行处理。

下面是基于C语言的先来先服务调度算法实现示例代码：```c#include<stdio.h>struct Process};void FCFS(struct Process proc[], int n)for (int i = 1; i < n; i++)}printf("进程号到达时间服务时间完成时间等待时间周转时间\n");for (int i = 0; i < n; i++)}for (int i = 0; i < n; i++)}int maiint n;printf("请输入进程数：");scanf("%d", &n);struct Process proc[n];for (int i = 0; i < n; i++)printf("请输入进程%d的到达时间和服务时间（用空格分隔）：", i + 1);}FCFS(proc, n);return 0;```其次，我们来看最短作业优先调度算法（SJF），该算法选择执行时间最短的进程先执行。

下面是基于C语言的最短作业优先调度算法实现示例代码：```c#include<stdio.h>struct Process};void SJF(struct Process proc[], int n)for (int i = 0; i < n; i++)for (int j = 0; j < i; j++)}shortest_job = i;for (int j = i + 1; j < n; j++)shortest_job = j;}}}for (int i = 1; i < n; i++)}printf("进程号到达时间服务时间完成时间等待时间周转时间\n");for (int i = 0; i < n; i++)}for (int i = 0; i < n; i++)}int maiint n;printf("请输入进程数：");scanf("%d", &n);struct Process proc[n];for (int i = 0; i < n; i++)printf("请输入进程%d的到达时间和服务时间（用空格分隔）：", i + 1);}SJF(proc, n);return 0;```最后，我们来看轮转法调度算法（RR），该算法分配一个时间片给每个进程，当时间片用完后，将CPU分配给下一个进程。

操作系统进程调度优先级算法C语言模拟```cstruct Processint pid; // 进程IDint priority; // 优先级};```接下来，我们使用一个简单的示例来说明操作系统进程调度优先级算法的模拟实现。

假设有5个进程需要调度执行，它们的初始优先级和运行时间如下：进程ID，优先级，已运行时间--------，--------，------------P1，4，2P2，3，4P3，1，6P4，2，1P5，5，3首先，我们需要将这些进程按照优先级排序，以得到调度队列。

可以使用冒泡排序算法实现，代码如下：```cvoid bubbleSort(struct Process *processes, int n)for (int i = 0; i < n - 1; i++)for (int j = 0; j < n - i - 1; j++)if (processes[j].priority > processes[j + 1].priority)struct Process temp = processes[j];processes[j] = processes[j + 1];processes[j + 1] = temp;}}}``````c#include <stdio.h>void bubbleSort(struct Process *processes, int n);int maistruct Process processes[] = {{1, 4, 2}, {2, 3, 4}, {3, 1, 6}, {4, 2, 1}, {5, 5, 3}};int n = sizeof(processes) / sizeof(struct Process);bubbleSort(processes, n);printf("初始调度队列：\n");printf("进程ID\t优先级\t已运行时间\n");for (int i = 0; i < n; i++)}//模拟进程调度printf("\n开始模拟进程调度...\n");int finished = 0;while (finished < n)struct Process *current_process = &processes[0];printf("执行进程 P%d\n", current_process->pid);finished++;printf("进程 P%d 执行完毕\n", current_process->pid);} else}bubbleSort(processes, n);}printf("\n所有进程执行完毕，调度队列的最终顺序为：\n"); printf("进程ID\t优先级\t已运行时间\n");for (int i = 0; i < n; i++)}return 0;```以上代码中，我们使用了一个变量`finished`来记录已完成的进程数量，当`finished`等于进程数量`n`时，所有进程执行完毕。

操作系统五种进程调度算法的代码一、先来先服务（FCFS）调度算法先来先服务（FCFS）调度算法是操作系统处理进程调度时比较常用的算法，它的基本思想是按照进程的提交时间的先后顺序依次调度进程，新提交的进程会在当前运行进程之后排队，下面通过C语言代码来实现先来先服务（FCFS）调度算法：#include <stdio.h>#include <stdlib.h>//定义进程的数据结构struct Processint pid; // 进程标识符int at; // 到达时间int bt; // 执行时间};//进程调度函数void fcfs_schedule(struct Process *processes, int n)int i, j;//根据进程的到达时间排序for(i = 0; i < n; i++)for(j = i+1; j < n; j++)if(processes[i].at > processes[j].at) struct Process temp = processes[i]; processes[i] = processes[j];processes[j] = temp;//获取各个进程执行完毕的时间int ct[n];ct[0] = processes[0].at + processes[0].bt; for(i = 1; i < n; i++)if(ct[i-1] > processes[i].at)ct[i] = ct[i-1] + processes[i].bt;elsect[i] = processes[i].at + processes[i].bt; //计算各个进程的周转时间和带权周转时间int tat[n], wt[n], wt_r[n];for(i = 0; i < n; i++)tat[i] = ct[i] - processes[i].at;wt[i] = tat[i] - processes[i].bt;wt_r[i] = wt[i] / processes[i].bt;printf("P%d:\tAT=%d\tBT=%d\tCT=%d\tTAT=%d\tWT=%d\tWT_R=%f\n", processes[i].pid, processes[i].at, processes[i].bt, ct[i], tat[i], wt[i], wt_r[i]);//主函数int mainstruct Process processes[] ={1,0,3},{2,3,5},{3,4,6},{4,5,2},{5,6,4}};fcfs_schedule(processes, 5);return 0;输出：。

时间片轮转调度算法是一种操作系统进程调度算法，它是先进先出（FIFO）调度算法的一种改进版本。

以下是一个用C语言实现的时间片轮转调度算法的简单示例：```c#include <stdio.h>#include <stdlib.h>#define QUANTUM 2 // 定义时间片长度#define PROCESSES 5 // 定义进程数量// 进程结构体typedef struct {int process_id;int arrival_time;int burst_time;int remaining_time;int finished;} Process;// 初始化进程队列void init_processes(Process *processes, int processes_num) {for (int i = 0; i < processes_num; i++) {processes[i].process_id = i + 1;processes[i].arrival_time = i % 5 + 1;processes[i].burst_time = 5;processes[i].remaining_time = processes[i].burst_time;processes[i].finished = 0;}}// 时间片轮转调度void round_robin(Process *processes, int processes_num) {int time = 0;int finished_processes = 0;while (finished_processes < processes_num) {for (int i = 0; i < processes_num; i++) {if (processes[i].arrival_time <= time && !processes[i].finished) { if (processes[i].remaining_time > QUANTUM) {processes[i].remaining_time -= QUANTUM;printf("Time %d: Process %d is running\n", time, processes[i].process_id);} else {processes[i].finished = 1;finished_processes++;printf("Time %d: Process %d is finished\n", time, processes[i].process_id);}}}time++;}}int main() {Process processes[PROCESSES];init_processes(processes, PROCESSES);round_robin(processes, PROCESSES);return 0;}```这个示例中，我们定义了一个进程结构体，包括进程ID、到达时间、运行时间、剩余时间和是否完成。

操作系统进程调度实验报告操作系统进程调度实验报告引言：操作系统是计算机系统中的核心软件之一，负责管理计算机的硬件资源并提供用户与计算机硬件之间的接口。

进程调度作为操作系统的重要功能之一，负责决定哪个进程可以获得处理器的使用权，以及进程如何在处理器上运行。

本实验旨在通过设计和实现一个简单的进程调度算法，加深对操作系统进程调度原理的理解。

一、实验目的本实验的主要目的是通过编写代码模拟操作系统的进程调度过程，掌握进程调度算法的实现方法，深入理解不同调度算法的特点和适用场景。

二、实验环境本实验使用C语言进行编程实现，可在Linux或Windows系统下进行。

三、实验内容1. 进程调度算法的选择在本实验中，我们选择了最简单的先来先服务（FCFS）调度算法作为实现对象。

FCFS算法按照进程到达的先后顺序进行调度，即先到先服务。

这种调度算法的优点是简单易实现，但缺点是无法适应不同进程的执行时间差异，可能导致长作业效应。

2. 进程调度的数据结构在实现进程调度算法时，我们需要定义进程的数据结构。

一个进程通常包含进程ID、到达时间、执行时间等信息。

我们可以使用结构体来表示一个进程，例如：```struct Process {int pid; // 进程IDint arrival_time; // 到达时间int burst_time; // 执行时间};```3. 进程调度算法的实现在FCFS调度算法中，我们需要按照进程到达的先后顺序进行调度。

具体实现时，可以使用一个队列来保存待调度的进程，并按照到达时间的先后顺序将进程入队。

然后，按照队列中的顺序依次执行进程，直到所有进程执行完毕。

4. 实验结果分析通过实现FCFS调度算法，我们可以观察到进程调度的过程和结果。

可以通过输出每个进程的执行顺序、等待时间和周转时间等指标来分析调度算法的效果。

通过比较不同调度算法的指标，可以得出不同算法的优缺点。

四、实验步骤1. 定义进程的数据结构，包括进程ID、到达时间和执行时间等信息。

int count;
// 记录进程执行的次数
struct node *next;
// 队列指针
}PCB;
PCB *ready=NULL,*run=NULL,*finish=NULL; // 和完成队列
定义三个队列， 就绪队列， 执 行队列
int num; void GetFirst(); void Output(); void InsertTime(PCB *in); void InsertFinish(PCB *in); TimeCreate(); void RoundRun(); void main() {
三、实验内容
1. 用 C 语言（或其它语言，如 Java ）编程实现对 N 个进程采用某种进程调度算
法（如动态优先权调度算法、先来先服务算法、短进程优先算法、时间片轮转调度
算法）调度执行的模拟。
2. 每个用来标识进程的进程控制块 typedef struct node {
PCB 可用结构来描述，包括以下字段：
一个时间片，当执行完时，有一个计时器发出时钟中断请求，该进程停止，并被送
到就绪队列的末尾，然后再把处理机分配就绪队列的队列进程，同时也让它执行一
个时间片。 （ 3 ）、通过亲手实验， 对上述写的时间片的工作流程和原理有了更贴切的认识。
另外本次实验遇到了很大的麻烦，其实大部分代码是借鉴网上的，但自己通过修改， 来获取自己想要的，在自己的努力和同学的帮助下终于调试正确，很是高兴。
void InsertTime(PCB *in)
// 将进程插入到就绪队列尾部
{ PCB *fst; fst = ready;
if(ready == NULL) {
in->next = ready; ready = in; } else { while(fst->next != NULL) {

第1篇一、实验目的通过本次实验，加深对操作系统进程调度过程的理解，掌握三种基本调度算法（先来先服务（FCFS）、时间片轮转、动态优先级调度）的原理和实现方法，并能够通过编程模拟进程调度过程，分析不同调度算法的性能特点。

二、实验环境1. 操作系统：Linux/Windows2. 编程语言：C/C++3. 开发环境：Visual Studio、Code::Blocks等三、实验内容1. 实现三种基本调度算法：FCFS、时间片轮转、动态优先级调度。

2. 编写代码模拟进程调度过程，包括进程创建、进程调度、进程运行、进程结束等环节。

3. 每次调度后，打印当前运行的进程、就绪队列以及所有进程的PCB信息。

4. 编写实验报告，描述数据结构、算法流程，展示实验结果，并总结心得。

四、实验步骤1. 定义进程控制块（PCB）结构体，包含进程名、到达时间、服务时间、已用时间、优先数、进程状态等信息。

2. 实现进程调度函数，根据所选调度算法进行进程调度。

3. 编写主函数，初始化进程信息，选择调度算法，并模拟进程调度过程。

4. 每次调度后，打印当前运行的进程、就绪队列以及所有进程的PCB信息。

5. 编写实验报告，描述数据结构、算法流程，展示实验结果，并总结心得。

五、实验结果与分析1. FCFS调度算法实验结果：按照进程到达时间依次调度，每个进程结束后，调度下一个进程。

分析：FCFS调度算法简单，易于实现，但可能会导致进程的响应时间较长，特别是当有大量进程到达时，后到达的进程可能会长时间等待。

2. 时间片轮转调度算法实验结果：每个进程完成一个时间片后，放弃处理机，转到就绪队列队尾。

分析：时间片轮转调度算法能够保证每个进程都能得到一定的运行时间，但可能会出现进程饥饿现象，即某些进程长时间得不到运行。

3. 动态优先级调度算法实验结果：每个进程完成一个时间片后，优先级减1，插入到就绪队列相关位置。

分析：动态优先级调度算法能够根据进程的运行情况动态调整优先级，使得优先级高的进程能够得到更多的运行时间，从而提高系统的响应速度。

实验一进程调度算法模拟一.实验题目：设计一个简单的进程调度算法，模拟OS中的进程调度过程二．要求：①进程数不少于5个；②进程调度算法任选；可以用动态优先数加时间片轮转法实现进程调度，每运行一个时间片优先数减3；③用C语言编程；④程序运行时显示进程调度过程。

三．程序中所用数据结构及说明:进程控制块结构体：typedef struct node1{int ID;//进程标识数int PRIORITY;//进程优先数int CPUTIME;//进程已占用时间片int ALLTIME;//进程还需占用时间片}Block,pcb;就绪进程链表节点：typedef struct node2{pcb data;struct node2 *next;}process;四．清单程序及描述：Procelink.h:typedef struct node1{int ID;//进程标识数int PRIORITY;//进程优先数int CPUTIME;//进程已占用时间片int ALLTIME;//进程还需占用时间片//char STATE;//进程状态//struct node *next;//进程队列指针}Block,pcb;typedef struct node2{pcb data;struct node2 *next;}process;void Initlink(process **PQ){/*如果有内存空间，申请头结点空间并使头指针head指向头结点*/if((*PQ = (process *)malloc(sizeof(process))) == NULL) exit(1);(*PQ)->next = NULL; /*置链尾标记NULL */}int IsEmpty(process *PQ){if(PQ->next == NULL)return 1;else return 0;}void EnInitlink(process *PQ,pcb p){while(PQ->next!=NULL) PQ=PQ->next;process *temp=(process *)malloc(sizeof(Block));temp->data.PRIORITY=p.PRIORITY;temp->data.ID=p.ID;temp->data.CPUTIME=p.CPUTIME;temp->data.ALLTIME=p.ALLTIME;temp->next=PQ->next;PQ->next=temp;}//插入pcb DeInitlink(process *PQ) //选择优先数最小的出列{if(IsEmpty(PQ)){printf("所有进程已运行完!\n");exit(0);//退出}process *temp=(process *)malloc(sizeof(Block));temp = PQ->next;process *te=(process *)malloc(sizeof(Block));process *t=(process *)malloc(sizeof(Block));te= PQ->next;//优先数最小的进程while(temp->next != NULL){if(te->data.PRIORITY<temp->next->data.PRIORITY){te=temp->next;t=temp->next->next;PQ=temp;}temp=temp->next;}PQ->next=PQ->next->next;pcb pp=te->data;// free(temp);// free(t);//free(te);return pp;}//出队列void outid(process *PQ)//输出就绪队列函数{ printf("当前就绪队列为: ");while(!IsEmpty(PQ)){printf("%d ",PQ->next->data.ID);PQ=PQ->next;}printf("\n");}void dispatch(pcb p,process *PQ)//进程运行函数{if((p.ALLTIME)!=0){p.PRIORITY-=3;p.CPUTIME+=1;p.ALLTIME-=1;printf("进程%d运行\n",p.ID);//printf("进程优先数：%d 进程已占用时间片：%d 进程还需占用时间片：%d\n",p.PRIORITY,p.CPUTIME,p.ALLTIME);outid(PQ);//输出就绪队列}if((p.ALLTIME)==0){printf("进程%d 运行完成!\n",p.ID);return;//完成则不加入链表}EnInitlink(PQ,p); return;//运行之后再加入链表}os_1.cpp:#include<stdio.h>#include<stdlib.h>#include"procelink.h"void main(){process * PQ;int n;//n为进程数pcb pro1;Initlink(& PQ);printf("请输入进程个数：");scanf("%d",&n);printf("请输入各个进程的进程标识数ID,进程优先数，进程已占用时间片，进程还需占用时间片\n");for(int i=1;i<=n;i++){printf("第%d进程: ",i);scanf("%d %d %d %d",&pro1.ID,&pro1.PRIORITY,&pro1.CPUTIME,&pro1.ALLTIME);EnInitlink(PQ,pro1);}while(!IsEmpty(PQ)){dispatch(DeInitlink(PQ),PQ);//进程运行函数调用}if(IsEmpty(PQ))printf("所有进程已运行完!\n");free(PQ);//释放内存空间}五．执行结果：六．实验总结：通过这次操作系统中进程调度算法的模拟，使我对操作系统中的进程调度有了更清晰的认识和了解，程序中也有不足之处，该程序是顺序进链，出链时再选择优先数最大的进程。

C语言中设置进程优先顺序的方法在C语言中，可以使用操作系统提供的函数或系统调用来设置进程的优先级顺序。

在大多数操作系统中，进程优先级可以通过设置进程的调度策略和优先级等属性来实现。

有以下几种方法可以设置进程的优先级顺序：1. 通过nice函数设置进程的调度优先级：- nice函数可以增加或降低进程的调度优先级，接受一个整数参数，范围一般是-20到19，负值降低优先级，正值增加优先级，默认为0。

- 调用nice函数可以改变进程的调度优先级，但是范围受到限制，通常只能调整较小的范围。

2.通过调度策略函数来设置进程的优先级：- 在Linux系统中，可以使用sched_setscheduler函数来设置进程的调度策略和优先级。

该函数接受一个进程ID、调度策略和优先级作为参数，可以将进程的优先级设置为较高或较低的值，如FIFO、RR等。

3.使用信号来设置进程的优先级：-在一些情况下，可以通过发送信号来改变进程的优先级。

例如，使用SIGSTOP和SIGCONT信号可以暂停和恢复进程的执行，从而实现优先级的切换。

4.创建多个线程并设置线程的优先级：- 如果在C语言中使用多线程编程，可以使用线程库提供的函数设置线程的优先级。

例如，在POSIX线程库中，可以使用pthread_setschedparam函数来设置线程的调度策略和优先级。

5.在操作系统层面设置进程的优先级：- 在一些操作系统中，可以通过操作系统提供的工具或命令行来设置进程的优先级。

例如，Linux系统中的nice命令可以通过命令行参数设置进程的优先级。

无论使用哪种方法，设置进程的优先级顺序需要有足够的权限来操作。

此外，需要理解不同操作系统可能的调度策略和优先级范围，以确保正确地设置进程的优先级。

需要注意的是，过度调整进程的优先级可能会导致系统性能下降或导致其他进程的执行受到影响。

因此，在设置进程的优先级时，需要权衡系统的整体性能和其他进程的公平性。

操作系统，时间⽚轮转算法的C语⾔实现RoundRobin1 #include "windows.h"2 #include <conio.h>3 #include <stdlib.h>4 #include <fstream.h>5 #include <io.h>6 #include <string.h>7 #include <stdio.h>89void Create_ProcInfo(); // 建⽴进程调度需要的数据10void Display_ProcInfo(); // 显⽰当前系统全部进程的状态11void Scheduler_FF();12void Cpu_Sched();13void IO_Sched();14void NextRunProcess();15void DisData();16void DisResult();1718int RunPoint; // 运⾏进程指针，-1时为没有运⾏进程19int WaitPoint; // 阻塞队列指针，-1时为没有阻塞进程20int ReadyPoint; // 就绪队列指针，-1时为没有就绪进程21long ClockNumber; // 系统时钟22int ProcNumber; // 系统中模拟产⽣的进程总数23int FinishedProc; // 系统中模拟产⽣的进程总数24int q=9;//时间⽚252627//进程信息结构28struct ProcStruct29 {30int p_pid; // 进程的标识号31char p_state; // 进程的状态，C--运⾏ R--就绪 W--组塞 B--后备 F--完成32int p_rserial[16]; // 模拟的进程执⾏的CPU和I/O时间数据序列，间隔存储，0项存储有效项数33int p_pos; // 当前进程运⾏到的序列位置34int p_starttime; // 进程建⽴时间35int p_endtime; // 进程运⾏结束时间36int p_cputime; // 当前运⾏时间段进程剩余的需要运⾏时间37int p_iotime; // 当前I/O时间段进程剩余的I/O时间38int p_next; // 进程控制块的链接指针39int p_excutetime; // 记录⼀次时间⽚内执⾏的时间40 } proc[10];4142////////////////////////////////////////////////////////////////////////////43//44// 随机⽣成进程数量和每个CPU--I/O时间数据序列，进程数量控制在5到10之间， //45// 数据序列控制在6到12之间，CPU和I/O的时间数据值在5到15的范围 //46//47////////////////////////////////////////////////////////////////////////////4849void Create_ProcInfo(void )50 {51int s,i,j;5253 srand(GetTickCount()); // 初始化随机数队列的"种⼦"54 ProcNumber=((float) rand() / 32767) * 5 ; // 随机产⽣进程数量5~10555657for(i=0;i<ProcNumber;i++) // ⽣成进程的CPU--I/O时间数据序列58 {59 proc[i].p_pid=((float) rand() / 32767) * 1000;60 proc[i].p_state='B'; // 初始都为后备状态6162 s=((float) rand() / 32767) *6 + 2; // 产⽣的进程数据序列长度在6~12间63 proc[i].p_rserial[0]=s; // 第⼀项⽤于记录序列的长度64for(j=1;j<=s;j++) // ⽣成时间数据序列65 proc[i].p_rserial[j]=((float) rand() / 32767) *10 + 5;66// 赋其他字段的值67 proc[i].p_pos=1;68 proc[i].p_starttime=((float) rand() / 32767) *49+1; // 随机设定进程建⽴时间69 proc[i].p_endtime=0;70 proc[i].p_cputime=proc[i].p_rserial[1];71 proc[i].p_iotime=proc[i].p_rserial[2];72 proc[i].p_next=-1;73 proc[i].p_excutetime=0;74 }75 printf("\n---------------------------\n 建⽴了%2d 个进程数据序列\n\n", ProcNumber);76 DisData();77 printf("\nPress Any Key To Continue.......");78 _getch() ;79return ;80 }84// 显⽰系统当前状态8586////////////////////////////////////////////////////////////////////////8788void Display_ProcInfo(void)89 { int i,n;9091 system("cls") ;92 printf("时间⽚为%d",q);93 printf("\n 当前系统模拟%2d 个进程的运⾏时钟：%ld\n\n", ProcNumber,ClockNumber);9495 printf(" 就绪指针=%d, 运⾏指针=%d, 阻塞指针=%d\n\n",ReadyPoint,RunPoint,WaitPoint );96if(RunPoint!= -1)97 {98 printf(" 当前运⾏的进程 No.%d ID：%d\n", RunPoint,proc[RunPoint].p_pid);99 printf(" %6d,%6d,%6d\n",proc[RunPoint].p_starttime,proc[RunPoint].p_rserial[proc[RunPoint].p_pos],proc[RunPoint].p_cputime); 100 printf("当前运⾏的进程执⾏的时间为%d",proc[RunPoint].p_excutetime);101 printf("当前运⾏的进程执⾏的cpu时间为%d",proc[RunPoint].p_cputime);102 }103else104 printf(" 当前运⾏的进程ID：No Process Running !\n");105106 n=ReadyPoint;107 printf("\n Ready Process ...... \n");108while(n!=-1) // 显⽰就绪进程信息109 {110 printf(" No.%d ID:%5d,%6d,%6d,%6d\n",n,proc[n].p_pid,proc[n].p_starttime,proc[n].p_rserial[proc[n].p_pos],proc[n].p_cputime );111 n=proc[n].p_next;112 }113114 n=WaitPoint;115 printf("\n Waiting Process ...... \n");116while(n!=-1) // 显⽰阻塞进程信息117 {118 printf(" No.%d ID:%5d,%6d,%6d,%6d\n",n,proc[n].p_pid,proc[n].p_starttime,proc[n].p_rserial[proc[n].p_pos],proc[n].p_iotime);119 n=proc[n].p_next;120 }121122 printf("\n=================== 后备进程 ====================\n");123for(i=0; i<ProcNumber; i++)124if (proc[i].p_state=='B')125 printf(" No.%d ID:%5d,%6d\n",i,proc[i].p_pid,proc[i].p_starttime);126127 printf("\n================ 已经完成的进程 =================\n");128for(i=0; i<ProcNumber; i++)129if (proc[i].p_state=='F')130 printf("No.%d ID:%5d,%6d,%6d\n",i,proc[i].p_pid,proc[i].p_starttime,proc[i].p_endtime);131132 }133134////////////////////////////////////////////////////////////////////////135136// 显⽰模拟执⾏的结果137138////////////////////////////////////////////////////////////////////////139void DisResult(void)140 { int i;141 printf("\n---------------------------------\n");142for(i=0; i<ProcNumber; i++)143 {144 printf("ID=%4d> %2d ",proc[i].p_pid ,proc[i].p_rserial[0] );145 printf("%4d,%4d",proc[i].p_starttime,proc[i].p_endtime);146 printf("\n" );147 }148 }149150////////////////////////////////////////////////////////////////////////151152// 显⽰进程数据序列153154////////////////////////////////////////////////////////////////////////155void DisData(void)156 { int i,j;157158for(i=0; i<ProcNumber; i++)159 {160 printf("ID=%4d %2d > ",proc[i].p_pid ,proc[i].p_rserial[0] );161for(j=1; j<=proc[i].p_rserial[0];j++)162 printf("%4d",proc[i].p_rserial[j]);163 printf("\n" );164 }168// 选择下⼀个可以运⾏的进程169170////////////////////////////////////////////////////////////////////////171void NextRunProcess(void)172 {173if (ReadyPoint==-1) { RunPoint = -1; return;} // 就绪队列也没有等待的进程174175 proc[ReadyPoint].p_state ='C'; //ReadyPoint所指⽰的进程状态变为执⾏状态176 RunPoint=ReadyPoint;177if( proc[ReadyPoint].p_excutetime==-1)//进程为执⾏成功，接着上次的cpu时间执⾏178 {179 proc[ReadyPoint].p_excutetime=0;180 }181else182 proc[ReadyPoint].p_cputime =proc[ReadyPoint].p_rserial[proc[ReadyPoint].p_pos] ;183 ReadyPoint=proc[ReadyPoint].p_next;184 proc[RunPoint].p_next = -1;185186 }187////////////////////////////////////////////////////////////////////////188189// CPU调度190191////////////////////////////////////////////////////////////////////////192193void Cpu_Sched(void)194 {195int n;196197if (RunPoint == -1) // 没有进程在CPU上执⾏198 { NextRunProcess(); return; }199200 proc[RunPoint].p_cputime--; // 进程CPU执⾏时间减少1个时钟单位201 proc[RunPoint].p_excutetime++;202if((proc[RunPoint].p_cputime == 0&&proc[RunPoint].p_excutetime<=q))//若时间⽚未完，但进程已经结束203 {204//printf("若时间⽚未完，但进程已经结束\n");205 proc[RunPoint].p_excutetime=0;//清空运⾏时间206// 进程完成本次CPU后的处理207if (proc[RunPoint].p_rserial[0]==proc[RunPoint].p_pos) //进程全部序列执⾏完成208 {209 FinishedProc++;210 proc[RunPoint].p_state ='F';211 proc[RunPoint].p_endtime = ClockNumber;212 RunPoint=-1; //⽆进程执⾏213 NextRunProcess();214 }215else//进⾏IO操作，进⼊阻塞队列216 {217 proc[RunPoint].p_pos++;218 proc[RunPoint].p_state ='W';219 proc[RunPoint].p_iotime =proc[RunPoint].p_rserial[proc[RunPoint].p_pos];220 printf("进⼊阻塞队列\n");221 n=WaitPoint;222if(n == -1) //是阻塞队列第⼀个I/O进程223 WaitPoint=RunPoint;224else225 { do//放⼊阻塞队列第尾226 {227if(proc[n].p_next == -1)228 { proc[n].p_next = RunPoint;229break;230 }231 n=proc[n].p_next;232 } while(n!=-1) ;233 }234 RunPoint=-1;235 NextRunProcess();236 }237return;238 }239if(proc[RunPoint].p_cputime > 0&&proc[RunPoint].p_excutetime<q)//时间⽚未完程序未执⾏结束继续执⾏240 {241//printf("时间⽚未完程序未执⾏结束继续执⾏\n");242return;243 }244//{ printf("\n RunPoint=%d,ctime=%d",RunPoint,proc[RunPoint].p_cputime);getchar();return; }245if(proc[RunPoint].p_cputime > 0&&proc[RunPoint].p_excutetime==q)//时间⽚完，但是程序未执⾏完放到就绪队列尾部246 {247//printf("时间⽚完，但是程序未执⾏完放到就绪队列尾部\n");248int n;249 proc[RunPoint].p_state='R'; // 进程状态修改为就绪250 proc[RunPoint].p_next=-1;251 proc[RunPoint].p_excutetime=-1;//清空运⾏时间,-1代表程序未执⾏完成252if(ReadyPoint==-1) // 就绪队列⽆进程253 ReadyPoint=RunPoint;254else// 就绪队列有进程，放⼊队列尾255 {256 n=ReadyPoint;257while(proc[n].p_next!=-1) n=proc[n].p_next;258 proc[n].p_next=RunPoint;259 }260 RunPoint=-1;261 NextRunProcess(); //执⾏下⼀个进程262 }263264 }265266267268////////////////////////////////////////////////////////////////////////269270// I/O调度271272////////////////////////////////////////////////////////////////////////273274void IO_Sched(void)275 {276int n,bk;277278if (WaitPoint==-1) return; // 没有等待I/O的进程，直接返回279280 proc[WaitPoint].p_iotime--; // 进⾏1个时钟的I/O时间281282if (proc[WaitPoint].p_iotime > 0) return; // 还没有完成本次I/O283284// 进程的I/O完成处理285if (proc[WaitPoint].p_rserial[0]==proc[WaitPoint].p_pos) //进程全部任务执⾏完成286 {287 FinishedProc++;288 proc[WaitPoint].p_endtime = ClockNumber;289 proc[WaitPoint].p_state ='F';290291if(proc[WaitPoint].p_next==-1)292 { WaitPoint=-1;return ;}293else//调度下⼀个进程进⾏I/O操作294 {295 n=proc[WaitPoint].p_next;296 proc[WaitPoint].p_next=-1;297 WaitPoint=n;298 proc[WaitPoint].p_iotime =proc[WaitPoint].p_rserial[proc[WaitPoint].p_pos] ; 299return ;300 }301 }302else//进⾏下次CPU操作，进就绪队列303 {304 bk=WaitPoint;305 WaitPoint=proc[WaitPoint].p_next;306307 proc[bk].p_pos++;308 proc[bk].p_state ='R'; //进程状态为就绪309 proc[bk].p_cputime = proc[bk].p_rserial[proc[bk].p_pos];310 proc[bk].p_next =-1;311312 n=ReadyPoint;313if(n == -1) //是就绪队列的第⼀个进程314 { ReadyPoint=bk; return; }315else316 { do317 {318if(proc[n].p_next == -1) { proc[n].p_next = bk; break ; }319 n=proc[n].p_next;320 }321while(n!=-1);322 }323 }324return ;325 }326327328329330331////////////////////////////////////////////////////////////////////////332333// 检查是否有新进程到达，有则放⼊就绪队列334335////////////////////////////////////////////////////////////////////////336337void NewReadyProc(void)338 {339int i,n;340341for(i=0; i<ProcNumber; i++)342 {343if (proc[i].p_starttime == ClockNumber) // 进程进⼊时间达到系统时间344 {345 proc[i].p_state='R'; // 进程状态修改为就绪346 proc[i].p_next=-1;347348if(ReadyPoint==-1) // 就绪队列⽆进程349 ReadyPoint=i;350else// 就绪队列有进程，放⼊队列尾351 {352 n=ReadyPoint;353while(proc[n].p_next!=-1) n=proc[n].p_next;354 proc[n].p_next=i;355 }356 }357 } // for358return;359 }360361362////////////////////////////////////////////////////////////////////////363364// 调度模拟算法365366////////////////////////////////////////////////////////////////////////367368void Scheduler_FF(void)369 {370 FinishedProc=0;371if(ProcNumber==0)372 { printf(" 必须⾸先建⽴进程调度数据！ \n");373 system("cls"); return;374 }375376 ClockNumber=0;// 时钟开始计时, 开始调度模拟377while(FinishedProc < ProcNumber) // 执⾏算法378 {379 ClockNumber++; // 时钟前进1个单位380 NewReadyProc(); // 判别新进程是否到达381 Cpu_Sched(); // CPU调度382 IO_Sched(); // IO调度383 Display_ProcInfo(); //显⽰当前状态384 }385 DisResult();386 getch(); return;387 }388389void Change_q(void)390 {391 scanf("%d",&q);392 }393394///////////////////////////////////////////////////////////////////395396// 主函数397398///////////////////////////////////////////////////////////////////399400int main(int argc, char* argv[])401 {402char ch;403404 RunPoint=-1; // 运⾏进程指针，-1时为没有运⾏进程405 WaitPoint=-1; // 阻塞队列指针，-1时为没有阻塞进程406 ReadyPoint=-1; // 就绪队列指针，-1时为没有就绪进程407 ClockNumber=0; // 系统时钟408 ProcNumber=0; // 当前系统中的进程总数409410 system("cls") ;411while ( true )412 {413 printf("***********************************\n");414 printf(" 1: 建⽴进程调度数据序列 \n") ;415 printf(" 2: 执⾏调度算法\n") ;416 printf(" 3: 显⽰调度结果 \n") ;417 printf(" 4: 更改时间⽚ \n");418 printf(" 5: 退出\n") ;419 printf("***********************************\n");420 printf( "Enter your choice (1 ~ 5): ");421422do{ //如果输⼊信息不正确，继续输⼊423 ch = (char)_getch() ;424 } while(ch != '1' && ch != '2'&& ch != '3'&& ch != '4'&& ch != '5'); 425426if(ch == '5') { printf( "\n");return0; } // 选择4，退出427if(ch == '3') DisResult(); // 选择3428if(ch == '2') Scheduler_FF(); // 选择2429if(ch == '1') Create_ProcInfo(); // 选择1430if(ch == '4') Change_q();431 _getch() ;432 system("cls") ;433 }434//结束435 printf("\nPress Any Key To Continue:");436 _getch() ;437return0;438 }。