实验一 编程模拟处理机调度
计算机操作系统：处理机调度模拟实验
display2(run);
}
p = ready;
if (p != NULL)
printf("\n ****当前就绪队列中进程的状态如下:\n"); /*显示就绪队列状态*/
while (p != NULL)
{
display2(p);
p = p->next;
}
p = finish;
根据单处理机，多任务的问题特性做好软件实现的需求分析。可根据问题的实际需要，可选择进程数量。
当系统运行时，能直观地、动态地反映当前处理机状态及各进程执行的状况。
实验环境
Windows 7或以上版本+ VS2010或以上版本
实验内容
程序运行一次中，要求三个进程队列，每个优先权依次为1、2、3，即优先权为1的只分配1个时间片，优先权为2的只分配2个时间片，优先权为3的只分配3个时间片；每个进程队列命名、进程命名与进程数自定，轮转打印出各个进程名，程序结束打印退出。
run->state = 'R';
display();
}
//探测到有就绪队列时，选择一个将处理机分配给它
void priority(int T)
{
while (run != NULL)
{
run->rtime = run->rtime + T;
run->syቤተ መጻሕፍቲ ባይዱime = run->sytime - T;
实验完成后请现场演示。
实验步骤描述
1.给一系列进程创建结构体
2.写一个printready函数探测就绪队列是否为空
3.写一个display1函数，用于显示当前进程
实验一 处理机调度实验报告
实验一处理机调度一、实验内容选择一个调度算法，实现处理机调度。
二、实验目的多道系统中，当就绪进程数大于处理机数时，须按照某种策略决定哪些进程优先占用处理机。
本实验模拟实现处理机调度，以加深了解处理机调度的工作。
三、实验题目1、设计一个按优先权调度算法实现处理机调度的程序；2、设计按时间片轮转实现处理机调度的程序。
PCB内容要求：进程名/PID；要求运行时间（单位时间）；优先权；状态：PCB指针；1、可随机输入若干进程，并按优先权排序；2、从就绪队首选进程运行：优先权-1要求运行时间-1要求运行时间=0时，撤销该进程3、重新排序，进行下轮调度；源代码：#include <stdio.h>#include <stdlib.h>#include <string.h>#include <windows.h>typedef struct pcb{char PID[50];int needTime;//需要运行时间int priority;//优先权char state[20];//进程状态struct pcb *next;}PCB;typedef struct{PCB* front;PCB* rear;}ProcessQueue;void SelectAlgorithm();void CreateQProcess(ProcessQueue &Q,char*,int time,int pri,char*);void ProcessSchedule();void InitQueue(ProcessQueue &Q);void visitQueue(ProcessQueue &Q);bool RunProcess(PCB* rp,ProcessQueue &Q);bool NonPreemptivePriority(ProcessQueue &Q);//非抢占式优先权调度void delProcess(PCB* delp);bool RunProcessPreem(PCB* rp,ProcessQueue &Q);//抢占式优先执行进程bool PreemptivePriority(ProcessQueue &Q);void RR(ProcessQueue &Q);int main(){int iSel;int i = 0;SelectAlgorithm();ProcessQueue readyQ;//就绪进程队列PCB newpcb;InitQueue(readyQ);printf("请选择调度算法：");do{scanf("%d",&iSel);} while (!(iSel == 1 || iSel == 2 || iSel == 3));while(i < 3){printf("请输入要创建的进程:\n");fflush(stdin);gets(newpcb.PID);fflush(stdin);scanf("%d",&newpcb.needTime);fflush(stdin);scanf("%d",&newpcb.priority);fflush(stdin);gets(newpcb.state);fflush(stdin);CreateQProcess(readyQ,newpcb.PID,newpcb.needTime,newpcb.priority,newpcb.state);printf("创建了一个进程\n");++i;}visitQueue(readyQ);//显示的是各个进程的优先权switch(iSel){case 1:while(NonPreemptivePriority(readyQ));//非抢占优先权调度break;case 2:PreemptivePriority(readyQ);//抢占式优先权调度break;case 3:RR(readyQ);break;}return 0;}void SelectAlgorithm(){printf("1.非抢占式优先权调度\n");printf("2.抢占式优先权调度\n");printf("3.时间片轮转调度\n");}void InitQueue(ProcessQueue &Q)//初始化进程队列{Q.front = Q.rear = (PCB*)malloc(sizeof(PCB));if(!Q.front) exit(-1);Q.front->next = NULL;}void CreateQProcess(ProcessQueue &Q,char* pid,int time,int pri,char* st)//指定进程入就绪队列，将优先权高的插在队列前面{PCB* p = (PCB*)malloc(sizeof(PCB));if(!p) exit(-1);strcpy(p->PID,pid); p->needTime = time;p->priority = pri; strcpy(p->state,st);p->next = NULL;PCB* q = Q.front->next, *old = Q.front;if(!q)//如果原队列为空{Q.rear->next = p;Q.rear = p;//q == NULL}else//如果原队列不为空{for(;q != NULL;){if(p->priority > q->priority){old->next = p;p->next = q;return;}q = q->next;old = old->next;if(q == NULL){Q.rear->next = p;Q.rear = q;//q == NULL}}}}void ProcessSchedule(){}void visitQueue(ProcessQueue &Q)//访问进程队列{PCB* p = (PCB*)malloc(sizeof(PCB));if(!p) exit(-1);p = Q.front->next;while(p != NULL){printf("%d,",p->priority);p = p->next;}printf("\n");int i = 0;}bool PreemptivePriority(ProcessQueue &Q){PCB* rprocess;if(!Q.front->next){printf("就绪队列中没有进程可以调度！\n");return false;}else{rprocess = Q.front->next;//选择优先权最高的进程Q.front->next = Q.front->next->next;//将进程移除就绪队列while(rprocess != NULL)//抢占式优先调度{RunProcessPreem(rprocess,Q);if(rprocess->needTime == 0){delProcess(rprocess);if((rprocess = Q.front->next) == NULL){printf("就绪队列中没有进程可以调度！\n");return false;}else{Q.front->next = Q.front->next->next;continue;}}if(Q.front->next != NULL){if(rprocess->priority < Q.front->next->priority)//判断运行了1个时间后还是否具有最高优先权{/*rprocess->next = Q.front->next->next;//正在运行中的进程因为优先权降低，重新进入就绪队列temp = Q.front->next;Q.front->next = rprocess;rprocess = temp;//rprocess保存运行进程*/CreateQProcess(Q,rprocess->PID,rprocess->needTime,rprocess->priority,rprocess->state);//正在运行中的进程因为优先权降低，重新进入就绪队列rprocess = Q.front->next;Q.front->next = Q.front->next->next;}}}}return true;}bool NonPreemptivePriority(ProcessQueue &Q)//非抢占式优先权调度{PCB* rprocess;//存放要调度运行的进程if(!Q.front->next){printf("就绪队列中没有进程可以调度！\n");return false;}else{rprocess = Q.front->next;Q.front->next = Q.front->next->next;//已经调度，从就绪队列中删除进程if(RunProcess(rprocess,Q)){delProcess(rprocess);printf("就绪队列状态:\n");visitQueue(Q);}return true;}}bool RunProcess(PCB* rp,ProcessQueue &Q)//执行进程{while(rp->needTime){printf("进程%s正在运行...\n",rp->PID);printf("PID[50]\tneedTime\tpriority\tstate[20]\n");printf("%s\t%d\t\t%d\t\t%s\n",rp->PID,rp->needTime,rp->priority,rp->state);Sleep(1000);--rp->needTime;}return true;}bool RunProcessPreem(PCB* rp,ProcessQueue &Q)//抢占式优先,RR执行进程{printf("进程%s正在运行...\n",rp->PID);printf("PID[50]\tneedTime\tpriority\tstate[20]\n");printf("%s\t%d\t\t%d\t\t%s\n",rp->PID,rp->needTime,rp->priority,rp->state);Sleep(1000);--rp->needTime;--rp->priority;return true;}void delProcess(PCB* delp)//撤销进程{free(delp);}void RR(ProcessQueue &Q){PCB* running = Q.front->next;PCB* old = Q.front;while(Q.front->next != NULL){if(running){RunProcessPreem(running,Q);if(running->needTime == 0)//撤销进程{old->next = running->next;delProcess(running);running = old->next;continue;}old = old->next;running = running->next;}else{old = Q.front;running = old->next;}}printf("就绪队列中没有进程可以调度！\n");}以下是使用时间片轮转算法的一次执行：选择算法3：进程输入，此处输入1，1，1，1，2，2，2，2，3，3，3，3测试。
实验一处理机调度
实验一处理机调度一.实验目的多道系统中，当就绪进程数大于处理机数时，须按照某种策略决定哪些进程优先占用处理机。
本实验模拟实现处理机调度，以加深了解处理机调度的工作。
二.实验内容选择一个调度算法，实现处理机调度。
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）假定系统有五个进程，每一个进程用一个进程控制块PCB来代表。
进程控制块的格式为：其中，进程名----作为进程的标识，假设五个进程的进程名分别是R, P2, P3，P4，R。
指针—按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块首地址，最后一个进程中的指针为“ 0”。
要求运行时间-- 假设进程需要运行的单位时间数。
优先数-赋予进程的优先数，调度时总是选取优先数大的进程先执行。
状态-可假设有两种状态，“就绪”状态和“结束“状态，五个进程的初始状态都为“就绪“状态，用“ R”表示，当一个进程运行结束后，它的状态变为“结束”，用“ E”表示。
（2）在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”和“要求运行时间”。
（3）为了调度方便，把五个进程按给定的优先数从大到小连成队列，用一单元指出队首进程，用指针指出队列的连接情况。
例：队首标志（4）处理器调度总是选队首进程运行。
采用动态改变优先数的办法，进程每运行一次优先数就减“ 1”。
由于本实验是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：优先数－ 1 要求运行时间－1来模拟进程的一次运行提醒注意的是：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，它占有处理器运行，直到出现等待事件或运行结束。
在这里省去了这些工作。
(5)进程运行一次后，若要求运行时间工0,则再将它加入队列(按优先数大小插入，且置队首标志)；若要求运行时间=0,则把它的状态修改为“结束”(),且退出队列。
计算机操作系统 实验一
实验一处理机调度实验
一、实验目的：
用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解。
二、实验要求：
设计一个有N个进程并发的进程调度程序。
进程调度算法：采用时间片轮转调度算法。
每个进程有一个进程控制块（PCB）表示。
进程控制块可以包含如下信息：进程名、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
就绪进程获得CPU后都只能运行一个时间片，运行后已占用CPU时间加1。
如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，则把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
操作系统实验之处理机调度实验报告
操作系统实验之处理机调度实验报告一、实验目的处理机调度是操作系统中的核心功能之一，本次实验的主要目的是通过模拟不同的处理机调度算法，深入理解操作系统对处理机资源的分配和管理策略，比较不同调度算法的性能差异，并观察它们在不同负载情况下的表现。
二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 Python 38。
实验中使用了 Python 的相关库，如`numpy`、｀matplotlib`等，用于数据生成、计算和图形绘制。
三、实验原理1、先来先服务（FCFS）调度算法先来先服务算法按照作业到达的先后顺序进行调度。
先到达的作业先被服务，直到完成或阻塞，然后再处理下一个到达的作业。
2、短作业优先（SJF）调度算法短作业优先算法选择预计运行时间最短的作业先执行。
这种算法可以有效地减少作业的平均等待时间，但可能导致长作业长时间等待。
3、时间片轮转（RR）调度算法时间片轮转算法将处理机的时间分成固定长度的时间片，每个作业轮流获得一个时间片的处理时间。
当时间片用完后，如果作业还未完成，则将其放入就绪队列的末尾等待下一轮调度。
4、优先级调度算法优先级调度算法为每个作业分配一个优先级，优先级高的作业先被执行。
优先级可以根据作业的性质、紧急程度等因素来确定。
四、实验内容与步骤1、数据生成首先，生成一组模拟的作业，包括作业的到达时间、预计运行时间和优先级等信息。
为了使实验结果更具代表性，生成了不同规模和特征的作业集合。
2、算法实现分别实现了先来先服务、短作业优先、时间片轮转和优先级调度这四种算法。
在实现过程中，严格按照算法的定义和规则进行处理机的分配和调度。
3、性能评估指标定义了以下性能评估指标来比较不同调度算法的效果：平均等待时间：作业在就绪队列中的等待时间的平均值。
平均周转时间：作业从到达系统到完成的时间间隔的平均值。
系统吞吐量：单位时间内完成的作业数量。
4、实验结果分析对每种调度算法进行多次实验，使用不同的作业集合，并记录相应的性能指标数据。
处理机调度实验报告
处理机调度实验报告处理机调度实验报告一、引言处理机调度是计算机操作系统中一个重要的概念，它涉及到如何合理地分配处理机资源以提高系统的运行效率。
本文将针对处理机调度进行实验，探讨不同调度算法对系统性能的影响。
二、实验目的本实验的目的是通过模拟不同的处理机调度算法，比较它们在不同负载下的性能表现，进而分析其优缺点，为实际操作系统的调度算法选择提供参考。
三、实验方法1. 实验环境本实验使用了一台配置较高的计算机作为实验环境，操作系统为Linux，处理器为Intel Core i7，内存为8GB。
2. 实验设置为了模拟不同的负载情况，我们使用了三个不同的测试程序：程序A、程序B和程序C。
程序A是一个计算密集型任务，程序B是一个I/O密集型任务，程序C是一个混合型任务。
3. 实验步骤首先，我们分别运行程序A、程序B和程序C，并记录它们的运行时间。
然后，我们使用不同的调度算法来调度这些任务，并记录它们的运行时间和系统资源利用率。
四、实验结果与分析1. 调度算法1：先来先服务（First-Come, First-Served，FCFS）FCFS算法按照任务到达的先后顺序进行调度，即先到先服务。
实验结果显示，在计算密集型任务下，FCFS算法表现较好，但在I/O密集型任务和混合型任务下，其性能明显下降。
这是因为在FCFS算法中，任务的执行顺序是固定的，无法根据任务的特性进行灵活调度。
2. 调度算法2：最短作业优先（Shortest Job First，SJF）SJF算法根据任务的执行时间进行调度，即执行时间最短的任务先执行。
实验结果显示，在计算密集型任务和混合型任务下，SJF算法表现较好，但在I/O密集型任务下，其性能较差。
这是因为在I/O密集型任务中，任务的执行时间不仅与计算量有关，还与I/O操作的耗时有关，因此SJF算法无法有效地进行调度。
3. 调度算法3：时间片轮转（Round Robin，RR）RR算法将处理机的运行时间划分为若干个时间片，每个任务在一个时间片内执行一定的时间，然后切换到下一个任务。
实验一 处理机调度实验报告
实验一处理机调度实验报告一、实验目的处理机调度是操作系统中的一个重要组成部分，其目的是合理地分配处理机资源，以提高系统的性能和效率。
本次实验的主要目的是通过模拟处理机调度算法，深入理解不同调度算法的工作原理和性能特点，并能够对它们进行比较和分析。
二、实验环境本次实验使用了以下软件和工具：1、操作系统：Windows 102、编程语言：Python3、开发环境：PyCharm三、实验内容1、先来先服务（FCFS）调度算法先来先服务调度算法按照作业或进程到达的先后顺序进行调度。
即先到达的作业或进程先得到处理机的服务。
2、短作业优先（SJF）调度算法短作业优先调度算法优先调度运行时间短的作业或进程。
在实现过程中，需要对作业或进程的运行时间进行预测或已知。
3、高响应比优先（HRRN）调度算法高响应比优先调度算法综合考虑作业或进程的等待时间和运行时间。
响应比的计算公式为：响应比＝（等待时间＋要求服务时间）／要求服务时间。
4、时间片轮转（RR）调度算法时间片轮转调度算法将处理机的时间分成固定大小的时间片，每个作业或进程在一个时间片内运行，当时间片用完后，切换到下一个作业或进程。
四、实验步骤1、设计数据结构为了表示作业或进程，设计了一个包含作业或进程 ID、到达时间、运行时间和等待时间等属性的数据结构。
2、实现调度算法分别实现了上述四种调度算法。
在实现过程中，根据算法的特点进行相应的处理和计算。
3、模拟调度过程创建一组作业或进程，并按照不同的调度算法进行调度。
在调度过程中，更新作业或进程的状态和相关时间参数。
4、计算性能指标计算了平均周转时间和平均带权周转时间等性能指标，用于评估不同调度算法的性能。
五、实验结果与分析1、先来先服务（FCFS）调度算法平均周转时间：通过计算所有作业或进程的周转时间之和除以作业或进程的数量，得到平均周转时间。
在 FCFS 算法中，由于按照到达顺序进行调度，可能会导致长作业或进程长时间占用处理机，从而使平均周转时间较长。
模拟调度实验报告(3篇)
第1篇一、实验背景进程调度是操作系统核心功能之一，它负责在多道程序环境下，按照一定的策略对进程进行调度，以确保系统资源的合理分配和高效利用。
为了加深对进程调度算法的理解，本次实验采用模拟的方式，实现了先来先服务（FCFS）、时间片轮转（RR）和动态优先级调度（DP）三种算法，并对实验过程进行了详细记录和分析。
二、实验目的1. 理解进程调度的基本原理和不同调度算法的特点。
2. 掌握进程控制块（PCB）的设计与实现。
3. 通过模拟实验，验证三种调度算法的执行效果。
三、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 2019四、实验内容1. 定义进程控制块（PCB）进程控制块是操作系统用于描述和管理进程的实体，它包含了进程的基本信息。
本实验中，PCB包含以下字段：- 进程ID：唯一标识一个进程。
- 到达时间：进程进入就绪队列的时间。
- 需要运行时间：进程完成所需的时间。
- 已运行时间：进程已运行的时间。
- 状态：进程当前的状态（就绪、运行、阻塞、完成）。
2. 实现三种调度算法（1）先来先服务（FCFS）算法FCFS算法按照进程到达就绪队列的顺序进行调度，先到先服务。
具体实现如下：- 将进程按照到达时间排序，形成就绪队列。
- 遍历就绪队列，依次执行进程，直到进程完成或被阻塞。
（2）时间片轮转（RR）算法RR算法将CPU时间划分为时间片，每个进程运行一个时间片后，让出CPU，等待下一个时间片。
具体实现如下：- 设置一个时间片大小。
- 将进程按照到达时间排序，形成就绪队列。
- 遍历就绪队列，每个进程执行一个时间片，如果进程未完成，则将其加入就绪队列队尾。
（3）动态优先级调度（DP）算法DP算法根据进程的优先级进行调度，优先级高的进程优先执行。
具体实现如下：- 设置一个优先级阈值，当进程的优先级高于阈值时，将其加入就绪队列。
- 遍历就绪队列，选择优先级最高的进程执行，直到进程完成或被阻塞。
操作系统 实验一 CPU调度
实验一CPU调度一、实验内容选择一个调度算法，实现处理机调度。
二、实验目的多道系统中，当就绪进程数大于处理机数时，须按照某种策略决定哪些进程优先占用处理机。
本实验模拟实现处理机调度，以加深了解处理机调度的工作。
三、实验题目1、设计一个按优先权调度算法实现处理机调度的程序；2、设计按时间片轮转实现处理机调度的程序。
四、实验要求PCB内容：进程名/PID；要求运行时间（单位时间）；优先权；状态：PCB指针；1、可随机输入若干进程，并按优先权排序；2、从就绪队首选进程运行：优先权-1/要求运行时间-1要求运行时间=0时，撤销该进程3、重新排序，进行下轮调度；4、最好采用图形界面；5、可随时增加进程；6、规定道数，设置后备队列和挂起状态。
若内存中进程少于规定道数，可自动从后备队列调度一作业进入。
被挂起进程入挂起队列，设置解挂功能用于将指定挂起进程解挂入就绪队列。
7、每次调度后，显示各进程状态。
五、实验源码/*** @(#)CPUScheduling.java*** @author Liang Jiabin* @version 1.00 2010/11/5*/import java.awt.*;import javax.swing.*;import java.awt.event.ActionListener;import java.awt.event.ActionEvent;import java.util.Vector;public class CPUScheduling extends Thread{private JFrame frame;private JScrollPane reserveSp,waitingSp,finishSp;private JList reserveList, readyList, waitingList, finishList;private DefaultListModel reserveLm, readyLm, waitingLm, finishLm;private JLabel reserveLbl, readyLbl, CPULbl, waitingLbl, finishLbl;private JTextField CPUTf;private JLabel needTimeLbl, priorityLbl;private JComboBox needTimeCb, priorityCb;private JButton newBtn, suspendBtn, unsuspendBtn, exitBtn;private JLabel rToRLbl,rToCPULbl,CPUToRLbl,CPUToWLbl,wToRLbl;private JLabel CPUToFLbl,warningLbl, explainLbl;private int number = 1; //进程名序号private String CPUProcess = "";private String CPUProcessId = "";private String CPUProcessPriority = "0"; private String CPUProcessTime = "0";private String maxPriorityProcess = "";private String maxPriorityProcessId = ""; private String maxPriorityProcessTime = ""; private String maxPriorityProcessPriority = "0";private Vector waitingReadyV = new Vector(1,1);public CPUScheduling(){frame = new JFrame("CPU Scheduling");Container c = frame.getContentPane();c.setBackground(Color.pink);c.setLayout(null);reserveLbl = new JLabel("后备队列");reserveLbl.setBounds(50,20,60,30);c.add(reserveLbl);reserveLm = new DefaultListModel(); reserveList = new JList(reserveLm);reserveSp = new JScrollPane(reserveList); reserveSp.setBounds(30,50,100,200);c.add(reserveSp);rToRLbl = new JLabel(">>>>>"); rToRLbl.setBounds(145,100,60,30);c.add(rToRLbl);readyLbl = new JLabel("就绪队列"); readyLbl.setBounds(220,20,60,30);c.add(readyLbl);readyLm = new DefaultListModel(); readyList = new JList(readyLm); readyList.setFixedCellHeight(30); readyList.setBounds(200,50,100,200);c.add(readyList);rToCPULbl = new JLabel(">>>>>"); rToCPULbl.setBounds(320,50,50,30);c.add(rToCPULbl);CPUToRLbl = new JLabel("<<<<<"); CPUToRLbl.setBounds(320,65,50,30);c.add(CPUToRLbl);CPULbl = new JLabel("CPU"); CPULbl.setBounds(410,20,50,30);c.add(CPULbl);CPUTf = new JTextField(20); CPUTf.setEditable(false);CPUTf.setBounds(370,55,100,30);c.add(CPUTf);CPUToWLbl = new JLabel("||"); CPUToWLbl.setBounds(415,80,20,50);c.add(CPUToWLbl);wToRLbl = new JLabel("<<<<<"); wToRLbl.setBounds(320,160,50,30);c.add(wToRLbl);waitingLbl = new JLabel("挂起队列"); waitingLbl.setBounds(390,110,60,30);c.add(waitingLbl);waitingLm = new DefaultListModel(); waitingList = new JList(waitingLm);waitingSp = new JScrollPane(waitingList); waitingSp.setBounds(370,140,100,200); c.add(waitingSp);CPUToFLbl = new JLabel(">>>>>"); CPUToFLbl.setBounds(480,55,50,30);c.add(CPUToFLbl);finishLbl = new JLabel("完成队列"); finishLbl.setBounds(560,20,60,30);c.add(finishLbl);finishLm = new DefaultListModel();finishList = new JList(finishLm);finishSp = new JScrollPane(finishList);finishSp.setBounds(540,50,100,200);c.add(finishSp);needTimeLbl = new JLabel("要求运行时间"); needTimeLbl.setBounds(10,330,100,30);c.add(needTimeLbl);String[] time = {"1","2","3","4","5","6","7","8","9"}; needTimeCb = new JComboBox(time); needTimeCb.setEditable(true);needTimeCb.setBounds(95,330,60,30);c.add(needTimeCb);priorityLbl = new JLabel("优先权");priorityLbl.setBounds(175,330,50,30);c.add(priorityLbl);String[] priority = {"1","2","3","4","5","6","7","8","9"}; priorityCb = new JComboBox(priority);priorityCb.setBounds(220,330,60,30);c.add(priorityCb);newBtn = new JButton("增加");newBtn.setBounds(120,380,60,30);c.add(newBtn);warningLbl = new JLabel();warningLbl.setForeground(Color.RED);warningLbl.setBounds(360,350,200,30);c.add(warningLbl);suspendBtn = new JButton("挂起");suspendBtn.setBounds(340,380,60,30);c.add(suspendBtn);unsuspendBtn = new JButton("解挂");unsuspendBtn.setBounds(440,380,60,30);c.add(unsuspendBtn);exitBtn = new JButton("退出");exitBtn.setBounds(560,380,60,30);c.add(exitBtn);explainLbl = new JLabel("注：进程信息表示为“进程名，需要运行时间，优先权”");explainLbl.setBounds(10,420,500,30);c.add(explainLbl);//Button事件注册ButtonListener btnListener = new ButtonListener();newBtn.addActionListener(btnListener);suspendBtn.addActionListener(btnListener);unsuspendBtn.addActionListener(btnListener);exitBtn.addActionListener(btnListener);//调度器线程开启this.start();frame.setSize(720,520);frame.setVisible(true);frame.setLocationRelativeTo(null);frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);}/** 开启线程*/public synchronized void run(){try{while (true){//判断waiting队列是否有进程在等待进ready队列while (readyLm.size()<4 && waitingReadyV.size() != 0){String s = waitingReadyV.get(0).toString();readyLm.addElement(s);wToRLbl.setForeground(Color.RED);this.sleep(500);wToRLbl.setForeground(Color.BLACK);waitingReadyV.remove(0);waitingLm.removeElement(s);}//判断后备队列进程能否进就绪队列while (readyLm.size()<4 && !reserveLm.isEmpty()){readyLm.addElement(reserveLm.getElementAt(0));rToRLbl.setForeground(Color.RED);this.sleep(500);rToRLbl.setForeground(Color.BLACK);reserveLm.removeElementAt(0);}//对就绪队列中的进程按优先级排序，找出优先级最大的进入CPU运行if (!readyLm.isEmpty()){String[] s;int index = -1;for (int i=readyLm.size()-1; i>=0; i--){s = readyLm.getElementAt(i).toString().split(",");if (Integer.parseInt(s[2]) >= Integer.parseInt(CPUProcessPriority)){maxPriorityProcess = readyLm.getElementAt(i).toString();maxPriorityProcessId = s[0];maxPriorityProcessTime = s[1];maxPriorityProcessPriority = s[2];index = i;CPUProcessPriority = maxPriorityProcessPriority;}}if (!maxPriorityProcessId.equals(CPUProcessId)){CPUProcess = maxPriorityProcess;CPUProcessId = maxPriorityProcessId;CPUProcessTime = maxPriorityProcessTime;CPUProcessPriority = maxPriorityProcessPriority;}rToCPULbl.setForeground(Color.RED);CPUTf.setText(CPUProcessId);this.sleep(500);readyLm.removeElement(CPUProcess);rToCPULbl.setForeground(Color.BLACK);}this.sleep(1000); //在CPU上运行一秒//时间片到了，CPU上的进程转到就绪队列或完成队列if (!CPUTf.getText().equals("")){CPUTf.setText("");int time = Integer.parseInt(CPUProcessTime);CPUProcessTime = String.valueOf(--time);if (Integer.parseInt(CPUProcessPriority) > 1) //若优先级不为1则减1{int priority = Integer.parseInt(CPUProcessPriority);CPUProcessPriority = String.valueOf(--priority);}if (Integer.parseInt(CPUProcessTime) != 0) //要求运行时间不为0则进入ready队列{CPUProcess = CPUProcessId + "," + CPUProcessTime + "," + CPUProcessPriority;readyLm.addElement(CPUProcess);CPUToRLbl.setForeground(Color.RED);this.sleep(500);CPUTf.setText("");CPUToRLbl.setForeground(Color.BLACK);}else //要求运行时间为0则转到完成队列{CPUToFLbl.setForeground(Color.RED);CPUProcessTime = String.valueOf(0);CPUProcessPriority = String.valueOf(0);CPUProcess = CPUProcessId + "," + CPUProcessTime + "," + CPUProcessPriority;finishLm.addElement(CPUProcess);CPUProcessId = "";this.sleep(500);CPUToFLbl.setForeground(Color.BLACK);}}}}catch (Exception e){e.printStackTrace();}}/** 按钮监听器*/class ButtonListener implements ActionListener{public synchronized void actionPerformed(ActionEvent ae) {JButton source = (JButton)ae.getSource();if (source == newBtn) //增加进程{String time = "1";time = needTimeCb.getSelectedItem().toString();String priority = "1";priority = priorityCb.getSelectedItem().toString();String pid = String.valueOf(number);String reserveItem = "";reserveItem = "P" + pid + "," + time + "," + priority;reserveLm.addElement(reserveItem);number++;}else if (source == suspendBtn) //挂起进程{System.out.println("点击挂起" ); /////if (!CPUTf.getText().equals("")){CPUToWLbl.setForeground(Color.RED);CPUTf.setText("");CPUProcessId = "";waitingLm.addElement(CPUProcess);System.out.println("挂起成功" ); /////try{sleep(500);}catch (Exception e){}CPUToWLbl.setForeground(Color.BLACK);}}else if (source == unsuspendBtn) //解挂进程{System.out.println("点击解挂" ); /////String unsuspendProcess = "";if (waitingList.getSelectedValue()!= null){unsuspendProcess = waitingList.getSelectedValue().toString();waitingReadyV.add(unsuspendProcess);warningLbl.setText("");System.out.println("解挂成功" ); /////}else{warningLbl.setText("请选要择解挂的进程");}}else if (source == exitBtn) //退出程序{System.exit(0);}}}/** main函数*/public static void main(String args[]){new CPUScheduling();}}六、实验结果。
操作系统实验之处理机调度实验报告
1、开发工具
Clion for mac 2016，采用 cmake 编译。
2、主要源码
//先来先服务 void FCFS(List *p, int count) {
List temp; int i, j; //按照到达时间排序 for (i = 1; i < count; i++) {
min = 100; temp = p[k].Finish_time; for (j = 0; j < count; j++) {
if (p[j].order != 0 || temp - p[j].Arrival_time < 0) continue;
if (min > p[j].Service_time) {
max = 0;
temp = p[k].Finish_time; //找响应比最高任务 for (j = 0; j < count; j++) {
if (p[j].order != 0 || temp - p[j].Arrival_time <= 0) continue;
if (max < (temp - p[j].Arrival_time) / p[j].Service_time) {
if (temp > p[i].Arrival_time) {
temp = p[i].Arrival_time; k = i; } } //按照响应比大小设置优先级，以及相应参数 for (i = 0; i < count; i++) { p[k].order = ++flag; p[k].Start_time = temp; p[k].Wait_time = temp - p[k].Arrival_time; p[k].Finish_time = temp + p[k].Service_time; p[k].Turnover_time = p[k].Finish_time - p[k].Arrival_time; p[k].WeightedTurn_time = p[k].Turnover_time / p[k].Service_time;
操作系统实验报告一处理机调度
实验课程名称：
workspace[i].offTim=workspace[i].costTim+workspace[i].startTim;
workspace[i].Ti=workspace[i].offTim-workspace[i].upTim;
workspace[i].Tr=workspace[i].Ti/workspace[i].costTim;
}
*T+=workspace[i].Ti;//计算平均周转时间
*W+=workspace[i].Tr;//计算平均带权周转时间
}
}
二、实验结果及分析（包括结果描述、实验现象分析、影响因素讨论、综合分析和结论等）测试用例一结果：
测试用例二结果：
三、实验心得
通过本次实验进一步理解了处理机调度问题的处理算法，学习到算法适用的前提是作业提交成功。
在实验编程过程中由于对一些概念理解不清楚导致实验结果出错，但通过调整修改得出正确结果如上。
在实验过程中代码相对简介，输出界面直观整齐易于分析，但仍有缺陷待改进。
实验一___处理器调度(设计一个按时间片轮转法实现处理器调度的程序)介绍
实验一处理器调度一、实验内容选择一个调度算法，实现处理器调度。
二、实验目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。
当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。
本实习模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。
三、实验题目第二题：设计一个按时间片轮转法实现处理器调度的程序。
[提示]：(1)假定系统有五个进程，每一个进程用一个进程控制块PCB来代表。
进程控制块的格式为：其中，Q1，Q2，Q3，Q4，Q5。
指针——进程按顺序排成循环队列，用指针指出下一个进程的进程控制块的首地址最后一个进程的指针指出第一个进程的进程控制块首地址。
要求运行时间——假设进程需要运行的单位时间数。
已运行时间——假设进程已经运行的单位时间数，初始值为“0”。
状态——有两种状态，“就绪”和“结束”，初始状态都为“就绪”，用“R”表示。
当一个进程运行结束后，它的状态为“结束”，用“E”表示。
(2) 每次运行所设计的处理器调度程序前，为每个进程任意确定它的“要求运行时间”。
(3) 把五个进程按顺序排成循环队列，用指针指出队列连接情况。
另用一标志单元记录轮到运行的进程。
例如，当前轮到P2执行，则有：标志单元K1K2K3K4K5PCB1 PCB2 PCB3 PCB4 PCB5(4)处理器调度总是选择标志单元指示的进程运行。
由于本实习是模拟处理器调度的功能，所以，对被选中的进程并不实际的启动运行，而是执行：已运行时间+1来模拟进程的一次运行，表示进程已经运行过一个单位的时间。
请同学注意：在实际的系统中，当一个进程被选中运行时，必须置上该进程可以运行的时间片值，以及恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行满一个时间片。
在这时省去了这些工作，仅用“已运行时间+1”来表示进程已经运行满一个时间片。
(5)进程运行一次后，应把该进程的进程控制块中的指针值送到标志单元，以指示下一个轮到运行的进程。
实验一 处理机调度
实验一处理机调度实验一、实验目的：用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解。
二、实验要求：用C++语言实验对N个进程采用非抢占式的动态优先权优先算法的进程调度三、实验内容：（1）设计一个有N个进程并发的进程调度程序。
进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）算法。
（2）每个进程有一个进程控制块（PCB）表示。
PCB用结构来描述，包括以下字段：●进程标识ID、●优先数，为初始设定的模拟条件●到达时间，为初始设定的模拟条件●需要运行时间，为初始设定的模拟条件●已用CPU时间，为初始设定的模拟条件●进程阻塞时间startblock（表示进程在运行startblock个时间片后，进程将进入阻塞状态），为初始设定的模拟条件●进程被阻塞的时间blocktime（表示进程等待blocktime个时间片后，将转换成就绪状态），为初始设定的模拟条件，模拟执行I/O操作需要的时间●进程状态state，就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态●队列指针next等等。
（3）优先数改变的规则进程在就绪对列中呆一个时间片，优先数增加1；进程每运行一个时间片，优先数减3；（4）运行过程描述首先按照初始化输入，按照各进程优先级高低排列就绪队列中进程顺序，优先级最高的进程最先获得CPU控制权运行。
如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，此时应将进程的优先数减3（即降低一级），如果到了进程需被阻塞的时间点，阻塞进程，然后把它插入阻塞队列，等待经过blocktime后，再唤醒进程，把它按照优先级高低，插入就绪队列相应位置等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
操作系统实验处理机调度C语言实现
操作系统实验处理机调度C语言实现
一、实验目的
1.理解操作系统分时调度的概念；
2.熟悉程序跟踪法；
3.开发一个C语言程序，实现调度算法。
二、实验内容
1.了解操作系统的分时调度概念，理解调度算法的实现原理；
2.根据操作系统调度实验案例中的要求，编写C语言程序并调试；
3.按照调度实验案例要求，进行操作系统分时调度实验，实现调度算法；
4.使用程序跟踪方法，对实验结果进行分析，并分析程序的调度结果。
三、实验步骤
1.仔细阅读操作系统分时调度实验，了解其原理；
2.编写C语言程序，实现调度算法；
3.编写操作系统分时调度实验的调度规则，并利用前面编写的C语言
程序实现调度规则；
4.设置实验测试数据，对操作系统分时调度进行模拟实验；
5.利用程序跟踪方法，进行实验结果分析及性能测试；
6.根据实验结果，对调度算法进行改进，提高系统调度效率；
7.完成实验报告，并总结分析程序的调度结果。
四、实验结果分析
1.首先，本次实验中，编写的C语言程序完成了操作系统分时调度要求，可以正确的实现调度算法。
2.其次，在实验中。
实验一 编程模拟处理机调度
一、实验教学内容与基本要求(时间：10月8号)实验一批处理系统的作业调度1 目的要求1.加深对作业概念的理解；2.深入了解批处理系统如何组织作业、管理作业和调度作业。
2 实验内容编写程序完成批处理系统中的作业调度，要求采用响应比高者优先的作业调度算法。
实验具体包括：首先确定作业控制块的内容，作业控制块的组成方式；然后完成作业调度；最后编写主函数对所做工作进行测试。
3 所需实验设施设备PC、windows操作系统4 教学形式及过程演示、学生独立完成重要数据结构:1. 作业信息Struct jobinfo {Int jid; 作业IDInt pid;进程IDChar** cmdarg;命令参数Int defpri;默认优先级Int curpri;当前优先级Int ownerid;作业所有者IDInt waittime;作业在队列中等待时间Time-t creat-time;作业创建时间Int runtime;作业运行时间Enum jobjobstate state;作业状态};2. 作业调度命令Struct jobcmd{Enum cmdtype;Int argnum;Int owner;Int defpri;Char data[buflen];};3. 就绪队列Struct waitqueue{Struct waitqurue *next;Struct jobinfo *job;};4. 作业状态Enum jobstate{Ready,running,done};实验一编程模拟处理机调度（实现一种算法）一、实验内容选择一个调度算法，实现处理器调度。
二、实验目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。
当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。
本实习模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。
三、实验题目设计一个按优先数调度算法实现处理器调度的程序。
计算机操作系统：处理机调度模拟实验资料
课程实验报告
在单处理机的情况下模拟用优先权的时间片轮转调度策略实现处理机调度，以加深了解处理机调度的工作过程。
要求：
可利用先来先服务、短作业优先、响应比高者优先、多级反馈队列模型、时间片轮转法等，来实现处理机的调度。
根据单处理机，多任务的问题特性做好软件实现的需求分析。
可根据问题的实际需要，可选择进程数量。
当系统运行时，能直观地、动态地反映当前处理机状态及各进程执行的状况。
描述6.create函数用于创建队列
7.insert为插入函数，用于将一个时间片运行结束的进程插入到就绪进程的
队尾
8.priority函数：如果有进程就绪，就将处理机分配给该进程让他执行。
调试过程及实验结果
总结每次运行一步，电脑将会将该时刻所有进程控制块的运行状态显示给用户。
包括进程名、要求运行时间、已经运行时间、还需要运行时间、状态等信息。
当每个进程运行一个时间片之后将它从该队列中移除，添加到就绪队列队尾中以便使每个进程可以循环执行。
当要求运行时间和已运行时间相等时，说明该进程运行结束，将该进程撤出该队列并且不再添加到就绪队列中。
直到就绪队列中没有就绪进程为止
附录#define _CRT_SECURE_NO_DEPRECATE #include"stdio.h"
#include"stdlib.h"
#include"string.h"
typedef struct node
{
char pname[10]; //进程名
int rtime; //已运行时间
int sytime; //剩余时间。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
一、实验教学内容与基本要求(时间：10月8号)
实验一批处理系统的作业调度
1 目的要求
1.加深对作业概念的理解；
2.深入了解批处理系统如何组织作业、管理作业和调度作业。
2 实验内容
编写程序完成批处理系统中的作业调度，要求采用响应比高者优先的作业调度算法。
实验具体包括：首先确定作业控制块的内容，作业控制块的组成方式；然后完成作业调度；最后编写主函数对所做工作进行测试。
3 所需实验设施设备
PC、windows操作系统
4 教学形式及过程
演示、学生独立完成
重要数据结构:
1. 作业信息
Struct jobinfo {
Int jid; 作业ID
Int pid;进程ID
Char** cmdarg;命令参数
Int defpri;默认优先级
Int curpri;当前优先级
Int ownerid;作业所有者ID
Int waittime;作业在队列中等待时间
Time-t creat-time;作业创建时间
Int runtime;作业运行时间
Enum jobjobstate state;作业状态
};
2. 作业调度命令
Struct jobcmd{
Enum cmdtype;
Int argnum;
Int owner;
Int defpri;
Char data[buflen];
};
3. 就绪队列
Struct waitqueue{
Struct waitqurue *next;
Struct jobinfo *job;};
4. 作业状态
Enum jobstate{
Ready,running,done
};
实验一编程模拟处理机调度（实现一种算法）
一、实验内容
选择一个调度算法，实现处理器调度。
二、实验目的
在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。
当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。
本实习模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。
三、实验题目
设计一个按优先数调度算法实现处理器调度的程序。
[提示]：
(1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表，进程控制块的格式为：
其中，进程名——作为进程的标识，假设五个进程的进程名分别为P1，P2，P3，P4，P5。
指针——按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程中的指针为“0”。
要求运行时间——假设进程需要运行的单位时间数。
优先数——赋予进程的优先数，调度时总是选取优先数大的进程先执行。
状态——可假设有两种状态，“就绪”状态和“结束”状态。
五个进程的初始状态都为“就绪”，用“R”表示，当一个进程运行结束后，它的状态为“结束”，用“E”表示。
(2) 在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”和“要求运行时间”。
(3) 为了调度方便，把五个进程按给定的优先数从大到小连成队列。
用一单元指出队首进程，用指针指出队列的连接情况。
例：
队首标志
K1K2K3K4K5
(4) 处理器调度总是选队首进程运行。
采用动态改变优先数的办法，进程每运行一次优先数就减“1”。
由于本实习是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，
而是执行：
优先数-1
要求运行时间-1
来模拟进程的一次运行。
提醒注意的是：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行结束。
在这里省去了这些工作。
(5) 进程运行一次后，若要求运行时间 0，则再将它加入队列（按优先数大小插入，且置队首标志）；若要求运行时间=0，则把它的状态修改成“结束”（E），且退出队列。
(6) 若“就绪”状态的进程队列不为空，则重复上面（4）和（5）的步骤，直到所有进程都成为“结束”状态。
(7) 在所设计的程序中应有显示或打印语句，能显示或打印每次被选中进程的进程名以及运行一次后进程队列的变化。
(8) 为五个进程任意确定一组“优先数”和“要求运行时间”，启动所设计的处理器调度程序，显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。