进程调度算法模拟
A. 求进程调度先来先服务算法，短进程优先算法完整c语言代码
/*（一）进程调度
进程调度算法有FIFO，优先数调度算法，时间片轮转调度算法，分级调度算法，
输入：进程流文件，其中存储的是一系列要执行的进程，
每个作业包括三个数据项：
进程名 所需时间 优先数(0级最高)
输出:
进程执行流 等待时间 平均等待时间
本程序包括:FIFO，优先数调度算法，时间片轮转调度算法
进程流文件process_stream.txt
测试数据：
p0 16 2
p1 5 1
p2 4 3
p3 8 0
p4 9 4
p5 7 6
VC++调试通过
*/
#include <stdio.h>
#include <string.h>
#include <iostream.h>
#include <stdlib.h>
const int Quatum=2;//定义时间片的长度为2秒
const int MAXPCB=100;//定义最大进程数
//定义进程结构体
typedef struct node
{
char name[20];//进程名
int time; //进程运行时间
int privilege;//进程优先级（静态）
int finished;//进程完成标志，0-未完成，1-已完成
int wait_time;//进程等待时间
}pcb;
pcb pcbs[MAXPCB];
int quantiry;//进程流文件中的进程总数
void initial()
{
int i;
for (i=0;i<MAXPCB;i++)
{
strcpy(pcbs[i].name,"");
pcbs[i].time=0;
pcbs[i].privilege=0;
pcbs[i].finished=0;
pcbs[i].wait_time=0;
}
quantiry=0;
}
int readData()
{
FILE *fp;
char fname[20];
int i;
cout<<"请输入进程流文件名:"<<endl;
cin>>fname;
if ((fp=fopen(fname,"r"))==NULL)
{
cout<<"错误,文件打不开，请检查文件名"<<endl;
}
else
{
while (!feof(fp))
{
fscanf(fp,"%s %d %d %d",pcbs[quantiry].name,
&pcbs[quantiry].time,&pcbs[quantiry].privilege);
quantiry++;
}
//输出所读入得数据
cout<<"输出所读入的数据"<<endl;
cout<<"进程流文件中的进程总数="<<quantiry<<endl;
cout<<"进程名 所需时间 优先数"<<endl;
for (i=0;i<quantiry;i++)
{
cout<<" "<<pcbs[i].name<<" "<<pcbs[i].time<<" "<<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<quantiry;i++)
{
cout<<" "<<pcbs[i].name<<" "<<pcbs[i].wait_time<<endl;
for (j=i+1;j<quantiry;j++)
{
pcbs[j].wait_time+=pcbs[i].time;
}
}
total=0;
for (i=0;i<quantiry;i++)
{
total+=pcbs[i].wait_time;
}
cout<<"总等待时间:"<<total<<" "<<"平均等待时间:"<<total/quantiry<<endl;
}
//优先度调度算法
void privilege()
{
int i,j,p;
int passed_time=0;
int total;
int queue[MAXPCB];
int current_privielege=1000;
for (i=0;i<quantiry;i++)
{
current_privielege=1000;
for (j=0;j<quantiry;j++)
{
if ((pcbs[j].finished==0)&&(pcbs[j].privilege<current_privielege))
{
p=j;
current_privielege=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<quantiry;i++)
{
cout<<" "<<pcbs[queue[i]].name<<" "<<pcbs[queue[i]].wait_time<<"--"<<queue[i]<<endl;
}
total=0;
for (i=0;i<quantiry;i++)
{
total+=pcbs[i].wait_time;
}
cout<<"总等待时间:"<<total<<" 平均等待时间:"<<total/quantiry<<endl;
}
//时间片轮转调度算法
void timer()
{
int i,j,sum,flag=1;
int passed_time=0;
int max_time=0;
int round=0;
int queue[1000];
int total=0;
while(flag==1)
{
flag=0;
for (i=0;i<quantiry;i++)
{
if (pcbs[i].finished==0)
{
flag=1;
queue[total]=i;
total++;
if (pcbs[i].time<=Quatum*(round+1))
pcbs[i].finished=1;
}
}
round++;
}
cout<<endl<<"---------------------------------------------------------------"<<endl;
cout<<"时间片轮转调度执行流:";
for(i=0;i<total;i++)
{
cout<<pcbs[queue[i]].name<<" ";
}
cout<<endl;
cout<<"进程名 结束时间 运行时间 等待时间"<<endl;
sum=0;
for (i=0;i<quantiry;i++)
{
for(j=total-1;j>=0;j--)//从轮转调度执行流序列由后往前比较，找到同名进程即可计算其完成时间
{
if (strcmp(pcbs[queue[j]].name,pcbs[i].name)==0)
{
cout<<" "<<pcbs[i].name<<" "<<(j+1)*Quatum<<" ";
cout<<pcbs[i].time<<" "<<(j+1)*Quatum-pcbs[i].time<<endl;
sum+=(j+1)*Quatum-pcbs[i].time;
break;
}
}
}
cout<<"总等待时间:"<<sum<<" "<<"平均等待时间:"<<sum/quantiry<<endl;
}
//显示版权信息函数
void version()
{
cout<<endl<<endl;
cout<<" ┏━━━━━━━━━━━━━━━━━━━━━━━┓"<<endl;
cout<<" ┃ 进程调度模拟系统 ┃"<<endl;
cout<<" ┠───────────────────────┨"<<endl;
cout<<" ┃ version 2011 ┃"<<endl;
cout<<" ┗━━━━━━━━━━━━━━━━━━━━━━━┛"<<endl;
cout<<endl<<endl;
}
//主函数
int main()
{
int flag;
version();
initial();
flag=readData();
if(flag==1){
FIFO();
init();
privilege();
init();
timer();
}
cout<<endl;
system("pause");
return 0;
}
B. 进程调度算法
算法原理： 就是谁先来谁就先执行
算法优点 ：易于理解且实现简单，只需要一个队列，公平
算法缺点 ：有利于长进程，不利于短进程，有利于CPU 繁忙的进程，不利于I/O 繁忙的进程
算法原理： 对预计执行时间短的进程优先执行。
算法优点 ：相比FCFS 算法，该算法可改善平均周转时间和平均带权周转时间，缩短进程的等待时间，提高系统的吞吐量。
算法缺点： 对长进程不利，可能长时间得不到执行产生饥饿，不能判断执行的优先级。
算法原理： 同时考虑每个作业的等待时间长短和估计需要的执行时间长短，从中选出响应比最高的作业投入执行。响应比R定义： R =(W+T)/T = 1+W/T
T为该作业估计需要的执行时间，W为作业在后备状态队列中的等待时间。执行之前系统计算每个作业的响应比，选择其中R最大者执行。这种算法是介于前面两种之间的一种折中算法。
算法优点： 长作业也有机会投入运行，避免了饥饿。
算法缺点： 每次调度前要计算响应比，增加系统开销。
算法原理： 设置一个时间片，每个进程轮流使用时间片，若一个时间片内进程还没结束，也会被其他的进程抢占时间片而退出执行，进入等待队列。
算法优点： 简单易行、平均响应时间短。
算法缺点： 不利于处理紧急作业。时间片的大小的设置对系统性能的影响很大，因此时间片的大小应选择恰当
算法原理： 根据优先级的来判断执行哪个进程。可以分为静态优先级和动态优先级，即优先级可以根据情况改变。比如如果一个进程等了很久，我们就可以把他的优先级适当的提高。
算法优点 ：可以优先处理紧急事件，适用于实时操作系统。
算法缺点 ：可能导致那些优先级低的进程饥饿。
UNIX操作系统采取的便是这种调度算法。
算法原理 ：
实现先说明执行队列优先级Q1>Q2>Q3.......>Qn，分配的时间片Qn>Qn-1>...Q1.
进程在进入待调度的队列等待时，首先进入优先级最高的队列Q1等待。若在Q1队列里面还没执行完，则下放到Q2里面，等Q1里面的进程都执行完了之后再执行Q2。以此类推。
若在低优先级的队列中的进程在运行时，又有新到达的作业，那么在运行完这个时间片后，CPU马上分配给新到达的作业（抢占式）。
在多级反馈队列调度算法中，规定第一个队列的时间片略大于多数人机交互所需之处理时间时，能够较好的满足各种类型用户的需要。
C. 进程调度的算法
算法总是把处理机分配给最先进入就绪队列的进程，一个进程一旦分得处理机，便一直执行下去，直到该进程完成或阻塞时，才释放处理机。
例如，有三个进程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规则排队，按一定的时间间隔把处理机分配给队列中的进程。这样，就绪队列中所有进程均可获得一个时间片的处理机而运行。
多级队列方法：将系统中所有进程分成若干类，每类为一级。 多级反馈队列方式是在系统中设置多个就绪队列，并赋予各队列以不同的优先权。
