实验一 进程状态转换

合集下载

实验一、进程调度实验报告

实验一、进程调度实验报告

实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一,其目的是合理地分配 CPU 资源给各个进程,以提高系统的整体性能和资源利用率。

通过本次实验,我们旨在深入理解进程调度的原理和算法,掌握进程状态的转换,观察不同调度策略对系统性能的影响,并通过实际编程实现来提高我们的编程能力和对操作系统概念的理解。

二、实验环境本次实验使用的操作系统为 Windows 10,编程语言为 C++,开发工具为 Visual Studio 2019。

三、实验原理1、进程状态进程在其生命周期中会经历不同的状态,包括就绪态、运行态和阻塞态。

就绪态表示进程已经准备好执行,只等待 CPU 分配;运行态表示进程正在 CPU 上执行;阻塞态表示进程由于等待某个事件(如 I/O操作完成)而暂时无法执行。

2、调度算法常见的进程调度算法有先来先服务(FCFS)、短作业优先(SJF)、时间片轮转(RR)等。

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

短作业优先算法优先调度执行时间短的进程。

时间片轮转算法将 CPU 时间划分成固定大小的时间片,每个进程轮流获得一个时间片执行。

四、实验内容1、设计并实现一个简单的进程调度模拟器定义进程结构体,包含进程 ID、到达时间、执行时间、剩余时间等信息。

实现进程的创建、插入、删除等操作。

实现不同的调度算法。

2、对不同调度算法进行性能测试生成一组具有不同到达时间和执行时间的进程。

分别采用先来先服务、短作业优先和时间片轮转算法进行调度。

记录每个算法下的平均周转时间、平均等待时间等性能指标。

五、实验步骤1、进程结构体的定义```c++struct Process {int pid;int arrivalTime;int executionTime;int remainingTime;int finishTime;int waitingTime;int turnaroundTime;};```2、进程创建函数```c++void createProcess(Process processes, int& numProcesses, int pid, int arrivalTime, int executionTime) {processesnumProcessespid = pid;processesnumProcessesarrivalTime = arrivalTime;processesnumProcessesexecutionTime = executionTime;processesnumProcessesremainingTime = executionTime;numProcesses++;}```3、先来先服务调度算法实现```c++void fcfsScheduling(Process processes, int numProcesses) {int currentTime = 0;for (int i = 0; i < numProcesses; i++){if (currentTime < processesiarrivalTime) {currentTime = processesiarrivalTime;}processesistartTime = currentTime;currentTime += processesiexecutionTime;processesifinishTime = currentTime;processesiwaitingTime = processesistartTime processesiarrivalTime;processesiturnaroundTime = processesifinishTime processesiarrivalTime;}}```4、短作业优先调度算法实现```c++void sjfScheduling(Process processes, int numProcesses) {int currentTime = 0;int minExecutionTime, selectedProcess;bool found;while (true) {found = false;minExecutionTime = INT_MAX;selectedProcess =-1;for (int i = 0; i < numProcesses; i++){if (processesiarrivalTime <= currentTime &&processesiremainingTime < minExecutionTime &&processesiremainingTime > 0) {found = true;minExecutionTime = processesiremainingTime;selectedProcess = i;}}if (!found) {break;}processesselectedProcessstartTime = currentTime;currentTime += processesselectedProcessremainingTime;processesselectedProcessfinishTime = currentTime;processesselectedProcesswaitingTime =processesselectedProcessstartTime processesselectedProcessarrivalTime;processesselectedProcessturnaroundTime =processesselectedProcessfinishTime processesselectedProcessarrivalTime;processesselectedProcessremainingTime = 0;}}```5、时间片轮转调度算法实现```c++void rrScheduling(Process processes, int numProcesses, int timeSlice) {int currentTime = 0;Queue<int> readyQueue;for (int i = 0; i < numProcesses; i++){readyQueueenqueue(i);}while (!readyQueueisEmpty()){int currentProcess = readyQueuedequeue();if (processescurrentProcessarrivalTime > currentTime) {currentTime = processescurrentProcessarrivalTime;}if (processescurrentProcessremainingTime <= timeSlice) {currentTime += processescurrentProcessremainingTime;processescurrentProcessfinishTime = currentTime;processescurrentProcesswaitingTime =processescurrentProcessstartTime processescurrentProcessarrivalTime;processescurrentProcessturnaroundTime =processescurrentProcessfinishTime processescurrentProcessarrivalTime;processescurrentProcessremainingTime = 0;} else {currentTime += timeSlice;processescurrentProcessremainingTime = timeSlice;readyQueueenqueue(currentProcess);}}}```6、性能指标计算函数```c++void calculatePerformanceMetrics(Process processes, int numProcesses, double& averageWaitingTime, double& averageTurnaroundTime) {double totalWaitingTime = 0, totalTurnaroundTime = 0;for (int i = 0; i < numProcesses; i++){totalWaitingTime += processesiwaitingTime;totalTurnaroundTime += processesiturnaroundTime;}averageWaitingTime = totalWaitingTime / numProcesses; averageTurnaroundTime = totalTurnaroundTime / numProcesses;}```7、主函数```c++int main(){Process processes100;int numProcesses = 0;//创建进程createProcess(processes, numProcesses, 1, 0, 5);createProcess(processes, numProcesses, 2, 1, 3);createProcess(processes, numProcesses, 3, 2, 4);createProcess(processes, numProcesses, 4, 3, 2);//先来先服务调度fcfsScheduling(processes, numProcesses);double fcfsAverageWaitingTime, fcfsAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, fcfsAverageWaitingTime, fcfsAverageTurnaroundTime);cout <<"先来先服务调度的平均等待时间:"<<fcfsAverageWaitingTime << endl;cout <<"先来先服务调度的平均周转时间:"<<fcfsAverageTurnaroundTime << endl;//短作业优先调度sjfScheduling(processes, numProcesses);double sjfAverageWaitingTime, sjfAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, sjfAverageWaitingTime, sjfAverageTurnaroundTime);cout <<"短作业优先调度的平均等待时间:"<<sjfAverageWaitingTime << endl;cout <<"短作业优先调度的平均周转时间:"<<sjfAverageTurnaroundTime << endl;//时间片轮转调度(时间片为 2)rrScheduling(processes, numProcesses, 2);double rrAverageWaitingTime, rrAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, rrAverageWaitingTime, rrAverageTurnaroundTime);cout <<"时间片轮转调度(时间片为 2)的平均等待时间:"<< rrAverageWaitingTime << endl;cout <<"时间片轮转调度(时间片为 2)的平均周转时间:"<< rrAverageTurnaroundTime << endl;return 0;}```六、实验结果与分析1、先来先服务调度平均等待时间:40平均周转时间:85分析:先来先服务调度算法简单直观,但对于短作业可能会造成较长的等待时间,导致平均等待时间和平均周转时间较长。

电大操作系统实验报告3_ 进程管理实验

电大操作系统实验报告3_ 进程管理实验

电大操作系统实验报告3_ 进程管理实验电大操作系统实验报告 3 进程管理实验一、实验目的进程管理是操作系统的核心功能之一,本次实验的目的是通过实际操作和观察,深入理解进程的概念、状态转换、进程调度以及进程间的通信机制,掌握操作系统中进程管理的基本原理和方法,提高对操作系统的整体认识和实践能力。

二、实验环境本次实验使用的操作系统为 Windows 10,编程语言为 C 语言,开发工具为 Visual Studio 2019。

三、实验内容及步骤(一)进程的创建与终止1、编写一个 C 程序,使用系统调用创建一个子进程。

2、在父进程和子进程中分别输出各自的进程 ID 和父进程 ID。

3、子进程执行一段简单的计算任务,父进程等待子进程结束后输出结束信息。

以下是实现上述功能的 C 程序代码:```cinclude <stdioh>include <stdlibh>include <unistdh>int main(){pid_t pid;pid = fork();if (pid < 0) {printf("创建子进程失败\n");return 1;} else if (pid == 0) {printf("子进程:我的进程 ID 是%d,父进程 ID 是%d\n",getpid(), getppid());int result = 2 + 3;printf("子进程计算结果:2 + 3 =%d\n", result);exit(0);} else {printf("父进程:我的进程 ID 是%d,子进程 ID 是%d\n",getpid(), pid);wait(NULL);printf("子进程已结束\n");}return 0;}```编译并运行上述程序,可以观察到父进程和子进程的输出信息,验证了进程的创建和终止过程。

(二)进程的状态转换1、编写一个 C 程序,创建一个子进程,子进程进入睡眠状态一段时间,然后被唤醒并输出状态转换信息。

操作系统实验一模拟进程状态转换

操作系统实验一模拟进程状态转换

操作系统实验一模拟进程状态转换四、运行结果:图1 创建2个进程,因为这时cpu空闲所以内核调度,b优先级高先执行图2 超时,因为这时cpu空闲所以内核调度,b优先级还是比a高所以先执行图3 2个进程均被阻塞,其中一旦进程被阻塞就会引发调度图4 唤醒1个进程,从阻塞队列取队首放到就绪队列队尾,由于这时cpu空闲所以内核调度五、源代码:#include<cstdio>#include<algorithm>using namespace std;int Ready_len=0;int Blocked_len=0;int CPU_state=0;struct PCB{char name;int priority;int needtime;bool operator < (const PCB &b) const{return priority>b.priority;}};PCB Ready[100];PCB Blocked[100];PCB Cpu;bool dispatch();bool creat(int NUM){//创建一个新的进程while(NUM--){printf("输入进程名(一个字符)、所需时间(一个整数)、优先级(一个整数): \n");scanf("%s%d%d",&(Ready[Ready_len].name),&(Ready[Ready_len ].needtime),&(Ready[Ready_len].priority));getchar();Ready_len++;}if(CPU_state==0)//如果CPU空闲,则调度dispatch();}bool dispatch(){if(CPU_state==0){if(Ready_len!=0){sort(Ready,Ready+Ready_len);=Ready[0].name;Cpu.needtime=Ready[0].needtime;Cpu .priority=Ready[0].priority;if(Ready_len!=1)//就绪队列剔除队首元素for(int indx=1;indx<Ready_len;indx++){Ready[indx-1].name=Ready[indx].name;Ready[indx-1].needtime= Ready[indx].needtime;Ready[indx-1].priority=Ready[indx].priority;}Ready_len--;CPU_state=1;printf("***%c进程送往CPU执行\n",);Cpu.needtime--;Cpu.priority--;}else{printf("***就绪队列为空,无法调度\n");return false;}}else{printf("***CPU忙,无法调度\n");}}bool time_out(){if(CPU_state==1){if(Cpu.needtime==0)printf("***%c时间片用完,并且执行完毕,被释放\n",);else{Ready[Ready_len].name=;Ready[Ready_len].needtime= Cpu.needtime;Ready[Ready_len].priority=Cpu.priority;Ready_len++;printf("***%c时间片用完\n",);}CPU_state=0;=0;Cpu.needtime=0;Cpu.priority=0;if(Ready_len!=0)//时间片用完,如果就绪队列不为空,则调度dispatch();}else{printf("***没有进程在CPU中,无法超时\n");}}bool event_wait(){if(CPU_state==1){Blocked[Blocked_len].name=;Blocked[Blocked_len].n eedtime=Cpu.needtime;Blocked[Blocked_len].priority=Cpu.priority;Blocked_len++;printf("***%c被阻塞\n",);CPU_state=0;if(Ready_len!=0)//进程被阻塞,如果就绪队列不为空,则调度dispatch();}elseprintf("***没有进程在CPU中,无法阻塞\n");}bool event_occur(){if(Blocked_len!=0){//sort(Blocked,Blocked+Blocked_len);Ready[Ready_len].name=Blocked[0].name;Ready[Ready_len].nee dtime=Blocked[0].needtime;Ready[Ready_len].priority=Blocked[0]. priority;Ready_len++;if(Blocked_len!=1)//阻塞队列剔除队首元素for(int indx=1;indx<Blocked_len;indx++){Blocked[indx-1].name=Blocked[indx].name;Blocked[indx-1].needti me=Blocked[indx].needtime;Blocked[indx-1].priority=Blocked[indx]. priority;}Blocked_len--;//printf("%d %d",Blocked_len,Ready_len);printf("***%c被唤醒\n",Ready[Ready_len-1].name);if(CPU_state==0)//如果CPU空闲,则调度dispatch();//printf("%d %d",Blocked_len,Ready_len);}elseprintf("***阻塞队列为空,无法唤醒\n");}int main(){int Cputime=1;while(1){printf("\n1:New\t\t\t2:Dispatch\n");printf("3:Timeout\t\t4:Event wait\n");printf("5:Event occur\t\t0:exit\n");printf("输入1--5实现相应的功能:\n");int select;scanf("%d",&select);getchar();switch(select){case 1:int num;printf("输入要创建的进程数:\n");scanf("%d",&num);getchar();creat(num);break;case 2:dispatch();break;case 3:time_out();break;case 4:event_wait();break;case 5:event_occur();break;case 0:exit(0);break;}printf("****************************Cputime:%3d********************* *******\n",Cputime);printf("状态\t\t进程名\t\t需要时间\t\t优先级\n");if(CPU_state){//显示CPU中的进程printf("Running:\t%c\t\t",);printf("%d\t\t\t",Cpu.needtime);printf("%d\n",Cpu.priority);}if(Ready_len){//显示Ready队列中的进程for(int a=0;a<Ready_len;a++){printf("Ready%d:\t\t",a);printf("%c\t\t",Ready[a].name);printf("%d\t\t\t",Ready[a].needtime);printf("%d\n",Ready[a].priority);}}if(Blocked_len){//显示Blocked队列中的程序for(int b=0;b<Blocked_len;b++){printf("Blocked%d:\t",b);printf("%c\t\t",Blocked[b].name);printf("%d\t\t\t",Blocked[b].needtime);printf("%d\n",Blocked[b].priority);}}printf("**************************************************************** ***\n");Cputime++;} }。

操作系统进程的三种状态的转换实验报告

操作系统进程的三种状态的转换实验报告
2.按照课本基本知识和自己的想法编写程序。
3.设计出可视性较好的界面,应能反映出进程状态的变化引起的对应内容。
4.代码书写要规范,要适当地加入注释。
5.编译并调试自己编写的程序,是程序编译成功。
6.检查运行的结果是否正确。
四、实验结果(含算法说明、程序、数据记录及分析等,可附页)
五、实验思考题
利用C语言编写了一个模拟Windows进程三种状态之间的转换的程序,虽然肥城精简,但是我从中学到的很多知识点,学会了编写程序时的一些技巧,为自己以后更加深造打下了坚实的基础和使自己更好的理解Windows如何更好的管理进程。
六、实验总结(含实验心得体会,收获与不足等)
通过这次实验让我受益匪浅,不仅明白了自己以前不知道如何定义和应用结构体,还提高了自己的编程能力,调试程序的能力,使自己的编程能力有了大幅度的提高。使自己更好的理解进程的概念和进程的三种状态之间转换的过程和他们之间的关系。为自己以后复习打下了夯实的基础。
1)根据课本第三章的内容设计并实现一个模拟进程状态转换。
2)独立编写和调试程序。进程的数目,进程的状态模型自行选择。
3)合理设计进程相对应的数据结构,内容要包括进程的基本信息。
4)是进程的三种状态之间的转化清晰的显示。
三、实验过程及步骤(包含使用软件或实验设备等情况)
1.打开DEV-C++,新建一个源代码文件
实验报告
实验名称
进程三种状态的转换
专业
计算机
课程名称
操作系统
指导老师
张海燕
班级
二表一班
姓名
刘广法
学号
11100140109
评分
实验地点
1cபைடு நூலகம்6217

操作系统实验一练习进程状态转换

操作系统实验一练习进程状态转换

实验一模拟进程状态转换及其PCB的变化一、实验目的:自行编制模拟程序,通过形象化的状态显示,使学生理解进程的概念、进程之间的状态转换及其所带来的PCB内容、组织的变化,理解进程与其PCB间的一一对应关系。

二、实验内容及要求:(1)、设计并实现一个模拟进程状态转换及其相应PCB内容、组织结构变化的程序。

(2)、独立编写、调试程序。

进程的数目、进程的状态模型(三状态、五状态、七状态或其它)以及PCB的组织形式可自行选择。

(3)、合理设计与进程PCB相对应的数据结构。

PCB的内容要涵盖进程的基本信息、控制信息、资源需求及现场信息。

(4)、设计出可视性较好的界面,应能反映出进程状态的变化引起的对应PCB内容、组织结构的变化。

(5)、代码书写要规范,要适当地加入注释。

(6)、鼓励在实验中加入新的观点或想法,并加以实现。

(7)、认真进行预习,完成预习报告。

(8)、实验完成后,要认真总结,完成实验报告。

三、实现:数据结构struct PCB{char name。

int priority。

int needtime。

bool operator < (const PCB &b) const{ return priority>b.priority。

}}。

五状态进程模型最高优先数优先调度算法流程图四、运行结果:图1创建2个进程,因为这时cpu空闲所以内核调度,b优先级高先执行图2超时,因为这时cpu空闲所以内核调度,b优先级还是比a高所以先执行图32个进程均被阻塞,其中一旦进程被阻塞就会引发调度图4唤醒1个进程,从阻塞队列取队首放到就绪队列队尾,由于这时cpu空闲所以内核调度五、源代码:#include<cstdio>#include<algorithm>using namespace std。

int Ready_len=0。

int Blocked_len=0。

int CPU_state=0。

操作系统--进程状态切换以及cpu调度(转)

操作系统--进程状态切换以及cpu调度(转)

操作系统--进程状态切换以及cpu调度(转)进程的状态转换 进程在运⾏中不断地改变其运⾏状态。

通常,⼀个运⾏进程必须具有以下三种基本状态。

进程状态执⾏态run:进程正在使⽤CPU等待态wait:进程正在等待I/O完成,不在使⽤也不能使⽤CPU就绪态ready:进程不在使⽤CPU,但已经纯备好⽤使⽤CPU 在特定的情况下,这三种状态可以相互转换。

状态转换 就绪->执⾏,当前运⾏进程阻塞,调度程序选⼀个优先权最⾼的进程占有处理机; 执⾏->就绪,当前运⾏进程时间⽚⽤完; 执⾏->等待,当前运⾏进程等待键盘输⼊,进⼊了睡眠状态。

等待->就绪,I/O操作完成,被中断处理程序唤醒。

刚从其他状态进⼊就绪态的进程需要置⼊调度队列,该队列不⼀定按进⼊队列的时间先后顺序排列。

从等待态中出来的进程通常不直接进⼊运⾏态,⽽要进⼊就绪态。

如果需要直接进⼊运⾏态,这属于抢先式调度,通过抢先式中断完成。

从执⾏态到就绪态的转换发⽣在抢先式终端处理中,例如I/O或分时下的时间⽚。

分时是在多个⽤户同时以交互⽅式使⽤计算机时采⽤的⼀种技术。

分时技术:每当时钟中断发⽣时且发现当前运⾏进程已连续在CPU上运⾏了⼀定的时间(称为时间⽚,⼀般为20ms~250ms)时,就强制地发⽣进程切换,使当前进程退出CPU,重新调度,选出另⼀个进程在CPU上运⾏。

此时,退出的进程不能变为等待状态,因为它不是因为等待I/O⽽退出的,也不能变为终⽌,因为它尚未结束,因此,它需要转换为就绪态,等待属于它的时间⽚的到来。

当正在建⽴⼀个新进程时,计算机上的当前运⾏进程是哪⼀个? 该新进程的⽗进程。

CPU调度算法 同时处于就绪态的进程经常有多个,因此需要⼀个CPU调度算法来君顶那⼀个就绪进程先运⾏。

衡量CPU调度算法的标准有:CPU利⽤率、⽤户程序响应时间、系统吞吐量、公平合理性、设备利⽤率等。

常见的调度算法有先来先服务FIFO、轮转调度法RR(时间⽚法)、优先级调度法、短作业优先SJF、最短剩余事件优先、最⾼相应⽐优先、多级反馈法、策略驱动法、最晚时间限调度、⼆级调度法。

实验一 进程状态转换

实验一 进程状态转换

实验一进程的状态及其转换一、实验目的:自行编制模拟程序,通过形象化的状态显示,加深理解进程的概念、进程之间的状态转换及其所带来的PCB内容、组织的变化,理解进程与其PCB间的一一对应关系。

二、实验内容及要求:1)设计并实现一个模拟进程状态转换及其相应PCB内容、组织结构变化的程序。

2)独立编写、调试程序。

进程的数目、进程的状态模型(三状态、五状态、七状态或其它)以及PCB的组织形式可自行选择。

3)合理设计与进程PCB相对应的数据结构。

PCB的内容要涵盖进程的基本信息、控制信息、资源需求及现场信息。

4)设计出可视性较好的界面,应能反映出进程状态的变化引起的对应PCB内容、组织结构的变化。

三、程序流程图:四、使用的数据结构及说明:在本实验中,主要用到的数据结构是PCB的结构,其中PCB的数据结构如下:struct PCB{int P_Id; //PCB的ID号char P_Name[10]; //PCB的名称char P_State[10]; //PCB状态int P_Runtime; //PCB的所需要的运行时间int P_Requiry; //PCB所需要的资源要求struct PCB * next ; //PCB块的下一个指针} ;其中,P_Id,和P_Name用来标示一个进程,而P_State用来标示进程的五种状态:Create_state,Ready_state,Block_state,Run_state,Exit_state。

P_Runtime标示要完成一个进程所需要的时间。

P_Requiry标示一个进程的执行所需要的其他条件,当其他的条件满足,则P_Requiry置1,否则置0。

Struct PCB * next 用来指向同一队列中的下一个PCB 块。

五、参考程序源代码:#include"stdlib.h"#include"stdio.h"#include"string.h"#include <windows.h>/*全局结构体及变量定义*/struct PCB{int P_Id; //PCB的ID号char P_Name[10]; //PCB的名称char P_State[10]; //PCB状态int P_Runtime; //PCB的所需要的运行时间int P_Requiry; //PCB所需要的资源要求struct PCB * next ; //PCB块的下一个指针} ;struct PCB * Create_state; //创建状态struct PCB * Run_state; //运行状态struct PCB * Ready_state; //就绪状态struct PCB * Block_state; //阻塞状态struct PCB * Exit_state; //退出状态int signal4=0; //标示进程4的完成状态int signal5=0; //标示进程5的完成状态void InsertQueue(struct PCB **head,struct PCB *node) //将进程插入到队列的尾部{struct PCB * p,*q;node->next=NULL;if(*head==NULL) //如果队列为空{*head=node;}else //队列不空{p=*head;q=p->next;while(q!=NULL) //找到最后的元素位置{p=q;q=q->next;}p->next=node; //将节点插入队列}}void DeleteQueue(struct PCB **head,struct PCB *node)//撤销进程,从队列中删除元素{struct PCB *p,*q;p=node;q=*head;if(*head==NULL||node==NULL) //如果队列为空,返回return ;if(*head==node) //如果要删除的元素是队首元素{*head=(*head)->next;return;}else //如果不是队列的首元素{while(q->next!=p&&q->next!=NULL)q=q->next;q=p->next;p->next=NULL;}}void Display_Process(struct PCB * node) //打印进程状态的元素函数{printf("\n\nthis process Id is : %d \n",node->P_Id);printf("this process name is : %s \n",node->P_Name);printf("this process state is : on %s \n ",node->P_State);printf("this process Runtime is : %d \n",node->P_Runtime);if(node->P_Requiry)printf("this process resource is ready \n");elseprintf("this process resource is not ready ! \n");}void DispatchToBlock(struct PCB *node) //调度到阻塞状态的函数{if(!node->P_Requiry) //如果所需要的资源没有满足则,调度到阻塞状态 {strcpy(node->P_State,"block");InsertQueue(&Block_state,node); //插入到阻塞队列Display_Process(node);}}void DispatchToReady(struct PCB *node) //调度到就绪状态的函数{if(node->P_Requiry) //如果所需的资源满足,则调度{strcpy(node->P_State,"Ready");InsertQueue(&Ready_state,node);Display_Process(node);}}void DispatchBlockToReady() //从阻塞状态调度到就绪状态函数{struct PCB*p,*q;q=Block_state;while(q!=NULL) //如果阻塞状态队列不空{p=q;q=q->next;if(signal4&&p->P_Id==1) //如果所需要的资源满足{p->P_Requiry=1;DeleteQueue(&Block_state,p);strcpy(p->P_State,"ready");InsertQueue(&Ready_state,p);printf("process1 will be in the state of ready!\n");Display_Process(p);}if(signal5&&p->P_Id==2){p->P_Requiry=1;DeleteQueue(&Block_state,p);strcpy(p->P_State,"ready");InsertQueue(&Ready_state,p);printf("process2 will be in the state of ready!\n");Display_Process(p);}}}void Create_Process() //创建进程函数{int i;struct PCB *p;char name[10];strcpy(name,"process");for(i=1;i<3;i++) //动态创建2个处于阻塞状态的进程{p=(struct PCB *)malloc(sizeof(struct PCB));p->P_Id=i;name[7]=i+'0';name[8]='\0';strcpy(p->P_Name,name);strcpy(p->P_State,"create");p->P_Runtime=1; //所需要的时间片为1p->P_Requiry=0;Display_Process(p);Sleep(4000);printf(" \n process%d will be in the state of Block, waiting the resource ready \n\n",i);DispatchToBlock(p); //同时调度到阻塞队列}for(i=3;i<7;i++) //创建4个就绪状态的队列{p=(struct PCB *)malloc(sizeof(struct PCB));p->P_Id=i;name[7]=i+'0';name[8]='\0';strcpy(p->P_Name,name);strcpy(p->P_State,"create");p->P_Requiry=1;if(i==6) //在这里个进程6所需要的时间片为2 p->P_Runtime=2;elsep->P_Runtime=1;Display_Process(p);Sleep(4000);printf(" \n process%d will be in the state of Ready, waiting to run \n\n",i); DispatchToReady(p);}}void display(struct PCB **head) //打印各个状态队列里进程数目{struct PCB *p;p=*head;while(p!=NULL){Sleep(2000);printf("\n\nthis process Id is : %d \n",p->P_Id);printf("this process name is : %s \n",p->P_Name);printf("this process state is : on %s \n ",p->P_State);printf("this process Runtime is : %d \n",p->P_Runtime);if(p->P_Requiry)printf("this process resource is ready \n");elseprintf("this process resource is not ready ! \n");p=p->next;}}void Process_Run() //进程运行函数{struct PCB *p;while(Ready_state!=NULL) //就绪队列不空则继续执行{p=Ready_state;if(p->P_Runtime<=0) break; //如果时间片执行完了,则跳出循环 strcpy(p->P_State,"running");Display_Process(p);p->P_Runtime=p->P_Runtime-1;Sleep(4000);if(p->P_Runtime>0) //没有完成,则进入就绪队列{printf("this process is not finished,will be dispatch to the ready queue!!\n");DeleteQueue(&Ready_state,p);strcpy(p->P_State,"ready");InsertQueue(&Ready_state,p);Display_Process(p);}else //执行完成,则跳出,并发送相应的信息{printf("\n\nProcess%d is finished and will be in the state of exit!\n\n",p->P_Id);if(p->P_Id==4) signal4=1;if(p->P_Id==5) signal5=1;DeleteQueue(&Ready_state,p);}if(signal4||signal5)DispatchBlockToReady(); //如果资源满足,则将进程调度到就绪队列 }if(Ready_state==NULL)printf("\nthere is no process ready!\n STOP Machine!!!\n");}void main(int argc,char * argv[]) //主函数{char c='c'; //界面printf("\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ \n"); printf("...................................Ding Hai bo\n");printf("......Press s to start the process.......\n");scanf("%c",&c);while(1){if(c=='s'||c=='S')break;scanf("%c",&c);}Create_Process(); //调用创建进程函数printf("\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");printf("\n>>>>>>> Display the Ready queue >>>>>>>>>>>>>>>\n");Sleep(5000);display(&Ready_state); ////////////////显示就绪队列里的进程printf("\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");printf("\n>>>>>>>> Display the Block queue >>>>>>>>>>>>\n");Sleep(5000); //显示阻塞队列函数display(&Block_state); /////////////////////printf("\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n\n\n");printf("\n>>>>>>>> Now the process start to run >>>>>>>>>>>\n"); Sleep(5000);Process_Run(); //调用进程运行函数}六.程序使用说明:1)输入字符‘s’启动程序2)程序将自动执行,自动创建进程,运行进程和结束进程。

实验一进程控制与描述

实验一进程控制与描述

死锁检测
死锁检测是通过检测系统状态是否满足死锁条件来确定系 统是否处于死锁状态。
死锁解除
死锁解除是当系统检测到死锁状态时采取措施来解除死锁 的过程。
资源有序分配法
资源有序分配法是一种预防死锁的方法,通过为每个资源 分配一个唯一的序号,并要求进程按照序号递增的顺序请 求资源来避免产生循环等待条件。
03 进程描述
实验一:进程控制与描述
目录
• 进程控制概述 • 进程控制机制 • 进程描述 • 实验步骤与操作 • 实验结果与分析
01 进程控制概述
进程的定义与特性
总结词
进程是程序的一次执行,具有动态性、 并发性、制约性、独立性和制约性等特 性。
VS
详细描述
进程是程序在计算机上的一次执行过程, 它具有动态性,即进程的状态可以在运行 过程中改变;并发性,即进程可以同时存 在于多个状态;制约性,即进程间的相互 制约关系;独立性,即进程是独立的,不 受其他进程的影响;制约性,即进程间的 相互制约关系。
04 实验步骤与操作
实验环境搭建
准备实验所需的操作 系统环境,如Linux 或Windows。
配置网络连接,确保 实验过程中能够访问 外部资源。
安装必要的软件工具, 如任务管理器、终端 等。
进程创建与终止实验
01 打开任务管理器或终端,
查看当前运行的进程。
观察并记录进程的创建 过程和结果,包括进程
PCB中包含了进程标识符、进 程状态、内存指针、文件描述 符表等信息。
通过PCB,操作系统可以对进 程进行创建、切换、终止等操 作,实现对进程的统一管理。
进程状态信息
1
进程状态信息是指描述进程当前状态的变量和数 据结构。

进程的管理实验报告

进程的管理实验报告

一、实验目的1. 理解进程的基本概念和进程状态转换过程。

2. 掌握进程创建、进程同步和进程通信的方法。

3. 了解进程调度算法的基本原理和实现方法。

4. 通过实验加深对进程管理的理解,提高操作系统实践能力。

二、实验环境1. 操作系统:Linux2. 编程语言:C/C++3. 开发工具:GCC三、实验内容1. 进程创建与状态转换(1)使用fork()函数创建一个子进程,并观察父进程和子进程的进程ID。

(2)使用exec()函数替换子进程的映像,实现进程的创建。

(3)观察进程状态转换过程,如创建、运行、阻塞、就绪、终止等。

2. 进程同步(1)使用互斥锁(mutex)实现进程的互斥访问共享资源。

(2)使用信号量(semaphore)实现进程的同步,如生产者-消费者问题。

(3)观察进程同步的效果,确保进程安全执行。

3. 进程通信(1)使用管道(pipe)实现进程间的单向通信。

(2)使用消息队列(message queue)实现进程间的双向通信。

(3)使用共享内存(shared memory)实现进程间的快速通信。

(4)观察进程通信的效果,确保数据正确传递。

(1)实现基于优先级的进程调度算法,如先来先服务(FCFS)和最高优先级优先(HPF)。

(2)实现基于时间片的轮转调度算法(RR)。

(3)观察进程调度算法的效果,分析不同算法的优缺点。

四、实验步骤1. 编写程序实现进程创建与状态转换,使用fork()和exec()函数。

2. 编写程序实现进程同步,使用互斥锁和信号量。

3. 编写程序实现进程通信,使用管道、消息队列和共享内存。

4. 编写程序实现进程调度,使用优先级调度和时间片轮转调度。

5. 编译并运行程序,观察实验结果,分析实验现象。

五、实验结果与分析1. 进程创建与状态转换通过实验,我们成功创建了父进程和子进程,并观察到进程ID的变化。

在进程创建过程中,父进程的进程ID与子进程的进程ID不同,说明子进程是独立于父进程的实体。

进程的状态转换

进程的状态转换

进程的状态转换
三态模型:在多道程序系统中,进程在处理器上交替运⾏,状态也不断地发⽣变化。

进程⼀般有3种基本状态:运⾏、就绪和阻塞。

(1)运⾏状态(ready):当⼀个进程在处理机上运⾏时,则称该进程处于运⾏状态。

处于此状态的进程的数⽬⼩于等于处理器的数⽬,对于单处理机系统,处于运⾏状态的进程只有⼀个。

在没有其他进程可以执⾏时(如所有进程都在阻塞状态),通常会⾃动执⾏系统的空闲进程。

(2)就绪状态(running):当⼀个进程获得了除处理机以外的⼀切所需资源,⼀旦得到处理机即可运⾏,则称此进程处于就绪状态。

就绪进程可以按多个优先级来划分队列。

例如,当⼀个进程由于时间⽚⽤完⽽进⼊就绪状态时,排⼊低优先级队列;当进程由I/O操作完成⽽进⼊就绪状态时,排⼊⾼优先级队列。

(3)阻塞/等待状态(wait):也称为等待或睡眠状态,⼀个进程正在等待某⼀事件发⽣(例如请求I/O⽽等待I/O完成等)⽽暂时停⽌运⾏,这时即使把处理机分配给进程也⽆法运⾏,故称该进程处于阻塞状态。

值得注意的是,处于运⾏状态的进程因请求某种服务⽽变为等待状态,但当该请求完成后,等待状态的进程并不能恢复到运⾏状态,它通常是先转变为就绪状态,再由调度程序来调度。

操作系统进程管理实验报告

操作系统进程管理实验报告

操作系统进程管理实验报告一、引言在现代计算机科学中,操作系统的进程管理是确保系统高效运行的关键环节。

本实验旨在通过观察和分析操作系统的进程管理行为,深入理解进程的创建、运行和终止过程,以及操作系统如何对进程进行调度和资源分配。

二、实验目标1、理解进程的基本概念、进程状态及转换。

2、掌握进程的创建、终止和调度方法。

3、观察和分析进程在运行过程中的资源消耗和调度行为。

4、分析操作系统对进程的资源分配和调度策略对系统性能的影响。

三、实验环境与工具本实验在Linux操作系统上进行,使用GNU/Linux环境下的工具进行进程的创建、监控和调度。

四、实验步骤与记录1、创建进程:使用shell命令“fork”创建一个新的进程。

记录下父进程和子进程的PID,以及它们在内存中的状态。

2、进程状态观察:使用“ps”命令查看当前运行进程的状态,包括进程的PID、运行时间、CPU使用率等。

同时,使用“top”命令实时监控系统的CPU、内存等资源的使用情况。

3、进程调度:在“crontab”中设置定时任务,观察系统如何根据预设的调度策略分配CPU资源给各个进程。

4、资源分配:通过修改进程的优先级(使用“nice”命令),观察系统如何调整资源分配策略。

5、终止进程:使用“kill”命令终止一个进程,并观察系统如何处理该进程占用的资源。

五、实验结果与分析1、创建进程:通过“fork”系统调用,成功创建了一个新的进程,并获取了父进程和子进程的PID。

在内存中,父进程和子进程的状态分别为“running”和“ready”。

2、进程状态观察:使用“ps”命令可以看到父进程和子进程的状态均为“running”,同时显示了它们的CPU使用率和运行时间等信息。

通过“top”命令,可以实时监控系统的CPU、内存等资源的使用情况,为进一步分析提供了数据支持。

3、进程调度:在“crontab”中设置定时任务后,系统会根据预设的调度策略以及各个进程的运行状态,动态地分配CPU资源给各个进程。

进程管理实验报告代码

进程管理实验报告代码

一、实验目的1. 理解进程的概念和进程状态转换。

2. 掌握进程同步与互斥的基本方法。

3. 学习使用信号量实现进程同步与互斥。

4. 熟悉进程调度算法。

二、实验环境1. 操作系统:Windows/Linux2. 编程语言:C/C++3. 开发工具:Visual Studio/Code::Blocks三、实验内容1. 进程状态转换2. 进程同步与互斥3. 信号量实现进程同步与互斥4. 进程调度算法四、实验步骤1. 进程状态转换```c#include <stdio.h>#include <unistd.h>void print_status(int state) {switch (state) {case 1: printf("创建状态\n"); break; case 2: printf("就绪状态\n"); break;case 3: printf("运行状态\n"); break; case 4: printf("阻塞状态\n"); break; case 5: printf("终止状态\n"); break; default: printf("未知状态\n"); break; }}int main() {int state = 1;print_status(state);sleep(1);state = 2;print_status(state);sleep(1);state = 3;print_status(state);sleep(1);state = 4;print_status(state);sleep(1);state = 5;print_status(state);return 0;}```2. 进程同步与互斥```c#include <stdio.h>#include <pthread.h>pthread_mutex_t lock;void thread_func(void arg) {pthread_mutex_lock(&lock);printf("线程 %d 进入临界区\n", (int )arg);sleep(2);printf("线程 %d 离开临界区\n", (int )arg);pthread_mutex_unlock(&lock);return NULL;}int main() {pthread_t tid1, tid2;int arg1 = 1, arg2 = 2;pthread_mutex_init(&lock, NULL);pthread_create(&tid1, NULL, thread_func, &arg1); pthread_create(&tid2, NULL, thread_func, &arg2); pthread_join(tid1, NULL);pthread_join(tid2, NULL);pthread_mutex_destroy(&lock);return 0;}```3. 信号量实现进程同步与互斥```c#include <stdio.h>#include <pthread.h>#include <semaphore.h>sem_t sem;void thread_func(void arg) {sem_wait(&sem);printf("线程 %d 进入临界区\n", (int )arg);sleep(2);printf("线程 %d 离开临界区\n", (int )arg);sem_post(&sem);return NULL;}int main() {pthread_t tid1, tid2;int arg1 = 1, arg2 = 2;sem_init(&sem, 0, 1);pthread_create(&tid1, NULL, thread_func, &arg1); pthread_create(&tid2, NULL, thread_func, &arg2);pthread_join(tid1, NULL);pthread_join(tid2, NULL);sem_destroy(&sem);return 0;}```4. 进程调度算法```c#include <stdio.h>#include <stdlib.h>#include <unistd.h>#define MAX_PROCESSES 5typedef struct {int pid;int arrival_time;int burst_time;int wait_time;int turnaround_time;} Process;int compare(const void a, const void b) {Process proc1 = (Process )a;Process proc2 = (Process )b;return proc1->arrival_time - proc2->arrival_time;}void fcfs(Process processes[], int n) {processes[0].wait_time = 0;processes[0].turnaround_time = processes[0].burst_time;for (int i = 1; i < n; i++) {processes[i].wait_time = processes[i - 1].turnaround_time + processes[i].arrival_time - processes[i].burst_time;processes[i].turnaround_time = processes[i].wait_time + processes[i].burst_time;}}int main() {Process processes[MAX_PROCESSES] = {{1, 0, 3, 0, 0},{2, 1, 6, 0, 0},{3, 4, 4, 0, 0},{4, 6, 5, 0, 0},{5, 8, 2, 0, 0}};qsort(processes, MAX_PROCESSES, sizeof(Process), compare);fcfs(processes, MAX_PROCESSES);for (int i = 0; i < MAX_PROCESSES; i++) {printf("PID: %d, Wait Time: %d, Turnaround Time: %d\n", processes[i].pid, processes[i].wait_time, processes[i].turnaround_time);}return 0;}```五、实验结果与分析通过以上实验,我们了解了进程状态转换、进程同步与互斥、信号量实现进程同步与互斥以及进程调度算法。

进程的三个基本状态及其转换

进程的三个基本状态及其转换

进程的三个基本状态及其转换
进程的三个基本状态是运行态、阻塞态和就绪态。

这些状态之间的转换有以下几种情况:
1. 就绪态转为运行态:当一个进程被调度器选中,分配到CPU进行执行时,就会从就绪态转为运行态。

2. 运行态转为就绪态:当一个进程在运行时被抢占,或者执行完毕后释放CPU,进入等待调度的状态时,就会从运行态转为就绪态。

3. 运行态转为阻塞态:当一个进程在执行过程中发生某些不可避免的等待事件(如等待用户输入、等待IO操作完成)时,就会从运行态转为阻塞态。

4. 阻塞态转为就绪态:当一个进程等待事件结束后,切换到就绪状态,等待被调度执行时,就会从阻塞态转为就绪态。

5. 阻塞态转为终止态:当一个进程的等待事件永远结束(如等待关闭的设备),或者因为某些异常事件(如访问非法内存)而引发错误,无法继续执行时,就会从阻塞态转为终止态。

以上是进程的基本状态及其转换,不同的操作系统可能会有些差异,但一般都会包括这些状态和转换。

进程描述、状态转换和控制实验

进程描述、状态转换和控制实验
1/6
计算机操作系统实验报告
PCB(){PID=-1;} }PCB,*PCBP; 5. 函数设计 5.1 用户选择菜单: 我们采用两级菜单显示: char menu()//用户选择菜单 char menu1()//进程操作菜单
0915257 吴龙龙
图 3-2 5.2 创建进程 void creat(int i,PCB a[]); 5.3 显示进程信息 void show(PCB a[]);
图 3-3 5.4 进程操作 1)io 请求 void iost(PCBP a,int i); 2)io 完成 void ioe(PCBP a,int i); 3)销毁进程 dest(PCBP a,int i);
2/6
计算机操作系统实验报告
0915257 吴龙龙
图 3-3 6. 数据测试 输入: 1\n2” ”3\n1\n3” ”4\n2\n3\n2\n1\n0\n2\n1\n4” ”5\n2\n\3\n2\n2\n0\n2 输出:
图 3-1 2.3 进程控制块 操作系统采用 PCB 块描述一个进程和其它进程以及系统资源的关系,刻 画一个进程在各个不同时期所处的状态. PCB 是系统感知进程存在的唯一标志, 进程与 PCB 是一一对应的. 3. 实验分析 根据实验要求,我们需要做的是模拟进程管理程序,其具体功能如下: 1) 进程创建 2) 进程显示 3) 对某进程操作: 1.io 请求 2.io 完成 3.销毁进程 4. 数据结构 typedef class PCB{ public: int PID; char name[10];//进程名 char state;//状态,R,W,G int pri;//priority 优先级 friend istream& operator >>(istream& ins,PCB& a);//重载>> friend ostream& operator <<(ostream& outs,PCB& a);//重载<<

操作系统实验进程状态转换及其PCB的变化

操作系统实验进程状态转换及其PCB的变化
操作系统实验进程状态 转换及其PCB的变化
XX,a click to unlimited possibilities
汇报人:XX
目录
01 添 加 目 录 项 标 题
02 进 程 状 态 转 换
03 P C B 的 变 化
04 实 验 操 作 步 骤
05 实 验 结 果 与 讨 论
Part One
优先级:用于确定进程的调度 优先级
内存指针:指向进程在内存中 的起始地址
PCB在进程状态转换时的变化
PCB中进程状态的变化 PCB中进程优先级的变化 PCB中进程控制块的变化 PCB中进程调度信息的变化
PCB变化的意义
跟踪进程状态转 换:通过PCB的 变化,可以跟踪 进程在操作系统 中的状态转换, 从而更好地理解 操作系统的调度 机制。
单击添加章节标题
Part Two
进程状态转换
进程的三种基本状态
执行状态:进程已获得CPU, 正在执行
就绪状态:进程已获得除 CPU外的所有必要资源,等 待分配CPU
阻塞状态:进程因等待某个 条件(如I/O操作)而暂时
无法执行
进程状态的转换过程
进程创建状态:新进程从 无到有,创建并初始化 PCB
PCB变化的实现方式
进程状态转换:描述进程在执行过程中状态的变化过程,包括就绪态、 运行态、阻塞态等。
PCB结构:介绍PCB的结构和组成,包括进程名、进程标识符、进程状 态、优先级等。
PCB变化过程:描述在进程状态转换过程中,PCB中各字段的变化情况, 如状态、优先级、时间片等。
调度算法:介绍常见的进程调度算法,如先来先服务、最短作业优先、 优先级调度等,以及它们对PCB变化的影响。
实验结果分析

操作系统进程实验

操作系统进程实验

实验一、进程管理(3学时、必做)一、实验目的通过实验使学生进一步了解进程、进程状态、进程控制等基本概念。

基本能达到下列具体的目标:1、理解进程 PCB 的概念,以及 PCB 如何实现、如何组织以及管理。

2、复习数据结构中如何对链的操作,包括建链、删除、插入结点等,来实现进程的管理。

二、实验内容1、建立一个结点,即 PCB 块包括用户标识域、状态域(执行、等待、就绪)、 link 域。

2、建立三个队列(执行队列、就绪队列、等待队列)。

3、根据进程状态转换实现对三个队列的具体操作。

具体的驱动可以采用时间片算法或手动调度的形式完成三个状态之间的转换4、用 switch 选择语句选择状态。

5、按照自己的设定能完成所有的状态转换的运行(包括创建和运行结束)。

三、实验步骤1、复习进程管理三状态模型部分内容。

2、预习C++Builder或VC++、Delphi、JBuilder线程编程。

3、运行示例程序,进一步明确实验要求。

可以采用控制台模式或窗口模式。

4、上机编程、调试程序。

5、完成实验报告。

实验1的附加资料1、控制台模式进程管理的使用说明图1. 输入结束字符本程序是输入一个字符串,每个作为一个进程的名称,以指定的字符为结束字符,比较容易实现,其实可以在程序运行期间任意创建进程才是最好的。

图2. 输入进程名称一次性的创建了多个进程,进入三状态模型,按照要求进行状态之间的转移,只要输入1、2、3、4、5数字,按回车即可。

图3. 进程管理程序的主界面2、窗口模式的进程管理图4. 简单进程管理的主界面创建进程进入就绪队列,其排序可以按照FIFO的形式,也可以按照优先级的形式,为此需要在PCB节点中增加优先级数。

进程状态的转化在三个队列之间实现,输入进程的名称,选择合适的功能按钮。

如果不符合状态转换的规则,则弹出错误的对话框,说明原因。

3、基于时间片调度的进程管理图5. 基于时间片的进程管理主界面创建一个进程,给出工作量,每个进程所占的时间片大小为20个单位,实现就绪状态到执行状态之间的转化。

进程切换实验报告

进程切换实验报告

一、实验目的通过本次实验,了解进程切换的基本概念和过程,掌握进程切换的触发条件、切换过程以及切换开销,加深对进程调度和管理的理解。

二、实验环境操作系统:Linux编程语言:C语言开发环境:gcc编译器三、实验原理1. 进程切换的概念进程切换是指CPU从一个进程切换到另一个进程的过程。

在多进程系统中,操作系统为了保证各个进程的并发执行,需要实现进程切换。

进程切换是操作系统进程管理的核心内容。

2. 进程切换的触发条件(1)运行时间片用完:当进程运行一定的时间片后,CPU会强制将进程切换到就绪队列,等待下一次调度。

(2)高优先级进程就绪:当有更高优先级的进程进入就绪队列时,当前运行的进程会被切换。

(3)进程主动放弃CPU:如进程调用sleep()、yield()等函数,主动放弃CPU。

(4)异常和中断:如程序错误、硬件中断等,导致当前运行的进程切换。

3. 进程切换的过程(1)保存当前进程的状态:包括寄存器状态、程序计数器等。

(2)选择下一个要运行的进程:根据调度算法,从就绪队列中选择一个进程。

(3)恢复下一个进程的状态:将保存的状态恢复到CPU中。

(4)执行下一个进程:CPU开始执行新进程。

4. 进程切换开销进程切换过程中,需要保存和恢复进程状态,这会带来一定的开销。

进程切换开销包括:(1)时间开销:进程切换需要一定的时间,包括保存和恢复进程状态的时间。

(2)空间开销:进程切换需要一定的空间来保存和恢复进程状态。

四、实验内容1. 创建进程:使用C语言创建两个进程,其中一个为父进程,另一个为子进程。

2. 进程切换:在父进程中,使用sleep()函数使进程休眠一段时间,触发进程切换。

3. 观察进程切换:在父进程中,使用ps命令查看进程状态,观察进程切换过程。

4. 分析进程切换开销:通过比较父进程和子进程的运行时间,分析进程切换的开销。

五、实验步骤1. 编写C程序,创建父进程和子进程。

2. 在父进程中,使用sleep()函数使进程休眠一段时间。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验一进程的状态及其转换一、实验目的:自行编制模拟程序,通过形象化的状态显示,加深理解进程的概念、进程之间的状态转换及其所带来的PCB内容、组织的变化,理解进程与其PCB间的一一对应关系。

二、实验内容及要求:1)设计并实现一个模拟进程状态转换及其相应PCB内容、组织结构变化的程序。

2)独立编写、调试程序。

进程的数目、进程的状态模型(三状态、五状态、七状态或其它)以及PCB的组织形式可自行选择。

3)合理设计与进程PCB相对应的数据结构。

PCB的内容要涵盖进程的基本信息、控制信息、资源需求及现场信息。

4)设计出可视性较好的界面,应能反映出进程状态的变化引起的对应PCB内容、组织结构的变化。

三、程序流程图:四、使用的数据结构及说明:在本实验中,主要用到的数据结构是PCB的结构,其中PCB的数据结构如下:struct PCB{int P_Id; //PCB的ID号char P_Name[10]; //PCB的名称char P_State[10]; //PCB状态int P_Runtime; //PCB的所需要的运行时间int P_Requiry; //PCB所需要的资源要求struct PCB * next ; //PCB块的下一个指针} ;其中,P_Id,和P_Name用来标示一个进程,而P_State用来标示进程的五种状态:Create_state,Ready_state,Block_state,Run_state,Exit_state。

P_Runtime标示要完成一个进程所需要的时间。

P_Requiry标示一个进程的执行所需要的其他条件,当其他的条件满足,则P_Requiry置1,否则置0。

Struct PCB * next 用来指向同一队列中的下一个PCB 块。

五、参考程序源代码:#include"stdlib.h"#include"stdio.h"#include"string.h"#include <windows.h>/*全局结构体及变量定义*/struct PCB{int P_Id; //PCB的ID号char P_Name[10]; //PCB的名称char P_State[10]; //PCB状态int P_Runtime; //PCB的所需要的运行时间int P_Requiry; //PCB所需要的资源要求struct PCB * next ; //PCB块的下一个指针} ;struct PCB * Create_state; //创建状态struct PCB * Run_state; //运行状态struct PCB * Ready_state; //就绪状态struct PCB * Block_state; //阻塞状态struct PCB * Exit_state; //退出状态int signal4=0; //标示进程4的完成状态int signal5=0; //标示进程5的完成状态void InsertQueue(struct PCB **head,struct PCB *node) //将进程插入到队列的尾部{struct PCB * p,*q;node->next=NULL;if(*head==NULL) //如果队列为空{*head=node;}else //队列不空{p=*head;q=p->next;while(q!=NULL) //找到最后的元素位置{p=q;q=q->next;}p->next=node; //将节点插入队列}}void DeleteQueue(struct PCB **head,struct PCB *node)//撤销进程,从队列中删除元素{struct PCB *p,*q;p=node;q=*head;if(*head==NULL||node==NULL) //如果队列为空,返回return ;if(*head==node) //如果要删除的元素是队首元素{*head=(*head)->next;return;}else //如果不是队列的首元素{while(q->next!=p&&q->next!=NULL)q=q->next;q=p->next;p->next=NULL;}}void Display_Process(struct PCB * node) //打印进程状态的元素函数{printf("\n\nthis process Id is : %d \n",node->P_Id);printf("this process name is : %s \n",node->P_Name);printf("this process state is : on %s \n ",node->P_State);printf("this process Runtime is : %d \n",node->P_Runtime);if(node->P_Requiry)printf("this process resource is ready \n");elseprintf("this process resource is not ready ! \n");}void DispatchToBlock(struct PCB *node) //调度到阻塞状态的函数{if(!node->P_Requiry) //如果所需要的资源没有满足则,调度到阻塞状态 {strcpy(node->P_State,"block");InsertQueue(&Block_state,node); //插入到阻塞队列Display_Process(node);}}void DispatchToReady(struct PCB *node) //调度到就绪状态的函数{if(node->P_Requiry) //如果所需的资源满足,则调度{strcpy(node->P_State,"Ready");InsertQueue(&Ready_state,node);Display_Process(node);}}void DispatchBlockToReady() //从阻塞状态调度到就绪状态函数{struct PCB*p,*q;q=Block_state;while(q!=NULL) //如果阻塞状态队列不空{p=q;q=q->next;if(signal4&&p->P_Id==1) //如果所需要的资源满足{p->P_Requiry=1;DeleteQueue(&Block_state,p);strcpy(p->P_State,"ready");InsertQueue(&Ready_state,p);printf("process1 will be in the state of ready!\n");Display_Process(p);}if(signal5&&p->P_Id==2){p->P_Requiry=1;DeleteQueue(&Block_state,p);strcpy(p->P_State,"ready");InsertQueue(&Ready_state,p);printf("process2 will be in the state of ready!\n");Display_Process(p);}}}void Create_Process() //创建进程函数{int i;struct PCB *p;char name[10];strcpy(name,"process");for(i=1;i<3;i++) //动态创建2个处于阻塞状态的进程{p=(struct PCB *)malloc(sizeof(struct PCB));p->P_Id=i;name[7]=i+'0';name[8]='\0';strcpy(p->P_Name,name);strcpy(p->P_State,"create");p->P_Runtime=1; //所需要的时间片为1p->P_Requiry=0;Display_Process(p);Sleep(4000);printf(" \n process%d will be in the state of Block, waiting the resource ready \n\n",i);DispatchToBlock(p); //同时调度到阻塞队列}for(i=3;i<7;i++) //创建4个就绪状态的队列{p=(struct PCB *)malloc(sizeof(struct PCB));p->P_Id=i;name[7]=i+'0';name[8]='\0';strcpy(p->P_Name,name);strcpy(p->P_State,"create");p->P_Requiry=1;if(i==6) //在这里个进程6所需要的时间片为2 p->P_Runtime=2;elsep->P_Runtime=1;Display_Process(p);Sleep(4000);printf(" \n process%d will be in the state of Ready, waiting to run \n\n",i); DispatchToReady(p);}}void display(struct PCB **head) //打印各个状态队列里进程数目{struct PCB *p;p=*head;while(p!=NULL){Sleep(2000);printf("\n\nthis process Id is : %d \n",p->P_Id);printf("this process name is : %s \n",p->P_Name);printf("this process state is : on %s \n ",p->P_State);printf("this process Runtime is : %d \n",p->P_Runtime);if(p->P_Requiry)printf("this process resource is ready \n");elseprintf("this process resource is not ready ! \n");p=p->next;}}void Process_Run() //进程运行函数{struct PCB *p;while(Ready_state!=NULL) //就绪队列不空则继续执行{p=Ready_state;if(p->P_Runtime<=0) break; //如果时间片执行完了,则跳出循环 strcpy(p->P_State,"running");Display_Process(p);p->P_Runtime=p->P_Runtime-1;Sleep(4000);if(p->P_Runtime>0) //没有完成,则进入就绪队列{printf("this process is not finished,will be dispatch to the ready queue!!\n");DeleteQueue(&Ready_state,p);strcpy(p->P_State,"ready");InsertQueue(&Ready_state,p);Display_Process(p);}else //执行完成,则跳出,并发送相应的信息{printf("\n\nProcess%d is finished and will be in the state of exit!\n\n",p->P_Id);if(p->P_Id==4) signal4=1;if(p->P_Id==5) signal5=1;DeleteQueue(&Ready_state,p);}if(signal4||signal5)DispatchBlockToReady(); //如果资源满足,则将进程调度到就绪队列 }if(Ready_state==NULL)printf("\nthere is no process ready!\n STOP Machine\n");}void main(int argc,char * argv[]) //主函数{char c='c'; //界面printf("\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ \n"); printf("...................................Ding Hai bo\n");printf("......Press s to start the process.......\n");scanf("%c",&c);while(1){if(c=='s'||c=='S')break;scanf("%c",&c);}Create_Process(); //调用创建进程函数printf("\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");printf("\n>>>>>>> Display the Ready queue >>>>>>>>>>>>>>>\n");Sleep(5000);display(&Ready_state); ////////////////显示就绪队列里的进程printf("\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");printf("\n>>>>>>>> Display the Block queue >>>>>>>>>>>>\n");Sleep(5000); //显示阻塞队列函数display(&Block_state); /////////////////////printf("\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n\n\n");printf("\n>>>>>>>> Now the process start to run >>>>>>>>>>>\n"); Sleep(5000);Process_Run(); //调用进程运行函数}六.程序使用说明:1)输入字符‘s’启动程序2)程序将自动执行,自动创建进程,运行进程和结束进程。

相关文档
最新文档