进程调度算法c语言实现_进程调度算法有哪些

进程调度算法c语言实现_进程调度算法有哪些对一个非抢占式多道批处理系统采用以下算法的任意两种,实现进程调度,并计算进程的开始执行时间,周转时间,带权周转时间,平均周转时间,平均带权周转时间1.先来先服务算法2.短进程优先算法*3.高响应比优先算法三、设计思想每个进程有一个进程控制块(PCB)表示。进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。进程的优先数及需要的运行时间…

大家好,又见面了,我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE稳定放心使用

对一个非抢占式多道批处理系统采用以下算法的任意两种,实现进程调度,并计算进程的开始执行时间,周转时间,带权周转时间,平均周转时间,平均带权周转时间
1.先来先服务算法 2.短进程优先算法 *3.高响应比优先算法

一、设计思想
每个进程有一个进程控制块( PCB)表示。进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算

1、先来先到算法:优先运行先到达的进程,后达到的进程后运行,类似数据结构中的队列,先进先出,对于先来先服务算法,我们只需要队进程进行排序即可;
2、短进程优先算法:若进程的到达时间有先后,则还是先运行先到达的进程,若当前有进程正在运行,则到达的进程置为就绪状态,等待进程运行完毕,释放资源后,比较处于就绪状态的进程,服务时间短的优先运行,等待下一个进程运行完毕后,继续比较就绪进程的服务时间,仍取服务时间短的。

数据结构:
在这里插入图片描述

先来先服务排序部分算法:
在这里插入图片描述

短进程优先部分算法:
在这里插入图片描述

将所有的进程信息存入数组里,本程序通过随机赋值赋予进程到达时间、服务时间等,然后通过计算计算出周转时间、带权周转时间、平均周转时间以及平均带权周转时间

程序源代码如下:

`#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h> 

//进程控制块(PCB)
struct PCB
{
	char name;
	float arrivetime;
	float servetime;
	float finishtime;
	float roundtime;
	float daiquantime;
};

struct PCB a[100];
struct PCB b[100];
char *jczt[] = { "运行", "就绪" };//*表示没有字符串的大小限制

//打印统计信息
void tjxx(int n)
{
	float averoundtime = 0.0f;		
	float avedaiquantime = 0.0f;	
	printf("按任意键查看统计信息");
	getchar(); getchar();
	printf("\n\n进程名称\t到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间");
	for (int j = 0; j < n; j++)
	{
		printf("\n   %c\t\t%4.f\t\t%4.f\t\t%4.f\t\t%4.f\t\t  %.2f\n", a[j].name, a[j].arrivetime, a[j].servetime, a[j].finishtime, a[j].roundtime, a[j].daiquantime);
		averoundtime += a[j].roundtime;
		avedaiquantime += a[j].daiquantime;
	}

	printf("\n平均周转时间:%.2f", averoundtime / n);
	printf("\n\n平均带权周转时间:%.2f\n", avedaiquantime / n);
}


void xlxfw(int n)
{
	int time = 0;				//定义当前时刻
	int processnum = 0;				//定义当前进程指向
	struct PCB t;				//定义一个空的结构体节点
	int processztsy = 0;				//定义进程状态索引

	while (1)
	{
		printf("当前时刻:%2d\n", time);

		//排序
		for (int i = 1; i < n; i++)
		{
			for (int j = 0; j < n - i; j++)
			{
				if (a[j].arrivetime > a[j + 1].arrivetime)//先到先运行
				{
					t = a[j];
					a[j] = a[j + 1];
					a[j + 1] = t;
				}
				if (a[j].arrivetime == a[j + 1].arrivetime)//进程同时到
				{
					if (a[j].servetime > a[j + 1].servetime)//比较服务时间,将运行时间短的放在优先级高的位置
					{
						t = a[j];
						a[j] = a[j + 1];
						a[j + 1] = t;
					}
				}
			}
		}

	
		for (int k = 0; k< n; k++)
		{
		
			if (time == a[k].arrivetime && a[k].arrivetime != 0)
			{
				
				if (k >= 1 && time >= a[k - 1].finishtime || k == 0)
				{
					processztsy = 0;
				}
				else
				{
					processztsy = 1;
				}
				printf("\t\t进程 %c 到达\t进程状态\n", a[k].name);
				printf("\n\t\t\t\t  %s\n\n\n", jczt[processztsy]);
			

			
				if (processnum >= 1)
				{
					a[k].finishtime = a[k - 1].finishtime + a[k].servetime;
					a[k].roundtime = a[k].finishtime - a[k].arrivetime;
					a[k].daiquantime = a[k].roundtime / a[k].servetime;
				}
				if (processnum == 0)
				{
					a[k].finishtime = a[k].arrivetime + a[k].servetime;
					a[k].roundtime = a[k].finishtime - a[k].arrivetime;
					a[k].daiquantime = a[k].roundtime / a[k].servetime;
					printf("\t\t\t进程  %c  开始\n\n\n\n", a[processnum].name);
					processnum++;
				}
			}
			
			if (time == a[k].finishtime && a[k].finishtime != 0)
			{
				printf("\t\t\t进程  %c  完成\n\n\n\n", a[k].name);
			}
		
			if ((k >= 1 && time >= a[k].arrivetime && time == a[k - 1].finishtime && a[k].arrivetime != 0))
			{
				printf("\t\t\t进程  %c  开始\n\n\n\n", a[k].name);
			}
		}

	
		if (time > a[n - 1].finishtime && a[n - 1].finishtime != 0)
		{
			printf("\t\t\t所有进程已进程已加载完毕! \n\n\n\n");
			break;
		}
		time++;
		Sleep(1000);
	}
	tjxx(n);
}




void djcyx(int n)
{
	struct PCB t;
	int time = 0;//定义当前时刻
	int jcnum = 0;
	int jcztsy = 0;
	bool ztgb = false;

	//排序
	for (int i = 1; i < n; i++)
	{
		for (int j = 0; j < n - i; j++)
		{
			if (a[j].arrivetime > a[j + 1].arrivetime)//先到达的优先级高
			{
				t = a[j];
				a[j] = a[j + 1];
				a[j + 1] = t;
			}
		}
	}

	while (1)
	{
		printf("当前时刻:%d\n", time);


		//遍历数组,注意同时达到的进程,所以采用for循环遍历
		for (int k = 0; k< n; k++)
		{
			//是否有进程的到达时间等于当前时刻
			if (time == a[k].arrivetime && a[k].arrivetime != 0)
			{
				//判断到达进程因该处于什么状态
				if (k >= 1 && time >= a[k - 1].finishtime || k == 0)
				{
					jcztsy = 0;
				}
				else
				{
					jcztsy = 1;
				}
				printf("\t\t进程 %c 到达\t进程状态\n\n\n\n", a[k].name);
			}
		}

		if (jcnum == 0)
		{
			//遍历数组
			for (int i = jcnum; i < n; i++)
			{
				//把当前到达的进程筛选出来
				if (time >= a[i].arrivetime)
				{
					//从挑选出来的进程中选取服务时间最短的一个
					if (a[i].servetime < a[jcnum].servetime)
					{
						t = a[jcnum];
						a[jcnum] = a[i];
						a[i] = t;
					}
					ztgb = true;
				}
			}
			if (ztgb == true)
			{
				printf("\t\t\t进程  %c  开始\n\n\n\n", a[jcnum].name);
				a[jcnum].finishtime = a[jcnum].arrivetime + a[jcnum].servetime;
				a[jcnum].roundtime = a[jcnum].finishtime - a[jcnum].arrivetime;
				a[jcnum].daiquantime = a[jcnum].roundtime / a[jcnum].servetime;
				ztgb = false;
				jcnum++;
			}
		}

		if (time == a[jcnum - 1].finishtime && a[jcnum - 1].finishtime != 0)
		{
			printf("\t\t\t进程  %c  完成\n\n\n\n", a[jcnum - 1].name);

			//遍历数组
			for (int i = jcnum; i < n; i++)
			{
				//把当前到达的进程筛选出来
				if (time >= a[i].arrivetime)
				{
					//从挑选出来的进程中选取服务时间最短的一个
					if (a[i].servetime < a[jcnum].servetime)
					{
						t = a[jcnum];
						a[jcnum] = a[i];
						a[i] = t;
					}
					ztgb = true;
				}
			}
			if (ztgb == true || jcnum == n - 1)
			{
				printf("\t\t\t进程  %c  开始\n\n\n\n", a[jcnum].name);
				a[jcnum].finishtime = a[jcnum - 1].finishtime + a[jcnum].servetime;
				a[jcnum].roundtime = a[jcnum].finishtime - a[jcnum].arrivetime;
				a[jcnum].daiquantime = a[jcnum].roundtime / a[jcnum].servetime;
				ztgb = false;
				jcnum++;
			}
		}
		if (time > a[n - 1].finishtime && a[n - 1].finishtime != 0)
		{
			printf("\t\t\t所有进程已加载完毕! \n\n\n\n");
			break;
		}
		time++;
		Sleep(1000);
	}
	tjxx(n);
}


//信息录入
int info()
{
	int n = 0;
	srand(time(NULL)); //初始化随机函数     	
	printf("\n\t\t请输入需要的进程数:");
	scanf("%d", &n);
	printf("\n");
	for (int i = 0; i < n; i++)
	{
		printf("\t\t进程 %d\t名称:", i + 1);
		scanf("%s", &a[i].name);
		a[i].arrivetime = (float)(rand() % 5 + 1);//随机获取进程运行到达时间
		a[i].servetime = (float)(rand() % 5 + 1);//随机获取进程运行服务时间
	}
	system("cls");
	return n;
}

void main()
{
	int b = 1, k;
	while (b)
	{
		system("cls");
		printf("\n\n\t\t进程调度算法\n\n");
		printf("\t\t 程序清单\n");
		printf("\t\t1.... 先来先服务算法        \n");
		printf("\t\t2.... 短进程优先算法        \n");
		printf("\t\t3.... 退出程序          \n\n\n");
		printf("\t\t请选择:");
		scanf("%d", &k);
		switch (k)
		{
		case 1:	 xlxfw(info());    	break;
		case 2:  djcyx(info());     break;
		case 3:  b = 0;               break;
		default:printf("\n\t\t请输入正确的选择!\n");
		}
		if (b != 0)
		{
			printf("\n"); system("pause");
		}
	}
	printf("\n\t\t谢谢使用!\n\n\t\t");
}`
版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/187809.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)
blank

相关推荐

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号