操作系统实验二：动态优先权的进程调度算法实验(C++实现)

于 2021-10-28 11:43:26 发布
阅读量8.1k 收藏 172
点赞数 33
分类专栏： C语言 操作系统 文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ihavehairssss/article/details/120981626
版权

目录

一、实验说明

 1.实验目的

 2.实验内容

 3.本次实验结果:(图片太长长长长长长长长长长长长了，仅展示一部分结果)

 ​4.本次实验代码：

二、算法目的以及功能

  1.输入实验中所要求的进程，查看结果

  2.输入3个进程，查看结果

  3.6个进程

三、算法结构功能介绍

 1.主函数不能少(全部代码还得请移步到下面)

 2.建立PCB的结构体--存储进程信息

 3.创建就绪与阻塞队列

 4.参数改变函数--用于时间片后进程参数的改变

 5.移动函数--根据进程参数对进程进行删除或移动

 6.排序函数-可将就绪队列按优先级降序排列，阻塞队列按BLOCK升序排列

 7.输出函数1--将队列中进程PCB中信息输出(我图省事没多想就把这段打码写的很啰嗦，老铁们看看图个乐就中)

 8.输出函数2--负责输出队列内容

 9.全部代码如下

三.运行结果

 1.输入实验所要求的进程(5个进程，图片太长只截取部分图片)

 2.输入3个进程，其中有一个进程一开始便要求阻塞

 3.输入多个进程(其实想输入多少就输入多少，图太长了，我就只输入6个，你们慢慢试8)

三、总结

四、补充的实验大图

 1.5个进程图实验完整图(其他的几种输出情况类似，这里不一一列举)

一、实验说明

1.实验目的

通过动态优先权算法的模拟，加深进程概念和进程调度过程的理解。

 2.实验内容

（1）用C语言实现对N个进程采用动态优先权算法的进程调度；

（2）每个用来标识进程的进程控制块PCB用结构来描述，包括以下字段：

  1. 进程标识数：id；
  2. 进程优先数：priority，并规定优先数越大的进程，其优先权越高；
  3. 进程已占用的CPU时间：cputime；
  4. 进程还需占用的CPU时间：alltime；
  5. 进程的阻塞时间：startblock，表示当进程再运行startblock个时间片后，进程将进入阻塞态；
  6. 进程被阻塞时间：blocktime，表示已阻塞的进程再等待blocktime个时间片后，将转换成就绪态；
  7. 进程状态：state；
  8. 队列指针：next，用来将PCB排成队列。

（3）优先数改变的原则：

  1. 进程在就绪队列中呆一个时间片，优先数增加1；
  2. 进程每运行一个时间片，优先数减3。

（4）假设在调度前，系统中有5个进程，它们的初始状态如下：

ID                          0       1       2     3        4

PRIORITY             9       38    30    29      0

CPUTIME              0       0       0      0       0

ALLTIME               3        3       6      3       4

STARTBLOCK      2       -1       -1     -1     -1

BLOCKTIME         3        0       0      0       0

STATE            READY  READY  READY  READY  READY

（5）为了清楚地观察所有进程的调度过程，程序应将每个时间片内进程的情况显示出来，参照的具体格式如下：

        RUNNING PROG: i

        READY_QUEUE: ->id1->id2

        BLOCK_QUEUE: ->id3->id4

     ==================================================

ID                                0       1          2       3       4

PRIORITY                  P0     P1       P2     P3    P4

CPUTIME                  C0      C1      C2     C3    C4

ALLTIME                    A0      A1      A2     A3     A4

STARTBLOCK           T0      T1      T2     T3      T4

BLOCKTIME              B0      B1      B2     B3     B4

STATE           S0      S1      S2     S3     S4


3.本次实验结果:(图片太长长长长长长长长长长长长了，仅展示一部分结果)


4.本次实验代码：

#include"stdio.h"
#include"iostream"
#include"cstdio"
#include"iomanip"
#include"malloc.h"
#include"conio.h"
using namespace std;
typedef struct PNode{
	int id;
	int priority;
	int cputime;
	int alltime;
	int startblock;
	int fstartblock; 
	int blocktime;
	int fblocktime;
	int state;//1为就绪，0为阻塞 
	PNode *next; 
}PCB; 
void Sort(PCB *&l)
{
	PCB *ll;
	PCB *promin;
	PCB *min;
	PCB *nextmin;
	ll=(PCB *)malloc(sizeof(PCB));
	ll->next=NULL;
	promin=l;
	min=nextmin=l->next;
	while(l->next!=NULL)
	{
		if(l->next->state==1) 
		{
			while(nextmin!=NULL)
			{
			if(nextmin->priority<min->priority)
			{
				min=nextmin;
			}
			nextmin=nextmin->next;
			}
		}
		else
		{
			while(nextmin!=NULL)
			{
			if(nextmin->blocktime>min->blocktime)
			{
				min=nextmin;
			}
			nextmin=nextmin->next;
			}
		}
		while(promin->next!=min)
		{
			promin=promin->next;
		}
		promin->next=min->next;
		min->next=ll->next;
		ll->next=min;
		promin=l;
		min=nextmin=l->next;
	}
	l=ll;
}
void Changeready(PCB*&l)
{
	if(l->next!=NULL)
	{
		PCB *first;
		PCB *s;
		first=l->next;
	 	s=first->next;
		if(first->startblock!=-1)	
		first->startblock--;
		first->priority=first->priority-3;
		first->alltime=first->alltime-1;
		first->cputime=first->cputime+1;
		while(s!=NULL)//其余进程优先级数加一 
			{
			 	s->priority=s->priority+1;
			 	s=s->next;
			}
	}
}
void Changeblock(PCB *&b)
{
	if(b->next!=NULL)
	{
		PCB *bn;
		bn=b->next;
		while(bn!=NULL)
		{
			bn->blocktime--;
			bn=bn->next;
		}
	}
}
int Moveready(PCB *&l,PCB *&b)
{
	if(l->next!=NULL)
	{
		PCB *bf;
		if(l->next->alltime==0)
		{
			bf=l->next;
			l->next=l->next->next;
			free(bf);
			return 0;
		}
		if(l->next->startblock!=-1)
		{
			if(l->next->startblock==0)
			{	
				l->next->state=0;
				bf=l->next;
				l->next=bf->next;
				bf->next=b->next;
				b->next=bf;
				bf->startblock=bf->fstartblock;			//头插法插入 
			}
			return 1;
		}
	}
}
void Moveblock(PCB *&l,PCB *&b)
{
	PCB *bn;
	PCB *bp;
	if(b->next!=NULL)
	{
		bn=b->next;
		bp=b;
		while(bn->blocktime==0) 
		{	
			bn->state=1;
			bn->blocktime=bn->fblocktime;
			bp->next=bn->next;
			bn->next=l->next;
			l->next=bn;
			bn=bp->next;
			if(bp->next==NULL)
			break;		
		 } 
		}	
}

void Creatready(PCB *&l,int pc)//创造就绪队列 block
{
	int as[7];//as存储进程的项目 
	int ass;//用于存储数组 
	PCB *s;
	l=(PCB *)malloc(sizeof(PCB));
	l->next=NULL;
	printf("请输入7个特征数后敲回车（录入STATE时:1代表READY，0代表BLOCK）\n");
	for(int i=0;i<pc;i++)
	{
		for(int j=0;j<7;j++)
		{
			scanf("%d",&ass);
			as[j]=ass;
		}
		s=(PCB*)malloc(sizeof(PCB));
		s->id=as[0];
		s->priority=as[1];
		s->cputime=as[2];
		s->alltime=as[3];
		s->startblock=as[4];
		s->fstartblock=as[4];
		s->blocktime=as[5];
		s->fblocktime=as[5];
		s->state=as[6];	
		s->next=l->next;
		l->next=s; 
	}
}

void Printque(PCB *&l,int a)
{
	PCB *s;
	s=l->next;
	if (a==0&&s!=NULL)
		cout<<"->"<<s->id;
	while(s!=NULL&&s->next!=NULL)
	{
		cout<<"->"<<s->next->id;
		s=s->next;
	}
}
void Print(PCB *&l)
{
	PCB *s;
	s=l->next;
	cout<<"ID:        ";
	while(s!=NULL)
	{
		cout<<setw(8)<<s->id<<" ";
		s=s->next;
	}
	s=l->next;
	cout<<"\nPRIORITY:  ";
	while(s!=NULL)
	{
		cout<<setw(8)<<s->priority<<" ";
		s=s->next;
	}	
	s=l->next;
	cout<<"\nCPUTIME:   ";
	while(s!=NULL)
	{
		cout<<setw(8)<<s->cputime<<" ";
		s=s->next;
	}
	s=l->next;
	cout<<"\nALLTIME:   ";
	while(s!=NULL)
	{
		cout<<setw(8)<<s->alltime<<" ";
		s=s->next;
	}
	s=l->next;
	cout<<"\nSTARTBLOCK:";
	while(s!=NULL)
	{
		cout<<setw(8)<<s->startblock<<" ";
		s=s->next;
	}
	s=l->next;
	cout<<"\nBLOCKTIME: ";
	while(s!=NULL)
	{
		cout<<setw(8)<<s->blocktime<<" ";
		s=s->next;
	}
	s=l->next;
	cout<<"\nSTATE:          ";
	while(s!=NULL)
	{
		if(s->state==1) 
		cout<<setw(8)<<"READY ";
		else
		cout<<setw(8)<<"BLOCK ";
		s=s->next;
	}
		cout<<"\n";
}
void Creatblock(PCB *&l,PCB *&b)
{
	b=(PCB*)malloc(sizeof(PCB));
	b->next=NULL;

	PCB *s;
	PCB *pros;
	pros=l;
	s=l->next;
	while(s!=NULL)
	{
		if(s->state==-1)
		{
			pros->next=s->next;
			s->next=b->next;
			b->next=s;
			s=pros->next;
			continue;
		}
		pros=pros->next;
		s=pros->next;	
	}
}
int main()	 
{
	PCB *l;
	PCB *b;
	int pros; 
	cout<<"请输入进程数\n"; 
	cin>>pros;
	Creatready(l,pros);
	cout<<"------------------初始队列如下:\n" ;
		Sort(l);
	Print(l);
	Creatblock(l,b);
	cout<<"<-----------------给computer整点时间片~~----------------->\n";
	int j;
	cin>>j;
	for(int i=0;i<j;i++) 
	{
		if(l->next==NULL&&b->next==NULL)
		{
			cout<<"任务完成，程序歇菜~"; 
			break;
		}
		cout<<"\n=========================在第"<<i+1<<"个时间片内：=========================\nRUNNING PROG:";
		if(l->next!=NULL)
			cout<<l->next->id<<"\n";
		cout<<"\nREADY_QUEUE:";
		Printque(l,1);
		cout<<"\nBLOCK_QUEUE:";
		Printque(b,0);
		Changeready(l);
		Changeblock(b);
		Moveready(l,b);
		Sort(b);
		Moveblock(l,b);
		Sort(l);	
		cout<<"\n-----------------------经过"<<i+1<<"个时间片:\n"	;
		cout<<"-----------------------就绪队列情况如下:\n" ;
		Print(l);
		cout<<"-----------------------阻塞队列情况如下:\n";
		Print(b);
	}
	return 0;
 }

二、算法目的以及功能

        通过C++实现实验要求并可以应对不同的初始插入进程情况进行正确的排序。

 1.输入实验中所要求的进程，查看结果

                 

  2.输入3个进程，查看结果

                       

   3.6个进程

                        

           理论上多少个进程插入都可，但我逝麻了，你们可以多试试。
 

三、算法结构功能介绍

1.主函数不能少(全部代码还得请移步到下面)

代码如下（示例）：

int main()	 
{
	PCB *l;//指向就绪队列
	PCB *b;//指向阻塞队列
	int pros; //记录进程数
    int j;//记录时间片
	cout<<"请输入进程数\n"; 
	cin>>pros;
	Creatready(l,pros);//创建就绪队列
	cout<<"------------------初始队列如下:\n" ;
		Sort(l);//排序函数
	Print(l);//输出就绪队列进程参数
	Creatblock(l,b);//创建阻塞队列
	cout<<"<-----------------给computer整点时间片~~----------------->\n";
	cin>>j;
	for(int i=0;i<j;i++) 
	{
		if(l->next==NULL&&b->next==NULL)
		{
			cout<<"任务完成，程序歇菜~"; 
			break;
		}
		cout<<"\n=========================在第"<<i+1<<"个时间片内：=========================\nRUNNING PROG:";
		if(l->next!=NULL)
			cout<<l->next->id<<"\n";
		cout<<"\nREADY_QUEUE:";
		Printque(l,1);//输出就绪队列
		cout<<"\nBLOCK_QUEUE:";
		Printque(b,0);//输出阻塞队列
		Changeready(l);//时间片后改变就绪队列参数//
		Changeblock(b);//时间片后改变阻塞队列参数//
		Moveready(l,b);//根据改变后的参数将队列的进程进行删除或移动操作
		Sort(b);//对阻塞队列排序
		Moveblock(l,b);//根据改变后的参数将队列的进程进行删除或移动操作
		Sort(l);//在排序便于下个时间片的操作	
		cout<<"\n-----------------------经过"<<i+1<<"个时间片:\n"	;
		cout<<"-----------------------就绪队列情况如下:\n" ;
		Print(l);
		cout<<"-----------------------阻塞队列情况如下:\n";
		Print(b);
	}
	return 0;
 }

2.建立PCB的结构体--存储进程信息

代码如下（示例）：

typedef struct PNode{
    int id;
    int priority;
    int cputime;
    int alltime;
    int startblock;
    int fstartblock;//因为startblock变为0时，变换队列需要重置为初始状态，故设此存储初态。
    int blocktime;
    int fblocktime;//与fstartblock同理，设此存储初始状态。
    int state;//1为就绪，0为阻塞 
    PNode *next; 
}PCB; 



3.创建就绪与阻塞队列

代码如下（示例）：

void Creatready(PCB *&l,int pc)//创造就绪队列 block
{
	int as[7];//as存储进程的项目 
	int ass;//用于存储数组 
	PCB *s;
	l=(PCB *)malloc(sizeof(PCB));
	l->next=NULL;
	printf("请输入7个特征数后敲回车（录入STATE时:1代表READY，0代表BLOCK）\n");
	for(int i=0;i<pc;i++)
	{
		for(int j=0;j<7;j++)
		{
			scanf("%d",&ass);
			as[j]=ass;
		}
		s=(PCB*)malloc(sizeof(PCB));
		s->id=as[0];
		s->priority=as[1];
		s->cputime=as[2];
		s->alltime=as[3];
		s->startblock=as[4];
		s->fstartblock=as[4];
		s->blocktime=as[5];
		s->fblocktime=as[5];
		s->state=as[6];	
		s->next=l->next;
		l->next=s; 
	}
}
void Creatblock(PCB *&l,PCB *&b)//创建block队列
{
	b=(PCB*)malloc(sizeof(PCB));
	b->next=NULL;

	PCB *s;
	PCB *pros;
	pros=l;
	s=l->next;
	while(s!=NULL)
	{
		if(s->state==-1)//如果录入的进程为-1则进入阻塞队列
		{
			pros->next=s->next;
			s->next=b->next;
			b->next=s;
			s=pros->next;
			continue;
		}
		pros=pros->next;
		s=pros->next;	
	}
}

4.参数改变函数--用于时间片后进程参数的改变

代码如下（示例）

void Changeready(PCB*&l)
{
	if(l->next!=NULL)
	{
		PCB *first;
		PCB *s;
		first=l->next;
	 	s=first->next;
		if(first->startblock!=-1)	
		first->startblock--;
		first->priority=first->priority-3;
		first->alltime=first->alltime-1;
		first->cputime=first->cputime+1;
		while(s!=NULL)//其余进程优先级数加一 
			{
			 	s->priority=s->priority+1;
			 	s=s->next;
			}
	}
}
void Changeblock(PCB *&b)
{
	if(b->next!=NULL)
	{
		PCB *bn;
		bn=b->next;
		while(bn!=NULL)
		{
			bn->blocktime--;
			bn=bn->next;
		}
	}
}

5.移动函数--根据进程参数对进程进行删除或移动

代码如下（示例）

int Moveready(PCB *&l,PCB *&b)//将就绪队列中满足条件的移入阻塞队列
{
	if(l->next!=NULL)
	{
		PCB *bf;
		if(l->next->alltime==0)
		{
			bf=l->next;
			l->next=l->next->next;
			free(bf);
			return 0;
		}
		if(l->next->startblock!=-1)
		{
			if(l->next->startblock==0)
			{	
				l->next->state=0;
				bf=l->next;
				l->next=bf->next;
				bf->next=b->next;
				b->next=bf;
				bf->startblock=bf->fstartblock;			//头插法插入 
			}
			return 1;
		}
	}
}
void Moveblock(PCB *&l,PCB *&b)//将阻塞队列中满足条件的移入就绪队列
{
	PCB *bn;
	PCB *bp;
	if(b->next!=NULL)
	{
		bn=b->next;
		bp=b;
		while(bn->blocktime==0) 
		{	
			bn->state=1;
			bn->blocktime=bn->fblocktime;
			bp->next=bn->next;
			bn->next=l->next;
			l->next=bn;
			bn=bp->next;
			if(bp->next==NULL)
			break;		
		 } 
		}	
}

6.排序函数-可将就绪队列按优先级降序排列，阻塞队列按BLOCK升序排列

代码如下（示例）

void Sort(PCB *&l)//本算法将依次找到值最小的节点并将此节点赋予新的链表
{
	PCB *ll;
	PCB *promin;
	PCB *min;
	PCB *nextmin;
	ll=(PCB *)malloc(sizeof(PCB));
	ll->next=NULL;
	promin=l;
	min=nextmin=l->next;
	while(l->next!=NULL)
	{
		if(l->next->state==1) //state==1则按照PRIORITY将就绪队列排序
		{
			while(nextmin!=NULL)
			{
			if(nextmin->priority<min->priority)
			{
				min=nextmin;
			}
			nextmin=nextmin->next;
			}
		}
		else
		{
			while(nextmin!=NULL)//否则按照blocktime将阻塞队列排序
			{
			if(nextmin->blocktime>min->blocktime)
			{
				min=nextmin;
			}
			nextmin=nextmin->next;
			}
		}
		while(promin->next!=min)
		{
			promin=promin->next;
		}
		promin->next=min->next;
		min->next=ll->next;
		ll->next=min;
		promin=l;
		min=nextmin=l->next;
	}
	l=ll;
}

7.输出函数1--将队列中进程PCB中信息输出(我图省事没多想就把这段打码写的很啰嗦，老铁们看看图个乐就中)

输出效果:

​

代码如下

void Print(PCB *&l)//print函数就是无脑重复的，大家看看图个乐就彳亍了
{
	PCB *s;
	s=l->next;
	cout<<"ID:        ";
	while(s!=NULL)
	{
		cout<<setw(8)<<s->id<<" ";
		s=s->next;
	}
	s=l->next;
	cout<<"\nPRIORITY:  ";
	while(s!=NULL)
	{
		cout<<setw(8)<<s->priority<<" ";
		s=s->next;
	}	
	s=l->next;
	cout<<"\nCPUTIME:   ";
	while(s!=NULL)
	{
		cout<<setw(8)<<s->cputime<<" ";
		s=s->next;
	}
	s=l->next;
	cout<<"\nALLTIME:   ";
	while(s!=NULL)
	{
		cout<<setw(8)<<s->alltime<<" ";
		s=s->next;
	}
	s=l->next;
	cout<<"\nSTARTBLOCK:";
	while(s!=NULL)
	{
		cout<<setw(8)<<s->startblock<<" ";
		s=s->next;
	}
	s=l->next;
	cout<<"\nBLOCKTIME: ";
	while(s!=NULL)
	{
		cout<<setw(8)<<s->blocktime<<" ";
		s=s->next;
	}
	s=l->next;
	cout<<"\nSTATE:          ";
	while(s!=NULL)
	{
		if(s->state==1) 
		cout<<setw(8)<<"READY ";
		else
		cout<<setw(8)<<"BLOCK ";
		s=s->next;
	}
		cout<<"\n";
}

8.输出函数2--负责输出队列内容

输出效果:

​

 代码如下：

void Printque(PCB *&l,int a)
{
	PCB *s;
	s=l->next;
	if (a==0&&s!=NULL)//a==0则按照阻塞队列输出
		cout<<"->"<<s->id;
	while(s!=NULL&&s->next!=NULL)
	{
		cout<<"->"<<s->next->id;
		s=s->next;
	}
}

9.全部代码如下

#include"stdio.h"
#include"iostream"
#include"cstdio"
#include"iomanip"
#include"malloc.h"
#include"conio.h"
using namespace std;
typedef struct PNode{
	int id;
	int priority;
	int cputime;
	int alltime;
	int startblock;
	int fstartblock; 
	int blocktime;
	int fblocktime;
	int state;//1为就绪，0为阻塞 
	PNode *next; 
}PCB; 
void Sort(PCB *&l)
{
	PCB *ll;
	PCB *promin;
	PCB *min;
	PCB *nextmin;
	ll=(PCB *)malloc(sizeof(PCB));
	ll->next=NULL;
	promin=l;
	min=nextmin=l->next;
	while(l->next!=NULL)
	{
		if(l->next->state==1) 
		{
			while(nextmin!=NULL)
			{
			if(nextmin->priority<min->priority)
			{
				min=nextmin;
			}
			nextmin=nextmin->next;
			}
		}
		else
		{
			while(nextmin!=NULL)
			{
			if(nextmin->blocktime>min->blocktime)
			{
				min=nextmin;
			}
			nextmin=nextmin->next;
			}
		}
		while(promin->next!=min)
		{
			promin=promin->next;
		}
		promin->next=min->next;
		min->next=ll->next;
		ll->next=min;
		promin=l;
		min=nextmin=l->next;
	}
	l=ll;
}
void Changeready(PCB*&l)
{
	if(l->next!=NULL)
	{
		PCB *first;
		PCB *s;
		first=l->next;
	 	s=first->next;
		if(first->startblock!=-1)	
		first->startblock--;
		first->priority=first->priority-3;
		first->alltime=first->alltime-1;
		first->cputime=first->cputime+1;
		while(s!=NULL)//其余进程优先级数加一 
			{
			 	s->priority=s->priority+1;
			 	s=s->next;
			}
	}
}
void Changeblock(PCB *&b)
{
	if(b->next!=NULL)
	{
		PCB *bn;
		bn=b->next;
		while(bn!=NULL)
		{
			bn->blocktime--;
			bn=bn->next;
		}
	}
}
int Moveready(PCB *&l,PCB *&b)
{
	if(l->next!=NULL)
	{
		PCB *bf;
		if(l->next->alltime==0)
		{
			bf=l->next;
			l->next=l->next->next;
			free(bf);
			return 0;
		}
		if(l->next->startblock!=-1)
		{
			if(l->next->startblock==0)
			{	
				l->next->state=0;
				bf=l->next;
				l->next=bf->next;
				bf->next=b->next;
				b->next=bf;
				bf->startblock=bf->fstartblock;			//头插法插入 
			}
			return 1;
		}
	}
}
void Moveblock(PCB *&l,PCB *&b)
{
	PCB *bn;
	PCB *bp;
	if(b->next!=NULL)
	{
		bn=b->next;
		bp=b;
		while(bn->blocktime==0) 
		{	
			bn->state=1;
			bn->blocktime=bn->fblocktime;
			bp->next=bn->next;
			bn->next=l->next;
			l->next=bn;
			bn=bp->next;
			if(bp->next==NULL)
			break;		
		 } 
		}	
}

void Creatready(PCB *&l,int pc)//创造就绪队列 block
{
	int as[7];//as存储进程的项目 
	int ass;//用于存储数组 
	PCB *s;
	l=(PCB *)malloc(sizeof(PCB));
	l->next=NULL;
	printf("请输入7个特征数后敲回车（录入STATE时:1代表READY，0代表BLOCK）\n");
	for(int i=0;i<pc;i++)
	{
		for(int j=0;j<7;j++)
		{
			scanf("%d",&ass);
			as[j]=ass;
		}
		s=(PCB*)malloc(sizeof(PCB));
		s->id=as[0];
		s->priority=as[1];
		s->cputime=as[2];
		s->alltime=as[3];
		s->startblock=as[4];
		s->fstartblock=as[4];
		s->blocktime=as[5];
		s->fblocktime=as[5];
		s->state=as[6];	
		s->next=l->next;
		l->next=s; 
	}
}

void Printque(PCB *&l,int a)
{
	PCB *s;
	s=l->next;
	if (a==0&&s!=NULL)
		cout<<"->"<<s->id;
	while(s!=NULL&&s->next!=NULL)
	{
		cout<<"->"<<s->next->id;
		s=s->next;
	}
}
void Print(PCB *&l)
{
	PCB *s;
	s=l->next;
	cout<<"ID:        ";
	while(s!=NULL)
	{
		cout<<setw(8)<<s->id<<" ";
		s=s->next;
	}
	s=l->next;
	cout<<"\nPRIORITY:  ";
	while(s!=NULL)
	{
		cout<<setw(8)<<s->priority<<" ";
		s=s->next;
	}	
	s=l->next;
	cout<<"\nCPUTIME:   ";
	while(s!=NULL)
	{
		cout<<setw(8)<<s->cputime<<" ";
		s=s->next;
	}
	s=l->next;
	cout<<"\nALLTIME:   ";
	while(s!=NULL)
	{
		cout<<setw(8)<<s->alltime<<" ";
		s=s->next;
	}
	s=l->next;
	cout<<"\nSTARTBLOCK:";
	while(s!=NULL)
	{
		cout<<setw(8)<<s->startblock<<" ";
		s=s->next;
	}
	s=l->next;
	cout<<"\nBLOCKTIME: ";
	while(s!=NULL)
	{
		cout<<setw(8)<<s->blocktime<<" ";
		s=s->next;
	}
	s=l->next;
	cout<<"\nSTATE:          ";
	while(s!=NULL)
	{
		if(s->state==1) 
		cout<<setw(8)<<"READY ";
		else
		cout<<setw(8)<<"BLOCK ";
		s=s->next;
	}
		cout<<"\n";
}
void Creatblock(PCB *&l,PCB *&b)
{
	b=(PCB*)malloc(sizeof(PCB));
	b->next=NULL;

	PCB *s;
	PCB *pros;
	pros=l;
	s=l->next;
	while(s!=NULL)
	{
		if(s->state==-1)
		{
			pros->next=s->next;
			s->next=b->next;
			b->next=s;
			s=pros->next;
			continue;
		}
		pros=pros->next;
		s=pros->next;	
	}
}
int main()	 
{
	PCB *l;
	PCB *b;
	int pros; 
	cout<<"请输入进程数\n"; 
	cin>>pros;
	Creatready(l,pros);
	cout<<"------------------初始队列如下:\n" ;
		Sort(l);
	Print(l);
	Creatblock(l,b);
	cout<<"<-----------------给computer整点时间片~~----------------->\n";
	int j;
	cin>>j;
	for(int i=0;i<j;i++) 
	{
		if(l->next==NULL&&b->next==NULL)
		{
			cout<<"任务完成，程序歇菜~"; 
			break;
		}
		cout<<"\n=========================在第"<<i+1<<"个时间片内：=========================\nRUNNING PROG:";
		if(l->next!=NULL)
			cout<<l->next->id<<"\n";
		cout<<"\nREADY_QUEUE:";
		Printque(l,1);
		cout<<"\nBLOCK_QUEUE:";
		Printque(b,0);
		Changeready(l);
		Changeblock(b);
		Moveready(l,b);
		Sort(b);
		Moveblock(l,b);
		Sort(l);	
		cout<<"\n-----------------------经过"<<i+1<<"个时间片:\n"	;
		cout<<"-----------------------就绪队列情况如下:\n" ;
		Print(l);
		cout<<"-----------------------阻塞队列情况如下:\n";
		Print(b);
	}
	return 0;
 }


三.运行结果

 1.输入实验所要求的进程(5个进程，图片太长只截取部分图片)

                ​

2.输入3个进程，其中有一个进程一开始便要求阻塞

 

​

 3.输入多个进程(其实想输入多少就输入多少，图太长了，我就只输入6个，你们慢慢试8)

 

三、总结

       总结就是敲代码和写文章都会让人变得想睡觉。

        代码用的算法比较简单所以看起来比较繁琐，在座的各位发现有什么错误或者待优化的直接留言就好啦。

四、补充的实验大图

1.5个进程图实验完整图(其他的几种输出情况类似，这里不一一列举)

 

 

 

 

 

mazeltov.
关注
  • 33
    点赞
  • 踩
  • 172
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值