实验2进程调度源代码
操作系统实验2进程调度源程序
cout<<p->name;
cout<<" &#utime;
cout<<" ";
cout<<p->needtime;
cout<<" ";
cout<<p->priority;
cout<<" ";
switch(p->process){
case ready:cout<<"ready"<<endl;break;
switch(k){
case 1:priority_cal();break;
case 2:round_cal();break;
case 3:break;
display_menu();
scanf("%d",&k);
}
}
t=head;
while(t->next!=k&&t->process==finish){
t=t->next;
}
}
return t;
}//获取下一个进程
void set_state(pcb*p){
while(p){
if(p->needtime==0){
p->process=finish;//如果所需执行时间为0，则设置运行状态为结束
state process;//进程状态
pcb*next;
};//定义进程pcb
pcb*get_process(){
pcb*q;
pcb*t;
pcb*p;
进程调度算法实验报告
计算机操作系统实验报告实验二进程调度算法一、实验名称：进程调度算法二、实验内容：编程实现如下算法：1.先来先服务算法；2.短进程优先算法；3.时间片轮转调度算法。
三、问题分析与设计：1.先来先服务调度算法先来先服务调度算法是一种最简单的调度算法，该算法既可以用于作业调度，也可用于进程调度。
当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将他们调入内存，为它们分配资源、创建进程，然后放入就绪队列。
在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。
该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。
FCFS算法比较有利于长作业（进程），2.短作业（进程）优先调度算法短作业（进程）优先调度算法SJ（P）F，是指对短作业或短进程优先调度的算法。
它们可以分别用于作业调度和进程调度。
短作业优先（SJF）的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。
而短进程（SPF）调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机再重新调度。
SJ(P)F调度算法能有效地降低作业（进程）的平均等待时间，提高系统吞吐量。
该算法对长作业不利，完全未考虑作业的紧迫程度。
3.时间片轮转算法在时间片轮转算法中，系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。
当执行的时间片用完时，由一个计数器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。
这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。
换言之，系统能在给定的时间内响应所有用户的请求。
2实验二进程调度(优先数调度)参考代码
进程调度算法（优先数调度）一、实验目的用高级语言编写一个模拟进程调度程序，以加深对进程调度和进程调度算法的理解。
二、实验要求编写一个可动态输入进程数，采用优先级调度算法实现，要求：（1）优先数动态变化，每运行一次优先数减1。
（2）使用链表链接进程控制块。
（3）进程运行完要撤销该进程。
三、源程序#include<stdio.h>#include<stdlib.h>#include<conio.h>#define getpch(type) (type *)malloc(sizeof(type))#define NULL 0struct pcb{ /*定义进程控制块*/char name[10]; //进程名char state; //进程状态int super; //优先数int ntime; //总运行时间int rtime; //已运行时间struct pcb *link;}*ready=NULL,*p;typedef struct pcb PCB;sort()//建立对进程优先级排序函数{PCB *first,*second;int insert=0;if((ready==NULL) || ((p->super)>(ready->super)))//优先级最大插入队首{p->link=ready;ready=p;}else//进程比实优先级，插入适当的位置中{first=ready;second=first->link ;while(second!=NULL){if((p->super)>(second->super))//若插入进程比当前进程优先数大{p->link=second;//插入到当前进程前面first->link =p;second=NULL;insert=1;}else//插入进程优先烽最低，则插入到队尾{first=first->link;second=second->link;}}if(insert==0)first->link=p;}}input()//建立进程控制块函数{int i,num;//clrscr()//清屏printf("\n 请输入被调度的进程数目：");scanf("%d",&num);for(i=0;i<num;i++){printf("\n 进程NO%d：",i);p=getpch(PCB);printf("\n 输入进程名：");scanf("%s",p->name);printf("\n 输入进程优先数：");scanf("%d",&p->super);printf("\n 输入进程运行时间:");scanf("%d",&p->ntime);p->rtime=0;p->state='W';p->link=NULL;sort();//调用sort()排序}}int space() //测试进程数{int l=0;PCB *pr=ready;while(pr!=NULL){l++;pr=pr->link;}return(l);}disp(PCB *pr)//建立进程显示函数，用显示当前进程{printf("\n进程名\t状态\t 优先数\t总运行时间\t已运行时间\n");printf("%s\t",pr->name);printf(" %c\t",pr->state);printf("%5d\t",pr->super);printf("%5d\t",pr->ntime);printf("%12d\t",pr->rtime);printf("\n");}check()//建立进程查看函数{PCB *pr;printf("****当前正在运行的进程是：%s",p->name);//显示当前运行进程disp(p);pr=ready;printf("当前就就绪队列的状态：\n");//显示就绪队列状态while(pr!=NULL){disp(pr);pr=pr->link ;}}destroy()//建立进程撤销函数（进程运行结束,撤销进程){printf("\n进程[%s]已完成。
进程调度算法实验报告
进程调度算法实验报告Newly compiled on November 23, 2020操作系统实验报告（二）实验题目：进程调度算法实验环境：C++实验目的：编程模拟实现几种常见的进程调度算法，通过对几组进程分别使用不同的调度算法，计算进程的平均周转时间和平均带权周转时间，比较各种算法的性能优劣。
实验内容：编程实现如下算法：1.先来先服务算法；2.短进程优先算法；3.时间片轮转调度算法。
设计分析：程序流程图：1.2.短进程优先算法3.时间片轮转调度算法实验代码：1.先来先服务算法#include <>#define n 20typedef struct{int id; d;cin>>f[i].runtime;}for(i=0;i<amount;i++) time>f[j+1].atime){diao=f[j].atime;f[j].atime=f[j+1].atime;f[j+1].atime=diao;huan=f[j].id;f[j].id=f[j+1].id;f[j+1].id=huan;}}}for(i=0;i<amount;i++){cout<<"进程:"<<f[i].id<<"从"<<f[i].atime<<"开始"<<","<<"在" <<f[i].atime+f[i].runtime<<"之前结束。
"<<endl;f[i+1].atime=f[i].atime+f[i].runtime;}}2.短进程优先算法#include<>#define n 5#define num 5#define max 65535typedef struct pro{ int PRO_ID;int arrive_time;int sum_time;int flag;}Pro;um_time>s[j+1].sum_time){temp=s[j];s[j]=s[j+1];s[j+1]=temp;lastX=0;}}if(lastX==1) break;}return s[0];}void SPF(int p){if(n>0)int i,j,k,l,tc=0;Pro seq[n];Pro temp_seq[n];printf("短进程优先调度算法SPF\n");printf("请依次输入5个进程的进程号、到达时间和执行时间\n");printf("成员变量用逗号隔开；进程间用回车隔开\n");for(i=0;i<n;i++){scanf("%d,%d,%d",&seq[i].PRO_ID,&seq[i].arrive_time,&seq[i].sum_time);}printf("调度顺序是：\n");rrive_time;}tc=bubble(temp);lag=-1;}for(i=0;i<n;i++){for(j=0;j<n;j++){if(seq[j].flag!=1&&seq[j].arrive_time<=tc){seq[j].flag=0;}}for(j=0;j<n;j++){temp_seq[j]=seq[j];if(seq[j].flag!=0){temp_seq[j].sum_time=max;}}l=bubble(temp_seq).PRO_ID;for(j=0;j<n;j++){if(l==seq[j].PRO_ID){k=j;}}tc=tc+bubble(temp_seq).sum_time;seq[k].flag=1;printf("%d",l);}printf("\n");}}void main(){SPF(n);}3.时间片轮转调度算法头文件#include<iostream>#include<>#include<>#include<>#include<>#define MaxNum 100typedef struct pcb 行时间小于0，删除队首if(p1->runtime<=0){p1->state='C';printf(" %c\n",p1->state);p1->FinishTime=t;p1->WeightTime=p1->FinishTime-p1->arrivetime;p1->WeightWholeTime=p1->WeightTime/p1->wholetime;SumWT+=p1->WeightTime;SumWWT+=p1->WeightWholeTime;printf("时刻%2d进程%s运行结束,进程%s周转时间=%,带权周转时间=%\n",t,p1->Name,p1->Name,p1->WeightTime,p1->WeightWholeTime);head->front=p1->next;free(p1);}行时间大于0，向后找位置插入else{printf(" %c\n",p1->state);p2=p1->next;while(p2->next && p2->arrivetime != t){p2=p2->next;}用找位置往后插入，队首不变，不做操作位置往后插入if(p2->arrivetime != t){PCB *p3=p1,*p4;while(p3->next && p3->arrivetime<t){p4=p3;p3=p3->next;}if(p3->arrivetime>t){if(p4!=p1) 行时间小于0，删除队首if(p1->runtime<=0){p1->state='C';printf(" %c\n",p1->state);p1->FinishTime=t;p1->WeightTime=p1->FinishTime-p1->arrivetime;p1->WeightWholeTime=p1->WeightTime/p1->wholetime;SumWT+=p1->WeightTime;SumWWT+=p1->WeightWholeTime;printf("时刻%2d进程%s运行结束,进程%s周转时间=%,带权周转时间=%\n",t,p1->Name,p1->Name,p1->WeightTime,p1->WeightWholeTime);行时间大于0，直接插在队尾else{printf(" %c\n",p1->state);//若原队列只有一个进程，不必往队尾插if(!p1->next)head->front=p1;//若原队列有多个进程else{head->front=p1->next;head->rear->next=p1;head->rear=p1;p1->next=NULL;}}//时刻变化，队列为空时不做时刻变化if(empty(head))return;else{if(head->front->runtime<q)t=t+head->front->runtime;elset=t+q;}}/*******第二种情况结束*********/}}主程序#include<iostream>#include<>#include<>#include<>#include<>#include ""void main(){queue *head;int q;head=init();head=creat(head);printf("\n您输入的时间片轮转进程队列为:\n");print(head);printf("\n请输入时间片轮转调度的时间片为:");scanf("%d",&q);//时间片轮转调度RR(head,q);AverageWT=SumWT/N;AverageWWT=SumWWT/N;printf("平均周转时间=%,平均带权周转时间=%",AverageWT,AverageWWT);}运行结果：先来先服务：短进程：时间片轮：心得体会：这次的实验与上次的实验相比，在很多方面都有更多的难度，所以我们参考了别人很多的程序然后稍作了修改。
实验二：进程调度
实验二 进程调度一、 实验目的多道程序设计中，经常是若干个进程同时处于就绪状态，必须依照某种策略来决定那个进程优先占有处理机。
因而引起进程调度。
本实验模拟在单处理机情况下的处理机调度问题，加深对进程调度的理解。
二、 实验要求1． 设计进程调度算法，进程数不定2． 包含几种调度算法，并加以实现3． 输出进程的调度过程——进程的状态、链表等。
三、 参考例1．题目——优先权法、轮转法简化假设1） 进程为计算型的（无I/O ）2） 进程状态：ready 、running 、finish3） 进程需要的CPU 时间以时间片为单位确定2．算法描述1） 优先权法——动态优先权当前运行进程用完时间片后，其优先权减去一个常数。
2） 轮转法四、 实验流程图 开始 键盘输入进程数n ，和调度方法的选择 优先权法？ 轮转法产生n 个进程，对每个进程产生一个PCB ，并用随机数产生进程的优先权及进程所需的CPU 时间按优先权大小，把n 个进程拉成一个就绪队列撤销进程就绪队列为空？结束 N YY注意：1．产生的各种随机数的取值范围加以限制，如所需的CPU 时间限制在1~20之间。
2．进程数n 不要太大通常取4~8个3．使用动态数据结构4．独立编程5．至少三种调度算法6．若有可能请在图形方式下，将PCB 的调度用图形成动画显示。
五．实验过程：要求：读懂下面给出的程序，然后将其改写成由用户选择调度方式，例如：1、 FIFO2、 优先权调度3、 时间片轮转4、 退出对于每一种调度算法，由用户确定进程数，数据可以从文件读取，也可由用户手动输入。
（1）输入：进程流文件（1.txt ），其中存储的是一系列要执行的进程， 每个作业包括四个数据项：进程名 进程状态(1就绪 2等待 3运行) 所需时间 优先数(0级最高)进程0 1 50 2进程1 2 10 4进程2 1 15 0进程3 3 28 5进程4 2 19 1 产生n需的时间片数，已占用CPU 的时间片数置为0按进程产生的先后次序拉成就绪队列链=0？ 撤销该进程就绪队列为空吗？ =轮转时间片数？NY YY 结束 N进程5 3 8 7输出: 进程执行流等待时间，平均等待时间本程序包括:FIFO算法，优先数调度算法，时间片轮转调度算法（2）程序代码#include<stdio.h>#include<string.h>#include<iostream.h>const int block_time=10; //定义时间片的长度为10秒const int MAXPCB=100; //定义最大进程数//定义进程结构体typedef struct node{char name[20];int status;int time;int privilege;int finished;int wait_time;}pcb;pcb pcbs[MAXPCB];int quantity;//初始化函数void initial(){int i;for(i=0;i<MAXPCB;i++){strcpy(pcbs[i].name,"");pcbs[i].status=0;pcbs[i].time=0;pcbs[i].privilege=0;pcbs[i].finished=0;pcbs[i].wait_time=0;}quantity=0;}//读数据函数int readData(){FILE *fp;char fname[20];int i;cout<<"请输入进程流文件名:";cin>>fname;if((fp=fopen(fname,"r"))==NULL){cout<<"错误,文件打不开,请检查文件名"<<endl;}else{while(!feof(fp)){fscanf(fp,"%s %d %d %d",pcbs[quantity].name,&pcbs[quantity].status,&pcbs[quantity].time,&pcbs[quantity].privilege);quantity++;} //输出所读入的数据cout<<"输出所读入的数据"<<endl;cout<<"进程名进程状态所需时间优先数"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" \t"<<pcbs[i].status<<" \t"<<pcbs[i].time<<" \t"<<pcbs[i].privilege<<endl;}return(1);}return(0);}//重置数据,以供另一个算法使用void init(){int i;for(i=0;i<MAXPCB;i++){pcbs[i].finished=0;pcbs[i].wait_time=0;}}//先进先出算法void FIFO(){int i,j; int total;//输出FIFO算法执行流cout<<endl<<"*****************************************************"<<endl;cout<<"FIFO算法执行流:"<<endl; cout<<"进程名等待时间"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" "<<pcbs[i].wait_time<<endl;for(j=i+1;j<quantity;j++){pcbs[j].wait_time+=pcbs[i].time;}}total=0;for(i=0;i<quantity;i++){total+=pcbs[i].wait_time;}cout<<"总等待时间:"<<total<<" 平均等待时间:"<<total/quantity<<endl;}//优先数调度算法void privilege(){int i,j,p;int passed_time=0;int total;int queue[MAXPCB];int current_privilege=1000;for(i=0;i<quantity;i++){current_privilege=1000;for(j=0;j<quantity;j++){if((pcbs[j].finished==0)&&(pcbs[j].privilege<current_privilege)){p=j;current_privilege=pcbs[j].privilege;}}queue[i]=p;pcbs[p].finished=1;pcbs[p].wait_time+=passed_time;passed_time+=pcbs[p].time;}//输出优先数调度执行流cout<<endl<<"***********************************************************"<< endl;cout<<"优先数调度执行流:"<<endl;cout<<"进程名等待时间"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[queue[i]].name<<" "<<pcbs[queue[i]].wait_time<<endl;}total=0;for(i=0;i<quantity;i++){total+=pcbs[i].wait_time;}cout<<"总等待时间:"<<total<<" 平均等待时间:"<<total/quantity<<endl; }//时间片轮转调度算法void timer(){int i,j,number,flag=1;int passed_time=0;int max_time=0;int round=0;int queue[1000];int total=0;while(flag==1){flag=0;number=0;for(i=0;i<quantity;i++){if(pcbs[i].finished==0){number++; j=i;}}if(number==1){queue[total]=j;total++;pcbs[j].finished=1;}if(number>1){for(i=0;i<quantity;i++){if(pcbs[i].finished==0){flag=1;queue[total]=i;total++;if(pcbs[i].time<=block_time*(round+1)){pcbs[i].finished=1;}}}}round++;}if(queue[total-1]==queue[total-2]){total--;}cout<<endl<<"*******************************************************"<<endl;cout<<"时间片轮转调度执行流:"<<endl;for(i=0;i<total;i++){cout<<pcbs[queue[i]].name<<" ";cout<<endl;}}//显示void version(){cout<<" /********************* 进程调度********************/";cout<<endl<<endl;}//主函数void main(){int flag;version();initial();flag=readData();if(flag==1){FIFO();init();privilege();init();timer();}}（3）运行结果：输入进程流文件名1.txt即可得出以下输出结果：。
进程管理实验报告代码
一、实验目的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;}```五、实验结果与分析通过以上实验，我们了解了进程状态转换、进程同步与互斥、信号量实现进程同步与互斥以及进程调度算法。
操作系统课程设计进程调度模拟源代码
runqueue->next=NULL;//从就绪队列选一个节点，插入运行队列
runqueue->killtime=timeslice;//计算消耗的时间
runqueue->runedtime=runqueue->runedtime+runqueue->killtime;//计算总共运行时间
return 0;
}
printf("kill name %d, runtime=%d, runedtime=%d,killtime=%d\n"
,runqueue->name,runqueue->runtime,runqueue->runedtime,runqueue->killtime);
n++;
delete(runqueue);
,runqueue->name,runqueue->runtime,runqueue->runedtime,runqueue->killtime);
}
else if(runqueue->runtime<=0){//判断是否结束
runqueue->killtime=0;
runqueue->runtime=0;
else if(top_wait->next!=NULL){//
p=top_wait;
while(p->next!=temp){
p=p->next;
}
if(temp==tail_wait)
tail_wait=p;
p->next=temp->next;
实验报告二 进程调度算法
实验报告二——进程调度算法的设计姓名: xxxx 学号: xxxxx班级: xxxx一、实习内容•实现短进程优先调度算法（SPF）•实现时间片轮转调度算法（RR）二、实习目的•通过对进程调度算法的设计, 深入理解进程调度的原理。
进程是程序在一个数据集合上运行的过程, 它是系统进行资源分配和调度的一个独立单位。
进程调度分配处理机, 是控制协调进程对CPU的竞争, 即按一定的调度算法从就绪队列中选中一个进程, 把CPU的使用权交给被选中的进程。
三、实习题目• 1.先来先服务（FCFS）调度算法原理: 每次调度是从就绪队列中, 选择一个最先进入就绪队列的进程, 把处理器分配给该进程, 使之得到执行。
该进程一旦占有了处理器, 它就一直运行下去, 直到该进程完成或因发生事件而阻塞, 才退出处理器。
将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列, 并按照先来先服务的方式进行调度处理, 是一种最普遍和最简单的方法。
它优先考虑在系统中等待时间最长的作业, 而不管要求运行时间的长短。
按照就绪进程进入就绪队列的先后次序进行调度, 简单易实现, 利于长进程, CPU繁忙型作业, 不利于短进程, 排队时间相对过长。
• 2.时间片轮转调度算法RR原理: 时间片轮转法主要用于进程调度。
采用此算法的系统, 其程序就绪队列往往按进程到达的时间来排序。
进程调度按一定时间片(q)轮番运行各个进程.进程按到达时间在就绪队列中排队, 调度程序每次把CPU分配给就绪队列首进程使用一个时间片, 运行完一个时间片释放CPU, 排到就绪队列末尾参加下一轮调度, CPU分配给就绪队列的首进程。
固定时间片轮转法:1 所有就绪进程按FCFS 规则排队。
2 处理机总是分配给就绪队列的队首进程。
3 如果运行的进程用完时间片, 则系统就把该进程送回就绪队列的队尾, 重新排队。
4 因等待某事件而阻塞的进程送到阻塞队列。
5 系统把被唤醒的进程送到就绪队列的队尾。
操作系统实验2进程调度 实验报告
（2）掌握带优先级的进程调度算法；
（3）选用面向对象的编程方法。
二、实验内容；
（1）用C语言（或其它语言，如Java）实现对N个进程采用动态优先调度算法的调度。
（2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：
进程标识数ID。
进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。
4．可动态添加、删除进程；
5.完成所有进程操作。
五、程序源代码及注释
六、实验结果分析
1、运行结果如下：
2、结果分析
首先，每次从就绪队列中选择最高优先权的进程时，需要计算出最高优先权和次高优先权之间的STARTBLOCK。即最高优先权进程运行多少个时间片后就会进入阻塞队列。每调度一次，就需要更新所有进程的信息，并判断CPUTIME是否等于ALLTIME，如果相等，则进程完成操作，需从就绪队列中删除。如果阻塞队列中进程的BLOCKTIME为0时，还需要将其转移到就绪队列中。
（5）用户可以干预进程的运行状态，程序应该设置可以让用户中断的入口，并可以通过以下命令查看，修改，终止进程。
A）create随机创建进程，进程的优先级与所需要的时间片随机决定；
B）ps查看当前进程状态
C）sleep命令将进程挂起
D）kill命令杀死进程
E）quit命令退出
（5）分析程序运行的结果，谈一下自己的认识。
三、实验原理；
无论是在批处理系统还是分时系统中，用户进程数一般都多于处理机数、这将导致它们互相争夺处理机。另外，系统进程也同样需要使用处理机。这就要求进程调度程序按一定的策略，动态地把处理机分配给处于就绪队列中的某一个进程，以使之执行。
根据进程的五个特征：(1)动态性；(2)并发性；(3)异步性；(4)独立性；(5)结构性及三种基本状态的转换，了解各进程对资源的共享和竞争。进程并发执行时，由于资源共享，带来各进程之间的相互制约。为了反映这些制约关系和资源共享关系，在创建一个进程时，应首先创建其PCB，然后才能根据PCB中信息对进程实施有效的管理和控制。当一个进程完成其功能之后，系统则最后释放PCB，进程也随之消亡。
计算机操作系统实验指导汤小丹版源代码
计算机操作系统实验指导汤小丹版源代码```python#实验指导：操作系统进程调度算法实现#题目描述：#设计一个操作系统的进程调度算法，使得CPU能够合理地分配给各个进程时间片，并实现算法的模拟。
#要求：#1.设计进程调度算法#2.实现进程控制块#3.实现模拟CPU的运行过程#实验步骤：#1.定义进程控制块#进程控制块（PCB）存储了一个进程的相关信息，包括进程ID、优先级、进程状态等等。
以下是一个简单的PCB类的定义：class PCB:def __init__(self, pid, priority):self.pid = pidself.priority = priorityself.state = 'ready'#2.实现进程调度算法# 进程调度算法决定了CPU如何从就绪队列中选择下一个要执行的进程。
以下是一个简单的调度算法（Round-Robin算法）的实现：def schedule(processes):while True:for process in processes:if process.state == 'ready':print(f"Running process {process.pid}...")process.state = 'running'#3.实现CPU的模拟#在模拟CPU运行过程中，可以将每个进程表示为一个线程，通过调度算法选择要运行的线程，并模拟线程执行的过程。
import threadingclass CPU(threading.Thread):def __init__(self, process):threading.Thread.__init__(self)self.process = processdef run(self):print(f"CPU: Running process {self.process.pid}...")print(f"CPU: Process {self.process.pid} finished.") self.process.state = 'finished'#4.实验结果展示#定义几个进程process1 = PCB(1, 1)process2 = PCB(2, 2)process3 = PCB(3, 3)#将进程放入就绪队列processes = [process1, process2, process3]#调度进程schedule(processes)#模拟CPU运行for process in processes:cpu = CPU(process)cpu.startcpu.join#5.实验总结# 本次实验基于Python语言，实现了一个简单的操作系统进程调度算法模拟。
进程调度源代码
proc[ReadyPoint].p_state ='C';
RunPoint=ReadyPoint;
proc[ReadyPoint].p_cputime =proc[ReadyPoint].p_rserial[proc[ReadyPoint].p_pos] ;
}
n=WaitPoint;
printf("\n Waiting Process ...... \n");
while(n!=-1) // 显示阻塞进程信息
{
printf(" No.%d ID:],m,m,m\n",n,proc[n].p_pid,proc[n].p_starttime,proc[n].p_rserial[proc[n].p_pos],proc[n].p_iotime);
proc[i].p_next=-1;
}
printf("\n---------------------------\n 建立了- 个进程数据序列\n\n", ProcNumber);
DisData();
printf("\nPress Any Key To Continue.......");
// 赋其他字段的值
proc[i].p_pos=1;
proc[i].p_starttime=((float) rand() / 32767) *49+1;
proc[i].p_endtime=0;
proc[i].p_cputime=proc[i].p_rserial[1];
proc[i].p_iotime=proc[i].p_rserial[2];
进程调度实验报告源码
一、实验目的本次实验旨在通过模拟进程调度过程，加深对进程调度算法的理解，并掌握进程调度程序的设计与实现方法。
实验内容主要包括：创建进程、进程调度、进程执行、进程结束等。
二、实验环境操作系统：Linux编程语言：C/C++三、实验内容1. 进程调度算法本实验采用三种进程调度算法：FIFO（先进先出）、时间片轮转法、多级反馈队列调度算法。
2. 进程调度程序设计进程调度程序主要由以下部分组成：（1）进程控制块（PCB）PCB用于描述进程的基本信息，包括进程名、到达时间、需要运行时间、已运行时间、进程状态等。
（2）就绪队列就绪队列用于存储处于就绪状态的进程，按照进程的优先级或到达时间进行排序。
（3）进程调度函数进程调度函数负责从就绪队列中选择一个进程进行执行，并将CPU分配给该进程。
（4）进程执行函数进程执行函数负责模拟进程的执行过程，包括进程的创建、执行、结束等。
四、实验源码```c#include <stdio.h>#include <stdlib.h>#include <time.h>#define MAX_PROCESSES 10typedef struct PCB {int pid;int arrival_time;int need_time;int used_time;int priority;int state; // 0: 等待 1: 运行 2: 完成} PCB;PCB processes[MAX_PROCESSES];int process_count = 0;typedef struct Queue {PCB queue;int front;int rear;int size;} Queue;Queue ready_queue;void init_queue(Queue q) {q->queue = (PCB )malloc(sizeof(PCB) MAX_PROCESSES); q->front = q->rear = 0;q->size = 0;}void enqueue(Queue q, PCB p) {if (q->size == MAX_PROCESSES) {printf("Queue is full.\n");return;}q->queue[q->rear] = p;q->rear = (q->rear + 1) % MAX_PROCESSES; q->size++;}PCB dequeue(Queue q) {if (q->size == 0) {printf("Queue is empty.\n");return NULL;}PCB p = &q->queue[q->front];q->front = (q->front + 1) % MAX_PROCESSES; q->size--;return p;}int is_empty(Queue q) {return q->size == 0;}void print_queue(Queue q) {printf("Queue: ");for (int i = 0; i < q->size; i++) {PCB p = &q->queue[(q->front + i) % MAX_PROCESSES];printf("PID: %d, Arrival Time: %d, Need Time: %d, Used Time: %d, Priority: %d, State: %d\n",p->pid, p->arrival_time, p->need_time, p->used_time, p->priority, p->state);}}void init_processes() {for (int i = 0; i < MAX_PROCESSES; i++) {processes[i].pid = i;processes[i].arrival_time = rand() % 10;processes[i].need_time = rand() % 10 + 1;processes[i].used_time = 0;processes[i].priority = rand() % 3;processes[i].state = 0;}}void schedule() {int time = 0;while (process_count > 0) {for (int i = 0; i < process_count; i++) {PCB p = &processes[i];if (p->arrival_time == time) {enqueue(&ready_queue, p);p->state = 1;}}if (!is_empty(&ready_queue)) {PCB p = dequeue(&ready_queue);p->used_time++;printf("Process %d is running.\n", p->pid);if (p->used_time == p->need_time) {p->state = 2;printf("Process %d is finished.\n", p->pid); }}time++;}}int main() {srand(time(NULL));init_queue(&ready_queue);init_processes();process_count = rand() % MAX_PROCESSES + 1;schedule();print_queue(&ready_queue);return 0;}```五、实验结果与分析1. FIFO调度算法实验结果表明，FIFO调度算法按照进程的到达时间进行调度，可能导致短作业等待时间长，效率较低。
进程调度算法实验报告
操作系统实验报告（二）实验题目：进程调度算法实验环境：C++实验目的：编程模拟实现几种常见的进程调度算法，通过对几组进程分别使用不同的调度算法，计算进程的平均周转时间和平均带权周转时间，比较各种算法的性能优劣。
实验内容：编程实现如下算法：1.先来先服务算法；2.短进程优先算法；3.时间片轮转调度算法。
设计分析：程序流程图：1.先来先服务算法2.短进程优先算法3.时间片轮转调度算法实验代码：1.先来先服务算法#include <>#define n 20typedef struct{int id; d; cin>>f[i].atime;cin>>f[i].runtime;}for(i=0;i<amount;i++) time>f[j+1].atime) {diao=f[j].atime;f[j].atime=f[j+1].atime;f[j+1].atime=diao;huan=f[j].id;f[j].id=f[j+1].id;f[j+1].id=huan;}}}for(i=0;i<amount;i++){cout<<"进程:"<<f[i].id<<"从"<<f[i].atime<<"开始"<<","<<"在"<<f[i].atime+f[i].runtime<<"之前结束。
"<<endl;f[i+1].atime=f[i].atime+f[i].runtime; }}2.短进程优先算法#include<>#define n 5#define num 5#define max 65535typedef struct pro{ int PRO_ID;int arrive_time;int sum_time;int flag;}Pro;um_time>s[j+1].sum_time){temp=s[j];s[j]=s[j+1];s[j+1]=temp;lastX=0;}}if(lastX==1) break;}return s[0];}void SPF(int p){if(n>0){int i,j,k,l,tc=0;Pro seq[n];Pro temp_seq[n];printf("短进程优先调度算法SPF\n");printf("请依次输入5个进程的进程号、到达时间和执行时间\n");printf("成员变量用逗号隔开；进程间用回车隔开\n");for(i=0;i<n;i++){scanf("%d,%d,%d",&seq[i].PRO_ID,&seq[i].arrive_time,&seq[i] .sum_time);}printf("调度顺序是：\n");rrive_time;}tc=bubble(temp);lag=-1;}for(i=0;i<n;i++){for(j=0;j<n;j++){if(seq[j].flag!=1&&seq[j].arrive_time<=tc){ seq[j].flag=0;}}for(j=0;j<n;j++){temp_seq[j]=seq[j];if(seq[j].flag!=0){temp_seq[j].sum_time=max;}}l=bubble(temp_seq).PRO_ID;for(j=0;j<n;j++){if(l==seq[j].PRO_ID){k=j;}}tc=tc+bubble(temp_seq).sum_time;seq[k].flag=1;printf("%d",l);}printf("\n");}}void main(){SPF(n);}3.时间片轮转调度算法头文件#include<iostream>#include<>#include<>#include<>#include<>#define MaxNum 100typedef struct pcb 行时间小于0，删除队首if(p1->runtime<=0){p1->state='C';printf(" %c\n",p1->state);p1->FinishTime=t;p1->WeightTime=p1->FinishTime-p1->arrivetime;p1->WeightWholeTime=p1->WeightTime/p1->wholetime;SumWT+=p1->WeightTime;SumWWT+=p1->WeightWholeTime;printf("时刻%2d进程%s运行结束,进程%s周转时间=%,带权周转时间=%\n",t,p1->Name,p1->Name,p1->WeightTime,p1->WeightWholeTim e);head->front=p1->next;free(p1);}行时间大于0，向后找位置插入else{printf(" %c\n",p1->state);p2=p1->next;while(p2->next && p2->arrivetime != t){p2=p2->next;}用找位置往后插入，队首不变，不做操作位置往后插入if(p2->arrivetime != t){PCB *p3=p1,*p4;while(p3->next && p3->arrivetime<t){p4=p3;p3=p3->next;}if(p3->arrivetime>t){if(p4!=p1) 行时间小于0，删除队首if(p1->runtime<=0){p1->state='C';printf(" %c\n",p1->state);p1->FinishTime=t;p1->WeightTime=p1->FinishTime-p1->arrivetime;p1->WeightWholeTime=p1->WeightTime/p1->wholetime;SumWT+=p1->WeightTime;SumWWT+=p1->WeightWholeTime;printf("时刻%2d进程%s运行结束,进程%s周转时间=%,带权周转时间=%\n",t,p1->Name,p1->Name,p1->WeightTime,p1->WeightWholeTim e);行时间大于0，直接插在队尾else{printf(" %c\n",p1->state);//若原队列只有一个进程，不必往队尾插 if(!p1->next)head->front=p1;//若原队列有多个进程else{head->front=p1->next;head->rear->next=p1;head->rear=p1;p1->next=NULL;}}//时刻变化，队列为空时不做时刻变化if(empty(head))return;else{if(head->front->runtime<q)t=t+head->front->runtime;elset=t+q;}}/*******第二种情况结束*********/}}主程序#include<iostream>#include<>#include<>#include<>#include<>#include ""void main(){queue *head;int q;head=init();head=creat(head);printf("\n您输入的时间片轮转进程队列为:\n");print(head);printf("\n请输入时间片轮转调度的时间片为:");scanf("%d",&q);//时间片轮转调度RR(head,q);AverageWT=SumWT/N;AverageWWT=SumWWT/N;printf("平均周转时间=%,平均带权周转时间=%",AverageWT,AverageWWT);}运行结果：先来先服务：短进程：时间片轮：心得体会：这次的实验与上次的实验相比，在很多方面都有更多的难度，所以我们参考了别人很多的程序然后稍作了修改。
实验进程调度源代码
实验进程调度源代码实验2 进程调度（一）目的和要求进程调度是处理机管理的核心内容。
本实验要求用高级语言编写和调试一个简单的进程调度程序。
通过本实验可以加深理解有关进程控制块、进程队列的概念，并体会和了解优先数和时间片轮转调度算法的具体实施方法。
（二）实验内容（1）设计进程控制块PCB结构，分别适用于优先数调度算法和循环轮转调度算法。
PCB结构包括以下信息：进程标识符，进程优先数（或轮转时间片），进程所占用的CPU时间、进程状态，当前队列指针等。
根据调度算法不同，PCB结构的内容可适当做增删。
（2）建立进程就绪队列。
对两种不同算法编制入链子程序。
（3）编制两种进程调度算法：1）优先数调度；2）循环轮转调度。
（三）实验环境用BORLAND C语言（四）范例说明采用C语言编写程序，选用优先数法或简单轮转法对五个进程进行调度，每个进程处于运行（RUN），就绪（READY）和完成（FINISH）三种状态之一，并假定起始状态为就绪状态。
1．数据结构PCB结构如下：NAME 进程标识符PRIO / ROUND 优先数/ 时间片CPUTIME 进程已占用的CPU时间NEEDTIME 进程到完成还需要的CPU时间NEXT 处于同一状态的下一进程的地址STATUS 进程所处的状态“R”进程处于运行状态“W”进程处于就绪状态“F”进程处于完成状态2．程序说明（1）在优先数算法中，进程每执行一次，优先数减3，CPU时间片加1，进程还需要的时间片数减1。
在轮转法中，采用固定时间片，时间片数为2，进程每执行一次，CPU时间片数加2，进程还需要的时间片数减2，并排在就绪队列的队尾。
（2）程序结构说明如下：①INSERT1：把未完成且优先数小于别的进程的进程PCB按进程优先数的顺序插入到就绪队列中。
②INSERT2：轮转法中使用的过程，将执行一个单位时间片数（为2）且还未完成的进程的PCB插入到就绪队列队尾。
③FIRSTIN：将就绪队列中的第一个进程投入运行。
处理器调度 时间片轮转法 实验报告(C和C 含源代码)
for(i=0;i<num;i++)
{
printf("\n mp;p[i].name
,p[i].priority
,p[i].time
,p[i].state);
}
printf("********************************************\n");
printf("\n 进程执行完成\n");
%d
%d
%c\n"
,&p[i].name
,p[i].priority
,p[i].time
,p[i].state);
}
printf("********************************************\n");
printf(" 按任意键继续执行：\n");
getchar();//等待输入回车符
把五个进程按顺序排成循环队列，用指针指出队列连接情况。另用一标志单
元记录轮到运行的进程。例如，当前轮到 P2 执行，则有：
标志单元 K2
K1
Q1
K2
2
1
R
PCB1
K2
Q2
K3
3
0
R
PCB2
K3
Q3
K4
1
0
R
PCB3
K4
Q4
K5
2
0
R
PCB4
K5
Q5
K1
4
0
R
PCB5
处理器调度总是选择标志单元指示的进程运行。由于本实验是模拟处理器调
void run(PCB *p)//进程运行子程序 {
操作系统实验二进程调度
操作系统实验二进程调度摘要：进程调度是操作系统中重要的功能之一，可以决定进程的优先级和执行顺序。
本实验主要介绍了进程调度的概念、不同的调度算法以及如何实现进程调度。
一、概念介绍进程调度是操作系统中的一项重要功能，用于决定哪个进程能够在处理器上运行。
在操作系统中存在多个进程需要同时运行，而处理器资源有限，因此需要通过进程调度来合理地安排进程的执行顺序，提高系统的效率。
进程调度的目标是使系统的吞吐量最大化、响应时间最短、资源利用率最高等。
常见的调度策略包括先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转、优先级调度等。
二、调度算法介绍1.先来先服务（FCFS）先来先服务（FCFS）是最简单的调度算法，按照进程到达的顺序进行调度，先到达的进程先执行。
FCFS算法不考虑进程的优先级和执行时间，容易导致平均等待时间长。
2.最短作业优先（SJF）最短作业优先（SJF）调度算法按照进程所需的CPU时间进行排序，优先调度所需时间最短的进程。
SJF算法可以减少平均等待时间，但可能会导致长作业等待时间过长。
3.时间片轮转时间片轮转是一种抢占式调度策略，将处理器的使用权分割为若干个时间片，每个进程在一个时间片内运行，如果时间片用完仍未运行完，则将该进程放到队列的末尾，并让下一个进程运行。
时间片轮转算法保证了公平性和响应时间，但可能会导致上下文切换次数过多。
4.优先级调度优先级调度是根据进程的优先级进行调度，优先级高的进程先执行。
优先级可以根据进程类型、实时性等因素确定，不同的操作系统可能有不同的优先级范围和策略。
三、实验步骤1.定义进程结构：定义进程结构体，包含进程ID、进程状态、优先级、执行时间等信息。
2.初始化进程队列：将所有进程按照到达的先后顺序加入到进程队列中。
3.实现调度算法：根据不同的调度算法，实现相应的进程调度算法代码。
可以使用循环遍历进程队列，并根据不同的调度策略决定下一个要执行的进程。
4.执行进程调度：在每个时间片结束后，根据调度算法选取下一个要执行的进程，并更新进程的状态和执行时间。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
//请编写程序
}
else
{
Ready = NULL;
for (i=0;i<5;i++)
{
scanf("%s",Na);
scanf("%d",&time);
p = (PCB)malloc(sizeof(PCBSTRUCT));
Run = NULL;
if (Ready != NULL)
FirstIn();
}
else if (Run->Count == Run->Round)
{
Run->Count = 0;
if (Ready != NULL)
{
Run->State = 'W';
printf("%8s %6d %8d %10d %8c\n",temp->Name,temp->CpuTime,
temp->NeedTime,temp->Proi,temp->State);
else
printf("%8s %6d %8d %8d %8d %8c\n",temp->Name,temp->CpuTime,
（二） 实验内容
（1） 设计进程控制块PCB结构，分别适用于优先数调度算法和循环轮转调度算法。
PCB结构包括以下信息：进程标识符，进程优先数（或轮转时间片），进程所占用的CPU时间、进程状态，当前队列指针等。根据调度算法不同，PCB结构的内容可适当做增删。
（2） 建立进程就绪队列。对两种不同算法编制入链子程序。
int Proi;
int Round;
int CpuTime;
int NeedTime;
int Count;
char
State;
printf("\nInput Name and NeedTime\n");
if ((strcmp(Means,"PR")==0) ||(strcmp(Means,"pr")==0))
{
Create(PR);
PriSch();
}
#define NUMBER 5
#define NULL 0
#define PCBSTRUCT struct PCBSTR
typedef PCBSTRUCT* PCB;
enum Algorithm {PR,RR};
char Means[2];
char b;
PCBSTRUCT
{
char Name[10];
else
printf("\n Name CpuTime NeedTime Count Round State\n");
}
void Print2(PCB temp)
{
if ((strcmp(Means,"PR")==0) || (strcmp(Means,"pr")==0))
printf("\nIt's Finished!");
g
etch();
}
（六） 参考书目
① 郭浩志 《计算机软件实践教程》
② 庞丽萍 《计算机操作系统》
PCBSTRUCT* Next;
};
PCB Finish,Ready,Tail,Run;
void FirstIn()
{
Run = Ready;
Run->State = 'R';
Ready = Ready->Next;
}
void Print1()
else
{
p->Next = Ready;
Ready = p;
Tail = p;
}
}
}
if (alg == PR)
printf("Output Of Priority:\n");
else
printf("Output of RoundRobin:\n");
Tail = p2;
p2->Next = NULL;
}
void Create(enum Algorithm alg)
{
PCB p;
int i,time;
char Na[10];
Ready = NULL;
Finish = NULL;
Run = NULL;
if (alg == PR)
Run->NeedTime = Run->NeedTime - 1;
Run->Count = Run->Count + 1;
if (Run->NeedTime == 0)
{
Run->Next = Finish;
Finish = Run;
Run->State = 'F';
实验2 进程调度
（一） 目的和要求
进程调度是处理机管理的核心内容。本实验要求用高级语言编写和调试一个简单的进程调度程序。通过本实验可以加深理解有关进程控制块、进程队列的概念，并体会和了解优先数和时间片轮转调度算法的具体实施方法。
Run = Ready;
Ready = Ready->Next;
Run-> State = 'R';
}
void PriSch()
{
//请编写程序
}
void RoundSch()
{
while (Run != NULL)
{
Run->CpuTime = Run->CpuTime + 1;
⑤ CREATE：创建新进程，即创建进程的PCB，并将此PCB链入到就绪对列中去。
⑥ FRISCH：按优先数算法调度进程。
⑦ ROUNDSCH：按时间片轮转法调度进程。
（五） 程序清单
#include "string.h"
#include "stdio.h"
（2） 程序结构说明如下：
① INSERT1：把未完成且优先数小于别的进程的进程PCB按进程优先数的顺序插入到就绪队列中。
② INSERT2：轮转法中使用的过程，将执行一个单位时间片数（为2）且还未完成的进程的PCB插入到就绪队列队尾。
③ FIRSTIN：将就绪队列中的第一个进程投入运行。
④ PRINT：打印每执行一次后的所有进程的状态。
STATUS 进程所处的状态
“R” 进程处于运行状态
“W” 进程处于就绪状态
“F” 进程处于完成状态
2．程序说明
（1） 在优先数算法中，进程每执行一次，优先数减3，CPU时间片加1，进程还需要的时间片数减1。在轮转法中，采用固定时间片，时间片数为2，进程每执行一次，CPU时间片数加2，进程还需要的时间片数减2，并排在就绪队列的队尾。
temp->NeedTime,temp->Count,temp->Round,temp->State);
}
void print()
{
PCB p;
Print1();
"It's the Run queue\n");
if (Run != NULL)
1．数据结构
PCB结构如下：
NAME 进程标识符
PRIO / ROUND 优先数 / 时间片
CPUTIME 进程已占用的CPU时间
NEEDTIME 进程到完成还需要的CPU时间
NEXT 处于同一状态的下一进程的地址
Insert2(Run);
FirstIn();
}
}
print();
getch();
}
}
void main()
{
printf("Type then Algorithm:(Priority/RoundRobin)");
scanf("%s",Means);
p = Finish;
while (p != NULL)
{
Print2(p);
p = p->Next;
}
printf("\n\n");
}
void Insert1(PCB q)
{
//请编写程序
}
void Insert2(PCB p2)