实验2 进程状态转换及其PCB的变化
操作系统实验二：进程管理
操作系统实验二：进程管理操作系统实验二：进程管理篇一：操作系统实验报告实验一进程管理一、目的进程调度是处理机管理的核心内容。
本实验要求编写和调试一个简单的进程调度程序。
通过本实验加深理解有关进程控制块、进程队列的概念，并体会和了解进程调度算法的具体实施办法。
二、实验内容及要求1、设计进程控制块PCB的结构（PCB结构通常包括以下信息：进程名（进程ID）、进程优先数、轮转时间片、进程所占用的CPU时间、进程的状态、当前队列指针等。
可根据实验的不同，PCB结构的内容可以作适当的增删）。
为了便于处理，程序中的某进程运行时间以时间片为单位计算。
各进程的轮转时间数以及进程需运行的时间片数的初始值均由用户给定。
2、系统资源(r1…rw),共有w类，每类数目为r1…rw。
随机产生n进程Pi(id,s(j,k)t),0<=i<=n,0<=j<=m,0<=k<=dt为总运行时间，在运行过程中，会随机申请新的资源。
3、每个进程可有三个状态（即就绪状态W、运行状态R、等待或阻塞状态B），并假设初始状态为就绪状态。
建立进程就绪队列。
4、编制进程调度算法：时间片轮转调度算法本程序用该算法对n个进程进行调度，进程每执行一次，CPU时间片数加1，进程还需要的时间片数减1。
在调度算法中，采用固定时间片（即：每执行一次进程，该进程的执行时间片数为已执行了1个单位），这时，CPU时间片数加1，进程还需要的时间片数减1，并排列到就绪队列的尾上。
三、实验环境操作系统环境：Windows系统。
编程语言：C#。
四、实验思路和设计1、程序流程图2、主要程序代码//PCB结构体struct pcb{public int id; //进程IDpublic int ra; //所需资源A的数量public int rb; //所需资源B的数量public int rc; //所需资源C的数量public int ntime; //所需的时间片个数public int rtime; //已经运行的时间片个数public char state; //进程状态，W（等待）、R（运行）、B（阻塞）//public int next;}ArrayList hready = new ArrayList();ArrayList hblock = new ArrayList();Random random = new Random();//ArrayList p = new ArrayList();int m, n, r, a,a1, b,b1, c,c1, h = 0, i = 1, time1Inteval;//m为要模拟的进程个数，n为初始化进程个数//r为可随机产生的进程数（r=m-n）//a，b，c分别为A，B，C三类资源的总量//i为进城计数，i=1…n//h为运行的时间片次数，time1Inteval为时间片大小（毫秒）//对进程进行初始化，建立就绪数组、阻塞数组。
2.2 进程的状态及转换
2.2 进程的状态及转换进程是操作系统中的基本执行单元，它的状态及其转换对于系统的正常运行具有重要的意义。
在本文中，我们将讨论进程的状态及各种状态之间的转换，以便更好地理解进程的运行机制。
进程的状态一般分为五种：（1）创建态（new）：当进程被创建但还未被执行时，它处于创建态。
此时，操作系统会为进程分配必要的资源，比如代码段、数据段、堆栈等，以便其能够执行。
（2）就绪态（ready）：当进程已经准备好执行时，但由于当前处理机正忙于执行其他进程，导致该进程无法执行时，它处于就绪态。
此时进程已经将所有必要的资源准备好，只需要分配到CPU才能运行。
（3）运行态（running）：当进程获得处理器时间并开始执行指令时，它处于运行态。
此时，进程会按照指令进行操作。
（4）阻塞态（blocked）：当进程由于某些原因无法继续执行时，它进入阻塞态。
比如，进程需要等待某个资源（如读取磁盘数据），或者它正在等待输入输出操作的结果。
（5）终止态（terminated）：当进程执行完毕或被强制终止时，它进入终止态。
此时，操作系统会释放进程所持有的资源，以便其他进程使用。
进程的状态之间可以相互转换。
在操作系统中，许多事件都可能导致进程状态的转换，比如中断请求、操作系统的调度、进程自身的请求等等。
下面我们来看几个具体的转换：（1）创建态-->就绪态：当操作系统为进程分配到必要的资源之后，进程会从创建态转换到就绪态。
此时进程已经准备好执行，只是没有获取到CPU的时间片。
（3）运行态-->就绪态：当进程执行完毕所有指令并主动释放CPU时间片时，它会从运行态转换到就绪态，等待下一次操作系统调度。
（4）运行态-->阻塞态：当进程需要等待某个事件发生时，它会从运行态转换到阻塞态。
比如，读取磁盘数据时就需要等待磁盘完成读取操作。
（5）阻塞态-->就绪态：当进程等待的事件已经发生或操作系统主动为其分配资源时，它会从阻塞态返回到就绪态，等待下一次操作系统调度。
操作系统进程的三种状态的转换实验报告
3.设计出可视性较好的界面，应能反映出进程状态的变化引起的对应内容。
4.代码书写要规范，要适当地加入注释。
5.编译并调试自己编写的程序，是程序编译成功。
6.检查运行的结果是否正确。
四、实验结果（含算法说明、程序、数据记录及分析等，可附页）
五、实验思考题
利用C语言编写了一个模拟Windows进程三种状态之间的转换的程序，虽然肥城精简，但是我从中学到的很多知识点，学会了编写程序时的一些技巧，为自己以后更加深造打下了坚实的基础和使自己更好的理解Windows如何更好的管理进程。
六、实验总结（含实验心得体会，收获与不足等）
通过这次实验让我受益匪浅，不仅明白了自己以前不知道如何定义和应用结构体，还提高了自己的编程能力，调试程序的能力，使自己的编程能力有了大幅度的提高。使自己更好的理解进程的概念和进程的三种状态之间转换的过程和他们之间的关系。为自己以后复习打下了夯实的基础。
1）根据课本第三章的内容设计并实现一个模拟进程状态转换。
2）独立编写和调试程序。进程的数目，进程的状态模型自行选择。
3）合理设计进程相对应的数据结构，内容要包括进程的基本信息。
4）是进程的三种状态之间的转化清晰的显示。
三、实验过程及步骤（包含使用软件或实验设备等情况）
1.打开DEV-C++,新建一个源代码文件
实验报告
实验名称
进程三种状态的转换
专业
计算机
课程名称
操作系统
指导老师
张海燕
班级
二表一班
姓名
刘广法
学号
11100140109
评分
实验地点
1cபைடு நூலகம்6217
实验二 进程调度实验
实验二进程调度实验(2学时)一、实验目的用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解。
二、实验内容：任务：设计一个有N个进程并行的进程调度程序进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和同优先级条件下先来先服务算法。
每个进程有一个进程控制块（PCB）表示。
进程控制块可以包含如下信息：进程名、优先数、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
调度算法的流程图2如下：图2调度算法的流程图三、实验步骤(1) 打开VC，选择菜单项file->new,选择projects选项卡并建立一个名为" ry2"的win32 console applicatoin工程；创建时注意指定创建该工程的目录；(2) 在工程中创建源文件" ry2.cpp"：选择菜单项project->add to project->files，在选择框中输入自己想要创建的文件名，这里是" ry2.cpp"；在接下来询问是否创建新文件时回答"yes"；然后通过Workspace->FileView->Source Files打开该文件，在其中编辑源文件并保存.(3) 通过调用菜单命令项build->build all进行编译连接,可以在指定的工程目录下得到debug-> sy2.exe程序，运行sy2.exe。
进程的调度实验报告(3篇)
第1篇一、实验目的通过本次实验，加深对操作系统进程调度原理的理解，掌握先来先服务（FCFS）、时间片轮转（RR）和动态优先级（DP）三种常见调度算法的实现，并能够分析这些算法的优缺点，提高程序设计能力。
二、实验环境- 编程语言：C语言- 操作系统：Linux- 编译器：GCC三、实验内容本实验主要实现以下内容：1. 定义进程控制块（PCB）结构体，包含进程名、到达时间、服务时间、优先级、状态等信息。
2. 实现三种调度算法：FCFS、RR和DP。
3. 创建一个进程队列，用于存储所有进程。
4. 实现调度函数，根据所选算法选择下一个执行的进程。
5. 模拟进程执行过程，打印进程执行状态和就绪队列。
四、实验步骤1. 定义PCB结构体：```ctypedef struct PCB {char processName[10];int arrivalTime;int serviceTime;int priority;int usedTime;int state; // 0: 等待，1: 运行，2: 完成} PCB;```2. 创建进程队列：```cPCB processes[MAX_PROCESSES]; // 假设最多有MAX_PROCESSES个进程int processCount = 0; // 实际进程数量```3. 实现三种调度算法：（1）FCFS调度算法：```cvoid fcfsScheduling() {int i, j;for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[i].processName); processes[i].usedTime++;if (processes[i].usedTime == processes[i].serviceTime) { processes[i].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[i].processName); }for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```（2）RR调度算法：```cvoid rrScheduling() {int i, j, quantum = 1; // 时间片for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[i].processName); processes[i].usedTime++;processes[i].serviceTime--;if (processes[i].serviceTime <= 0) {processes[i].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[i].processName); } else {processes[i].arrivalTime++;}for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```（3）DP调度算法：```cvoid dpScheduling() {int i, j, minPriority = MAX_PRIORITY;int minIndex = -1;for (i = 0; i < processCount; i++) {if (processes[i].arrivalTime <= 0 && processes[i].priority < minPriority) {minPriority = processes[i].priority;minIndex = i;}}if (minIndex != -1) {processes[minIndex].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[minIndex].processName);processes[minIndex].usedTime++;processes[minIndex].priority--;processes[minIndex].serviceTime--;if (processes[minIndex].serviceTime <= 0) {processes[minIndex].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[minIndex].processName); }}}```4. 模拟进程执行过程：```cvoid simulateProcess() {printf("请选择调度算法（1：FCFS，2：RR，3：DP）：");int choice;scanf("%d", &choice);switch (choice) {case 1:fcfsScheduling();break;case 2:rrScheduling();break;case 3:dpScheduling();break;default:printf("无效的调度算法选择。
进程操作的实验报告
一、实验目的1. 理解进程的基本概念和进程控制块（PCB）的作用。
2. 掌握进程创建、调度、同步和通信的基本方法。
3. 熟悉进程状态转换及进程同步机制。
4. 提高编程能力，加深对操作系统进程管理的理解。
二、实验环境1. 操作系统：Windows 102. 编程语言：C/C++3. 开发环境：Visual Studio 2019三、实验内容1. 进程创建与销毁2. 进程调度3. 进程同步4. 进程通信四、实验步骤1. 进程创建与销毁（1）定义进程结构体```ctypedef struct {int pid; // 进程IDchar name[50]; // 进程名int status; // 进程状态struct PCB next; // 指向下一个进程的指针} PCB;```（2）创建进程```cPCB createProcess(char name) {PCB newProcess = (PCB )malloc(sizeof(PCB)); newProcess->pid = ...; // 分配进程IDstrcpy(newProcess->name, name);newProcess->status = ...; // 初始化进程状态 newProcess->next = NULL;// ... 其他初始化操作return newProcess;}```（3）销毁进程```cvoid destroyProcess(PCB process) {free(process);}```2. 进程调度（1）定义进程队列```ctypedef struct {PCB head; // 队列头指针PCB tail; // 队列尾指针} ProcessQueue;```（2）初始化进程队列```cvoid initProcessQueue(ProcessQueue queue) {queue->head = NULL;queue->tail = NULL;}```（3）入队```cvoid enqueue(ProcessQueue queue, PCB process) { if (queue->head == NULL) {queue->head = process;queue->tail = process;} else {queue->tail->next = process;queue->tail = process;}}（4）出队```cPCB dequeue(ProcessQueue queue) {if (queue->head == NULL) {return NULL;}PCB process = queue->head;queue->head = queue->head->next; if (queue->head == NULL) {queue->tail = NULL;}return process;}```3. 进程同步（1）互斥锁```ctypedef struct {int locked; // 锁的状态} Mutex;void initMutex(Mutex mutex) {mutex->locked = 0;void lock(Mutex mutex) {while (mutex->locked) {// 等待锁释放}mutex->locked = 1;}void unlock(Mutex mutex) {mutex->locked = 0;}```（2）信号量```ctypedef struct {int count; // 信号量值Mutex mutex; // 互斥锁} Semaphore;void initSemaphore(Semaphore semaphore, int count) { semaphore->count = count;initMutex(&semaphore->mutex);}void P(Semaphore semaphore) {lock(&semaphore->mutex);while (semaphore->count <= 0) {// 等待信号量}semaphore->count--;unlock(&semaphore->mutex);}void V(Semaphore semaphore) {lock(&semaphore->mutex);semaphore->count++;unlock(&semaphore->mutex);}```4. 进程通信（1）管道通信```cint pipe(int pipefd[2]) {// 创建管道}void writePipe(int pipefd[2], const void buf, size_t nbyte) { // 向管道写入数据}void readPipe(int pipefd[2], void buf, size_t nbyte) {// 从管道读取数据}```（2）消息队列通信```cint msgget(key_t key, int msgflg) {// 创建消息队列}void msgsnd(int msqid, const void msgp, size_t msgsz, int msgflg) {// 向消息队列发送消息}void msgrcv(int msqid, void msgp, size_t msgsz, long msgtype, int msgflg) {// 从消息队列接收消息}```五、实验结果与分析1. 进程创建与销毁：通过创建和销毁进程，验证了进程结构体的正确性。
PCB[进程控制块作用]
![PCB[进程控制块作用]](https://img.taocdn.com/s3/m/24408a9ca0116c175f0e48ae.png)
PCB为了描述控制进程的运行，系统中存放进程的管理和控制信息的数据结构称为进程控制块（PCB Process Control Block），它是进程实体的一部分，是操作系统中最重要的记录性数据结构。
它是进程管理和控制的最重要的数据结构，每一个进程均有一个PCB，在创建进程时，建立PCB，伴随进程运行的全过程，直到进程撤消而撤消。
中文名进程管理块外文名Process Control BlockPCB中记录了操作系统所需的，用于描述进程的当前情况以及控制进程运行的全部信息。
PCB 的作用是使一个在多道程序环境下不能独立运行的程序（含数据），成为一个能独立运行的基本单位，一个能与其他进程并发执行的进程。
或者说，OS是根据PCB来对并发执行的进程进行控制和管理的。
例如，当OS要调度某进程执行时，要从该进程的PCB中查处其现行状态及优先级；在调度到某进程后，要根据其PCB中所保存的处理机状态信息，设置该进程恢复运行的现场，并根据其PCB中的程序和数据的内存始址，找到其程序和数据；进程在执行过程中，当需要和与之合作的进程实现同步，通信或者访问文件时，也都需要访问PCB；当进程由于某种原因而暂停执行时，又须将器断点的处理机环境保存在PCB中。
可见，在进程的整个生命期中，系统总是通过PCB对进程进行控制的，即系统是根据进程的PCB 而不是任何别的什么而感知到该进程的存在的。
所以说，PCB是进程存在的唯一标志。
组成PCB进程控制块是进程的静态描述，由PCB、有关程序段和该程序段对其进行操作的数据结构集三部分组成。
在Unix或类Unix系统中，进程是由进程控制块，进程执行的程序，进程执行时所用数据，进程运行使用的工作区组成。
其中进程控制块是最重要的一部分。
进程控制块是用来描述进程的当前状态，本身特性的数据结构，是进程中组成的最关键部分，其中含有描述进程信息和控制信息，是进程的集中特性反映，是操作系统对进程具体进行识别和控制的依据。
操作系统作业《模拟进程转换》
实验一进程状态模拟进程状态转换及其PCB的变化一.实验目的自行编制模拟程序，通过形象化的状态显示，使学生理解进程的概念、进程之间的状态转换及其所带来的PCB内容、组织的变化，理解进程与其PCB间的一一对应关系。
二. 实验要求设计并实现一个模拟进程状态转换及其相应PCB组织结构变化的程序；独立设计、编写、调试程序；程序界面应能反映出在模拟条件下，进程之间状态转换及其对应的PCB组织的变化。
三. 程序流程图时间片超时初始化进程状态接收用户操作命令S时间等待进程调度 开始S=1? S=2?S=3?事件发生显示PCB 信息结束退出？四. 数据结构本次试验主要用到的是队列的数据结构: 就绪队列：queue Q0;等待队列: queue Q1；五.源程序#include<iostream>#include<stdlib.h>#include<queue>using namespace std;queue <char>q[11];void menu();char ch; //CPU中运行的进程void Qout(int a) //输出队列中的进程{char c;switch(a){case 0: cout<<"就绪队列：";break;case 1: cout<<"等待队列：";break;case 2: cout<<"就绪队列：";break;case 3: cout<<"等待队列：";break;case 4: cout<<"就绪队列：";break;case 5: cout<<"等待队列：";break;case 6: cout<<"就绪队列：";break;case 7: cout<<"等待队列：";break;case 8: cout<<"就绪队列：";break;case 9: cout<<"等待队列：";break;case 10: cout<<"就绪队列：";break;case 11: cout<<"等待队列：";break;default:break;}while(!q[a].empty()){c=q[a].front();cout<<c<<" ";q[a].pop();}cout<<endl;}void Dispatch(){if(q[0].empty())cout<<"就绪队列为空,无法调度!"<<endl;else{ch=q[0].front();q[0].pop();q[2]=q[0];q[3]=q[1];Qout(2);Qout(3);cout<<"运行："<<ch<<endl;}menu();}void Timeout(){if(ch>='A'&&ch<='E') //判断CPU不为空{q[0].push(ch);ch=q[0].front();q[0].pop();q[4]=q[0];q[5]=q[1];Qout(4);Qout(5);cout<<"运行："<<ch<<endl;}else cout<<"CPU空闲,不存在超时!"<<endl;menu();}void Event_Wait(){if(ch>='A'&&ch<='E'&&!q[0].empty()){q[1].push(ch);ch=q[0].front();q[0].pop();q[8]=q[0];q[9]=q[1];Qout(8);Qout(9);cout<<"运行："<<ch<<endl;}else {cout<<"CPU空闲或就绪队列为空!"<<endl;if(ch>='A'&&ch<='E'){q[1].push(ch);ch=' ';q[10]=q[0];q[11]=q[1];Qout(10);Qout(11);cout<<"运行："<<ch<<endl;}}menu();}void Event_Occor(){ch=' ';if(!q[1].empty()){char c2=q[1].front();q[0].push(c2);q[1].pop();if(ch>='A'&&ch<='E'){q[6]=q[0];q[7]=q[1];Qout(6);Qout(7);cout<<"运行："<<ch<<endl;}else{ch=q[0].front();q[0].pop();q[6]=q[0];q[7]=q[1];Qout(6);Qout(7);cout<<"运行："<<ch<<endl;}}else cout<<"等待队列为空!"<<endl;menu();}void menu(){int s,m;cout<<"退出?(1:是；0:否) [ ]\b\b";cin>>m;while(1){if(m==1) exit(0);else if(m==0) break;else {cout<<"输入错误，请重新选择：[ ]\b\b";cin>>m;}}cout<<"请选择操作：[ ]\b\b";cin>>s;while(s!=1&&s!=2&&s!=3&&s!=4){cout<<"无此操作，请重新选择：[ ]\b\b";cin>>s;}switch(s){case 1: Dispatch();break;case 2: Timeout();break;case 3: Event_Wait();break;case 4: Event_Occor();break;default :break;}}int main(){char ch1='A';cout<<"操作说明：(1)Dispatch,(2)Timeout,(3)Event_Wait,(4)Event_Occor"<<endl;cout<<"我们预设初始状态如下"<<endl;cout<<"就绪队列：";for(int i=0;i<3;i++) //定义2个进程入就绪队列{cout<<ch1<<" ";q[0].push(ch1);ch1+=1;}cout<<endl;cout<<"等待队列：";for(int j=0;j<2;j++) //定义3个进程入等待队列{cout<<ch1<<" ";q[1].push(ch1);ch1+=1;}cout<<endl;cout<<"运行："<<endl;menu();return 0;}六. 运行结果。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验2进程状态转换及其PCB的变化1.目的自行编制模拟程序，通过形象化的状态显示，使学生理解进程的概念、进程之间的状态转换及其所带来的PCB内容、组织的变化，理解进程与其PCB间的一一对应关系。
2. 内容及要求1）设计并实现一个模拟进程状态转换及其相应PCB内容、组织结构变化的程序。
2）独立编写、调试程序。
进程的数目、进程的状态模型（三状态、五状态、七状态或其它）以及PCB的组织形式可自行选择。
3）合理设计与进程PCB相对应的数据结构。
PCB的内容要涵盖进程的基本信息、控制信息、资源需求及现场信息。
4）设计出可视性较好的界面，应能反映出进程状态的变化引起的对应PCB 内容、组织结构的变化。
5）代码书写要规范，要适当地加入注释。
6）鼓励在实验中加入新的观点或想法，并加以实现。
7）认真进行预习，完成预习报告。
8）实验完成后，要认真总结，完成实验报告。
3.程序流程图进程的三种基本状态及其转换如下图所示。
开始输入要执行的指令1？N 2？N 3？N 4？N 5？N 0？YY 结束N提示输入错误就绪队列已满？N创建进程Y提示就绪队列已满Y有进程处于运行状态?Y 该进程执行一个时间片后放回就绪队列N将就绪队列中优先级最高的进程放入运行队列有进程处于运行状态?Y该进程所需执行时间减1，并回到就绪队列Cputime++Y有进程处于运行状态？Y将该进程放入阻塞队列N提示无运行的进程输入事件发生的进程名称阻塞队列中有该进程？Y 将该进程放入就绪队列N提示该进程并未阻塞4.数据结构及说明在本实验中，主要的数据结构是PCB 的数据结构，具体如下： struct process{char name; //进程名称int needtime; //进程所需要的运行时间int priority; //进程的优先级};5.源程序#include<stdio.h>#include<stdlib.h>#include<string.h>struct process{char name;int needtime;int priority;};struct process readyQueue[5];struct process run;struct process blockedQueue[5];const struct process null={NULL,0,0};int readyQueueHead=0;int blockedQueueHead=0;int cpuState=0;int cpuTime=0;void Order(struct process parameter[],int head);//将队列中的进程按优先级排列int Creat();void Dispath();int Timeout();int EventWait();int EventOccur();void Order(struct process parameter[],int head){int k,i;struct process temp;for(k=0;k<head-1;k++){for(i=0;i<head-k-1;i++){if(parameter[i].priority>=parameter[i+1].priority){temp=parameter[i];parameter[i]=parameter[i+1];parameter[i+1]=temp;}}}}int Creat(){if(readyQueueHead>=5){printf("The Ready Queue has been full\n");return 0;}label1:printf(" input new process name(must be a letter): \n");scanf("%c",&(readyQueue[readyQueueHead].name));getchar();int k;for( k=0;k<readyQueueHead;k++)if(readyQueue[readyQueueHead].name==readyQueue[k].name||readyQueue[rea dyQueueHead].name==readyQueue[k].name+32||readyQueue[readyQueueHead].na me==readyQueue[k].name-32){printf("the process is already exist!\n");goto label1;}for( k=0;k<blockedQueueHead;k++)if(readyQueue[readyQueueHead].name==blockedQueue[k].name||readyQueue[r eadyQueueHead].name==blockedQueue[k].name+32||readyQueue[readyQueueHea d].name==blockedQueue[k].name-32){printf("the process is already exist!\n");goto label1;}if(readyQueue[readyQueueHead].name==||readyQueue[readyQueueH ead].name==+32||readyQueue[readyQueueHead].name==-32) {printf("the process is already exist!\n");goto label1;}printf("input needtime (input a int number):\n");label2:scanf("%d",&(readyQueue[readyQueueHead].needtime));getchar();if(readyQueue[readyQueueHead].needtime<1||readyQueue[readyQueueHead].n eedtime>100){printf("please input the true needtime(1--100)\n");goto label2;}printf(" input the priority(1--10): \n");label3:scanf("%d",&(readyQueue[readyQueueHead].priority));getchar();if(readyQueue[readyQueueHead].priority<1||readyQueue[readyQueueHead].prio rity>10){printf("please 1--10!\n");goto label3;}readyQueueHead++;Order(readyQueue,readyQueueHead);return 0;}void Dispath(){if (cpuState==0){readyQueueHead--;if(readyQueue[readyQueueHead].needtime>0){Order(readyQueue,readyQueueHead);run=readyQueue[readyQueueHead];readyQueue[readyQueueHead]=null;cpuState=1;}else printf("no process in the Ready Queue\n");}else {Timeout();Dispath();}}int Timeout(){cpuTime++;if (==NULL) return 0;readyQueue[readyQueueHead]=run;run=null;cpuState=0;readyQueue[readyQueueHead].needtime--;if(readyQueue[readyQueueHead].needtime==0){printf("The process '%c' has finished",readyQueue[readyQueueHead].name);readyQueue[readyQueueHead]=null;return 0;}readyQueueHead++;Order(readyQueue,readyQueueHead);return 0;}int EventWait(){if(blockedQueueHead>=5){printf("error:The Blocked Queue has been full\n");return 0;}if(cpuState==0){printf("error:no process in CPU");return 0;}run.needtime--;blockedQueue[blockedQueueHead]=run;blockedQueueHead++;run=null;cpuState=0;cpuTime++;printf("The process is blocked!\n");return 0;}int EventOccur(){if(readyQueueHead>=5){printf("The Ready Queue has been full\n");return 0;}printf("Please input the process name whose event occured!\n");char name=getchar();getchar();int i;struct process temp;for(i=0;i<blockedQueueHead;i++){if(name==blockedQueue[i].name){blockedQueueHead--;readyQueue[readyQueueHead]=blockedQueue[i];readyQueueHead++;blockedQueue[i]=blockedQueue[blockedQueueHead];blockedQueue[blockedQueueHead]=null;Order(readyQueue,readyQueueHead);printf("The process %c is ready!\n",name);return 0;}}if(i==blockedQueueHead){printf("error:This process has not been blocked!\n");}return 0;}int Show(){printf("\nCPU time:%d\n",cpuTime);printf(" name needtime priority\n");printf("Ready Queue: ");int i;if(readyQueue[0].name!=NULL)for(i=readyQueueHead;i>0;i--)printf("%c %d %d\n ",readyQueue[i-1].name,readyQueue[i-1].needtime,readyQueue[i-1].priority);else printf("null");printf("\nRunning Process: ");if(==NULL) printf("null");else printf("%c %d %d\n ",,run.needtime,run.priority);printf("\nBlock Queue: ");if(blockedQueue[0].name==NULL) printf("null");else for(i=blockedQueueHead;i>0;i--)printf("%c %d %d\n ",blockedQueue[i-1].name,blockedQueue[i-1].needtime,blockedQueue[i-1].priority); }int main(){SELECT:printf("\n\n1:input new process\n2:Dispath\n3:Timeout\n4:EventWait\n5:EventOccurs\n0:exit\n");int select=getchar();getchar();switch(select){case '1':Creat();Show();break;case '2':Dispath();Show();break;case '3':Timeout();Show();break;case '4':EventWait();Show();break;case '5':EventOccur();Show();break;case '0':exit(0);default:printf("Please select from 0 to 5\n");}goto SELECT;return 0;6.运行结果及其说明（1）创建进程：按‘1’创建进程，进程被放入就绪队列，并按优先级从高到低排列。