时间片轮转算法和优先级调度算法-C语言模拟实现-收藏
操作系统进程调度C语言代码
操作系统进程调度C语言代码操作系统是计算机系统中的重要组成部分，用于管理和控制计算机资源的分配和使用。
在操作系统中，进程调度是指将系统资源（如 CPU、内存、磁盘、网络等）分配给运行中的进程的过程。
进程调度是操作系统实现多任务、多用户和分时系统的关键。
进程调度的算法有多种。
最常见的是时间片轮转算法、优先级调度算法、最短进程优先算法和先到先服务算法等。
下面我们将介绍一下时间片轮转算法的 C 语言代码实现。
1. 时间片轮转算法时间片轮转算法是一种基于时间片的调度算法，它给每个进程分配一个时间片，当时间片用完后，系统将进程暂停，并将 CPU 分配给下一个进程。
时间片轮转算法可以让所有进程公平地使用 CPU 时间，并且可以避免进程饥饿的情况发生。
2. C 语言代码实现在 C 语言中，可以用结构体来表示一个进程，包括进程 ID、进程状态、优先级、到达时间和需要运行的时间片等属性。
下面是一个简单的进程结构体的定义：```struct Process processes[5];在实现时间片轮转算法之前，需要先实现一个进程调度函数，它的作用是找到就绪进程中优先级最高的进程，并返回它的位置。
下面是一个简单的进程调度函数：```int find_highest_priority_process(struct Process *processes, int n) {int highest_priority = -1;int highest_priority_index = -1;for (int i = 0; i < n; i++) {if (processes[i].state != 2 && processes[i].priority >highest_priority) {highest_priority = processes[i].priority;highest_priority_index = i;}}return highest_priority_index;}```在实现时间片轮转算法之前，需要先定义一些全局变量，包括就绪队列、当前时间、时间片大小和进程数量等。
时间片轮转算法和优先级调度算法
时间片轮转算法和优先级调度算法-C语言模拟实现-收藏时间片轮转算法和优先级调度算法C语言模拟实现收藏一、目的和要求进程调度是处理机管理的核心内容。
本实验要求用高级语言编写模拟进程调度程序，以便加深理解有关进程控制快、进程队列等概念，并体会和了解优先数算法和时间片轮转算法的具体实施办法。
二、实验内容1. 设计进程控制块PCB的结构，通常应包括如下信息：进程名、进程优先数（或轮转时间片数）、进程已占用的CPU时间、进程到完成还需要的时间、进程的状态、当前队列指针等。
2. 编写两种调度算法程序：优先数调度算法程序循环轮转调度算法程序3. 按要求输出结果。
二、提示和说明分别用两种调度算法对伍个进程进行调度。
每个进程可有三种状态；执行状态（RUN）、就绪状态（READY,包括等待状态）和完成状态（FINISH ），并假定初始状态为就绪状态。
（一）进程控制块结构如下：NAME ----- 进程标示符PRIO/ROUND ――进程优先数/进程每次轮转的时间片数（设为常数2）CPUTIME ――进程累计占用CPU的时间片数NEEDTIME ――进程到完成还需要的时间片数I STATE——进程状态NEXT ――链指针注：2.各进程的优先数或轮转时间片数，以及进程运行时间片数的初值，均由用户在程序运行时给定。
（二）进程的就绪态和等待态均为链表结构，共有四个指针如下：RUN ――当前运行进程指针READY ――就需队列头指针TAIL ――就需队列尾指针FINISH ――完成队列头指针（三）程序说明1. 在优先数算法中，进程优先数的初值设为：50-NEEDTIME每执行一次，优先数减1，CPU时间片数加1,进程还需要的时间片数减1。
在轮转法中，采用固定时间片单位（两个时间片为一个单位），进程每轮转一次，CPU时间片数加2,进程还需要的时间片数减2,并退出CPU，排到就绪队列尾，等待下一次调度。
2. 程序的模块结构提示如下：整个程序可由主程序和如下7个过程组成：（1）INSERT1 ――在优先数算法中，将尚未完成的PCB按优先数顺序插入到就绪队列中；（2）INSERT2 ――在轮转法中，将执行了一个时间片单位（为2），但尚未完成的进程的PCB，插到就绪队列的队尾；（3）FIRSTIN ――调度就绪队列的第一个进程投入运行；（4）PRINT ――显示每执行一次后所有进程的状态及有关信息。
进程调度算法(时间片轮转法+优先级)
进程调度算法时间片轮转法+优先级#include<stdio.h>#include<stdlib.h>#include<iostream.h>#define P_NUM 5//进程数#define P_TIME 50//时间片数//状态enum state{ready,//就绪execute,//执行block,//阻塞finish//结束};//PCB结构体struct pcb{char name[5];//进程名IDint priority;//优先级int cputime;//进程已占用时间片int alltime;//还需占用时间片state process;//进程状态pcb * next;//队列指针next，用来将多个进程控制块PCB链接为队列}PCB;pcb * get_process(){pcb *q;pcb *t;pcb *p;int i=0;cout<<"input ID and ALLTIME"<<endl;while (i<P_NUM){q=(struct pcb *)malloc(sizeof(pcb));//申请cin>>q->name;cin>>q->alltime;//输入名字及时间q->cputime=0;//初始q->priority=P_TIME-q->alltime;//优先数越大，优先级越高q->process=ready;//就绪q->next=NULL;if (i==0){p=q;t=q;}else{t->next=q;t=q;}i++;}return p;}//输出过程void display(pcb *p){cout<<" ID"<<" "<<"CPUTIME"<<" "<<"ALLTIME"<<" "<<"PRIORITY"<<" "<<"STATE"<<endl;while(p){cout<<" "<<p->name<<" "<<p->cputime<<" "<<p->alltime<<" "<<p->priority<<" ";switch(p->process){case ready:cout<<"ready"<<endl;break;case execute:cout<<"execute"<<endl;break;case block:cout<<"block"<<endl;break;case finish:cout<<"finish"<<endl;break;}p=p->next;cout<<"\n";}}//状态的函数//结束int process_finish(pcb *q){int a=1;while(a&&q){a=a&&q->alltime==0;q=q->next;}return a;}//执行void cpuexe(pcb *q){pcb *t=q;int tp=0;while(q){if (q->process!=finish){q->process=ready;if(q->alltime==0){q->process=finish;}}if(tp<q->priority&&q->process!=finish){tp=q->priority;t=q;}q=q->next;}if(t->alltime!=0){t->priority-=3;//进程每运行一个时间片,优先数减3t->alltime--;t->process=execute;t->cputime++;}}//进程调度void process_way(){pcb * p;p=get_process();display(p);int cpu=0;while(!process_finish(p)){cpu++;cout<<"cputime:"<<cpu<<endl;cpuexe(p);display(p);}printf("All processes have finished"); }void main(){process_way();}结果：。
用c语言实现时间片轮转调度算法
用c语言实现时间片轮转调度算法时间片轮转调度算法是一种常见的进程调度算法，其主要思想是将所有就绪进程按顺序排列，每个进程分配一个时间片，当时间片用尽后，进程被送到队列的末尾，然后下一个进程被执行。
本文将介绍如何使用C语言实现时间片轮转调度算法。
首先，我们需要定义进程控制块（PCB），包括进程的ID、状态、优先级和时间片等信息。
可以使用结构体来表示PCB，代码如下：```typedef struct PCB {int pid; // 进程IDint status; // 进程状态（就绪、运行、等待、结束） int priority; // 进程优先级int time_slice; // 时间片} PCB;```接下来，我们需要创建一个就绪队列和一个等待队列来存储所有进程。
可以使用链表来实现队列，代码如下：```typedef struct Node {PCB *pcb; // PCB指针struct Node *next; // 指向下一个节点的指针} Node;// 就绪队列Node *ready_queue = NULL;// 等待队列Node *wait_queue = NULL;```然后，我们需要编写一个函数来创建进程并添加到就绪队列中。
该函数接受进程的ID、优先级和时间片作为参数，并返回一个指向新进程PCB的指针。
代码如下：```PCB *create_process(int pid, int priority, int time_slice) {PCB *pcb = (PCB*)malloc(sizeof(PCB));pcb->pid = pid;pcb->status = 0; // 就绪状态pcb->priority = priority;pcb->time_slice = time_slice;// 将新进程添加到就绪队列末尾Node *p = (Node*)malloc(sizeof(Node));p->pcb = pcb;p->next = NULL;if (ready_queue == NULL) {ready_queue = p;} else {Node *q = ready_queue;while (q->next != NULL) {q = q->next;}q->next = p;}return pcb;}```接下来，我们需要编写一个函数来模拟时间片轮转调度算法。
四种进程调度算法 先到先服务,优先级,短作业优先,时间片轮转
#include"stdio.h"#define N 50int n;int sj;struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int wct; //完成时刻int yxj; //优先级int st2; //标志是否完成float zt; //周转时间float dczt; //带权周转时间};Gzuo a[N];void input(Gzuo a[]){printf("请输入进程个数：");scanf("%d",&n);for(int i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);a[i].st2 = a[i].st;printf("\n");}printf("\t请输入时间片大小(0<sjp):\t"); scanf("%d",&sj);}void sjp(Gzuo a[],int sj)//时间片轮转调度{int i,j,min,time;float sum1,sum2;bool flag=true;/*printf("\t请输入进程数(0<n<=50):\t"); scanf("%d",&n);while(n>50||n<=0){printf("n\t请重新输入：");scanf("%d",&n);printf("\n\n");printf("\t请输入时间片大小(0<sjp):\t"); scanf("%d",&sjp);while(sjp<=0){printf("n\t请重新输入：");scanf("%d",&sjp);}/*struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int wct; //完成时刻int st2; //标志是否完成float zt; //周转时间float dczt; //带权周转时间};Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);a[i].st2 = a[i].st;printf("\n");}*/for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].st2;a[i].st2=a[i+1].st2;a[i+1].st2=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}time = a[0].dt;//printf("赋值后TIME值为：%d\n",time);min = 0;while(min<n){flag=true;for(i=0;i<n;i++){if(a[i].st2>0&&a[i].dt<=time)flag=false;}for(i=0;i<n;i++){if(a[i].st2 > 0 ){if(a[i].dt<=time){//printf("当前a[%d].st2值为：%d\n",i,a[i].st2);a[i].st2 = a[i].st2 - sj;//printf("运算后当前a[%d].st2值为：%d\n",i,a[i].st2); //printf("当前TIME值为：%d\n",time);time = time + sj;//printf("增加之后TIME值为：%d\n",time);if(a[i].st2<=0){a[i].wct = time + a[i].st2;a[i].zt=(float)(a[i].wct-a[i].dt);a[i].dczt=a[i].zt/a[i].st;min++;}}else if(flag)for(i=0;i<n;i++){if(a[i].st2>0&&a[i].dt>time){time = a[i].dt;break;}}}}}}printf("\n进程：到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");sum1=0;sum2=0;for(j=0;j<n;j++){for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d：%d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i].zt ,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("**************************************************************** *****\n");}void fcfs(Gzuo a[])//先到先服务调度{int i,j,min;float sum1,sum2;/*printf("\t请输入进程数(0<n<=50):\t");scanf("%d",&n);while(n>50||n<=0)printf("n\t请重新输入："); scanf("%d",&n);}printf("\n\n");/*struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int wct; //完成时刻float zt; //周转时间float dczt; //带权周转时间 };Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);printf("\n");}*/for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}a[0].wct=a[0].st+a[0].dt;a[0].zt=(float)a[0].st;a[0].dczt=a[0].zt/a[0].st;for(i=1;i<n;i++){if(a[i].dt>a[i-1].wct){a[i].wct=a[i].dt+a[i].st;a[i].zt=(float)a[i].st;a[i].dczt=a[i].zt/a[i].st;}else{a[i].wct=a[i-1].wct+a[i].st;a[i].zt=(float)(a[i].wct-a[i].dt);a[i].dczt=a[i].zt/a[i].st;}}printf("\n进程：到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");sum1=0;sum2=0;for(j=0;j<n;j++){for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d：%d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i].zt ,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("****************************************************************** ***\n");}void sjf(Gzuo a[])//短作业优先调度{int i,j,min;int b=0,z;float sum1,sum2;/*printf("\n\t\t请输入进程数(0<n<=50):\t"); scanf("%d/n",&n);while(n>50||n<=0){printf("n\t请重新输入：");scanf("%d",&n);}printf("\n");/*struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int wct; //完成时刻float zt; //周转时间float dczt; //带权周转时间};Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);printf("\n");}*/min=a[0].dt;for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}if(a[i].dt==a[i+1].dt&&a[i].st>a[i+1].st) {min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}a[0].wct=a[0].st+a[0].dt;a[0].zt=(float)a[0].st;a[0].dczt=a[0].zt/a[0].st;for(i=1;i<n;i++){if(a[i].dt>a[0].wct) ;else b=b+1;}for(j=b-1;j>=1;j--){for(i=1;i<j;i++){if(a[i].st>a[i+1].st){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}for(i=1;i<n;i++){if(a[i].dt>a[i-1].wct){a[i].wct=a[i].dt+a[i].st;a[i].zt=(float)a[i].st;a[i].dczt=a[i].zt/a[i].st;}else{a[i].wct=a[i-1].wct+a[i].st;a[i].zt=(float)(a[i].wct-a[i].dt); a[i].dczt=a[i].zt/a[i].st;}for(j=i+1,b=j;j<n;j++){if(a[j].dt>a[i].wct) ;else b=b+1;}for(j=b-1;j>=i;j--){for(z=i;z<j;z++){if(a[z].st>a[z+1].st){min=a[z].dt;a[z].dt=a[z+1].dt;a[z+1].dt=min;min=a[z].st;a[z].st=a[z+1].st;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}}printf("\n进程：到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");sum1=0;sum2=0;for(j=0;j<n;j++){ for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d：%d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i].zt, a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("****************************************************************** ***\n");}void yxj(Gzuo a[])//优先级优先调度{int i,j,min;int b=0,z;float sum1,sum2;/*printf("\n\t\t请输入进程数(0<n<=50):\t");scanf("%d/n",&n);while(n>50||n<=0){printf("n\t请重新输入：");scanf("%d",&n);}printf("\n");/* struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int yxj; //优先级int wct; //完成时刻float zt; //周转时间float dczt; //带权周转时间 };Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间："); scanf("%d",&a[i].dt);printf("\t服务时间："); scanf("%d",&a[i].st);printf("\t优先级：");scanf("%d",&a[i].yxj);printf("\n");}*/min=a[0].dt;for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min; min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;min=a[i].yxj;a[i].yxj=a[i+1].yxj;a[i+1].yxj=min;}if(a[i].dt==a[i+1].dt&&a[i].yxj<a[i+1].yxj) {min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;min=a[i].yxj;a[i].yxj=a[i+1].yxj;a[i+1].yxj=min;}}}a[0].wct=a[0].st+a[0].dt;a[0].zt=(float)a[0].st;a[0].dczt=a[0].zt/a[0].st;for(i=1;i<n;i++){if(a[i].dt>a[0].wct) ;else b++;}for(j=b-1;j>=1;j--){for(i=1;i<j;i++){if(a[i].yxj<a[i+1].yxj){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;min=a[i].yxj;a[i].yxj=a[i+1].yxj;a[i+1].yxj=min;}}}for(i=1;i<n;i++){if(a[i].dt>a[i-1].wct){a[i].wct=a[i].dt+a[i].st;a[i].zt=(float)a[i].st;a[i].dczt=a[i].zt/a[i].st;}else{a[i].wct=a[i-1].wct+a[i].st;a[i].zt=(float)(a[i].wct-a[i].dt); a[i].dczt=a[i].zt/a[i].st;}for(j=i+1,b=j;j<n;j++){if(a[j].dt>a[i].wct) ;else b=b+1;}for(j=b-1;j>=i;j--){for(z=i;z<j;z++){if(a[z].yxj<a[z+1].yxj){min=a[z].dt;a[z].dt=a[z+1].dt;a[z+1].dt=min;min=a[z].st;a[z].st=a[z+1].st;a[z+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}}printf("\n进程：到达时间\t服务时间\t优先级\t完成时间\t周转时间\t带权周转时间\n"); sum1=0;sum2=0;for(j=0;j<n;j++){ for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d：%d\t\t%d\t\t%d\t\t%d\t\t%.0f\t%.2f\n",a[i].id,a[i].dt,a[i].yxj,a[i].st,a[i ].wct,a[i].zt,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("****************************************************************** ***\n");}void main(){ int n;input(a);printf("以下是先到先服务调度：");fcfs(a);printf("以下是短作业优先调度：");sjf(a);printf("以下是时间片轮转法：");sjp(a,sj);printf("以下是优先级优先调度：");yxj(a); }。
操作系统时间片轮转算法与优先级调度算法
操作系统时间片轮转算法与优先级调度算法操作系统作为计算机的核心，需要负责管理和分配系统资源的功能。
其中，调度算法是操作系统中非常重要的一个功能，它决定了如何分配CPU时间，因此直接影响系统的性能和响应速度。
本文将介绍两种操作系统中常用的调度算法：时间片轮转算法和优先级调度算法。
时间片轮转算法时间片轮转算法（Round Robin）是一种基本的调度算法，它是多道程序设计中常用的一种算法。
在内存中同时存放多个进程，并根据每个进程的优先级轮流分配 CPU 时间，以保证每个进程都能得到一定的CPU时间片，从而保证操作系统的公平性和系统的稳定性。
基本思想时间片轮转算法的基本思想是：将每个进程分配相同长度的CPU时间片，一旦时间片用完，立即将该进程挂起，并将 CPU 分配给下一个进程。
这样就可以保证每个进程都有相同的机会获得 CPU 时间，避免了某个进程长时间霸占CPU而导致其他进程无法运行的情况。
算法流程时间片轮转算法的具体实现过程如下：1.将所有待运行的进程加入到就绪队列中；2.从就绪队列中取出第一个进程，将其运行指定时间片长度的时间；3.如果该进程在运行时间片结束之前自己退出，那么直接将其从就绪队列中取出，释放资源；4.如果该进程在运行时间片结束之前没有自己退出，那么将其挂起放到队列的尾部，然后将 CPU 分配给下一个进程，重复2-4步骤，直到所有进程执行完毕。
算法优点时间片轮转算法的优点如下：1.公平：每个进程都能得到相同长度的时间片，避免了某个进程长时间霸占CPU的情况，从而保证了每个进程都会运行；2.适用：时间片轮转算法适用于多任务并发的环境下，可以有效地避免死锁和饥饿现象；3.高效：时间片轮转算法可以保证 CPU 的高效利用，能够最大限度地提高 CPU 的性能。
算法缺点时间片轮转算法的缺点如下：1.精度问题：时间片长度不能太长，否则会导致某些进程长时间等待CPU时间片；2.资源浪费：如果一个进程只需要很短的时间就可以完成任务，但由于时间片的限制而占用CPU的时间，这就是一种资源浪费。
【精品】进程模拟调度时间片和优先级
仲恺农业工程学院课程设计进程调度模拟算法实现（优先数算法和时间片算法）课程名称计算机系统开发综合训练（2）姓名杜松耀院(系）信息科学与技术学院专业班级计算机科学与技术121学号2指导教师史婷婷目录1需求分析............................................ 错误!未指定书签。
2概要设计............................................ 错误!未指定书签。
2.1实验原理....................................... 错误!未指定书签。
2。
2数据结构...................................... 错误!未指定书签。
2.3算法描述....................................... 错误!未指定书签。
2.4算法流程图..................................... 错误!未指定书签。
3详细设计............................................ 错误!未指定书签。
3.1源程序代码..................................... 错误!未指定书签。
4调试分析............................................ 错误!未指定书签。
5总结................................................ 错误!未指定书签。
1需求分析本实验完成的系统是进程调度模拟算法实现（优先数算法和时间片算法)，进程是操作系统中最基本、最重要的概念，是在多道程序系统出现后，为了刻画系统内部的动态状况、描述运行程序的活动规律而引进的新概念，所有多道程序设计操作系统程序设计操作系统都建立在进程的基础上。
进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。
优先级和时间片轮转调度
for(j=0;j<processnum;j++)
{q=processarray[j];
printf("\n检查进程%3c是否结束,进程当前状态:%3d",q->name,qgame is over!\n");
}
void main()
{
*processarray=createprocess(processarray);
#include "stdio.h"
#include <malloc.h>
#define max 100
#define etime 4
#define pfree 0
#define running 1
#define aready 2
#define blocking 3
typedef struct node
{
char name;
int status;
int pri;
int ptime;
int ax,bx,cx,dx;
int pc;
int psw;
}pcb;
pcb *processarray[max];
static int processnum;
pcb *createprocess(pcb *processarray[])组
q->status=aready;
totaltime-=etime;}
if(i<processnum-1)
i++;
else if(i==processnum-1)
i=0;
}}
void processStaPri(pcb *processarray[])
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
一、目的和要求进程调度是处理机管理的核心容。
本实验要求用高级语言编写模拟进程调度程序，以便加深理解有关进程控制快、进程队列等概念，并体会和了解优先数算法和时间片轮转算法的具体实施办法。
二、实验容1.设计进程控制块PCB的结构，通常应包括如下信息：进程名、进程优先数（或轮转时间片数）、进程已占用的CPU时间、进程到完成还需要的时间、进程的状态、当前队列指针等。
2.编写两种调度算法程序：优先数调度算法程序循环轮转调度算法程序3.按要求输出结果。
三、提示和说明分别用两种调度算法对伍个进程进行调度。
每个进程可有三种状态；执行状态（R UN）、就绪状态（READY,包括等待状态）和完成状态（FINISH），并假定初始状态为就绪状态。
（一）进程控制块结构如下：NAME——进程标示符PRIO/ROUND——进程优先数/进程每次轮转的时间片数（设为常数2）CPUTIME——进程累计占用CPU的时间片数NEEDTIME——进程到完成还需要的时间片数STATE——进程状态NEXT——链指针注：1.为了便于处理，程序中进程的的运行时间以时间片为单位进行计算；2.各进程的优先数或轮转时间片数，以及进程运行时间片数的初值，均由用户在程序运行时给定。
（二）进程的就绪态和等待态均为链表结构，共有四个指针如下：RUN——当前运行进程指针READY——就需队列头指针TAIL——就需队列尾指针FINISH——完成队列头指针（三）程序说明1. 在优先数算法中，进程优先数的初值设为：50-NEEDTIME每执行一次，优先数减1，CPU时间片数加1，进程还需要的时间片数减1。
在轮转法中，采用固定时间片单位（两个时间片为一个单位），进程每轮转一次，CPU时间片数加2，进程还需要的时间片数减2，并退出CPU，排到就绪队列尾，等待下一次调度。
2. 程序的模块结构提示如下：整个程序可由主程序和如下7个过程组成：（1）INSERT1——在优先数算法中，将尚未完成的PCB按优先数顺序插入到就绪队列中；（2）INSERT2——在轮转法中，将执行了一个时间片单位（为2），但尚未完成的进程的PCB，插到就绪队列的队尾；（3）FIRSTIN——调度就绪队列的第一个进程投入运行；（4）PRINT——显示每执行一次后所有进程的状态及有关信息。
（5）CREATE——创建新进程，并将它的PCB插入就绪队列；（6）PRISCH——按优先数算法调度进程；（7）ROUNDSCH——按时间片轮转法调度进程。
主程序定义PCB结构和其他有关变量。
（四）运行和显示程序开始运行后，首先提示：请用户选择算法，输入进程名和相应的NEEDTIM E值。
每次显示结果均为如下5个字段：name cputime needtime priority state注：1．在state字段中，"R"代表执行态，"W"代表就绪（等待）态，"F"代表完成态。
2．应先显示"R"态的，再显示"W"态的，再显示"F"态的。
3．在"W"态中，以优先数高低或轮转顺序排队；在"F"态中，以完成先后顺序排队。
view plaincopy to clipboardprint?1./*2.操作系统实验之时间片轮转算法和优先级调度算法3.By Visual C++ 6.04.*/#include <stdio.h>#include <stdlib.h>#include <string.h>typedef struct node{char name[20]; /*进程的名字*/int prio; /*进程的优先级*/int round; /*分配CPU的时间片*/int cputime; /*CPU执行时间*/int needtime; /*进程执行所需要的时间*/char state; /*进程的状态，W——就绪态，R——执行态，F——完成态*/int count; /*记录执行的次数*/struct node *next; /*链表指针*/}PCB;PCB *ready=NULL,*run=NULL,*finish=NULL; /*定义三个队列，就绪队列，执行队列和完成队列*/int num;void GetFirst(); /*从就绪队列取得第一个节点*/void Output(); /*输出队列信息*/void InsertPrio(PCB *in); /*创建优先级队列，规定优先数越小，优先级越高* /void InsertTime(PCB *in); /*时间片队列*/void InsertFinish(PCB *in); /*时间片队列*/void PrioCreate(); /*优先级输入函数*/void TimeCreate(); /*时间片输入函数*/void Priority(); /*按照优先级调度*/void RoundRun(); /*时间片轮转调度*/int main(void){char chose;printf("请输入要创建的进程数目:\n");scanf("%d",&num);getchar();printf("输入进程的调度方法：(P/R)\n");scanf("%c",&chose);switch(chose){case 'P':case 'p':PrioCreate();Priority();break;case 'R':case 'r':TimeCreate();RoundRun();break;default:break;}Output();return 0;}void GetFirst() /*取得第一个就绪队列节点*/{run = ready;if(ready!=NULL){run ->state = 'R';ready = ready ->next;run ->next = NULL;}}void Output() /*输出队列信息*/{PCB *p;p = ready;printf("进程名\t优先级\t轮数\tcpu时间\t需要时间\t进程状态\t计数器\n ");while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p ->round,p->cputime,p->needtime,p->state,p->count);p = p->next;}p = finish;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p ->round,p->cputime,p->needtime,p->state,p->count);p = p->next;}p = run;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p ->round,p->cputime,p->needtime,p->state,p->count);p = p->next;}}void InsertPrio(PCB *in) /*创建优先级队列，规定优先数越小，优先级越低* /{PCB *fst,*nxt;fst = nxt = ready;if(ready == NULL) /*如果队列为空，则为第一个元素*/{in->next = ready;ready = in;}else /*查到合适的位置进行插入*/{if(in ->prio >= fst ->prio) /*比第一个还要大，则插入到队头*/{in->next = ready;ready = in;}else{while(fst->next != NULL) /*移动指针查找第一个别它小的元素的位置进行插入*/{nxt = fst;fst = fst->next;}if(fst ->next == NULL) /*已经搜索到队尾，则其优先级数最小，将其插入到队尾即可*/{in ->next = fst ->next;fst ->next = in;}else /*插入到队列中*/{nxt = in;in ->next = fst;}}}}void InsertTime(PCB *in) /*将进程插入到就绪队列尾部*/{PCB *fst;fst = ready;if(ready == NULL){ready = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void InsertFinish(PCB *in) /*将进程插入到完成队列尾部*/ {PCB *fst;fst = finish;if(finish == NULL){in->next = finish;finish = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;}}void PrioCreate() /*优先级调度输入函数*/{PCB *tmp;int i;printf("输入进程名字和进程所需时间：\n");for(i = 0;i < num; i++){if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL){perror("malloc");exit(1);}scanf("%s",tmp->name);getchar(); /*吸收回车符号*/scanf("%d",&(tmp->needtime));tmp ->cputime = 0;tmp ->state ='W';tmp ->prio = 50 - tmp->needtime; /*设置其优先级，需要的时间越多，优先级越低*/tmp ->round = 0;tmp ->count = 0;InsertPrio(tmp); /*按照优先级从高到低，插入到就绪队列*/}}void TimeCreate() /*时间片输入函数*/{PCB *tmp;int i;printf("输入进程名字和进程时间片所需时间：\n");for(i = 0;i < num; i++){if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL){perror("malloc");exit(1);}scanf("%s",tmp->name);getchar();scanf("%d",&(tmp->needtime));tmp ->cputime = 0;tmp ->state ='W';tmp ->prio = 0;tmp ->round = 2; /*假设每个进程所分配的时间片是2*/tmp ->count = 0;InsertTime(tmp);}}void Priority() /*按照优先级调度，每次执行一个时间片*/{int flag = 1;GetFirst();while(run != NULL) /*当就绪队列不为空时，则调度进程如执行队列执行* /{Output(); /*输出每次调度过程中各个节点的状态*/while(flag){run->prio -= 3; /*优先级减去三*/run->cputime++; /*CPU时间片加一*/run->needtime--;/*进程执行完成的剩余时间减一*/if(run->needtime == 0)/*如果进程执行完毕，将进程状态置为F，将其插入到完成队列*/{run ->state = 'F';run->count++; /*进程执行的次数加一*/InsertFinish(run);flag = 0;}else /*将进程状态置为W，入就绪队列*/{run->state = 'W';run->count++; /*进程执行的次数加一*/InsertTime(run);flag = 0;}}flag = 1;GetFirst(); /*继续取就绪队列队头进程进入执行队列*/}}void RoundRun() /*时间片轮转调度算法*/{int flag = 1;GetFirst();while(run != NULL){Output();while(flag){run->count++;run->cputime++;run->needtime--;if(run->needtime == 0) /*进程执行完毕*/{run ->state = 'F';InsertFinish(run);flag = 0;}else if(run->count == run->round)/*时间片用完*/ {run->state = 'W';run->count = 0; /*计数器清零，为下次做准备*/ InsertTime(run);flag = 0;}}flag = 1;GetFirst();}}。