操作系统实验二（调度算法模拟-先进先出-时间片轮转法-优先服务调度算法）

实验二 进程调度

一、     实验目的

1.       理解进程运行的并发性。 

2.       理解处理器的三级调度。

3.       掌握先来先服务的进程调度算法。

4.       掌握短进程优先的进程调度算法。

5.       掌握时间片轮转的进程调度算法。 

二、     实验设备

1.     安装windows或者linux操作系统的PC机

2.     C程序编译环境

三、     实验内容

用c语言编程模拟实现至少一个操作系统的常见进程调度算法。常见的进程调度算法有先来先服务、短进程优先、时间片轮转法等。

四、     实验要求

1.     上机编写并调试进程调度的模拟程序。

2.     要把相应的程序代码及程序运行结果写入实验报告中。

 

//操作系统—进制控制模拟
#include<stdio.h>
#include<stdlib.h>
#include <windows.h>
#include<tlhelp32.h>
#define N 10
struct pb
{
  int ko;
  int no;
  int cha;
};
typedef struct pb PCB;
PCB a[N];
int showallproc()
{
    PROCESSENTRY32 pe32;//用来存储进程信息的结构体
    pe32.dwSize=sizeof(pe32);
    HANDLE hProcessSnap=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);//获取进程快照
    if(hProcessSnap==INVALID_HANDLE_VALUE)
    {
        printf("调用失败\n");
        return 1;
    }
    BOOL bProc=Process32First(hProcessSnap,&pe32);
    while(bProc)
    {
        printf("%5d %s\n",pe32.th32ProcessID,pe32.szExeFile);//输出进程ID和进程名
        bProc=Process32Next(hProcessSnap,&pe32);
    }
    CloseHandle(hProcessSnap);
    return 0;
}
static int count=1;
void create()   //创建
{
  static int pi=1;
  int k,l=0,m;
  printf("请输入创建的进程号:");
  scanf("%d",&m);
  for(k= 1;k<= N;k++ )
    if(a[k].no ==m)
	  l=1;
	if(l == 1)
	{
	  printf("错误，进程创建重复！\n");
	  create();
	}
    else
	{
		for(k= 1;k<= N;k++ )
		{
			if(a[k].no==0)
			{
				pi=k;break;}
		}
	  a[pi].no=m;
	  printf("\n输入优先级:");
	  scanf("%d",&a[pi].ko);
	  if(count>1)            //首次进程状态为执行，之后为活动就绪
	    a[pi++].cha=3;
	  else
	    a[pi++].cha=5;
	  count++;
	}
}

int stopproc()
{
    DWORD ProcessID;
    printf("请输入想要终止的进程ID\n");
    scanf(" %d",&ProcessID);
    HANDLE hProcess=OpenProcess(PROCESS_TERMINATE,FALSE,ProcessID);//打开对应进程句柄
    if (hProcess==NULL)
    {
        printf("失败\n");
        return -1;
    }
    if (!TerminateProcess(hProcess,0))//关闭进程
    {
        printf("关闭失败\n");
    }
    else
    {
        printf("关闭成功\n");
    }
    CloseHandle(hProcess);
    
    return 0;
}

void dispatch()   //调度
{
	int i,m,l=0,j=0,k,min=10000;

	for(m= 1;m<= N;m++ )
		if(a[m].cha==5)
			l=m;
		if(l!=0)
		{
			printf("调度失败！");
			return;
		}
		else 
	for(k= 1;k<= N;k++ )
	{
		if(a[k].cha==3)
		if(min>a[k].ko)
		{
			min=a[k].ko;
		    i=k;
			j=1;
		}
	}
	    if(j)         
		    a[i].cha=5;
        else if(j==0)
			printf("调度失败！\n");
	
}

void block()   //阻塞
{
  int k,m,l=0;
  printf("请输入已经创建的进程号:");
  scanf("%d",&m);
  for(k= 1;k<= N;k++ )
    if(a[k].no==m)
	  l=k;
	if(l!=0)
	{
	  if(a[l].cha==3 || 5)
	    a[l].cha=4;
		else if(a[l].cha==1)
		  a[l].cha=2;
		  else
		  printf("阻塞失败!\n");
	}
	else
		printf("阻塞失败!");
}

void wakeup()   //唤醒
{
  int k,m,l=0;
  printf("请输入已经创建的进程号:");
  scanf("%d",&m);
  for(k= 1;k<= N;k++ )
   if(a[k].no==m)
     l=k;
   if(l!=0)
   {
	 if(a[l].cha==2)
	   a[l].cha=1;
	   else if(a[l].cha==4)
	     a[l].cha=3;
	     else
		 printf("唤醒失败!\n");
   }
   else
	   printf("唤醒失败!");
}


void suspend()   //挂起
{
  int k,m,l=0;
  printf("请输入已经创建的进程号:");
  scanf("%d",&m);
  for(k= 1;k<= N;k++ )
    if(a[k].no==m)
	  l=k;
	if(l!=0)
	{
	  if(a[l].cha==3 || 5)
	    a[l].cha=1;
		else if(a[l].cha==4)
		  a[l].cha=2;
		  else
		  printf("错误！挂起失败\n");
	}
	else
		printf("错误！挂起失败！");
}

void active()   //激活
{
  int k,m,l=0;
  printf("请输入已经创建的进程号:");
  scanf("%d",&m);
  for(k= 1;k<= N;k++ )
    if(a[k].no==m)
	  l=k;
	if(l!=0)
	{
	  if(a[l].cha==1)
	    a[l].cha=3;
		else if(a[l].cha==2)
		  a[l].cha=4;
		  else
		  printf("激活失败！\n");
	}
	else 
		printf("激活失败！");
}

void display()   //查看PCB功能模块
{
  int i; 
  printf("\t\tPCB\t进程号\t优先级\t状态\n");
  for(i= 1;i<= 10;i++ )
  printf("\t\t%d\t%d\t%d\t%d\n",i,a[i].no,a[i].ko,a[i].cha);
  printf("\t1-静止就绪  2--静止阻塞  3--活动就绪  4--活动阻塞  5--执行\n");
}

void change_KO()   //改变优先数
{
  int k,m,l=0;
  printf("请输入已创建的进程号:");
  scanf("%d",&m);
  for(k= 1;k<= N;k++ )
    if(a[k].no==m)
	  l=k;
    if(l!=0)
	{
	    printf("输入新的优先级：");
	    scanf("%d",&a[l].ko);
	    display();
	}
	else
		printf("失败！");
}
/********************这是先来先服务的程序*********************************/
struct fcfs{//定义先来先服务结构体、参数
char name[10];
float daodatime;//到达时间
float fuwutime;//服务时间
float kaishitime;//开始时间
float wanchengtime;//完成时间
float zhouztime;//周转时间
float daiquantime;//带权周转时间
};
fcfs b[10000];
void input(fcfs *p,int N1)  //构造一个输入进程的信息的函数，定义结构体指针
{ 
	int i;   
   for(i=0;i<=N1-1;i++)
   {
     printf("输入第%d个进程的名字、到达时间、服务时间:\n",i+1);
     scanf("%s%f%f",&p[i].name,&p[i].daodatime,&p[i].fuwutime);//把输入的信息保存到结构体指针所对应的内存中
   }

}//构造一个输出函数
void Print(fcfs *p,float daodatime,float fuwutime,float kaishitime,float wanchengtime,float zhouztime,float daiquantime,int N1)
{
	int k;
    printf("执行顺序:\n");
    printf("%s",p[0].name);
    for(k=1;k<N1;k++)
	{
		printf("-->%s",p[k].name);
	}
     printf("\n进程的相关信息如下:\n");
     printf("\n名字\t到达\t服务\t开始\t完成\t周转\t带权周转\n");
     for(k=0;k<=N1-1;k++)
	 { 
      printf("%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n",p[k].name,p[k].daodatime,p[k].fuwutime,p[k].kaishitime,p[k].wanchengtime,p[k].zhouztime,p[k].daiquantime);
	 } //题目中加入-.2是保留双精度的两位。一般f默认保留六位小数的。  
} 
  void sort(fcfs *p,int N1)//进程根据到达时间进行排序
  { 
     for(int i=0;i<=N1-1;i++)
      for(int j=0;j<=i;j++)
       if(p[i].daodatime<p[j].daodatime)//如果i的时间到达时间小于j的到达时间，就交换
	   {
         fcfs temp;//在结构体中定义第三个变量进行交换
         temp=p[i];
         p[i]=p[j];
         p[j]=temp;
	   }
}
//核心的运行阶段
void deal(fcfs *p, float daodatime,float fuwutime,float kaishitime,float wanchengtime,float zhouztime,float daiquantime,int N1)
{ int k;
    for(k=0;k<=N1-1;k++)
	{
	  if(k==0)//K=0,表示第一个进程到达
	  { 
       p[k].kaishitime=p[k].daodatime;//那么开始时间=到达时间
       p[k].wanchengtime=p[k].daodatime+p[k].fuwutime;//完成时间=到达时间+服务时间
	  }
         else
		 {
           p[k].kaishitime=p[k-1].wanchengtime;//下一个进程的开始时间=上一个进程的完成时间
           p[k].wanchengtime=p[k-1].wanchengtime+p[k].fuwutime;//完成时间=上一个进程的完成时间+服务时间
		 }
	}
     for(k=0;k<=N1-1;k++)//计算周转时间和带权周转时间
     { 
      p[k].zhouztime=p[k].wanchengtime-p[k].daodatime;//周转时间=完成时间-到达时间
      p[k].daiquantime=p[k].zhouztime/p[k].fuwutime;//带权周转时间=周转时间/服务时间   
	 }
}
void FCFS(fcfs *p,int N1)//定义先来先服务函数
{  
     float daodatime=0,fuwutime=0,kaishitime=0,wanchengtime=0,zhouztime=0,daiquantime=0;//初始化变量为0
     sort(p,N1);//声明排序函数
     deal(p,daodatime,fuwutime,kaishitime,wanchengtime,zhouztime,daiquantime,N1);//声明运行函数
     Print(p,daodatime,fuwutime,kaishitime,wanchengtime,zhouztime,daiquantime,N1); //声明输出函数
}
/****************************这是优先服务调度算法的代码***********************************/
typedef struct PCB2
{  
   char name[10];//进程名
   int runtime;//要求运行时间
   int frist;//定义优先数
   char zhuangtai; //定义状态，R为就绪，F为完成
};
struct PCB2 PCBcontrol[4];//定义进程控制块数组 
void youxian()//构造优先函数 
{
	int i,n;
	printf("请输入进程的个数:\n");
    scanf("%d",&n);
	printf("请输入进程的名字、优先权、运行时间\n");
	printf("\n");
	for(i=0;i<n;i++)
	{
		printf("请输入第%d个进程的信息:\n",i+1);
		scanf("%s%d%d",&PCBcontrol[i].name,&PCBcontrol[i].frist,&PCBcontrol[i].runtime);
        PCBcontrol[i].zhuangtai='R';//进程初始状态均为就绪
        getchar();//等待回车进入下一次运行
	} 
} 
  int max_frist_process()//确定最大优先级进程子程序 
  { 
     int max=-10;//max为最大优先数，初始化为-10  
     int i,key;  
     for(i=0;i<3;i++) 
	 {
		 if(PCBcontrol[i].zhuangtai=='r')//r表示正在运行
			 return -1;//返回-1
		 else
			 if(max<PCBcontrol[i].frist&&PCBcontrol[i].zhuangtai=='R')//从就绪进程中选取优先数最大的进程
			 {
				 max=PCBcontrol[i].frist;//max存放每次循环中的最大优先数
				 key=i;//将进程号赋给key
			 }
	 }
	 if(PCBcontrol[key].zhuangtai=='F')//具有最大优先数的进程若已运行完毕
		 return -1;//则返回-1
	 else
		 return key;//将key作为返回值返回 
  }
  void show()//显示函数
  {
	  int i;  
      printf("\n进程名  优先级 运行时间 当前状态\n");
	  printf("*****************************************\n");
      for(i=0;i<3;i++)//依次显示每个进程的名、优先数、要求运行时间和状态
	  {
		  printf("  %s\t %d\t  %d\t   %s\t\n",&PCBcontrol[i].name,PCBcontrol[i].frist,PCBcontrol[i].runtime,&PCBcontrol[i].zhuangtai); 
	  }
	   printf("\n请按回车键进行查看");
  }
  void run()//进程运行子程序
  {
	  int i,j;
	  int t=0;//t为运行次数
	  for(j=0;j<3;j++)
	  {
		  t+=PCBcontrol[j].runtime;}//运行次数即为各个进程运行时间之和 
          printf("\n进程没运行前，当前的状态是:\n");  
          show(); //调用show()子程序显示运行前PCB的情况
		  getchar();//等待回车进入下一次运行
		  for(j=0;j<t;j++) 
		  {
			  while(max_frist_process()!=-1)//具有最大优先数的进程没有运行完，让其运行
			  {
				  PCBcontrol[max_frist_process()].zhuangtai='r';//将其状态置为r，表示其正在运行
			  }
			  for(i=0;i<3;i++)
			  {
				  if(PCBcontrol[i].zhuangtai=='r')
				  {
					  PCBcontrol[i].frist-=1;//将当前运行进程的优先数减1
					  PCBcontrol[i].runtime--;//要求运行时间减1
					  {
						  if(PCBcontrol[i].runtime==0)
							  PCBcontrol[i].zhuangtai='F';//运行完则将该进程状态置为结束
						  else
							  PCBcontrol[i].zhuangtai='R';//未运行完将其状态置为就绪
					  }
					  show();//显示每次运行后各PCB的情况
					  getchar();//等待回车进入下一次运行
				  }  
			  } 
		  } 
  }
  /***********************这是算法时间片轮转法的代码*****************************************/
  struct shijian {//定义时间片的结构体
	char name;  //定义进程名
    int daodatime;// 到达时间
    int fuwutime;  //服务时间
    int shengyutime;//剩余时间
	char *state;//所处状态
	struct shijian *next;
};
struct shijian *time()
{
	int a,i;
	struct shijian *head, *rear,*p,*q,*t;//定义队首、队尾、P是队尾指针、Q是队首指针和执行时间
	head=rear=NULL;//初始化队首和队尾为空 
    printf("请输入进程数目：");  
    scanf("%d",&a); 
	for(i=0;i<a;i++)
	{
		p=(struct shijian*)malloc(sizeof(struct shijian)); //初始化一个空间给进程进入
		printf("输入第%d个进程的名字、到达时间、服务时间:\n",i+1);
        scanf("%s%d%d",&p->name,&p->daodatime,&p->fuwutime);  
        p->shengyutime=p->fuwutime; 
        p->state="就绪";            
        if(rear==NULL) //当输入结束时，把P的数据放到队首，以便执行下一步
		{
			head=p;   
            p->next=NULL;   
            rear=p;  
		}
		else  //否则执行时间就为空，队首变成Q
		{
			t=NULL;   
            q=head;
			while(q&&q->daodatime<p->daodatime)//当Q和Q的到达时间小于P的到达时间时，把执行时间给Q
			{
				t=q;      
                q=q->next;
			}
			if(q==head)  //而当Q是队首时，则下一个队首变成P，以便每个进程都能够得到时间片
			{
				p->next=head;  
                head=p;
			}
			else if(t==rear)  //当执行时间片到达队尾时（执行完时），返回给队首P
			{
				rear->next=p; 
                p->next=NULL; 
                rear=p;
			}
			else   //否则给队首P占用执行时间，P执行完后到Q
			{
				t->next=p;   
                p->next=q;
			}   
		}   
	}
	return head;//返回队首
}
void output(struct shijian *head)//定义输出函数
{
	struct shijian *p,*t,*r; 
    int num;  
    printf("请输入时间片:");  
    scanf("%d",&num);
	while(head!=NULL) //当队首不为空时，把P给队首
	{
		r=p=head;
		while(p!=NULL) //把执行时间给队首
		{
			t=head;  
            p->shengyutime=p->shengyutime-num;  //P的剩余时间=剩余时间-时间片
            p->state="运行"; //状态变成运行态
            if(p->shengyutime<0) //当P运行完，即剩余时间小于0时，仍然把它当做0处理
            p->shengyutime=0;  
            printf("\n************程序开始运行*****************\n");
            printf("进程  到达时间 服务时间  剩余时间  当前状态\n");
			while(t!=NULL)  //时间不为空时，输出当前进程的信息，并把时间片交给下一个进程
			{
				printf("%2c%8d%8d%14d%10s\n",t->name,t->daodatime,t->fuwutime,t->shengyutime,t->state);  
                t=t->next;
			}
			getchar(); //按住回车键观看
			if(p->shengyutime==0)//当队首的剩余时间为0时，先把队首改成P的下一个，然后释放内存，删除队首节点
			{
				if(p==head)
				{
					head=p->next;
		            free(p);
		            p=head;
				}
				else  //否则返回执行，把队尾的下一个指针变成P的下一个指针，队尾的位置移动到队首
				{
					r->next=p->next; 
                    p=r->next; 
                    r=p;
				} 
			}
			else  //否则把队首的位置给队尾，把队首的状态显示为"就绪"状态
			{
				r=p;
				p->state="就绪";    
                p=p->next; 
			} 
		}   
    } 
}  
void diaodusuanfa()
{
	int N1;
	  int number;
	  char Tishikuang;//提示框
	  do{
        printf("    **                       输入 1-先来先服务                           *\n");
        printf("    **                       输入 2-时间片轮转法                         *\n");
        printf("    **                       输入 3-优先服务法                           *\n");
        printf("    **                       输入 0-退出该程序                           *\n");
        printf("\n提示:请根据自己的需求选择相应的操作数：\n");
        scanf("%d",&number);/*提示输入字母，用switch语句存入到case中，最后增加提示框是否继续*/
        switch(number)
        {
        case 0:
           break;
        case 1:
             printf("您选择的是**先来先服务调度**\n\n");
		     printf("请输入进程的数量:\n");
             scanf("%d",&N1);
             input(b,N1);
             FCFS(b,N1);
            break;
        case 2:
			printf("\n您选择的是时间片轮转发调度\n\n");
			struct shijian *head; //定义时间片的队首结构体
            head=time(); //队首执行的时间
            output(head) ;//输出函数
            break;
        case 3:
			printf("\n您选择的是优先服务调度，本程序可提供3个进程的调度。\n\n");
		    youxian();//初始化各个进程PCB 
            run();//进程调度模拟
		   break;
        default:
            printf("\n你的输入有误，请确定是从0到3之间进行输入，O(∩_∩)O谢谢\n");
            break;
        }
        printf("\n是否继续操作(y/n) ?");
        fflush(stdin);
        Tishikuang=getchar();
	}while(Tishikuang=='y'||Tishikuang=='Y');
} 

int main()
{
  int i;

  do
  {
   	printf("\t\t**************功能模块 ***************\n");
    printf("\t\t*        1-----进程创建             *\n");
    printf("\t\t*        2-----进程撤消             *\n");
    printf("\t\t*        3-----调度                 *\n");
	printf("\t\t*        4-----阻塞                 *\n");
    printf("\t\t*        5-----唤醒                 *\n");
    printf("\t\t*        6-----挂起                 *\n");
    printf("\t\t*        7-----激活                 *\n");
    printf("\t\t*        8-----查看进程控制块       *\n");
    printf("\t\t*        9-----改变优先数           *\n");
    printf("\t\t*       10----查看进程              *\n");
    printf("\t\t*       11----调度算法模拟          *\n");
    printf("\t\t*        0-----退出                 *\n");
    printf("\t\t*************************************\n");
    printf("\t\t请选择0-10：");
    scanf("%d",&i);
    printf("\n");
    switch(i)
    {
      case 1: create();break;
	  case 2:stopproc();break; 
	  case 3: dispatch();break;
	  case 4: block();break;
	  case 5: wakeup();break;
	  case 6: suspend();break;
	  case 7: active();break;
	  case 8: display();break;
	  case 9: change_KO();break;
      case 10: showallproc();break;
      case 11: diaodusuanfa();break;
	  case 0: exit(0);   //程序正常退出
    }
  }
  while(i!=0);
}