进程调度算法代码
① 进程调度的算法
算法总是把处理机分配给最先进入就绪队列的进程，一个进程一旦分得处理机，便一直执行下去，直到该进程完成或阻塞时，才释放处理机。
例如，有三个进程P1、P2和P3先后进入就绪队列，它们的执行期分别是21、6和3个单位时间，
执行情况如下图：
对于P1、P2、P3的周转时间为21、27、30，平均周转时间为26。
可见，FIFO算法服务质量不佳，容易引起作业用户不满，常作为一种辅助调度算法。 最短CPU运行期优先调度算法(SCBF--Shortest CPU Burst First)
该算法从就绪队列中选出下一个“CPU执行期最短”的进程，为之分配处理机。
例如，在就绪队列中有四个进程P1、P2、P3和P4，它们的下一个执行期分别是16、12、4和3个单位时间，执行情况如下图：
P1、P2、P3和P4的周转时间分别为35、19、7、3，平均周转时间为16。
该算法虽可获得较好的调度性能，但难以准确地知道下一个CPU执行期，而只能根据每一个进程的执行历史来预测。 前几种算法主要用于批处理系统中，不能作为分时系统中的主调度算法，在分时系统中，都采用时间片轮转法。
简单轮转法：系统将所有就绪进程按FIFO规则排队，按一定的时间间隔把处理机分配给队列中的进程。这样，就绪队列中所有进程均可获得一个时间片的处理机而运行。
多级队列方法：将系统中所有进程分成若干类，每类为一级。 多级反馈队列方式是在系统中设置多个就绪队列，并赋予各队列以不同的优先权。
② 进程调度算法
调度算法是指：根据系统的资源分配策略所规定的资源分配算法。
一、先来先服务和短作业（进程）优先调度算法
1. 先来先服务调度算法。先来先服务（FCFS）调度算法是一种最简单的调度算法，该算法既可用于作业调度， 也可用于进程调度。FCFS算法比较有利于长作业（进程），而不利于短作业（进程）。由此可知，本算法适合于CPU繁忙型作业， 而不利于I/O繁忙型的作业（进程）。
2. 短作业（进程）优先调度算法。短作业（进程）优先调度算法（SJ/PF）是指对短作业或短进程优先调度的算法，该算法既可用于作业调度， 也可用于进程调度。但其对长作业不利；不能保证紧迫性作业（进程）被及时处理；作业的长短只是被估算出来的。
二、高优先权优先调度算法
1. 优先权调度算法的类型。为了照顾紧迫性作业，使之进入系统后便获得优先处理，引入了最高优先权优先（FPF）调度算法。 此算法常被用在批处理系统中，作为作业调度算法，也作为多种操作系统中的进程调度，还可以用于实时系统中。当其用于作业调度， 将后备队列中若干个优先权最高的作业装入内存。当其用于进程调度时，把处理机分配给就绪队列中优先权最高的进程，此时， 又可以进一步把该算法分成以下两种：
1)非抢占式优先权算法
2)抢占式优先权调度算法（高性能计算机操作系统）
2. 优先权类型 。对于最高优先权优先调度算法，其核心在于：它是使用静态优先权还是动态优先权， 以及如何确定进程的优先权。
3. 高响应比优先调度算法
为了弥补短作业优先算法的不足，我们引入动态优先权，使作业的优先等级随着等待时间的增加而以速率a提高。 该优先权变化规律可描述为：优先权=（等待时间+要求服务时间）/要求服务时间；即 =（响应时间）/要求服务时间
三、基于时间片的轮转调度算法
1. 时间片轮转法。时间片轮转法一般用于进程调度，每次调度，把CPU分配队首进程，并令其执行一个时间片。 当执行的时间片用完时，由一个记时器发出一个时钟中断请求，该进程被停止，并被送往就绪队列末尾；依次循环。 2. 多级反馈队列调度算法 多级反馈队列调度算法多级反馈队列调度算法，不必事先知道各种进程所需要执行的时间，它是目前被公认的一种较好的进程调度算法。 其实施过程如下：
1) 设置多个就绪队列，并为各个队列赋予不同的优先级。在优先权越高的队列中， 为每个进程所规定的执行时间片就越小。
2) 当一个新进程进入内存后，首先放入第一队列的末尾，按FCFS原则排队等候调度。 如果他能在一个时间片中完成，便可撤离；如果未完成，就转入第二队列的末尾，在同样等待调度…… 如此下去，当一个长作业（进程）从第一队列依次将到第n队列（最后队列）后，便按第n队列时间片轮转运行。
3) 仅当第一队列空闲时，调度程序才调度第二队列中的进程运行；仅当第1到第（i-1）队列空时， 才会调度第i队列中的进程运行，并执行相应的时间片轮转。
4) 如果处理机正在处理第i队列中某进程，又有新进程进入优先权较高的队列， 则此新队列抢占正在运行的处理机，并把正在运行的进程放在第i队列的队尾。
③ 求代码~操作系统 进程管理实验 语言C++ 要求如下：
四、实验思路和设计
1、进程管理
（1）程序流程图
由学生自行完成。
（2）主要程序代码
//PCB结构体
struct pcb{
int id; //进程序号
int ra; //所需资源A的数量
int rb; //所需资源B的数量
int rc; //所需资源C的数量
int ntime; //所需的时间片个数
int rtime; //已经运行的时间片个数
char state; //进程状态
struct pcb *next;
} *hready=NULL,*hblock=NULL,*p; //hready，hblock分别为指向就绪和阻塞队列
typedef struct pcb PCB;
int m,n,r,a,b,c,h=0,i=1,time1Inteval; //m为要模拟的进程个数，n为初始化进程个数
//r为可随机产生的进程数（r=m-n）
//a，b，c分别为A，B，C三类资源的总量
//i为进城计数，i=1…n
//h为运行的时间片次数，time1Inteval为时间片大小（毫秒）
//建立一个PCB结构体型的空链表
PCB *increat(void)
{ PCB *head;
head=NULL;
return(head);
}
//从链表起始地址开始输出该链表的内容
void disp(PCB *head)
{PCB *p1;
p1=head;
AnsiString str2;
if(head!=NULL) //链表非空
{
do
{
str2+=" ";
str2+=IntToStr(p1->id);str2+=" ";
str2+=(p1->state);str2+=" ";
str2+=IntToStr(p1->ra);str2+=" ";
str2+=IntToStr(p1->rb);str2+=" ";
str2+=IntToStr(p1->rc);str2+=" ";
str2+=IntToStr(p1->ntime);str2+=" ";
str2+=IntToStr(p1->rtime);str2+="\r\n";
p1=p1->next;
}while(p1!=NULL); //不断输出进程的信息，直到链尾！
} //if
else
{ str2+="\t\t该 队 列 中 没 有 进 程！\r\n" ;}
Form1->Memo1->Lines->Add(str2);
}
//将进程插入到链尾（包括就绪队列和阻塞队列）
PCB *insert(PCB *head,PCB*pcb) //带两个指针形参：队列指针和当前进程PCB
{
PCB *pi,*p1;
p1=head;
pi=pcb;
if (head==NULL)
{
head=pi;
pi->next=NULL;
}
else
{
while(p1->next!=NULL)
{p1=p1->next;}
p1->next=pi;
pi->next=NULL;
}
return(head);
}
//对进程进行初始化，建立就绪队阻塞队列。
void input()
{
AnsiString str1;
m=StrToInt (Form1->Edit1->Text); //读取要模拟的进程总数给m
n=StrToInt (Form1->Edit2->Text); //读取需初始化进程数给n
a=StrToInt (Form1->Edit3->Text); //读取A类资源的总数给a
b=StrToInt (Form1->Edit4->Text); //读取B类资源的总数给b
c=StrToInt (Form1->Edit5->Text); //读取C类资源的总数给c
time1Inteval=StrToInt(Form1->Edit6->Text); //读取时间片长度给time1Inteval
Form1->Timer1->Interval=time1Inteval;
r=m-n; //计算可随机产生的进程数为r
for(i=1;i<=n;i++) //初始化n个进程信息
{
p=getpcb(PCB); // #define getpcb(type) (type*)malloc(sizeof(type))
p->id=i;
str1+=" 产生进程ID：";str1+=IntToStr(p->id);str1+="\r\n";
p->ra=(random(a-3)+3);
str1+=" 所需A类资源数：";str1+=IntToStr(p->ra);str1+="\r\n";
p->rb=(random(b));
str1+=" 所需B类资源数：";str1+=IntToStr(p->ra);str1+="\r\n";
p->rc=(random(c-2)+2);
str1+=" 所需C类资源数：";str1+=IntToStr(p->ra);str1+="\r\n";
p->ntime=(random(5)+1);
str1+=" 所需时间片个数：";str1+=IntToStr(p->ntime);str1+="\r\n";
p->rtime=0;
p->next=NULL;
if (((a-(p->ra))>=0)&&((b-(p->rb))>=0)&&((c-(p->rc))>=0)) //如果资源符合所需要求
{ //则写入就绪队列队尾
a=a-(p->ra); //当前所剩A类资源数目
b=b-(p->rb); //当前所剩B类资源数目
c=c-(p->rc); //当前所剩C类资源数目
p->state='W';
hready=insert(hready,p); //将进程插入就绪队列
}//if
else //如果资源不符合所需要求，则写入阻塞队列队尾
{
p->state='B';
hblock=insert(hblock,p);
} //if
str1+=" 当前进程状态：";
str1+=(p->state);
str1+="\r\n";
str1+="\r\n";
}//for
Form1->Memo1->Lines->Add(str1);
}
//输出就绪队列和阻塞队列的信息
void outputall()
{
AnsiString str1,str2,str3;
str3+="\r\n" ;
str3+="= = = = = = = = = = = = = = = CPU时间片运行了: " ;
str3+=IntToStr(h);
str3+=" 次= = = = = = = = = = = = = = =\r\n";
Form1->Memo1->Lines->Add(str3);
str1+="*********************************当 前 就 绪 队 列 的 信 息" ;
str1+="*********************************\r\n" ;
str1+="进程ID 进程状态 A资源数 B资源数 C资源数 需要时间片 已运行时间片";
Form1->Memo1->Lines->Add(str1);
disp(hready);
str2+="*********************************当 前 阻 塞 队 列 的 信 息";
str2+="*********************************\r\n" ;
str2+="\r\n";
str2+="进程ID 进程状态 A资源数 B资源数 C资源数 需要时间片 已运行时间片";
Form1->Memo1->Lines->Add(str2);
disp(hblock);
}
//运行就绪队列的头进程，运行一个时间片（FCFS），轮转一个时间片
PCB *running(PCB *head)
{
PCB *p1;
p1=head;
AnsiString str4;
If (p1->next==NULL) head=increat();
else {head=p1->next; }
p1->state='R'; //进程状态由就绪转向运行
(p1->rtime)++; //已运行时间片数增加1
h++;
str4+="~~~~~~~~~~~~~~~~ 当前正在运行的进程ID是： ";
str4+=IntToStr(p1->id);
str4+=" ~~~~~~~~~~~~~~~~~~\r\n";
str4+="进程ID 进程状态 A资源数 B资源数 C资源数 需要时间片 已运行时间片\r\n";
str4+=" ";
str4+=IntToStr(p1->id);str4+=" ";
str4+=(p1->state);str4+=" ";
str4+=IntToStr(p1->ra);str4+=" ";
str4+=IntToStr(p1->rb);str4+=" ";
str4+=IntToStr(p1->rc);str4+=" ";
str4+=IntToStr(p1->ntime);str4+=" ";
str4+=IntToStr(p1->rtime);str4+=" ";
Form1->Memo1->Lines->Add(str4);
if(p1->ntime==p1->rtime) //如果已经运行的时间片到达所需次数，该进程结束
{
str4+="\r\n\r\n\t\tID号为：";
str4+=IntToStr(p1->id);
str4+=" 的进程已经完成！！！";
Form1->Memo1->Lines->Add(str4);
a=a+(p1->ra);
b=b+(p1->rb);
c=c+(p1->rc);
free(p1); //释放当前指针
}
else //如果已经运行的时间片未到达所需次数，该进程运行一个时间片后进入就绪队列尾
{
p1->state='W';
head=insert(head,p1);
}
return(head);
}
//检测当前资源数目是否满足阻塞队列里进程的需求
void testblock()
{
PCB *p1,*p2;
p1=hblock;
p2=hblock;
AnsiString str5;
while((hblock!=NULL)&&(p1!=NULL))
{
if((a-(p1->ra)>=0)&&(b-(p1->rb)>=0)&& (c-(p1->rc)>=0)) //如果满足
{if(p1==hblock)
{
hblock=p1->next;
p1->state='W';
hready=insert(hready,p1); //将阻塞的进程插入就绪队列
a=a-(p->ra);
b=b-(p->rb);
c=c-(p->rc);
str5="\tID号为： " ;
str5+=IntToStr(p1->id);
str5+=" 的进程由阻塞队列转入就绪队列！\r\n";
p1=hblock;
} //if(p1==hblock)
else
{p2->next=p1->next;
p1->state='W';
hready=insert(hready,p1);
str5="\tID号为： " ;
str5+=IntToStr(p1->id);
str5+=" 的进程由阻塞队列转入就绪队列！\r\n";
p1=p2->next;
}//else
} //大if
else
{p2=p1;
p1=p1->next;
} //else
Form1->Memo1->Lines->Add(str5);
} //whlie
}
//检测是否有新的进程产生，随机产生新进程
void testnew()
{
int t;
AnsiString str6;
if(r>0) //r=m-n为可随机产生的进程数目
{
t=random(9); //生成随机数
if(t<=7) //如果随机数小于等于7，则产生新进程，否则不产生
{
p=getpcb(PCB);
str6+="有新的进程申请加入：\r\n" ;
p->id=i++; //i为全程变量，表示进程号？
str6+="进程ID：";
str6+=IntToStr(p->id);
str6+="\r\n";
p->ra=(random(a-3)); //随机分配资源
str6+="所需A类资源数：";
str6+=IntToStr(p->ra);
str6+="\r\n";
p->rb=(random(b-3));
str6+="所需B类资源数：";
str6+=IntToStr(p->rb);
str6+="\r\n";
p->rc=(random(c-3));
str6+="所需C类资源数：";
str6+=IntToStr(p->rc);
str6+="\r\n";
p->ntime=(random(5)+1); //随机分配时间片总数
str6+="所需时间片个数：";
str6+=IntToStr(p->ntime);
str6+="\r\n";
p->rtime=0; //已运行时间片数初始为0
p->next=NULL;
if (((a-(p->ra))>=0)&&((b-(p->rb))>=0)&&((c-(p->rc))>=0))
{ //进程满足要求，进入就绪队列
a=a-(p->ra); //分配资源给该进程，总资源数减少
b=b-(p->rb);
c=c-(p->rc);
p->state='w';
str6+="当前进程状态：";
str6+=(p->state);
str6+="\r\n";
hready=insert(hready,p);
str6+="资源满足新进程需求，该进程进入就绪队列！";
}//if
else //进程不满足要求，进入阻塞队列
{
p->state='B';
hblock=insert(hblock,p);
str6+="当前进程状态：";
str6+=(p->state);
str6+="\r\n";
str6+="资源不能满足新进程需求，该进程进入阻塞队列！" ;
}//else
}//if (t<=7)
Form1->Memo1->Lines->Add(str6);
}//if(r>0)
r--;
}
//系统三类资源变化情况的显示
void rescore()
{
if(a>a1) {Form1->Edit7->Text=IntToStr(a1);}
if(a<0) {Form1->Edit7->Text=0;}
if(a>=0&&a<a1) {Form1->Edit7->Text=IntToStr(a);}
if(b>b1) {Form1->Edit8->Text=IntToStr(b1);}
if(b<0) {Form1->Edit8->Text=0;}
if(b>=0&&b<=b1) {Form1->Edit8->Text=IntToStr(b); }
if(c>c1) {Form1->Edit9->Text=IntToStr(c1);}
if(c<0) {Form1->Edit9->Text=0;}
if(c>=0&&c<=c1) {Form1->Edit9->Text=IntToStr(c); }
}
void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
runFcfs(); //先来先服务（FCFS）调度算法
}
//先来先服务（FCFS）调度算法
void runFcfs()
{
AnsiString str;
if(form1_hready!=NULL) //如果就绪队列为非空，则不断运行，直到就绪队列为空为止
{
outputall(); //输出就绪队列和阻塞队列的信息
form1_hready=running(form1_hready); //将就绪队列的第一个进程运行一个时间片
testblock(); //检查阻塞队列是否有进程可以进入就绪队列
testnew(); //检查是否有新进程产生
rescore() ; //系统三类资源变化情况的显示
}
else
{
Form1->Timer1->Enabled=false;
Form1->Edit7->Text=IntToStr(a1);
Form1->Edit8->Text=IntToStr(b1);
Form1->Edit9->Text=IntToStr(c1);
str+="\r\n\r\n<<<<<<<<<<<<<<<所 有 的 进 程 都 已 经 成 功 运 行 结 束 ！>>>>>>>>>>>>>>";
Form1->Memo1->Lines->Add(str);
}
}
//将结果保存成txt文件
void __fastcall TForm1::N8Click(TObject *Sender)
{
if(Form1->SaveDialog1->Execute())
{
FILE* fp=fopen(Form1->SaveDialog1->FileName.c_str(),"w");
if(fp==NULL)
{
MessageBox(NULL,"打开文件出错","信息",MB_OK);
return;
}
for(int i=0;i<Form1->Memo1->Lines->Count;i++)
{ fputs(Form1->Memo1->Lines->Strings[i].c_str(),fp);
fputc('\n',fp);
}
fclose(fp);
}
}
//开始模拟按钮单击执行函数
void __fastcall TForm1::Button1Click(TObject *Sender)
{
runmain();
Form1->Button1->Enabled=false;
Form1->Edit1->Enabled=false;
Form1->Edit2->Enabled=false;
Form1->Edit3->Enabled=false;
Form1->Edit4->Enabled=false;
Form1->Edit5->Enabled=false;
Form1->Edit6->Enabled=false;
}
//清除屏幕按钮单击执行函数
void __fastcall TForm1::Button2Click(TObject *Sender)
{
Form1->Memo1->Clear();
Button1->Enabled=true;
h=0;
Form1->Edit1->Enabled=true;
Form1->Edit2->Enabled=true;
Form1->Edit3->Enabled=true;
Form1->Edit4->Enabled=true;
Form1->Edit5->Enabled=true;
Form1->Edit6->Enabled=true;
}
//运行的主函数
void runmain()
{
AnsiString str,str1;
input();
Form1->Timer1->Enabled=true; //触发时钟，调用runFCFS。
str+="\r\n";
}
④ 基于优先级的时间片轮转进程调度算法
#include<iostream>
using namespace std;
struct PCB_Type{
char name;
int cpu_time;
};
struct QueueNode{
struct PCB_Type PCB;
struct QueueNode *next;
};
int main(){
int m,n,t;
int usecpu=0,unusecpu=0;
cout<<"输入就绪队列中的进程数目m：";
cin>>m;
cout<<"输入阻塞队列中的进程的数目n：";
cin>>n;
cout<<"输入唤醒系统资源的相隔时间片个数t：";
cin>>t;
struct QueueNode *readyhead=new QueueNode ,*readytail=new QueueNode,
*blockedhead=new QueueNode,*blockedtail=new QueueNode;
// readyhead=NULL;readytail=NULL;blockedhead=NULL;blockedtail=NULL;
readyhead=readytail;
blockedhead=blockedtail;
for(int i=1;i<=m;i++){
struct QueueNode *t1=new QueueNode;
cout<<"输入就绪队列中进程的name和cpu_time：";
cin>>t1->PCB.name>>t1->PCB.cpu_time;
readytail->next=t1;
readytail=t1;
}
for(int j=1;j<=n;j++){
struct QueueNode *t2=new QueueNode;
cout<<"输入阻塞队列中进程的name和cpu_time：";
cin>>t2->PCB.name>>t2->PCB.cpu_time;
blockedtail->next=t2;
blockedtail=t2;
}
cout<<"输出就绪队列的进程信息：";
for(struct QueueNode *t3=readyhead->next;t3!=readytail->next;t3=t3->next){
cout<<t3->PCB.name<<"、"<<t3->PCB.cpu_time<<"---> ";
}
cout<<"无进程";
cout<<endl;
cout<<"输出阻塞队列的进程信息：";
struct QueueNode *t4;
t4=blockedhead->next;
while(t4!=blockedtail->next){
cout<<t4->PCB.name<<"、"<<t4->PCB.cpu_time<<"---> ";
t4=t4->next;
}
cout<<"无进程";
cout<<endl<<"进程的运行顺序：";
int x=0;
while(readyhead!=readytail||blockedhead!=blockedtail){
if(readyhead!=readytail){
struct QueueNode *p=readyhead->next;
cout<<p->PCB.name<<",";
p->PCB.cpu_time--;
usecpu++;
if(readyhead->next!=readytail){
if(p->PCB.cpu_time>0){
readyhead->next=p->next;//出队列
readytail->next=p;
readytail=p;
}
else{
readyhead->next=p->next;
delete p;
}
}
else//队列中只有两个节点 头结点和尾结点
{
if(p->PCB.cpu_time<=0){readytail=readyhead;//只有进程为执行完，就继续执行，完成之后，把队列清空，释放指针p；就绪队列无进程
delete p;}
}
}
else
{
unusecpu++;
cout<<"_,";
}
x++;
if(x==t){
if(blockedhead!=blockedtail){
struct QueueNode *q=blockedhead->next;
if(blockedhead->next!=blockedtail)
{
blockedhead->next=q->next;
}
else
{
blockedhead=blockedtail;
}
readytail->next=q;
readytail=q;
x=0;
}
}
}
cout<<endl;
cout<<"cpu的利用率="<<usecpu<<"/"<<usecpu+unusecpu<<endl;
return 0;
}
#include"stdio.h"
#include"stdlib.h"
#include "string.h"
#define WAIT 1
#define RUN 2
#define FINISH 3
typedef struct pcb
{
int num;
struct pcb *next;
int priority;
int timeneed;
int state;
}pcb;/*用此结构体来模拟一个进程*/
struct pcb *head;
struct pcb *run;
pcb *jccreat(int n)/*此函数用于创建进程队列*/
{
int i=1;
pcb *head,*p,*q;
randomize();/*随机函数的初始化*/
head=(pcb *)malloc(sizeof(pcb));/*创建一个空表头*/
p=head;
for(i=1;i<=n;i++)/*用循环来创建指定个 结点*/
{
q=(pcb *)malloc(sizeof(pcb));
p->next=q;
q->num=i;
q->next=NULL;
q->priority=random(10);/*随机产生优先级*/
q->timeneed=random(10);/*随机产生运行时间*/
q->state=WAIT;
p=q;
}
return head;/*返回表头指针*/
}
pcb *getmaxpriority(struct pcb *head)/*此函数用来挑选一个优先级最大的进程来执行*/
{
struct pcb *p,*q;
int max;
p=head->next;
max=p->priority;/*初始max为队首结点的优先级*/
q=p;
while(p) /*当p不为空时，进行逐一比较*/
{
if(p->priority>max)/*逐一比较，选出优先级最大的结点*/
{max=p->priority;
q=p;}
p=p->next;
}
return q;
}
void delect(struct pcb *head,struct pcb *run)/*此函数用来将运行完的进程删除出进程队列*/
{
struct pcb *q=head;
while(q->next)/*扫描进程队列，找到执行完了的进程*/
{
if(q->next->num==run->num)/*判断是不是已完成的进程*/
{
if(run->next!=NULL)
q->next=run->next;
else q->next=NULL;
free(run);/*释放申请的空间*/
return;
}
q=q->next;
}
}
void control()/*此函数是用来控制各个进程的执行和调度*/
{
struct pcb *p;
run=head->next;/*初始让第一个进程运行*/
run->state=RUN;
while(run) /*当进程状态是不为空时运行*/
{
if(run->timeneed>0)/*如果当前run指针指向的进程所需时间不为零，状态为运行状态，就让这个进程运行*/
if(run->state==RUN)
{printf("pcb%d is running.\n",run->num);
printf("Waiting list:");/*显示整个等待队列*/
p=head->next;
while(p)
{
if(p!=run)
printf("pcb%d ",p->num);
p=p->next;
}
printf("\n");
delay(10000000);/*模拟进程运行*/
run->timeneed--;/*进程需要时间减一*/
run->priority=run->priority-3;/*进程优先级减三*/
}
if(run->timeneed!=0)
{
if(run->priority<=head->next->priority)/*如果当前运行完的进程的优先级低于队首进程的优先级*/
{run->state=WAIT;
run=getmaxpriority(head);/*则从进程队列中挑选一个优先级最大的进程来运行*/
run->state=RUN;}
}
else
{ printf("pcb%d is finished.\n",run->num);
delect(head,run);/*删除该结点*/
if(head->next!=NULL)/*判断进程队列是不是为空*/
{run=head->next;
run->state=RUN;}
else
{printf("All progresses are done.\n");
return;}
}
}
}
main()
{
int n;
int flag=1;
printf("Enter the number of the progresses:");
scanf("%d",&n);/*输入要创建的进程的数量*/
head=jccreat(n);/*创建进程队列，将链表的表头赋给head指针*/
run=head->next;/*run指针指向正在运行的进程的pcb*/
while(run)
{
printf("num: %d ,priority: %d ,timenees: %d \n",run->num,run->priority,run->timeneed);
run=run->next;
} /*将刚创建的进程队列打印出来*/
while(flag)/*由flag的值判断是否继续执行control()函数*/
{
if(head->next)/*判断进程是否完成*/
control();
else flag=0;
}
getch();
}
选一个把
⑤ 进程调度算法模拟_C语言_求救
短消息联系
⑥ 操作系统的进程调度算法[总结]
操作系统的进程调度算法直接关系到用户的使用体验。
如果把用户的体验时间，引入到计算机里面，我们引入以下几个概念。
周转时间，指作业从提交系统开始，直到作业完成为止的时间间隔。包括：
是指作业周转时间与作业实际运行服务时间的比值。
平均周转时间和平均带权周转时间是衡量批处理系统调度算法的重要准则。
先来先服务调度算法（First Come First Served, FCFS）是最简单的调度算法，可以用于作业调度和进程调度。
按照作业进入系统后备作业队列的先后次序来挑选作业，加入就绪队列，等待执行。
FCFS是非抢占式的，易于实现，效率不高，性能不好.
有利于长作业（CPU繁忙性）而不利于短作业（I/O繁忙性）。
服务时间：作业需要运行的时间
完成时间 = 开始时间 + 服务时间
等待时间 = 开始时间 - 提交时间
周转时间 = 完成时间 - 提交时间
带权周转时间 = 周转时间 / 服务时间
响应比 = （等待时间 + 服务时间） / 服务时间 = 等待时间/服务时间 + 1
该算法每次从后备作业队列中挑选估计服务时间最短的一个或几个作业，
将他们调入内存，分配必要的资源，创建进程并放入就绪队列。
在进程调度中的原理类似。
SJF是非抢占式的，优先照顾短作业，具有很好的性能，降低平均等待时间，提高吞吐量。
但是不利于长作业，长作业可能一直处于等待状态，出现饥饿现象；
完全未考虑作业的优先紧迫程度，不能用于实时系统。
高响应比优先调度算法（Highest Reponse Ratio First, HRRF）是非抢占式的，主要用于作业调度。
基本思想：每次进行作业调度时，先计算后备作业队列中每个作业的响应比，挑选最高的作业投入系统运行。
响应比 = （等待时间 + 服务时间） / 服务时间 = 等待时间 / 服务时间 + 1
由响应比分析可知，该算法介于FCFS和SJF之间，但是每次需要计算每个作业的响应比，增加系统开销。
⑦ 急求 程序代码 c/c++ 操作系统中的 处理机调度算法
#include <iostream>
#include <stdio.h>
#include <string>
//#include <windows.h>
using namespace std;
//hyugtyftydrtdtrdrrtrdrt
struct Node
{
string name;//进程（作业）名称
int arriveTime;//到达时间
int ServerTime;//服务时间
int leftTime;//the left time
Node *link;//指向下一个节点的指针
};
class CProcess
{
public:
CProcess();//构造函数
~CProcess();//析构函数
const CProcess &operator =(const CProcess& p);//重载赋值操作符
void insertNode(string &na,int& at,int& st);//插入新元素（at由小到大）到链表合适的位置
void sort();//按照服务时间由大到小排序
bool isEmpty();//判断是否为空
void destroy();//销毁
int length();//求出链表长度
void print();//打印出元素
void FCFS();//先到先服务
void SJF();//短进程(作业)优先
void RR(int& q);//时间片轮转
void priority();//优先权调度
protected:
Node *first;
Node *last;
};
const CProcess& CProcess::operator=(const CProcess& p)
{
Node *newNode;
Node *Current;
if(this!=&p)//避免自己给自己赋值
{
if(first!=NULL)//如果链表不为空
destroy();
if(p.first==NULL)
{//如果要拷贝的对象为空
this->first = NULL;
this->last = NULL;
}
else
{
Current = p.first;
first= new Node;
first->name=Current->name;//
first->arriveTime=Current->arriveTime;
first->ServerTime=Current->ServerTime;
first->link =NULL;
last =first;
Current = Current->link;
while(Current!=NULL)
{
newNode = new Node;
newNode->name=Current->name;
newNode->arriveTime=Current->arriveTime;
newNode->ServerTime=Current->ServerTime;
newNode->link=NULL;
last->link=newNode;
last=newNode;
Current = Current->link;
}
}
}
return *this;
}
CProcess::CProcess()
{//构造函数
first=NULL;
last=NULL;
}
CProcess::~CProcess()
{
Node *temp;
while(first!=NULL)
{
temp=first;
first=first->link;
delete temp;
}
last=NULL;
}
void CProcess::insertNode(string &na,int& at,int& st)
{//按照到达时间升序排序
Node *Current;
Node *trailCurrent;//指向Current的前一个节点
Node *newNode;
bool found;
newNode = new Node;//建立一个新节点
newNode->name=na;
newNode->arriveTime=at;
newNode->ServerTime=st;
newNode->link=NULL;//
if(first==NULL)//如果第一个节点为空（如果是第一次插入元素）
first=newNode;//将新节点赋给第一个节点
else
{//如果不是第一次
Current =first;
found = false;
while(Current!=NULL && !found)
{
if(Current->arriveTime >= at)
found = true;
else
{
trailCurrent = Current;
Current = Current->link;
}
}
if(Current==first)
{
newNode->link = first;
first = newNode;
}
else
{
trailCurrent->link = newNode;
newNode->link = Current;
}
}
}
int CProcess::length()
{
int count =0;//声明变量，并初始化为0（用来记录长度）
Node *Current;
Current = first;
while(Current!=NULL)//当前节点不为空，记录值自加，一直向后遍历,
{
count++;
Current = Current->link;
}
return count;//返回长度
}
void CProcess::sort()//按照服务时间，升序排列
{//冒泡排序
string sname;
int at;
int st;
Node *Current;//指向当前节点
Node *trailCurrent;//指向当前节点的前一个节点
for(trailCurrent=first->link;trailCurrent!=NULL;trailCurrent=trailCurrent->link)//控制条件有问题
{
for(Current=trailCurrent->link;Current!=NULL;Current=Current->link)//控制条件有问题
{
if(trailCurrent->ServerTime > Current->ServerTime)
{
sname=trailCurrent->name;
at=trailCurrent->arriveTime;
st=trailCurrent->ServerTime;
trailCurrent->name=Current->name;
trailCurrent->arriveTime=Current->arriveTime;
trailCurrent->ServerTime=Current->ServerTime;
Current->name=sname;
Current->arriveTime=at;
Current->ServerTime=st;
}
}
}
}
bool CProcess::isEmpty()//判断是否为空
{
return (first==NULL);//如果第一个节点为空，返回值
}
void CProcess::print()
{
Node *Current;
Current = first->link;//头节点赋给当前节点
while(Current!=NULL)//当前节点不为空，一直向后遍历打印
{
cout<<Current->name<<" ";
cout<<Current->arriveTime<<" ";
cout<<Current->ServerTime<<"\n";
Current = Current->link;
}
}
void CProcess::destroy()
{
Node *temp;//定义一个临时指针变量
while(first!=NULL)
{
temp=first;
first=first->link;
delete temp;
}
last=NULL;
}
void CProcess::FCFS()//先到先服务
{
Node *Current;
int T0=0;//完成时间
int T1=0;//周转时间
Current = first->link;//头节点赋给当前节点
while(Current!=NULL)
{
if(T0 < Current->arriveTime)
{
T0=Current->arriveTime+Current->ServerTime;
T1=T0-Current->arriveTime;
cout<<Current->name<<"\t";//打印出进程名
cout<<T0<<"\t";//打印出完成时间
cout<<T1<<"\n";//打印出周转时间
Current = Current->link;
}
else
{
T0=Current->ServerTime+T0;
T1=T0-Current->arriveTime;//周转时间等于，完成时间 - 到达时间
cout<<Current->name<<"\t";//打印出进程名
cout<<T0<<"\t";//打印出完成时间
cout<<T1<<"\n";//打印出周转时间
Current = Current->link;
}
}
}
void CProcess::SJF()//短进程(作业)优先
{
//首先执行第一个到达的作业
Node *Current;
int T0=0;//完成时间
int T1=0;//周转时间
T0=first->link->ServerTime+T0;
T1=T0-first->link->arriveTime;
cout<<first->link->name<<"\t";
cout<<T0<<"\t";//打印出完成时间
cout<<T1<<"\n";//打印出周转时间
first->link=first->link->link;//删除
//执行剩下的
sort();//对剩下的排序
Current = first->link;//头节点赋给当前节点
while(Current!=NULL)
{
if(T0 < Current->arriveTime)
{
T0=Current->arriveTime+Current->ServerTime;
T1=T0-Current->arriveTime;
cout<<Current->name<<"\t";//打印出进程名
cout<<T0<<"\t";//打印出完成时间
cout<<T1<<"\n";//打印出周转时间
Current = Current->link;
}
else
{
T0=Current->ServerTime+T0;
T1=T0-Current->arriveTime;//周转时间等于，完成时间 - 到达时间
cout<<Current->name<<"\t";//打印出进程名
cout<<T0<<"\t";//打印出完成时间
cout<<T1<<"\n";//打印出周转时间
Current = Current->link;
}
}
}
void CProcess::RR(int& q)//时间片轮转
{
cout<<"时间片轮转操作完成！\n";
}
void CProcess::priority()//优先权调度
{
cout<<"优先权操作完成！\n";
}
void main()
{
CProcess p0,p1,p2,p3,p4;
int at,st;
string na;
int judge=1;//控制退出程序
int choice;//控制选择操作
while(judge)
{
cout<<"********************************************************\n";
cout<<"****** 说明：本程序适用于单道进程（作业） ******\n";
cout<<"******** 请选择您的操作 ***************\n";
cout<<"*********输入相应的数字，按下（Enter）键！**************\n";
cout<<"************* 5.录入信息 ************\n";
cout<<"************* 1.先到先服务 ************\n";
cout<<"************* 2.短进程（作业）优先 ************\n";
cout<<"************* 3.时间片轮转 ************\n";
cout<<"************* 4.优先权(静态)调度 ************\n";
cout<<"************* 0.退出程序 ************\n";
cout<<"********************************************************\n";
cin>>choice;
switch(choice)
{
case 0:
judge=0;
break;
case 5:
cout<<"请输入信息以“end”结束输入！\n";
cout<<"进程名 到达时间 服务时间"<<endl;
while(na.compare("end"))//如果相等则会返回0
{
p0.insertNode(na,at,st);
cin>>na>>at>>st;
}
cout<<"录入成功，目前的信息为：\n";
cout<<"进程名 到达时间 服务时间"<<endl;
p0.print();
break;
case 1://先到先服务
p1=p0;//拷贝一份
if(p1.isEmpty())
{
cout<<"请先录入信息\n";
break;
}
else
{
cout<<"先到先服务\n";
cout<<"进程名 完成时间 周转时间\n";
p1.FCFS();
break;
}
case 2://短作业优先
p2=p0;//拷贝一份
//p2.sort();
//p2.print();
if(p2.isEmpty())
{
cout<<"请先录入信息\n";
break;
}
else
{
cout<<"短作业优先\n";
cout<<"进程名 完成时间 周转时间\n";
p2.SJF();
break;
}
case 3://时间片轮转
p3=p0;//拷贝一份
int q;
if(p3.isEmpty())
{
cout<<"请先录入信息\n";
break;
}
else
{
cout<<"请输入时间片大小";
cin>>q;
cout<<"时间片轮转\n";
cout<<"进程名 完成时间 周转时间\n";
p3.RR(q);
break;
}
case 4://优先权
p4=p0;//拷贝一份
if(p4.isEmpty())
{
cout<<"请先录入信息\n";
break;
}
else
{
cout<<"时间片轮转\n";
cout<<"进程名 完成时间 周转时间\n";
p4.priority();
break;
}
default:
cout<<"请选择目录中的选项！\n";
break;
}
}
return;
}
⑧ 求进程调度算法
进程调度源程序如下：
jingchendiao.cpp
#include "stdio.h"
#include <stdlib.h>
#include <conio.h>
#define getpch(type) (type*)malloc(sizeof(type))
#define NULL 0
struct pcb { /* 定义进程控制块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:\n",i);
p=getpch(PCB);
printf("\n 输入进程名:");
scanf("%s",p->name);
printf("\n 输入进程优先数:");
scanf("%d",&p->super);
printf("\n 输入进程运行时间:");
scanf("%d",&p->ntime);
printf("\n");
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 qname \t state \t super \t ndtime \t runtime \n");
printf("|%s\t",pr->name);
printf("|%c\t",pr->state);
printf("|%d\t",pr->super);
printf("|%d\t",pr->ntime);
printf("|%d\t",pr->rtime);
printf("\n");
}
check() /* 建立进程查看函数 */
{
PCB* pr;
printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/
disp(p);
pr=ready;
printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/
while(pr!=NULL)
{
disp(pr);
pr=pr->link;
}
}
destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/
{
printf("\n 进程 [%s] 已完成.\n",p->name);
free(p);
}
running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/
{
(p->rtime)++;
if(p->rtime==p->ntime)
destroy(); /* 调用destroy函数*/
else
{
(p->super)--;
p->state='w';
sort(); /*调用sort函数*/
}
}
main() /*主函数*/
{
int len,h=0;
char ch;
input();
len=space();
while((len!=0)&&(ready!=NULL))
{
ch=getchar();
h++;
printf("\n The execute number:%d \n",h);
p=ready;
ready=p->link;
p->link=NULL;
p->state='R';
check();
running();
printf("\n 按任一键继续......");
ch=getchar();
}
printf("\n\n 进程已经完成.\n");
ch=getchar();
}
⑨ 进程调度算法模拟程序设计
这么有技术含量的问题，应该要更有技术含量的回答，你给个30分悬赏，高手都不睬你~！
⑩ （操作系统）编写进程调度算法程序
这个只要调个队列就够了,主要的代码应该这样写就可以了：
while(!que.empty()) //que是进程的队列
{
pid_t pid = fork();
switch(pid)
{
case -1 : printf("ERROR:cannot create the child process.\n"); break;
case 0: execlp(……)； //这里execlp调用的是que.top(),这个进程要写在当前目录下
default : wait(NULL);
}
}
等待某一时间不能继续执行，可以使wait函数的参数取具体的状态值，希望可以帮到你！