实验1 单处理机进程调度

实验一处理机调度一.实验目的多道系统中，当就绪进程数大于处理机数时，须按照某种策略决定哪些进程优先占用处理机。

本实验模拟实现处理机调度，以加深了解处理机调度的工作。

二.实验内容选择一个调度算法，实现处理机调度。

1.设计一个按优先权调度算法实现处理机调度的程序。

2.设计按时间片轮转实现处理机调度的程序。

三.实验要求要求：进程名/PID要求运行时间（单位时间）优先权状态PCB指针1、可随机输入若干进程，并按优先权排序；2、从就绪队列首选进程运行：优先权-1，要求运行时间-1，要求运行时间=0时，撤销该进程。

3、重新排序，进行下轮调度。

4、最好采用图形界面。

5、可以随时增加进程。

6、规定道数，设置后备队列和挂起状态。

若内存中进程少于规定道数，可自动从后备队列调度一作业进入。

被挂起进程入挂起队列，设置解挂功能用于将指定挂起进程解挂入就绪队列。

7、每次调度后，显示各进程状态。

四.实验过程#include"windows.h"#include<iostream.h>#include<stdio.h>#include<conio.h>enum PCBSTATE {READY,RUN,FINISH}; //定义进程状态的数据类型typedef struct PCB_Struct{ //定义进程控制块char Name[8]; //进程名int Priority; //优先数double WorkTime; //已运行的时间double NeedTime; //还需运行时间double WaitTime; //进程总共花费时间PCBSTATE State; //进程状态PCB_Struct *Next; //指针} PCB;bool RunOk;PCB *ReadyList; //声明就绪链表PCB *FinishList; //声明完成链表PCB *RearReady; //声明就绪监听队列PCB *RearFinish; //声明完成监听队列PCB *CurrentRun; //声明当前运行队列void AdjustProcessList(PCB *Insert) //调整进程队列{PCB *tmp,*Parent; //定义线程tmp=ReadyList; //把临时线程加入就绪链表if (tmp->Priority<Insert->Priority) //比较优先级安排链表序{ReadyList=Insert;Insert->Next=tmp;}else{Parent=tmp;while(tmp){if (tmp->Priority>=Insert->Priority){Parent=tmp;tmp=tmp->Next;}elsebreak;}if (!tmp){RearReady->Next=Insert;RearReady=Insert;}else{Insert->Next=tmp;Parent->Next=Insert;}}}void GetOnePCB() //增加进程{PCB *tmp; //初始化变量tmp=new PCB;char Name[8];int Priority;double Time; //人机交互获取进程参数cin>>Name;cout<<" 优先数：";cin>>Priority;cout<<" 所需时间：";cin>>Time;cout<<endl;strcpy(tmp->Name,Name);tmp->Priority=Priority; //把参数到进程中tmp->WorkTime=0.0;tmp->WaitTime=0.0;tmp->NeedTime=Time;tmp->State=READY;tmp->Next=NULL;if (RearReady) //如果监听链表不为空{AdjustProcessList(tmp); //调用调整进程队列}else //为空则初始化监听队列{ReadyList=tmp;RearReady=tmp;}}void GetAllPCB() //输入开始时的进程{int i,j,k; //+kcout<<endl<<"请输入需要调度进程的个数："; //获取进程数cin>>i;if(i<1) i=2;if(i>0) //获取进程for (j=0;j<i;j++){k=j+1;cout<<" 第"<<k<<"个进程名：";GetOnePCB(); //调用增加进程}}void AddWaitWorkTime() //时间控制{PCB *tmp=ReadyList; //处理队首时间while(tmp){tmp->WaitTime++;tmp=tmp->Next;}}void AdjustRunProcess() //调整运行队列{AddWaitWorkTime(); //调用时间控制CurrentRun=ReadyList; //把就绪进程放入运行队列ReadyList=ReadyList->Next;CurrentRun->Next=NULL;if(CurrentRun->Priority>=1) //修改运行进程的属性CurrentRun->Priority;CurrentRun->WorkTime++;CurrentRun->NeedTime--;if(CurrentRun->NeedTime==0) //处理结束的进程{CurrentRun->State=RUN;if(FinishList==NULL) //如果结束进程为空，创建FinishList=CurrentRun;else //否则，添加入完成监听队列RearFinish->Next=CurrentRun;RearFinish=CurrentRun;if(!ReadyList)ReadyList=RearReady=NULL;}elseif(!ReadyList) //如果就绪队列为空{RearReady=ReadyList=CurrentRun; //把监听队列中的进程防入就绪队列}else{AdjustProcessList(CurrentRun); //递归}if(!ReadyList) //如果就绪队列为空{CurrentRun=NULL; //把运行进程置空RunOk=true; //设置进程完成开关}}void ShowProcess() //显示队列情况{PCB *tmp;if(CurrentRun) //存在运行队列，显示{cout<<"本次调度运行的进程："<<endl;cout<<" 进程名 "<<" 进程优先数 "<<" 已运行的时间 "<<" 还需运行时间 "<<"进程总共花费时间 "<<" 进程状态 "<<endl;cout<<" "<<CurrentRun->Name<<" "<<CurrentRun->Priority<<" "<<CurrentRun->WorkTime<<" "<<CurrentRun->NeedTime<<""<<CurrentRun->WaitTime<<" "<<CurrentRun->State<<endl;}if(ReadyList) //存在就绪队列，显示{tmp=ReadyList;cout<<"就绪队列中的进程："<<endl;cout<<" 进程名 "<<" 进程优先数 "<<" 已运行的时间 "<<" 还需运行时间 "<<"进程总共花费时间 "<<" 进程状态 "<<endl;while(tmp){cout<<" "<<tmp->Name<<" "<<tmp->Priority<<""<<tmp->WorkTime<<" "<<tmp->NeedTime<<""<<tmp->WaitTime<<" "<<tmp->State<<endl;tmp=tmp->Next;}}if(FinishList) //运行至结束，显示{tmp=FinishList;cout<<"显示已运行好的进程调度结果："<<endl;cout<<" 进程名 "<<" 进程优先数 "<<" 已运行的时间 "<<" 还需运行时间 "<<"进程总共花费时间 "<<" 进程状态 "<<endl;while (tmp){cout<<" "<<tmp->Name<<" "<<tmp->Priority<<""<<tmp->WorkTime<<" "<<tmp->NeedTime<<""<<tmp->WaitTime<<" "<<tmp->State<<endl;tmp=tmp->Next;}}}void FreeProcess() //释放进程{PCB *tmp;if(!FinishList) //就绪队列为空，报错cout<<endl<<"\n发生错误！";for(;FinishList->Next;) //删除进程{tmp=FinishList;FinishList=FinishList->Next;delete tmp;}ReadyList=NULL; //将所有队列置空FinishList=NULL;RearReady=NULL;CurrentRun=NULL;RearFinish=NULL;}void RunOnce() //单步调度{AdjustRunProcess(); //调整运行队列}char SelectStyle() //选择类型{char i;printf("\n"); //人机交互选择下一步的操作printf("点击1--继续下一次调度，并显示就绪队列中的进程情况\n");printf("点击2--向就绪队列添加新进程\n");printf("点击3--运行程序\n");printf("请选择你要的操作:");do{i=(char)_getch();}while(i!='1'&&i!='2'&&i!='3');cout<<i<<endl<<endl;return i;}void RunAlor() //进程运行控制{char j='1';RunOk=false;GetAllPCB(); //获取全部进程do {if(j!='3'&&!RunOk)j=SelectStyle(); //调用选择操作if(j=='3')RunOnce(); //调用单步运行if(j=='1'){RunOnce();ShowProcess(); //调用显示队列}if(j=='2') //添加新进程{system("cls");cout<<" 新进程名：";GetOnePCB();}}while(!RunOk); //当进程全部运行完毕cout<<"运行完成，显示进程调度结果：\n";ShowProcess(); //显示进程队列FreeProcess(); //释放进程}int main() //主程序{char Key;ReadyList=NULL; //设置链表为空FinishList=NULL;RearReady=NULL;CurrentRun=NULL;RearFinish=NULL;while(true) //人机交互界面{system("cls");printf("==========================================\n");printf(" +++ 优先数进程调度算法 +++\n\n");printf("==========================================\n");printf("\n");printf("******************************************\n");printf("+++++ 按1 执行 ! +++++\n");printf("+++++ 按2 退出 ! +++++\n");printf("+++++ 状态0 表示进程还没运行完! +++++\n");printf("+++++ 状态1 表示进程运行已结束! +++++\n");printf("******************************************\n");printf("请选择:");do{Key=(char)_getch();}while(Key!='1'&&Key!='2'); //重新输入/* system("cls");*/if(Key=='2') //退出系统return 0;else if(Key=='1') //开始模拟 RunAlor();printf("\n按任意键继续");_getch();}return 0;}五.实验结果主界面运行过程添加新进程实验二主存空间的分配和回收一.实验目的帮助了解在不同的存储管理方式下，应怎样实现主存空间的分配和回收。

一．一、单处理器系统的进程调度1．实验目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。

当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。

本实验模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。

2．实验内容与要求（1）设计多个进程并发执行的模拟调度程序，每个程序由一个PCB表示。

（2）模拟调度程序可任选两种调度算法之一实现。

（3）程序执行中应能在屏幕上显示出各进程的状态变化，以便于观察调度的整个过程。

3．实验说明设计一个按优先数调度算法实现处理器调度的程序。

(1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表，进程控制块的格式为：其中，进程名——作为进程的标识，假设五个进程的进程名分别为P1，P2，P3，P4，P5。

指针——按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程中的指针为“0”。

要求运行时间——假设进程需要运行的单位时间数。

优先数——赋予进程的优先数，调度时总是选取优先数大的进程先执行。

状态——可假设有两种状态，“就绪”状态和“结束”状态。

五个进程的初始状态都为“就绪”，用“R”表示，当一个进程运行结束后，它的状态为“结束”，用“E”表示。

(2) 在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”和“要求运行时间”。

(3) 为了调度方便，把五个进程按给定的优先数从大到小连成队列。

用一单元指出队首进程，用指针指出队列的连接情况。

例：队首标志K2K 1K2K3K4 K5PCB1 PCB2 PCB3 PCB4 PCB5(4) 处理器调度总是选队首进程运行。

采用动态改变优先数的办法，进程每运行一次优先数就减“1”。

由于本实验是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：优先数-1要求运行时间-1来模拟进程的一次运行。

提醒注意的是：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行结束。

实验一进程调度一.实验题目:1、编写并调试一个模拟的进程调度程序，采用“最高优先数优先”调度算法对五个进程进行调度。

2、编写并调试一个模拟的进程调度程序，采用“轮转法”调度算法对五个进程进行调度。

二:实验目的用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解．三.实验内容:最高优先级优先调度算法1)优先级简介动态优先数是指在进程创建时先确定一个初始优先数，以后在进程运行中随着进程特性的改变不断修改优先数，这样，由于开始优先数很低而得不到CPU的进程，就能因为等待时间的增长而优先数变为最高而得到CPU运行。

例如：在进程获得一次CPU后就将其优先数减少1。

或者，进程等待的时间超过某一时限时增加其优先数的值，等等。

2)详细设计优先权调度算法：1、设定系统中有五个进程，每一个进程用一个进程控制块（ PCB）表示，进程队列采用链表数据结构。

2、进程控制块包含如下信息：进程名、优先数、需要运行时间、已用CPU时间、进程状态等等。

3、在每次运行设计的处理调度程序之前，由终端输入五个进程的“优先数”和“要求运行时间”。

4、进程的优先数及需要的运行时间人为地指定.进程的运行时间以时间片为单位进行计算。

5、采用优先权调度算法，将五个进程按给定的优先数从大到小连成就绪队列。

用头指针指出队列首进程，队列采用链表结构。

6、处理机调度总是选队列首进程运行。

采用动态优先数办法，进程每运行一次优先数减“1”，同时将已运行时间加“1”。

7、进程运行一次后，若要求运行时间不等于已运行时间，则再将它加入就绪队列；否则将其状态置为“结束”,且退出就绪队列。

8、“就绪”状态的进程队列不为空，则重复上面6，7步骤，直到所有进程都成为“结束”状态。

9、在设计的程序中有输入语句，输入5个进程的“优先数”和“要求运行时间”，也有显示或打印语句，能显示或打印每次被选中进程的进程名、运行一次后队列的变化，以及结束进程的进程名。

实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一，其目的是合理地分配 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分析：先来先服务调度算法简单直观，但对于短作业可能会造成较长的等待时间，导致平均等待时间和平均周转时间较长。

处理器调度一、实验内容选择一个调度算法，实现处理器调度。

二、实验目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。

当就绪状态进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。

本实验模拟在单处理器情况下处理器调度，帮助学生加深了解处理器调度的工作。

三、实验题目设计一个按优先数调度算法实现处理器调度的程序提示：（1）假定系统有五个进程，每一个进程用一个进程控制块PCB来代表。

进程控制块的格式为：其中，进程名----作为进程的标识，假设五个进程的进程名分别是R, P2, P3，P4，R。

指针—按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块首地址，最后一个进程中的指针为“ 0”。

要求运行时间-- 假设进程需要运行的单位时间数。

优先数-赋予进程的优先数，调度时总是选取优先数大的进程先执行。

状态-可假设有两种状态，“就绪”状态和“结束“状态，五个进程的初始状态都为“就绪“状态，用“ R”表示，当一个进程运行结束后，它的状态变为“结束”，用“ E”表示。

（2）在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”和“要求运行时间”。

（3）为了调度方便，把五个进程按给定的优先数从大到小连成队列，用一单元指出队首进程，用指针指出队列的连接情况。

例：队首标志（4）处理器调度总是选队首进程运行。

采用动态改变优先数的办法，进程每运行一次优先数就减“ 1”。

由于本实验是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：优先数－ 1 要求运行时间－1来模拟进程的一次运行提醒注意的是：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，它占有处理器运行，直到出现等待事件或运行结束。

在这里省去了这些工作。

(5)进程运行一次后，若要求运行时间工0,则再将它加入队列(按优先数大小插入，且置队首标志)；若要求运行时间=0,则把它的状态修改为“结束”(),且退出队列。

实验一处理器调度一、实验内容选择一个调度算法，实现处理器调度。

二、实验目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。

当就绪状态进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。

本实验模拟在单处理器情况下处理器调度，帮助学生加深了解处理器调度的工作。

三、实验题目设计一个按优先数调度算法实现处理器调度的程序提示：（1）假定系统有五个进程，每一个进程用一个进程控制块PCB 来代表。

进程控制块的格式为：其中，进程名----作为进程的标识，假设五个进程的进程名分别是P1，P2，P3，P4，P5。

指针----按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块首地址，最后一个进程中的指针为“0”。

要求运行时间----假设进程需要运行的单位时间数。

优先数----赋予进程的优先数，调度时总是选取优先数大的进程先执行。

状态----可假设有两种状态，“就绪”状态和“结束“状态，五个进程的初始状态都为“就绪“状态，用“R”表示，当一个进程运行结束后，它的状态变为“结束”，用“E”表示。

（2）在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”和“要求运行时间”。

（3）为了调度方便，把五个进程按给定的优先数从大到小连成队列，用一单元指出队首进程，用指针指出队列的连接情况。

例：队首标志（4）处理器调度总是选队首进程运行。

采用动态改变优先数的办法，进程每运行一次优先数就减“1”。

由于本实验是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：优先数－1要求运行时间－1来模拟进程的一次运行。

提醒注意的是：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，它占有处理器运行，直到出现等待事件或运行结束。

在这里省去了这些工作。

（5）进程运行一次后，若要求运行时间≠0，则再将它加入队列（按优先数大小插入，且置队首标志）；若要求运行时间=0，则把它的状态修改为“结束”（），且退出队列。

2017-2018学年第一学期电信学院计算机系实验报告课程名称：操作系统实验名称：单处理器系统的进程调度班级：计学号：201506姓名：成绩：一、实验目的1. 加深对进程概念的理解，明确进程和程序的区别。

2. 深入了解系统如何组织进程、创建进程。

3. 进一步认识如何实现处理器调度。

二、实验内容编写程序完成单处理机系统中的进程调度，要求采用时间片轮转调度算法。

实验具体包括：首先确定进程控制块的内容，进程控制块的组成方式；然后完成进程创建原语和进程调度原语；最后编写主函数对所做工作进行测试。

三、数据结构1.进程控制块结构定义如下：struct pcb{int name; //进程标识符int status; //进程状态int ax, bx, cx,dx; //进程现场信息，通用寄存器内容int pc; //进程现场信息，程序计数器内容int psw; //进程现场信息，进程状态字寄存器内容int next; //下一个进程控制块的位置}2. 运行进程的进程块指针，就绪队列指针和空闲进程控制块队列指针定义如下：Int run; //定义指针正在运行进程的进程控制块的指针Struct{Int head;Int tail;}Ready; //定义指针就绪队列的头指针，head和尾指针tailInt pfree; //定义指向空闲进程控制块队列的指针四、算法流程进程创建是一个原语，因此在实验中应该用一个函数实现，进程创建的过程应该包括：1.申请进程控制块：进程控制块的数量是有限的，如果没有空闲进程控制块，则进程不能创建，如果申请成功才可以执行第②步；2.申请资源：除了进程控制块外，还需要有必要的资源才能创建进程，如果申请资源不成功，则不能创建进程，并且归还已申请的进程控制块；如果申请成功，则执行第三步，实验无法申请资源，所以模拟程序忽略了申请资源这一步；3.填写进程控制块：将该进程信息写入进程控制块内，实验中只有进程标识符、进程状态可以填写，每个进程现场信息中的寄存器内容由于没有具体数据而使用进程（模拟进程创建时，需输入进程标识符字，进程标识符本应系统建立，并且是惟一的，输入时注意不要冲突），刚刚创建的进程应该为就绪态，然后转去执行第四步；4.挂入就绪队列：如果原来就绪队列不为空，则将该进程控制块挂入就绪队列尾部，并修改就绪队列尾部指针；如果原来就绪队列为空，则将就绪队列的头指针、尾指针均指向该进程控制块，进程创建完成。

实验一单处理器调度算法的实现班级：计算机04-1班学号： 04034040112姓名：汀芷约成绩：___ ________日期：_ 2006-11-02实验一单处理器调度算法的实现一、实验目的在多道程序或多任务系统中，系统同时处于就绪态的进程有若干个。

为了使系统中的各进程能有条不紊地运行，必须选择某种调度策略，以选择占用处理机。

要求学生设计一个模拟单处理机调度的算法，以巩固和加深处理机调度的概念。

二、实验内容设计一个按时间片轮转法调度的算法。

提示：1、假设系统有5个进程，每个进程用一个进程控制块PCB来代表。

PCB 的格式如图所示。

其中，进程名即是进程标识。

链接指针：指出下一个到达进程的进程控制块首地址。

按照进程到达的顺序排队。

系统设置一个队头和队尾指针分别指向第一个和最后一个进程。

新生成的进程放队尾。

2、为每个进程任意确定一个要求运行时间和到达时间。

3、按照进程到达的先后顺序排成一个循环队列。

再设一个队首指针指向第一个到达进程的首地址。

4、执行处理机调度时，开始选择队首的第一个进程运行。

另外再设一个当前运行进程指针，指向当前正运行的进程。

5、由于本实验是模拟实验，所以对被选中进程并不实际启动运行，而是执行：一是估计运行时间减1；二是输出当前运行进程的名字。

用这两个操作来模拟进程的一次执行。

6、进程运行一次后，以后的调度则将当前指针依次下移一个位置，指向下一个进程，即调整当前运行指针指向该进程的链接指针所指进程，以指示应运行进程。

同时还应该判断该进程的剩余运行是否为0。

若不为0，则等待下一轮的运行；若该进程的剩余时间为0，则将该进程的状态置为C，并退出循环队列。

7、若就绪队列不空，则重复上述的（5）和（6）步骤直到所有进程都运行为止。

8、在所设计的调度程序中，应包含显示或打印语句。

以便显示或打印每次选中进程的名称及运行一次后队列的变化情况。

三、实验说明1、程序中使用的数据结构及符号说明：数据结构：数组data[][]符号说明：每个进程的状态是就绪 W（Wait）、运行R（Run）、或完成C（Complete）三种状态之一。

操作系统实验一进程调度在计算机科学中，操作系统是管理计算机硬件与软件资源的程序，是计算机系统的内核与基石。

而进程调度作为操作系统的核心功能之一，对于系统的性能和资源利用率起着至关重要的作用。

本次操作系统实验一，我们将深入探讨进程调度的原理和实现。

进程，简单来说，是正在运行的程序的实例。

在多道程序环境下，多个进程可能同时竞争计算机系统的资源，如 CPU、内存、I/O 设备等。

进程调度的任务就是从就绪队列中选择一个合适的进程，并将 CPU 分配给它，以实现资源的合理分配和系统的高效运行。

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

先来先服务算法按照进程到达就绪队列的先后顺序进行调度，这种算法简单直观，但可能导致短作业等待时间过长，从而影响系统的整体性能。

短作业优先算法则优先调度运行时间短的进程，能够有效降低平均等待时间，但可能对长作业不利，容易造成“饥饿”现象。

时间片轮转算法将 CPU 时间划分成固定大小的时间片，每个进程轮流获得一个时间片的 CPU 使用权。

这种算法能够保证每个进程都能得到及时响应，但时间片的大小选择需要权衡系统的开销和响应时间。

优先级调度算法为每个进程赋予一个优先级，优先级高的进程优先获得 CPU 资源。

然而，确定合理的优先级以及避免低优先级进程“饥饿”是该算法需要解决的问题。

在实验中，我们通过模拟实现这些调度算法，来深入理解它们的工作原理和性能特点。

以时间片轮转算法为例，我们首先需要创建一个就绪队列来存放等待调度的进程。

每个进程包含进程 ID、所需运行时间、已运行时间等信息。

在调度过程中，从就绪队列头部取出一个进程，判断其剩余运行时间是否小于等于时间片。

如果是，则该进程运行完毕，从队列中删除；否则，将其已运行时间增加时间片大小，剩余运行时间减少时间片大小，然后将其移到队列尾部，等待下一轮调度。

通过对不同调度算法的模拟实验，我们可以观察到它们在不同场景下的表现。