多级反馈队列FCFS

最新推荐文章于 2022-11-04 15:07:44 发布
最新推荐文章于 2022-11-04 15:07:44 发布
阅读量173 收藏 3
点赞数
分类专栏： 操作系统 C/C++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44735475/article/details/125822270
版权

c语言

多级反馈队列FCFS(周转时间的计算方法可能是错误的)在这里插入图片描述

代码1

#define  _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<time.h>

#include<Windows.h>

//作业结构体
typedef struct PCB
{
	//int Numbers;					//进程个数
	char name;						//进程名
	//int ID;							//进程号
	int ComeTime;					//到达时间
	int ServerTime;					//服务时间
	int FinishTime;					//完成时间
	int NeedTime;					// 需要时间
	int TurnoverTime;				//周转时间
	double WeightedTurnoverTime;	//带权周转时间
	char state;		/*进程的状态，W——就绪态，R——执行态，F——完成态*/
	int round; // 分配给进程的时间片
	int count; // 计数器
	struct PCB* next;
}PCB;

typedef struct Queue/*多级就绪队列节点信息*/
{
	PCB* LinkPCB;/*就绪队列中的进程队列指针*/
	int prio;/*本就绪队列的优先级*/
	int round; /*本就绪队列所分配的时间片*/
	struct Queue* next;/*指向下一个就绪队列的链表指针*/
}ReadyQueue;

int cometime;
int ProcessNum = 1; // 进程个数
int  timeslice =2;		//当前时间片
PCB* run = NULL, * finish = NULL;/*定义三个队列，就绪队列，执行队列和完成队列*/
int TimNum=0;				//时间统计
int ReadyNum = 3;		//队列个数
char name = 'A';		//进程名字

ReadyQueue* Head = NULL; // 定义多级就绪队列的头指针


//void Output();		/*进程信息输出函数*/
void endOutput();
void InsertFinish(PCB* in);		/*将进程插入到完成队列尾部*/
void PrioCreate();				/*创建就绪队列函数*/
void GetFirst(ReadyQueue* queue); //取得某一个就绪队列中的队头进程
void InsertLast(PCB* in, ReadyQueue* queue);//将进程插入到就绪队列末尾
void InsertFinal(PCB* pcb);/*将进程插入到完成队列尾部*/
void ProcessCreate();//进程创建函数
void RoundRun(ReadyQueue* timechip);//时间片轮转调度算法
void MultiDispatch();//多级调度算法，每次执行一个时间片
void SortQueue(ReadyQueue* que);  // 队列排序
void InsertPrio(ReadyQueue* in);
void InsertReady(PCB* pcb, ReadyQueue* queue);
void sortPCB(PCB* T);//进程排序
int main(void)
{
	PrioCreate();//创建就绪队列
	ProcessCreate();//创建就绪进程队列
	MultiDispatch();//算法开始
	//Output();//输出最终的调度序列
	endOutput();
	return 0;
}



void MultiDispatch()//多级调度算法，每次执行一个时间片
{
	//char choice;
	ReadyQueue* q;

 	q = Head;
	printf("正在进行排序\n");
	sortPCB(Head->LinkPCB);
	printf("排序完成\n");
	//char* tempName;
	int flag=1;
	printf("取队列头元素\n");
	GetFirst(q);  // 取就绪队列的第一个进程，开始算法
	//int begintime = run->ComeTime;
	while (run != NULL) // 循环执行，执行队列中的进程
	{
		if (Head->LinkPCB != NULL)
			q = Head;
		while (flag)
		{
			run->count++;// 进程的执行次数加1
			run->ServerTime++;// 进程的服务时间加1
			run->NeedTime--;// 进程的需要时间减1
			TimNum++;
			if (run->NeedTime == 0)// 进程执行完毕
			{
				run->FinishTime = TimNum ;		//完成时间
				run->TurnoverTime = run->FinishTime - run->ComeTime;//周转时间
				run->WeightedTurnoverTime = run->TurnoverTime / run->ServerTime;//带权周转时间
				run->state = 'F';
				InsertFinish(run);// 把该进程插入到完成队列中
				flag = 0;
			}
			else if (run->count == run->round)
			{
				run->state = 'w';
				run->count = 0;
				if (q->next != NULL)
				{
					run->round = q->next->round;
					InsertLast(run, q->next);
					flag = 0;
				}
				else
				{
					RoundRun(q);
				}
			}
			
		}
		flag = 1;

		if (q->LinkPCB == NULL)/*就绪队列指针下移*/
			q = q->next;
		if (q->next == NULL)
		{
			RoundRun(q);
			break;
		}
		GetFirst(q);

	}
}





void GetFirst(ReadyQueue* queue)
{
	if (queue->LinkPCB != NULL) // 队列中的进程不为空
	{
		run = queue->LinkPCB;
		run->state = 'R';
		queue->LinkPCB = queue->LinkPCB->next; // 队列指向进程的指针后移
		run->next = NULL;
	}
	else
	{
		run = NULL;
	}
}



void PrioCreate()/*创建就绪队列输入函数*/
{
	ReadyQueue* tmp;
	int i;
	printf("输入就绪队列的个数,最多输入3个:\n");
	scanf("%d", &ReadyNum);

	//printf("输入每个就绪队列的CPU时间片;\n");
	//创建3个就绪队列
	for (i = 0; i < ReadyNum; i++)
	{
		int times = timeslice * pow(2, i);
		if ((tmp = (ReadyQueue*)malloc(sizeof(ReadyQueue))) == NULL)
		{
			perror("malloc");
			exit(1);
		}

		//scanf("%d", &(tmp->round)); //输入此就绪队列中给每个进程所分配的CPU时间片* /
		tmp->round = times;
		tmp->prio = times;/*设置其优先级，时间片越高，其优先级越低*/
		tmp->LinkPCB = NULL; /*初始化其连接的进程队列为空*/

		tmp->next = NULL;
		InsertPrio(tmp);
	}
}


void ProcessCreate()/*进程创建函数*/
{
	
	time_t ts;//设置时间变量
	PCB* tmp;
	int i;
	int Pronum;
	printf("输入进程的个数:\n");
	scanf("%d", &Pronum);
	getchar();
	cometime = 0;	//将第一个进程到达的时间设为0
	//printf("输入进程名字和进程所需要时间\n");
	printf("等待%d秒钟，正在生成随机数", Pronum);
	for (i = 0; i < Pronum; i++)
	{
		Sleep(1000);
		//随机函数
		srand((unsigned)time(NULL));
		
		int num1 = rand() % 5+1 ;	//到达时间
		int num2 = rand() %9 + 1;		//服务时间

		

		if ((tmp = (PCB*)malloc(sizeof(PCB))) == NULL)
		{
			perror("malloc");
			exit(1);
		}
		
		tmp->name = name;
		name = name + 1;		//字符+1，自动更改进程名字
		tmp->ComeTime= cometime;
		cometime = num1;	//为下一个进程设定到达时间
	
		tmp->ServerTime = 0;
		tmp->NeedTime= num2;
		tmp->state = 'W';
		//tmp->. = 50 - tmp->needtime; /*设置其优先级，需要的时间越多，优先级越低*/

		tmp->round = Head->round;
		tmp->count = 0;
		InsertLast(tmp, Head);/*按照先来先服务*/
	}
}

void InsertPrio(ReadyQueue* in)
{
	ReadyQueue* fst, * nxt;
	fst = nxt = Head;
	if (Head == NULL)
	{
		in->next = Head;
		Head = in;
	}
	else
	{
		if (in->prio <= fst->prio)
		{
			in->next = Head;
			Head = 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 InsertReady(PCB* pcb, ReadyQueue* queue)
{
	PCB* p;
	pcb->state = 'W';
	pcb->round = queue->round;
	p = queue->LinkPCB;

	if (queue->LinkPCB == NULL) // 队列中进程为空，直接插入到队列中
	{
		pcb->next = queue->LinkPCB;
		queue->LinkPCB = pcb;
	}
	else
	{
		while (p->next != NULL) // 搜索到队列中进程的尾部，将其插入到尾部
		{
			p = p->next;
		}
		pcb->next = p->next;
		p->next = pcb;
	}
}


void InsertFinal(PCB* pcb) // 将进程插入到完成队列尾部
{
	PCB* p;
	pcb->state = 'F';
	p = finish;
	if (finish == NULL)  // 完成队列为空，直接插入
	{
		pcb->next = NULL;
		finish = pcb;
	}
	else
	{
		while (p->next != NULL)
		{
			p = p->next;
		}
		pcb->next = p->next;
		p->next = pcb;
	}
}

void InsertLast(PCB* in, ReadyQueue* queue) /*将进程插入到就绪队列尾部*/
{
	PCB* fst;
	fst = queue->LinkPCB;

	if (queue->LinkPCB == NULL)
	{
		in->next = queue->LinkPCB;
		queue->LinkPCB = 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;
		fst->next = in;
	}
}


void RoundRun(ReadyQueue* timechip)
{
	int flag = 1;
	GetFirst(timechip);
	while (run != NULL)
	{
		while (flag)
		{
			run->count++;
			//run->cputime++;
			run->ServerTime++;

			run->NeedTime--;
			
			TimNum++;
			if (run->NeedTime == 0)
			{
				run->FinishTime = TimNum;		//完成时间
				run->TurnoverTime = run->FinishTime - run->ComeTime;//周转时间
				run->WeightedTurnoverTime = run->TurnoverTime / run->ServerTime;//带权周转时间
				run->state = 'F';
				InsertFinish(run);
				flag = 0;
			}
			else if (run->count == timechip->round)
			{
				run->state = 'W';
				run->count = 0;
				InsertLast(run, timechip);

				flag = 0;

				break;
			}
		}

		flag = 1;
		if (timechip->LinkPCB != NULL) // 就绪队列中的进程不为空
		{
			GetFirst(timechip);
			//Output();
		}
		else
		{

			//printf("查看当前全部进程的状态：\n");
			//printf("多级反馈队列调度算法模拟结束，所有进程执行完毕\n");
			endOutput();
			// printf("多级反馈队列调度算法模拟结束，所有进程执行完毕！\n");
			break;
		}
		

	}
}



void endOutput()
{
	PCB* p;
	printf("进程名\t到达时间\t已服务时间\t完成时间\t周转时间\t带权周转时间\n");

	p = finish;

	while (p != NULL)
	{
		/*p->TurnoverTime = p->FinishTime - p->ComeTime;
		p->WeightedTurnoverTime = p->TurnoverTime / p->ServerTime;*/

		printf("%c\t %d\t\t%d\t\t%d\t\t %d\t\t%.2f\n", p->name, p->ComeTime, p->ServerTime, p->FinishTime, p->TurnoverTime, p->WeightedTurnoverTime);


			p = p->next;
	}

}

void SortQueue(ReadyQueue* queue)
{

	ReadyQueue* m, * n;
	m = n = Head;
	if (Head == NULL)
	{
		queue->next = NULL;
		Head = queue;
	}
	else
	{
		if (queue->prio <= m->prio)
		{
			queue->next = m;
			Head = queue;
		}
		else
		{
			while (m->next != NULL)
			{
				n = m;
				m = m->next;
			}

			if (m->next == NULL)
			{
				queue->next = m->next;
				m->next = queue;
			}
			else
			{
				n->next = queue;
				queue->next = m;
			}
		}
	}
}

void sortPCB(PCB* T)
{

	PCB* X = (PCB*)malloc(sizeof(PCB));//用来保存排序后的链表
	PCB* p = (PCB*)malloc(sizeof(PCB));//用来保存当此最小值的前一位
	PCB* Current = T->next;
	PCB* PreCurrent = T;
	PCB* TailX = X;
	*X = *T;
	while (T->next != NULL) {
		int tem = 999998;

		Current = T->next;
		PreCurrent = T;
		while (Current != NULL) {
			if (Current->ComeTime<= tem) {
				tem = Current->ComeTime;

				p = PreCurrent;
				//cout << "处理" << p->name << p->need << "\n";
			}
			Current = Current->next;
			PreCurrent = PreCurrent->next;
		}


		TailX->next = p->next;
		TailX = TailX->next;

		if (p->next->next != NULL)
			p->next = p->next->next;
		else
			p->next = NULL;
	}
	*T = *X;
}

代码2

#define  _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<time.h>



//作业结构体
typedef struct PCB
{
	int Numbers;					//进程个数
	char name;						//进程名
	//int ID;							//进程号
	int ComeTime;					//到达时间
	int ServerTime;					//服务时间
	int FinishTime;					//完成时间
	int NeedTime;					// 需要时间
	int TurnoverTime;				//周转时间
	double WeightedTurnoverTime;	//带权周转时间
	char state;		/*进程的状态，W——就绪态，R——执行态，F——完成态*/
	int round; // 分配给进程的时间片
	int count; // 计数器
	struct PCB* next;
}PCB;

typedef struct Queue/*多级就绪队列节点信息*/
{
	PCB* LinkPCB;/*就绪队列中的进程队列指针*/
	int prio;/*本就绪队列的优先级*/
	int round; /*本就绪队列所分配的时间片*/
	struct Queue* next;/*指向下一个就绪队列的链表指针*/
}ReadyQueue;

int cometime;
int ProcessNum = 1; // 进程个数
int  timeslice =1;		//当前时间片
PCB* run = NULL, * finish = NULL;/*定义三个队列，就绪队列，执行队列和完成队列*/
int TimNum=0;				//时间统计
int ReadyNum = 3;		//队列个数
char name = 'A';		//进程名字

ReadyQueue* Head = NULL; // 定义多级就绪队列的头指针


void Output();		/*进程信息输出函数*/
void endOutput();
void InsertFinish(PCB* in);		/*将进程插入到完成队列尾部*/
void PrioCreate();				/*创建就绪队列输入函数*/
void GetFirst(ReadyQueue* queue); //取得某一个就绪队列中的队头进程
void InsertLast(PCB* in, ReadyQueue* queue);//将进程插入到就绪队列末尾
void InsertFinal(PCB* pcb);/*将进程插入到完成队列尾部*/
void ProcessCreate();//进程创建函数
void RoundRun(ReadyQueue* timechip);//时间片轮转调度算法
void MultiDispatch();//多级调度算法，每次执行一个时间片
void SortQueue(ReadyQueue* que);  // 队列排序
void InsertPrio(ReadyQueue* in);
void InsertReady(PCB* pcb, ReadyQueue* queue);

int main(void)
{
	PrioCreate();//创建就绪队列
	ProcessCreate();//创建就绪进程队列
	MultiDispatch();//算法开始
	//Output();//输出最终的调度序列
	endOutput();
	return 0;
}



void MultiDispatch()//多级调度算法，每次执行一个时间片
{
	//char choice;
	ReadyQueue* q;
 	q = Head;
	//char* tempName;
	int flag=1;

	GetFirst(q);  // 取就绪队列的第一个进程，开始算法
	//int begintime = run->ComeTime;
	while (run != NULL) // 循环执行，执行队列中的进程
	{
		if (Head->LinkPCB != NULL)
			q = Head;
		while (flag)
		{
			run->count++;// 进程的执行次数加1
			run->ServerTime++;// 进程的服务时间加1
			run->NeedTime--;// 进程的需要时间减1
			TimNum++;
			if (run->NeedTime == 0)// 进程执行完毕
			{
				run->FinishTime = TimNum ;		//完成时间
				run->TurnoverTime = run->FinishTime - run->ComeTime;//周转时间
				run->WeightedTurnoverTime = run->TurnoverTime / run->ServerTime;//带权周转时间
				run->state = 'F';
				InsertFinish(run);// 把该进程插入到完成队列中
				flag = 0;
			}
			else if (run->count == run->round)
			{
				run->state = 'w';
				run->count = 0;
				if (q->next != NULL)
				{
					run->round = q->next->round;
					InsertLast(run, q->next);
					flag = 0;
				}
				else
				{
					RoundRun(q);
				}
			}
			
		}
		flag = 1;

		if (q->LinkPCB == NULL)/*就绪队列指针下移*/
			q = q->next;
		if (q->next == NULL)
		{
			RoundRun(q);
			break;
		}
		GetFirst(q);

	}
}
		//while (1) 
		//{
		//	//cout << "当前时间片：" << ++timeslice << endl;
		//	//outFile << "当前时间" << timeSlice << "：" << "第" << q->level << "队列的进程" << run->name << "正在执行" << endl;
		//	run->ServerTime++;  // 进程的服务时间加1
		//	run->ServerTime--;  // 进程的需要时间减1
		//	run->count++; // 进程的执行次数加1
		//	if (run->ServerTime == 0) // 进程执行完毕
		//	{
		//		InsertFinal(run); // 把该进程插入到完成队列中
		//		tempName = run->name;
		//		run->FinishTime =timeslice;
		//		run = NULL;  // 执行队列设为空
		//		Output();
		//		//cout << tempName << "进程已完成，插入到完成队列中" << endl << endl;
		//		//outFile << "当前时间" << timeSlice << "：" << "进程" << tempName << "执行完毕，插入完成队列中" << endl;
		//		break; // 跳出循环
		//
		//	}
		//	else if(run)
		//	{ 
		//		//Output();
		//		//if (run->count == run->round) // 时间片用完
		//		//{
		//		//	run->count = 0; // 进程的执行次数归零
		//		//	if (q->next != NULL) // 还有下一个队列
		//		//	{
		//		//		InsertReady(run, q->next); // 将进程插入到下一个就绪队列中
		//		//		//cout << "进程：" << run->name << "在第" << q->level << "队列内未完成，插入第" << q->level + 1 << "队列中" << endl;
		//		//	//	outFile << "当前时间" << timeSlice << "：" << "进程" << run->name << "在第" << q->level << "队列内未完成，插入第" << q->next->level << "队列" << endl;
		//		//		break;
		//		/*	}*/
		//		/*}*/
		//	}
		//}

		 插入新进程
		cout << "是否有新进程到达，请选择（Y/N）：" << endl;
		cin >> choice;
		//if (choice == 'y' || choice == 'Y') // 有新进程到达
		//{
		//	CreateProcess();  // 创建新进程
		//	q = Head;  // 指向就绪队列
		//	GetFirst(q);  // 取首进程
		//}
		//else
		//{
		//	cout << "没有新进程到达" << endl << endl;
		//	if (q->LinkPCB == NULL) // 队列中的进程为空，指向队列的指针后移
		//	{
		//		q = q->next;
		//	}
		//	if (q->next == NULL) // 后继队列为空，说明当前是最后一个队列
		//	{
		//		cout << "执行到最后一个队列，使用时间片轮转算法" << endl;
		//		outFile << "当前时间" << timeSlice << "：" << "执行到最后一个队列，使用时间片轮转算法" << endl;
		//		RR(q);
		//		break;
		//	}
			//GetFirst(q);
		//}
	//}






void GetFirst(ReadyQueue* queue)
{
	if (queue->LinkPCB != NULL) // 队列中的进程不为空
	{
		run = queue->LinkPCB;
		run->state = 'R';
		queue->LinkPCB = queue->LinkPCB->next; // 队列指向进程的指针后移
		run->next = NULL;
	}
	else
	{
		run = NULL;
	}
}



void PrioCreate()/*创建就绪队列输入函数*/
{
	ReadyQueue* tmp;
	int i;
	/*printf("输入就绪队列的个数:\n");
	scanf("%d", &ReadyNum);*/

	//printf("输入每个就绪队列的CPU时间片;\n");
	//创建3个就绪队列
	for (i = 0; i < ReadyNum; i++)
	{
		int times = timeslice * pow(2, i);
		if ((tmp = (ReadyQueue*)malloc(sizeof(ReadyQueue))) == NULL)
		{
			perror("malloc");
			exit(1);
		}

		//scanf("%d", &(tmp->round)); //输入此就绪队列中给每个进程所分配的CPU时间片* /
		tmp->round = times;
		tmp->prio = times;/*设置其优先级，时间片越高，其优先级越低*/
		tmp->LinkPCB = NULL; /*初始化其连接的进程队列为空*/

		tmp->next = NULL;
		InsertPrio(tmp);
	}
}


void ProcessCreate()/*进程创建函数*/
{
	//随机函数
	srand(time(NULL));

	PCB* tmp;
	int i;
	int num;
	printf("输入进程的个数:\n");
	scanf("%d", &num);
	getchar();
	cometime = 0;	//将第一个进程到达的时间设为0
	//printf("输入进程名字和进程所需要时间\n");
	for (i = 0; i < num; i++)
	{
		//随机函数
		//srand(time(NULL));
		//
		//int num1 = rand() % 3+1 ;	//到达时间
		//int num2 = rand() % 5 + 1;		//服务时间

		/*scanf("%s", tmp->name);
		getchar();*/

		//strcpy(tmp->name ,(char *) ('A' + i));

		if ((tmp = (PCB*)malloc(sizeof(PCB))) == NULL)
		{
			perror("malloc");
			exit(1);
		}
		printf("输入进程到达时间和进程所需要时间\n");

		scanf("%d%d", &tmp->ComeTime,&tmp->NeedTime);
		tmp->name = name;
		name = name + 1;		//字符+1，自动更改进程名字
		//tmp->ComeTime= cometime;
		//cometime = num1;	//为下一个进程设定到达时间
		//cometime = num1;
		tmp->ServerTime = 0;
		//tmp->NeedTime= num2;
		tmp->state = 'W';
		//tmp->. = 50 - tmp->needtime; /*设置其优先级，需要的时间越多，优先级越低*/

		tmp->round = Head->round;
		tmp->count = 0;
		InsertLast(tmp, Head);/*按照先来先服务*/
	}
}

void InsertPrio(ReadyQueue* in)
{
	ReadyQueue* fst, * nxt;
	fst = nxt = Head;
	if (Head == NULL)
	{
		in->next = Head;
		Head = in;
	}
	else
	{
		if (in->prio <= fst->prio)
		{
			in->next = Head;
			Head = 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 InsertReady(PCB* pcb, ReadyQueue* queue)
{
	PCB* p;
	pcb->state = 'W';
	pcb->round = queue->round;
	p = queue->LinkPCB;

	if (queue->LinkPCB == NULL) // 队列中进程为空，直接插入到队列中
	{
		pcb->next = queue->LinkPCB;
		queue->LinkPCB = pcb;
	}
	else
	{
		while (p->next != NULL) // 搜索到队列中进程的尾部，将其插入到尾部
		{
			p = p->next;
		}
		pcb->next = p->next;
		p->next = pcb;
	}
}


//void InsertPrio(ReadyQueue* in)
//{
//	ReadyQueue* fst, * nxt;
//	fst = nxt = Head;
//	if (Head == NULL)
//	{
//		in->next = Head;
//		Head = in;
//	}
//	else
//	{
//	
//			while (fst->next != NULL)
//			{
//				nxt = fst;
//				fst = fst->next;
//			}
//
//			if (fst->next == NULL)
//			{
//				in->next = fst->next;
//				fst->next = in;
//			}
//	
//		}
//	}
//}


void InsertFinal(PCB* pcb) // 将进程插入到完成队列尾部
{
	PCB* p;
	pcb->state = 'F';
	p = finish;
	if (finish == NULL)  // 完成队列为空，直接插入
	{
		pcb->next = NULL;
		finish = pcb;
	}
	else
	{
		while (p->next != NULL)
		{
			p = p->next;
		}
		pcb->next = p->next;
		p->next = pcb;
	}
}

void InsertLast(PCB* in, ReadyQueue* queue) /*将进程插入到就绪队列尾部*/
{
	PCB* fst;
	fst = queue->LinkPCB;

	if (queue->LinkPCB == NULL)
	{
		in->next = queue->LinkPCB;
		queue->LinkPCB = 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;
		fst->next = in;
	}
}


void RoundRun(ReadyQueue* timechip)
{
	int flag = 1;
	GetFirst(timechip);
	while (run != NULL)
	{
		while (flag)
		{
			run->count++;
			//run->cputime++;
			run->ServerTime++;

			run->NeedTime--;
			
			TimNum++;
			if (run->NeedTime == 0)
			{
				run->FinishTime = TimNum;		//完成时间
				run->TurnoverTime = run->FinishTime - run->ComeTime;//周转时间
				run->WeightedTurnoverTime = run->TurnoverTime / run->ServerTime;//带权周转时间
				run->state = 'F';
				InsertFinish(run);
				flag = 0;
			}
			else if (run->count == timechip->round)
			{
				run->state = 'W';
				run->count = 0;
				InsertLast(run, timechip);

				flag = 0;

				break;
			}
		}

		flag = 1;
		if (timechip->LinkPCB != NULL) // 就绪队列中的进程不为空
		{
			GetFirst(timechip);
			//Output();
		}
		else
		{

			//printf("查看当前全部进程的状态：\n");
			//printf("多级反馈队列调度算法模拟结束，所有进程执行完毕\n");
			endOutput();
			// printf("多级反馈队列调度算法模拟结束，所有进程执行完毕！\n");
			break;
		}
		

	}
}


void Output()
{
	ReadyQueue* q = Head;
	PCB* p;
	printf("进程名\t  时间片\t 已服务时间\t所需时间\t状态\t\n");

	p = run;
	while (p != NULL)
	{
		printf( " %c\t %d\t %d \t%d\t%c\n",p->name , p->round ,p->ServerTime, p->NeedTime,p->state );
		p = p->next;
	}

	while (q)
	{
		if (q->LinkPCB != NULL)
		{
			p = q->LinkPCB;
			while (p)
			{
				printf(" %c\t %d\t %d \t%d\t%c\n", p->name, p->round, p->ServerTime, p->NeedTime, p->state);
				p = p->next;
			}
		}
		q = q->next;
	}

	p = finish;
	while (p != NULL)
	{
		printf(" %c\t\t %d\t\t %d \t\t%d\t\t%c\n", p->name, p->round, p->ServerTime, p->NeedTime, p->state);
		p = p->next;
	}
	
}

void endOutput()
{
	PCB* p;
	printf("进程名\t到达时间\t已服务时间\t完成时间\t周转时间\t带权周转时间\n");

	p = finish;

	while (p != NULL)
	{
		/*p->TurnoverTime = p->FinishTime - p->ComeTime;
		p->WeightedTurnoverTime = p->TurnoverTime / p->ServerTime;*/

		printf("%c\t %d\t\t%d\t\t%d\t\t %d\t\t%.2f\n", p->name, p->ComeTime, p->ServerTime, p->FinishTime, p->TurnoverTime, p->WeightedTurnoverTime);


			p = p->next;
	}

}

void SortQueue(ReadyQueue* queue)
{

	ReadyQueue* m, * n;
	m = n = Head;
	if (Head == NULL)
	{
		queue->next = NULL;
		Head = queue;
	}
	else
	{
		if (queue->prio <= m->prio)
		{
			queue->next = m;
			Head = queue;
		}
		else
		{
			while (m->next != NULL)
			{
				n = m;
				m = m->next;
			}

			if (m->next == NULL)
			{
				queue->next = m->next;
				m->next = queue;
			}
			else
			{
				n->next = queue;
				queue->next = m;
			}
		}
	}
}
以后的事，以后再说
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
操作系统导论：多级反馈队列
人邮异步社区
04-25 1223
本文将介绍一种著名的调度方法——多级反馈队列（Multi-level Feedback Queue，MLFQ）。1962年，Corbato首次提出多级反馈队列[C+62]，应用于兼容时分共享系统（CTSS）。Corbato因在CTSS中的贡献和后来在Multics中的贡献，获得了ACM颁发的图灵奖（Turing Award）。该调度程序经过多年的一系列优化，出现在许多现代操作系统中。 多级反馈队列需要解决两方面的问题。首先，它要优化周转时间。在第7章中我们看到，这通过先执行短工作来实现。然而，操作系统通常
先来先服务（FCFS）调度算法
weixin_56851161的博客
03-24 425
#include<iostream> #include<queue> #include<string> using namespace std; class Time{ public : string getTime(); Time(int hou,int min,int sec); Time(); int getHour(){return hour;} int getMinute()...
计算机操作系统调度算法，C++实现FSFS，SJF，RR，多级反馈队列算法
tingyuanss的专栏
05-17 4675
代码有点乱，没有分开写，希望读者耐心看。 #include #include #include #include using namespace std; unsigned int q_id=0;          //用于队列进程号的全局变量 unsigned int l_id=0;          //用于链表进程号的全局变量 unsigned int stime=0;
【自顶向下模块化编程】C语言实现多级反馈队列调度算法
究极小白-行者千面的博客
10-31 2384
本文旨在让读者在学习C语言实现多级反馈调度队列算法这一过程中，体会如何使用自顶向下模块化设计的方法解决问题。
进程调度算法
qq_52878986的博客
02-16 246
为了确定首先执行哪个进程以及最后执行哪个进程以实现最大 CPU 利用率，采用进程调度算法： 1.先到先服务(FCFS)调度算法: 从就绪队列中选择一个最先进入该队列的进程为之分配资源，使它立即执行并一直执行到完成或发生某事件而被阻塞放弃占用 CPU 时再重新调度。 2.短作业优先(SJF)的调度算法: 从就绪队列中选出一个估计运行时间最短的进程为之分配资源，使它立即执行并一直执行到完成或发生某事件而被阻塞放弃占用 CPU 时再重新调度。 3.时间片轮转调度算法: 每个进程被分配一个时间段，称作它的时间
jincheng.zip_先来先服务_多级反馈队列_多级反馈队列调度算法_高 优先权调度 算法_高响应比
09-14
本文将详细探讨标题和描述中提到的几种主要调度算法，包括先来先服务（FCFS）、多级反馈队列（Multi-Level Feedback Queue, MLFQ）调度算法、优先权调度算法以及高响应比优先（High Response Ratio Next, HRRN）调度...
多级反馈队列调度算法
06-08
多级反馈队列调度算法（Multilevel Feedback Queue Scheduling Algorithm）是一种在操作系统中用于进程调度的策略，它结合了多种调度算法的优点，以适应不同类型的进程需求，从而提高系统的效率和响应时间。...
操作系统模拟：多级反馈队列
04-10
5. **队列数据结构**：为了实现多级队列，可能需要使用Java的`Queue`接口，例如`LinkedList`或`ArrayDeque`，来存储和管理线程。 6. **状态管理**：每个线程需要有一个状态表示（如新建、就绪、运行、阻塞、结束等...
OS_DESIGN.rar_delphi队列_多级反馈队列_操作系统课程设计_效率 模拟_澶氱骇鍙嶉闃熷垪
09-19
操作系统是计算机科学中的核心课程，而多级反馈队列（Multi-Level Feedback Queue, MLFQ）是一种高效且灵活的进程调度算法，常被用于操作系统设计中。本课程设计旨在通过Delphi编程语言来实现和模拟这种算法，以及...
多级反馈队列调度（模拟实现）
weixin_34184561的博客
11-10 1398
算法描述（来自百度）： 1、进程在进入待调度的队列等待时，首先进入优先级最高的Q1等待。 2、首先调度优先级高的队列中的进程。若高优先级中队列中已没有调度的进程，则调度次优先级队列中的进程。例如：Q1,Q2,Q3三个队列，当且仅当在Q1中没有进程等待时才去调度Q2，同理，只有Q1,Q2都为空时才会去调度Q3。 3、对于同一个队列中的各个进程，按照FCFS分配时间片调度。比如Q1队列的时间片为...
多级反馈队列调度算法C语言
QingYuanM的博客
05-17 4143
包含各种多级反馈队列调度算法，C代码，尤其是抢占！
进程状态变换模拟
u014285517的专栏
10-26 3577
问题： 编写一个程序，模拟若干进程调度执行的情况。假设进程的状态分为执行和就绪两种。每个进程以其PCB为代表即可，无需创建真正的进程。以链表的方式组织PCB，分为三个队列： freeQueue：一个空白PCB队列 readyQueue：一个就绪队列 runningQueue：一个执行队列 程序开始运行时，用户输入进程数量n，以及每个进程需要运行的时间t0/t1/…/tn。程序从空
动态优先权调度算法的模拟
qq_39285153的博客
05-07 1845
动态优先权调度算法的模拟 动态优先权调度算法的模拟 实验要求：用C语言编程实现动态优先权进程调度过程的模拟。 实验内容： （1）每个进程控制块PCB用结构描述，包括以下字段： *进程标识符id *进程优先数priority,并规定优先数越大的进程，其优先权越高。 *进程已占用的CPU时间cputime *进程还需占用的CPU时间alltime，当进程运行完毕时，aiitime变为0 *进程的阻塞时...
操作系统非抢占式静态优先级调度算法（C语言）
是我的博客啊
11-03 1万+
**主要数据结构 单链表（进程表，就绪进程表），结构体（结构化进程信息）** 大致步骤： 1.输入模块：接收进程信息，包括进程代号，进程创建时间，进程运行时间，进程优先级，得到进程表 2.就绪进程判断模块：用Time记录系统当前运行的时间，得出就绪进程表** 3.对就绪进程表按照优先序列排序 注意点: state用来记录当前进程是否存在于就绪队列中； 排序算法采用的是交换结点值的冒泡算法，而不是直...
c语言创建PCB并调度进城,有c语言模拟调度算法吗?？
weixin_28595749的博客
05-24 473
/*本c程序为按优先数的进程调度*/#include#include#include#define NULL 0#define LEN sizeof(struct pcb)struct pcb{ int pid;struct pcb *next;int time;int priority;char status;};int n,m;struct pcb *head,*runpcb;main(){ ...
操作系统实验（一）：进程控制块的作用
qq_40019838的博客
09-30 1898
实验要求： 定义多个进程实体（2个以上）； 初始化进程实体； 标识进程状态； 依次输出每个执行进程的开始时间和周转时间； 采用随机函数模拟进程的到达时间； 采用随机函数产生每个进程实体的执行时间。 源码 PCB的定义 #ifndef __PCB_H__ #define __PCB_H__ #define BLOCK -1 #define READY 0 #...
＜OS Concepts 9th＞ Chap 3 进程管理
emon22的博客
11-04 153
介绍进程的概念：执行中的程序 描述进程的特征：如调度、创建、终止 探索进程间通信：使用共享内存和消息传递 描述客户端-服务端框架下的通信
Java模拟操作系统实验一：四种进程调度算法实现（FCFS,SJF,RR,HRN）
热门推荐
走过，路过，别错过的博客
01-01 3万+
前言 刚学完操作系统，模拟实现了其中一些经典的算法，内容比较多，打算写一个系列的总结，将自己的源码都分享出来，既方便自己以后复习，也希望能帮助到一些刚入坑的小伙伴。我的所有代码的运行环境都是基于Eclipse，jdk1.10下。 1.问题概述 编程实现常用调度算法，即先来先服务、短作业（进程）优先、时间片轮转以及最高响应比优先调度算法。编程语言及环境不限。须给出关键数据结构、算法以及变量的详...
多级反馈队列调度fcfs
最新发布
06-12
多级反馈队列调度和FCFS是两种不同的调度算法。 多级反馈队列调度是一种动态的调度算法，它将进程按照优先级划分为多个队列，每个队列的优先级不同。新到达的进程首先被插入到最高优先级队列中，如果它在运行时仍...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值