精华内容
下载资源
问答
  • 进程调度算法c语言
    2021-05-25 06:22:04

    操作系统课程设计(2015)

    进程调度算法的模拟实现

    PAGE 2

    PAGE 1

    操作系统课程设计报告

    题目: 进程调度算法的模拟实现_

    专业

    计算机科学与技术

    学生姓名

    班级

    学号

    指导教师

    发放日期

    2015.1.30

    信 息 工 程 学 院

    目 录

    TOC \o "1-2" \h \z \u HYPERLINK \l _Toc28843 1 概述 PAGEREF _Toc28843 1

    HYPERLINK \l _Toc7961 2 设计原理 PAGEREF _Toc7961 1

    HYPERLINK \l _Toc18029 2.1先来先服务算法 PAGEREF _Toc18029 1

    HYPERLINK \l _Toc17098 3 详细设计与编码 PAGEREF _Toc17098 1

    HYPERLINK \l _Toc6166 3.1 模块设计 PAGEREF _Toc6166 1

    HYPERLINK \l _Toc5304 3.2 系统流程图 PAGEREF _Toc5304 2

    HYPERLINK \l _Toc14012 3.3 系统详细设计 PAGEREF _Toc14012 2

    HYPERLINK \l _Toc21238 4 结果与分析 PAGEREF _Toc21238 6

    HYPERLINK \l _Toc15992 4.1 测试方案 PAGEREF _Toc15992 6

    HYPERLINK \l _Toc28242 4.2 测试结果 PAGEREF _Toc28242 6

    HYPERLINK \l _Toc11989 4.3 测试结果分析 PAGEREF _Toc11989 9

    HYPERLINK \l _Toc18316 5 设计小结 PAGEREF _Toc18316 12

    HYPERLINK \l _Toc20308 6 参考文献 PAGEREF _Toc20308 13

    HYPERLINK \l _Toc24610 附录 程序代码 PAGEREF _Toc24610 14

    进程调度算法的模拟实现

    1 概述

    选择一个调度算法,实现处理机调度,进程调度算法包括:先来先服务算法,短进程优先算法,时间片轮转算法,动态优先级算法。可选择进程数量,本程序包括四种算法,用C或C++语言实现,执行时在主界面选择算法(可用函数实现),进入子页面后输入进程数,(运行时间,优先数由随机函数产生),执行,显示结果。

    2 设计原理

    2.1先来先服务(FCFS)算法

    每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业,将它们调入内存,为它们分配资源创建进程,然后放入就绪队列

    2.2 时间片轮转法(RR)算法

    系统将所有的就绪进程按先来先服务的原则排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片。时间片的大小从几ms到几百ms。当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片。

    2.3短作业优先(SJF)算法

    短作业优先调度算法是从就绪队列中选出一个估计运行时间最短的进程,将处理机分配给它,使它立即执行并一直执行到完成,或发生某事件而被阻塞放弃处理机时再重新调度。

    2.4最高优先权优先(HRRN)算法

    优先权调度算法是为了照顾紧迫型作业,使之在进入系统后便获得优先处理,引入最高优先权优先调度算法。动态优先权是指在创建进程时所赋予的优先权,是可以随进程的推进或随其等待时间的增加而改变的,以便获得更好的调度性能。

    3 详细设计与编码

    3.1 模块设计

    (1) 进入系统模块,进入登陆界面。

    (3) 菜单选择模块。选择相应的进程调度方式,选择相应的数字,进入相应的功能。

    (4) 算法模块。选择相应的进程调度算法。

    (5) 显现输出模块。显示每种进程调度算法情况。

    (6) 平均周转时间与平均带权周转时间的计算结果。

    (7) 退出系统模块。

    开始3.2 系统流程图

    开始

    FCFS算法,对于先到达的进程优先分配CPU

    FCFS算法,对于先到达的进程优先分配CPU

    SJF算法,每次都从未完成的队列中选取服务时间最短的作业进行调度

    SJF算法,每次都从未完成的队列中选取服务时间最短的作业进行调度

    RR算法,每次调度时将CPU 分派给队首进程,按照时间片依次执行进程

    RR算法,每次调度时将CPU 分派给队首进程,按照时间片依次执行进程

    HRRN算法,考虑每个作业的等待时间长短和估计需要的执行时间长短,从中选出

    HRRN算法,考虑每个作业的等待时间长短和估计需要的执行时间长短,从中选

    更多相关内容
  • 进程调度算法C语言

    2010-03-12 12:49:11
    这是一个关于进程调度算法,这是一个关于进程调度算法,这是一个关于进程调度算法
  • 操作系统进程调度算法 c语言实现

    热门讨论 2011-04-07 08:59:30
    实现进程调度算法,具有后备序列的调度 题目:设计一个有 N个进程共行的进程调度程序。 进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法。 每个进程有一个进程...
  • C语言实现:短进程优先-进程调度算法 1. 采用“短进程优先”调度算法对五个进程进行调度。每个进程有一个进程控制块( PCB)表示。进程控制块可以包含如下信息:进程名、到达时间、需要运行时间、已用CPU时间、进程...
  • 操作系统 用c语言实现的短进程调度算法(文档+源代码 已测试) Word版 内含源代码、说明文档、演示截图
  • 进程调度算法C语言实现

    千次阅读 2020-04-08 09:55:00
    进程调度算法C语言实现 #define _CRT_SECURE_NO_WARNINGS #define NUMBER 5 #include <stdio.h> #include <windows.h> char process_name[NUMBER] = { 'A', 'B', 'C', 'D', 'E' }; int arrive_time...

    进程调度算法C语言实现

    #define _CRT_SECURE_NO_WARNINGS
    #define NUMBER 5
    
    #include <stdio.h>
    #include <windows.h>
    char process_name[NUMBER] = { 'A', 'B', 'C', 'D', 'E' };
    int arrive_time[NUMBER] = { 0, 2, 2, 3, 4 };
    int server_time[NUMBER] = { 1, 3, 5, 2, 4 };
    int fcfs_finished[NUMBER];
    int fcfs_work[NUMBER];
    double a_fcks_work[NUMBER];
    typedef struct name_server{
    	char process_name;
    	int arrive_time;
    	int server_time;
    	int finished;
    	int work;
    	double a_work;
    	double prioprity;
    	int is_finished;//代表轮转周期结束时,当前进程是否结束
    };
    
    
    void init_data(name_server *init_data);
    void chang_position(name_server *temp_name_server, int index, int temp_value);
    void calc_work_or_a_work(name_server *new_name_server_psa);
    void print(name_server print_struct[5]);
    void recovery_order(name_server *new_name_server, name_server *old_name_server);
    void fcfs();
    void sjf();
    void psa();
    
    
    //先来先服务
    void fcfs() {
    	name_server name_server_fcfs[NUMBER];
    	//初始化
    	init_data(name_server_fcfs);
    	int is_true = 1;
    	int temp_sum = 0;
    	int is_wait = 0;
    	while (is_true){
    		//完成时间
    		int is_finished = 0;
    		for (int i = 0; i<NUMBER; i++) {
    			//当时间无法达到到达时刻时执行
    			if (is_wait > NUMBER+1) {
    				temp_sum++;
    				is_wait = 0;
    				break;
    			}
    
    			//判断是否到达
    			if (name_server_fcfs[i].arrive_time > temp_sum) {
    				is_wait++;
    				continue;
    			}
    
    			if (name_server_fcfs[i].is_finished == 1){
    				is_finished++;
    				is_wait++;
    				if (is_finished == NUMBER){
    					is_true = 0;
    					break;
    				}
    				continue;
    			}
    		
    
    			//完成时间
    			name_server_fcfs[i].finished = temp_sum + name_server_fcfs[i].server_time;
    			temp_sum += name_server_fcfs[i].server_time;
    			name_server_fcfs[i].is_finished = 1;
    			is_wait = 0;
    			break;
    		}
    	}
    
    	calc_work_or_a_work(name_server_fcfs);
    }
    
    //短作业优先
    void sjf() {
    	//初始化一个进程名与服务时间有关的结构体
    	name_server name_server_sjf[NUMBER];
    	//初始化数据
    	init_data(name_server_sjf);
    
    	//完成时间的计算
    	int temp_sum = 0;
    	double avg_work = 0.0;
    	double avg_a_work = 0.0;
    	for (int j = 0; j < NUMBER; j++) {//循环进程的次数
    			if (j == 0) {//0时刻进入的进程先执行
    				name_server_sjf[j].finished = temp_sum + name_server_sjf[j].server_time;
    			}
    			else{
    				//循环遍历查找是否满足到达时间
    				int temp = 0;
    				for (int i = j;i<NUMBER-j;i++){
    					if (name_server_sjf[i].arrive_time > temp_sum){
    						temp++;
    					}
    				}
    				//不满足到达条件进入下次循环,等待进程到达
    				if(temp == NUMBER - j - 1){
    					if (j < NUMBER - 1){
    						j--;
    						temp_sum++;
    						continue;
    					}
    				}
    
    				int min_index = j;
    				//查找剩余进程中最小的服务时间的进程
    				for (int i = j + 1; i<NUMBER; i++) {
    					name_server min = name_server_sjf[min_index];
    
    
    					//判断是否到达
    					if (name_server_sjf[i].arrive_time > temp_sum){
    						//进入每次对比的最后一次,进行向前替换
    						if (i == NUMBER-1) {
    							//交换位置
    							chang_position(name_server_sjf, min_index, j);
    						}
    						continue;
    					}
    
    					if (min.server_time > name_server_sjf[i].server_time) {
    						min_index = i;
    					}
    
    					if (i == NUMBER-1) {
    						//交换位置
    						chang_position(name_server_sjf, min_index, j);
    					}
    				
    				}
    				name_server_sjf[j].finished = temp_sum + name_server_sjf[j].server_time;
    			}
    			temp_sum += name_server_sjf[j].server_time;
    	}
    	
    	//恢复进程名的顺序
    	name_server new_name_server_sjf[NUMBER];
    	recovery_order(new_name_server_sjf, name_server_sjf);
    
    	//输出计算后的数据
    	calc_work_or_a_work(new_name_server_sjf);
    }	
    
    //优先级
    void psa() {
    	//初始化一个进程名与服务时间有关的结构体
    	name_server name_server_psa[NUMBER];
    	//初始化数据
    	init_data(name_server_psa);
    
    	//总完成时间
    	int temp_sum = 0;
    	for (int i = 0; i<NUMBER; i++) {
    		if (i == 0) {
    			name_server_psa[i].finished = arrive_time[i] + server_time[i];
    			temp_sum += name_server_psa[i].finished;
    		}
    		else {
    
    			//循环遍历查找是否满足到达时间
    			int temp = 0;
    			for (int j = i; j<NUMBER - i; j++){
    				if (name_server_psa[j].arrive_time > temp_sum){
    					temp++;
    				}
    			}
    			//不满足到达条件进入下次循环,等待进程到达
    			if (temp == NUMBER - i - 1){
    				if (i < NUMBER - 1){
    					i--;
    					temp_sum++;
    					continue;
    				}
    			}
    
    			//计算优先级
    			for (int j = i; j < NUMBER; j++) {
    				name_server_psa[j].prioprity = (name_server_psa[i - 1].finished - name_server_psa[j].arrive_time + name_server_psa[j].server_time)/ (name_server_psa[j].server_time*1.0);
    			}
    			//找出当次循环的最大优先级
    			name_server max = name_server_psa[i];
    			int max_index = i;
    			for (int j = i + 1; j < NUMBER; j++) {
    				//判断是否到达
    				if (name_server_psa[i].arrive_time > temp_sum){
    					//前移最大优先级
    					if (j == NUMBER-1) {
    						//交换位置
    						chang_position(name_server_psa, max_index, i);
    					}
    					continue;
    				}
    
    				if (max.prioprity < name_server_psa[j].prioprity) {
    					max = name_server_psa[j];
    					max_index = j;
    				}
    
    				//前移最大优先级
    				if (j == NUMBER-1) {
    					//交换位置
    					chang_position(name_server_psa, max_index, i);
    				}
    			}
    			//计算完成时间
    			name_server_psa[i].finished = temp_sum + name_server_psa[i].server_time;
    			temp_sum += name_server_psa[i].server_time;
    		}
    	}
    
    	//恢复进程名的顺序
    	name_server new_name_server_psa[NUMBER];
    	recovery_order(new_name_server_psa, name_server_psa);
    
    	//计算带输出
    	calc_work_or_a_work(new_name_server_psa);
    }
    
    //轮转调度算法
    void rr() {
    	name_server name_server_rr[NUMBER];
    	init_data(name_server_rr);
    
    	int r_r = 4;
    
    	int finished_circle = 1;
    	int circle_times = 1;
    	int temp_sum = 0;
    	while (finished_circle) {
    		finished_circle = 0;
    		for (int i = 0; i < NUMBER; i++) {
    			//循环遍历查找是否满足到达时间
    			int temp = 0;
    			for (int j = i; j<NUMBER - i; j++){
    				if (name_server_rr[j].arrive_time > temp_sum){
    					temp++;
    				}
    			}
    			//不满足到达条件进入下次循环,等待进程到达
    			if (temp == NUMBER - i - 1){
    				//当不是第一个数据的时候
    				if (i != 0){
    					if (i < NUMBER - 1){
    						i--;
    						temp_sum++;
    						continue;
    					}
    				}
    				
    			}
    			if (name_server_rr[i].is_finished == 1) {
    				continue;
    			}
    			//判断是否出现周期大于服务时间的情况
    			if ((name_server_rr[i].server_time - (circle_times - 1)*r_r) <= r_r) {
    				temp_sum += (name_server_rr[i].server_time - (circle_times-1)*r_r);
    			}
    			else{
    				temp_sum += r_r;
    			}
    			//判断是否为结束状态
    			if ((circle_times*r_r) >= name_server_rr[i].server_time) {
    				name_server_rr[i].is_finished = 1;
    				name_server_rr[i].finished = temp_sum;
    			}
    			//继续循环
    			if (name_server_rr[i].server_time > (circle_times*r_r)) {
    				finished_circle = 1;
    			}
    		}
    		circle_times++;
    	}
    
    	//计算带输出
    	calc_work_or_a_work(name_server_rr);
    
    }
    
    //多级反馈队列
    void mfq() {
    	//用于最后存储完成时间和计算使用
    	name_server copy_name_server_mfq[NUMBER];
    	//用于计算操作使用
    	name_server name_server_mfq[NUMBER];
    	init_data(copy_name_server_mfq);
    	init_data(name_server_mfq);
    
    	int r_r = 1;
    	int temp_sum = 0;
    	int num_queue = 0;
    	while (true) {
    		if (temp_sum != 0){
    			r_r *= 2;
    		}
    		printf("----------------------\n");
    		num_queue++;
    		printf("%d队列:\n", num_queue);
    		int temp = 0;
    		for (int i = 0; i<NUMBER; i++) {
    
    			//循环遍历查找是否满足到达时间
    			int is_temp = 0;
    			for (int j = i; j<NUMBER - i; j++){
    				if (name_server_mfq[j].arrive_time > temp_sum){
    					is_temp++;
    				}
    			}
    			//不满足到达条件进入下次循环,等待进程到达
    			if (is_temp == NUMBER - i - 1){
    				//当不是第一个数据的时候
    				if (i != 0){
    					if (i < NUMBER - 1){
    						i--;
    						temp_sum++;
    						continue;
    					}
    				}
    
    			}
    			//判断此进程是否运行结束
    			if (name_server_mfq[i].server_time == 0) {
    				temp++;
    				continue;
    			}
    			//判断当前时间就进程是否到达
    			if (name_server_mfq[i].arrive_time > temp_sum) {
    				continue;
    			}
    			//判断此进程是否在当前就绪队列结束
    			if (name_server_mfq[i].server_time <= r_r ) {
    				temp_sum += name_server_mfq[i].server_time;
    				printf("%c进程在此队列运行%d时间,%c进程运行完毕!\n",
    					name_server_mfq[i].process_name, 
    					name_server_mfq[i].server_time,
    					name_server_mfq[i].process_name);
    				name_server_mfq[i].server_time = 0;
    				copy_name_server_mfq[i].finished = temp_sum;
    			}
    			else{
    				temp_sum += r_r;
    				name_server_mfq[i].server_time -= r_r;
    				printf("%c进程在此队列运行%d时间\n", name_server_mfq[i].process_name, r_r);
    			}
    		}
    
    		//判断进程就绪队列是否为空
    		if (temp == NUMBER) {
    			break;
    		}
    	}
    	//计算周转时间和带权周转时间
    	calc_work_or_a_work(copy_name_server_mfq);
    }
    
    //初始化数据
    void init_data(name_server *init_data){
    	for (int i = 0; i < NUMBER; i++) {
    		init_data[i].process_name = process_name[i];
    		init_data[i].arrive_time = arrive_time[i];
    		init_data[i].server_time = server_time[i];
    		init_data[i].is_finished = 0;
    	}
    }
    
    //交换位置
    void chang_position(name_server *temp_name_server, int index, int temp_value){
    	name_server temp = temp_name_server[index];
    	temp_name_server[index] = temp_name_server[temp_value];
    	temp_name_server[temp_value] = temp;
    }
    
    //恢复进程名顺序
    void recovery_order(name_server *new_name_server, name_server *old_name_server) {
    	for (int i = 0; i<NUMBER; i++) {
    		new_name_server[old_name_server[i].process_name - 'A'] = old_name_server[i];
    	}
    }
    
    //计算周转时间和带权周转时间
    void calc_work_or_a_work(name_server *new_name_server) {
    	double avg_work = 0.0;
    	double avg_a_work = 0.0;
    	for (int i = 0; i<NUMBER; i++) {
    		//周转时间
    		new_name_server[i].work = new_name_server[i].finished - new_name_server[i].arrive_time;
    		//总周转时间
    		avg_work += new_name_server[i].work;
    		//带权周转时间
    		new_name_server[i].a_work = (new_name_server[i].work * 1.0) / new_name_server[i].server_time;
    		//总带权周转时间
    		avg_a_work += new_name_server[i].a_work;
    	}
    
    	print(new_name_server);
    	printf("平均周转时间:%5.2f\n", avg_work / 5);
    	printf("平均带权周转时间:%5.2f\n", avg_a_work / 5);
    }
    
    //输出数据
    void print(name_server print_struct[NUMBER]){
    	printf("进程名 到达时间 服务时间 完成时间 周转时间 带权周转时间\n");
    	for (int i = 0; i<NUMBER; i++){
    		printf("%c\t%d\t%-7d\t%-8d\t%-d\t%.2f\n", print_struct[i].process_name,
    			print_struct[i].arrive_time,
    			print_struct[i].server_time,
    			print_struct[i].finished,
    			print_struct[i].work,
    			print_struct[i].a_work);
    	}
    }
    
    //选项跳转
    void choice_ui(int choice){
    	switch (choice) {
    	case 1:
    		fcfs();
    		break;
    	case 2:
    		sjf();
    		break;
    	case 3:
    		psa();
    		break;
    	case 4:
    		rr();
    		break;
    	case 5:
    		mfq();
    		break;
    	default:
    		printf("输入有误!");
    	}
    	system("pause");
    }
    
    
    void main() {
    	int choice;
    	while (1) {
    		printf("选择查看的作业调度算法:\n");
    		printf("1、先来先服务(fcfs)\n");
    		printf("2、短作业优先(sjf)\n");
    		printf("3、优先调度算法(psa)\n");
    		printf("4、轮转调度算法(rr)\n");
    		printf("5、多级反馈队列调度算法\n");
    		scanf("%d",&choice);
    		choice_ui(choice);
    		system("cls");
    	}
    	system("pause");
    }
     
    
    展开全文
  • 比较简单,全程再小黑框里,输出有点问题,可以自己改改2这是积分版,欢迎支持,免费版去我主页下载
  • 假设要求从系统中输入N个需访问的柱面号,当前磁头的移动方向由键盘输入(1代表磁头从外往内移动,-1代表磁头由内往外移动),当前磁头刚完成访问序号为M的柱面,请编程输出采用电梯调度算法得到的柱面访问序列号,...
  • 操作系统进程调度算法c语言实现)

    万次阅读 多人点赞 2019-12-03 17:15:00
    进程调度算法 一、先来先服务(FCFS) 基本思想:先到达的进程先进入就绪队列,先进行调度的原则。非抢占方式。 二、短作业优先(SJF) 基本思想:根据进程中的执行时间,选取执行时间最短的作业优先调度;可有抢占...

    进程调度算法

    一、先来先服务(FCFS)
    基本思想:先到达的进程先进入就绪队列,先进行调度的原则。非抢占方式。
    二、短作业优先(SJF)
    基本思想:根据进程中的执行时间,选取执行时间最短的作业优先调度;可有抢占或非抢占方式。
    三、优先权高者优先(HPF)
    基本思想:系统根据作业的优先权进行作业调度,每次选取优先权高的作业优先调度。作业的优先权通常用一个整数表示,也叫做优先数。可有抢占或非抢占方式。
    四、时间片轮转(RR)
    基本思想:系统将所有的就绪进程按先来先服务的原则,排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片。时间片结束之后,将该进程加到就绪队列队尾;然后再把处理机分配给就绪队列中新的首进程。

    各程序的实现算法

    (1)FCFS先来先服务
    算法思想:①首先将输入的进程放入一个进程数组中,然后根据进程的到达时间进行排序(冒泡排序)。将最先到达的进程放入进程就绪队列中。②当队列不空时,从队头取出一个进程来执行,直至此进程执行完,并将在此进程执行期间到达的进程依次加入进程就绪队列。③如果队列为空,但进程数组中仍存在未到达的进程,这时将要到达进程加入进程就绪队列。

    void FCFS(program pro[],int num){
    	printf("进程 到达时间  服务时间 开始时间 完成时间 周转时间 带权周转时间\n");
    	sortWithEnterTime(pro,num);    //按照到达顺序排序 
    	programQueue* queue = (programQueue*)malloc(sizeof(programQueue)); 
    	Queueinit(queue);   //初始化进程就绪队列
    	EnterQueue(queue,&pro[0]);   //将第一个进程放入队列
    	int time = pro[0].enter_time;
    	int pronum=1;    //记录当前已进入的进程 
    	float sum_T_time = 0,sum_QT_time = 0 ; 
    	while(queue->size>0){    //当队列不为空
    		program* curpro = poll(queue);   //从进程队列中取出进程 
    		if(time<curpro->enter_time)      //如果此进程的进入时间大于此时的时间,需要将时间转换到此进程的到达时间
    			time =  curpro->enter_time;
    		int done_time = time+curpro->running_time;  //记录完成时间
    		int T_time = done_time - curpro->enter_time;  //记录周转时间
    		sum_T_time += T_time;    
    		float QT_time = T_time / (curpro->running_time+0.0) ; //记录带权周转
    		sum_QT_time += QT_time;
    		for(int tt = time;tt<=done_time&&pronum<num;tt++){    //模拟进程的执行过程 
    		
    			if(tt>=pro[pronum].enter_time){   //程序执行时有程序到达则进入程序队列
    				EnterQueue(queue,&pro[pronum]);
    				pronum++;
    			}
    		}
    		printf("%s\t%d\t%d\t%d\t%d\t%d\t%.2f\n",curpro->name,curpro->enter_time,curpro->running_time,time,done_time,T_time,QT_time); //输出结果
    		time +=  curpro->running_time;
    		if(queue->size==0&&pronum<num){   //防止出现前一个进程执行完到下一个进程到达之间无进程进入 
    			EnterQueue(queue,&pro[pronum]);
    			pronum++; 
    		}
    	}
    	printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n",sum_T_time/(num+0.0),sum_QT_time/(num+0.0));
    }
    

    (2)短作业优先(SJF)
    算法思想:①首先也是按进程的到达时间进行排序。让最先到达的进程入队。②当队列不空时,从队头取出一个进程来执行,直至此进程执行完,设置一个变量记录此进程执行过程中所有到达的进程。③将这些到达的进程进行排序,按照进程服务时间的大小。然后将排序好的进程数组中的进程依次加入进程队列。(只排当前进程执行期间到达的进程)④此时也要考虑如果队列为空,但进程数组中仍存在未到达的进程,这时将要到达进程加入进程就绪队列。

    void SJF(program pro[],int num) {
    	printf("进程 到达时间  服务时间 开始时间 完成时间 周转时间 带权周转时间\n");
    	sortWithEnterTime(pro,num);
    	programQueue* queue = (programQueue*)malloc(sizeof(programQueue));;
    	Queueinit(queue);
    	EnterQueue(queue,&pro[0]);   //第一个进程入队
    	int time = pro[0].enter_time;
    	int pronum=1;    //记录当前的进程 
    	float sum_T_time = 0,sum_QT_time = 0;
    	while(queue->size>0){
    		program* curpro = poll(queue);   //从进程队列中取出进程 
    		if(time<curpro->enter_time)
    			time =  curpro->enter_time;
    		int done_time = time+curpro->running_time;
    		int T_time = done_time - curpro->enter_time;
    		float QT_time = T_time / (curpro->running_time+0.0) ;
    		sum_T_time += T_time;
    		sum_QT_time += QT_time;
    		int pre = pronum;  //记录此进程执行期间第一个到达的进程的位置
    		for(int tt = time;tt<=done_time&&pronum<num;tt++){    //模拟进程的执行过程 
    			if(tt>=pro[pronum].enter_time){ // 统计从此任务开始到结束之间有几个进程到达 
    				pronum++;
    			}
    		}
    		sortWithLongth(pro,pre,pronum);//将到达的进程按照服务时间排序
    		for(int i=pre;i<pronum;i++){    //到达的进程入队进程链入队列 
    			EnterQueue(queue,&pro[i]);
    		}
    		pre = pronum;
    		printf("%s\t%d\t%d\t%d\t%d\t%d\t%.2f\n",curpro->name,curpro->enter_time,curpro->running_time,time,done_time,T_time,QT_time);
    		time +=  curpro->running_time;
    		if(queue->size==0&&pronum<num){   //防止出现前一个进程执行完到下一个进程到达之间无进程进入 
    			EnterQueue(queue,&pro[pronum]);
    			pronum++; 
    		}
    	}
    	printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n",sum_T_time/(num+0.0),sum_QT_time/num);
    }
    

    (3)优先权高者优先(HPF)
    算法思想:①首先也是按进程的到达时间进行排序。让最先到达的进程入队。②当队列不空时,从队头取出一个进程来执行,直至此进程执行完,设置一个变量记录此进程执行过程中所有到达的进程。③将这些到达的进程进行排序,按照进程优先权排序(权值小的先入)。然后将排序好的进程数组中的进程依次加入进程队列。(只排当前进程执行期间到达的进程)④此时也要考虑如果队列为空,但进程数组中仍存在未到达的进程,这时将要到达进程加入进程就绪队列。

    void HPF(program pro[],int num){
    	printf("进程 到达时间  服务时间 开始时间 完成时间 周转时间 带权周转时间\n");
    	sortWithEnterTime(pro,num);
    	programQueue* queue = (programQueue*)malloc(sizeof(programQueue));;
    	Queueinit(queue);
    	EnterQueue(queue,&pro[0]);
    	int time = pro[0].enter_time;
    	int pronum=1;    //记录当前的进程 
    	float sum_T_time = 0,sum_QT_time = 0;
    	while(queue->size>0){
    		program* curpro = poll(queue);   //从进程队列中取出进程 
    		if(time<curpro->enter_time)
    			time =  curpro->enter_time;
    		int done_time = time+curpro->running_time;
    		int T_time = done_time - curpro->enter_time;
    		float QT_time = T_time / (curpro->running_time+0.0) ;
    		sum_T_time += T_time;
    		sum_QT_time += QT_time;
    		int pre = pronum;
    		for(int tt = time;tt<=done_time&&pronum<num;tt++){    //模拟进程的执行过程 
    			if(tt>=pro[pronum].enter_time){ // 统计从此任务开始到结束之间有几个进程到达 
    				pronum++;
    			}
    		}
    		sortWithPriority(pro,pre,pronum);//将到达的进程按照服务时间排序
    		for(int i=pre;i<pronum;i++){    //将进程链入队列 
    			EnterQueue(queue,&pro[i]);
    		}
    		pre = pronum;
    		printf("%s\t%d\t%d\t%d\t%d\t%d\t%.2f\n",curpro->name,curpro->enter_time,curpro->running_time,time,done_time
    			,T_time,QT_time);
    		time +=  curpro->running_time;
    		if(queue->size==0&&pronum<num){   //防止出现前一个进程执行完到下一个进程到达之间无进程进入 
    			EnterQueue(queue,&pro[pronum]);
    			pronum++; 
    		}
    	} 
    	printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n",sum_T_time/(num+0.0),sum_QT_time/(num+0.0));
    }
    

    (4)时间片轮转(RR)
    算法思想:
    ①首先也是按进程的到达时间进行排序。让最先到达的进程入队。
    ②当队列不空时,从队头取出一个进程来执行。此时分两种情况
    2.1、如果当前进程的剩余服务时间不大于时间片大小,说明此次将会将这个进程执 行完毕,在此进程执行过程中到达的进程需要添加到进程就绪队列中,这时就可以输出 此进程执行完毕。
    2.2、如果当前进程的剩余服务时间大于时间片大小,还需将此进程执行过程中到达 的进程需要添加到进程就绪队列中,然后此进程的剩余服务时间减少时间片大小,此进 程重新进入进程就绪队列。
    ③此时也要考虑如果队列为空,但进程数组中仍存在未到达的进程,这时将要到达进程加入进程就绪队列。

    void RR(program pro[],int num){
    	printf("请输入时间片大小"); 
    	int timeslice;scanf("%d",&timeslice);
    	printf("进程 到达时间  服务时间 开始时间 完成时间 周转时间 带权周转时间\n");
    	sortWithEnterTime(pro,num);
    	programQueue* queue = (programQueue*)malloc(sizeof(programQueue));;
    	Queueinit(queue);
    	pro[0].start_time = pro[0].enter_time;
    	EnterQueue(queue,&pro[0]);
    	int time = 0;
    	int pronum = 1;
    	float sum_T_time = 0,sum_QT_time = 0;
    	while(queue->size>0){
    		program* curpro = poll(queue);    // 从队列中取出头节点 
    		if(time<curpro->enter_time)
    			time = curpro->enter_time;
    		if(timeslice >= curpro->running_time){   // 如果剩余时间小于时间片  则此任务完成
    			for(int tt = time;tt<=time+curpro->running_time&&pronum<num;tt++){    // 模拟进程的执行过程 
    				if(tt>=pro[pronum].enter_time){ // 统计从此任务开始到结束之间有几个进程到达 
    					pro[pronum].start_time = tt;
    					EnterQueue(queue,&pro[pronum]);
    					pronum++;
    				}
    			}
    			time += curpro->running_time;
    			curpro->running_time = 0;
    			curpro->done_time = time;
    			int T_time = curpro->done_time-curpro->start_time;
    			float QT_time = T_time / (curpro->copyRunning_time+0.0);
    			sum_T_time += T_time;
    			sum_QT_time += QT_time;
    			printf("%s\t%d\t%d\t  %d\t   %d\t %d\t  %.2f\n",curpro->name,curpro->enter_time,curpro->copyRunning_time,
    				curpro->start_time,curpro->done_time,T_time,QT_time);
    			if(queue->size==0&&pronum<num){   //防止出现前一个进程执行完到下一个进程到达之间无进程进入 
    				pro[pronum].start_time = pro[pronum].enter_time;
    				EnterQueue(queue,&pro[pronum]);
    				pronum++; 
    			}
    			continue; 
    		}
    		for(int tt = time;tt<=time+timeslice&&pronum<num;tt++){    //模拟进程的执行过程 
    			if(tt>=pro[pronum].enter_time){ // 统计从此任务开始到结束之间有几个进程到达 
    				pro[pronum].start_time = tt;
    				EnterQueue(queue,&pro[pronum]);
    				pronum++;
    			}
    		}
    		time += timeslice;
    		curpro->running_time -= timeslice; 
    		EnterQueue(queue,curpro);    //当前程序未完成  继续添加到队列中 
    		if(queue->size==0&&pronum<num){   //防止出现前一个进程执行完到下一个进程到达之间无进程进入 
    			pro[pronum].start_time = pro[pronum].enter_time;
    			EnterQueue(queue,&pro[pronum]);
    			pronum++; 
    		}
    	}
    	printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n\n",sum_T_time/(num+0.0),sum_QT_time/(num+0.0));
    } 
    

    完整c语言代码

    #include<stdio.h>
    #include<malloc.h>
    #include<string.h> 
    #include<stdlib.h>
    typedef struct program{
    	char name[20];
    	int running_time;
    	int enter_time;
    	int priority;
    	int done_time;    //用于时间片轮转
    	int copyRunning_time;  //用于时间片轮转
    	int start_time; 
    	program* next;
    } Program;
    typedef struct programQueue{
    	program* firstProg;
    	program* LastProg;
    	int size;
    } programQueue;
    void Queueinit(programQueue* queue){
    	if(queue==NULL){
    		return ;
    	}
    	queue->size = 0;
    	queue->LastProg = (program*)malloc(sizeof(program));
    	queue->firstProg = queue->LastProg;
    }
    void print(program pro[],int num){
    	for(int i=0;i<num;i++){
    		printf("%d ",pro[i].enter_time);
    	}
    }
    void printQueue(programQueue* queue){
    	program* p=queue->firstProg->next;
    	while(p!=NULL){
    		printf("%s ",p->name);
    		p=p->next;
    	}
    	printf("\n");
    } 
    void EnterQueue(programQueue* queue,program* pro){   //加入进程队列 
    	queue->LastProg->next = (program*)malloc(sizeof(program));
    	queue->LastProg = queue->LastProg->next; 
    	queue->LastProg->enter_time = pro->enter_time;
    	memcpy(queue->LastProg->name,pro->name,sizeof(pro->name));   
    	queue->LastProg->priority = pro->priority;
    	queue->LastProg->running_time = pro->running_time;
    	queue->LastProg->copyRunning_time = pro->copyRunning_time;
    	queue->LastProg->start_time = pro->start_time;
    	queue->size++;
    }
    program* poll(programQueue* queue){
    	program* temp = queue->firstProg->next;
    	if(temp == queue->LastProg){
    		queue->LastProg=queue->firstProg;
    		queue->size--;
    		return temp;
    	}
    	queue->firstProg->next = queue->firstProg->next->next;
    	queue->size--;
    	return temp;
    }
    void inputProgram(program pro[],int num){
    	for(int i=0;i<num;i++){
    		program prog ;
    		printf("请输入第%d个进程的名字,到达时间,服务时间,优先级\n",i+1);
    		scanf("%s",prog.name);
    		scanf("%d",&prog.enter_time) ;
    		scanf("%d",&prog.running_time);
    		prog.copyRunning_time = prog.running_time; 
    		scanf("%d",&prog.priority);
    		pro[i]=prog;
    	}
    }
    void sortWithEnterTime(program pro[],int num){
    	for(int i=1;i<num;i++){
    		for(int j= 0;j<num-i;j++){
    			if(pro[j].enter_time>pro[j+1].enter_time){
    				program temp = pro[j];
    				pro[j] = pro[j+1];
    				pro[j+1] = temp;
    			}
    		}
    	}
    }
    
    void FCFS(program pro[],int num){
    	printf("进程 到达时间  服务时间 开始时间 完成时间 周转时间 带权周转时间\n");
    	sortWithEnterTime(pro,num);    //按照进入顺序排序 
    	programQueue* queue = (programQueue*)malloc(sizeof(programQueue));
    	Queueinit(queue);
    	EnterQueue(queue,&pro[0]);
    	int time = pro[0].enter_time;
    	int pronum=1;    //记录当前的进程 
    	float sum_T_time = 0,sum_QT_time = 0 ; 
    	while(queue->size>0){
    		program* curpro = poll(queue);   //从进程队列中取出进程 
    		if(time<curpro->enter_time)
    			time =  curpro->enter_time;
    		int done_time = time+curpro->running_time;
    		int T_time = done_time - curpro->enter_time;
    		sum_T_time += T_time;
    		float QT_time = T_time / (curpro->running_time+0.0) ;
    		sum_QT_time += QT_time;
    		for(int tt = time;tt<=done_time&&pronum<num;tt++){    //模拟进程的执行过程 
    		
    			if(tt>=pro[pronum].enter_time){
    				EnterQueue(queue,&pro[pronum]);
    				pronum++;
    			}
    		}
    		printf("%s\t%d\t%d\t%d\t%d\t%d\t%.2f\n",curpro->name,curpro->enter_time,curpro->running_time,time,done_time
    			,T_time,QT_time);
    		time +=  curpro->running_time;
    		if(queue->size==0&&pronum<num){   //防止出现前一个进程执行完到下一个进程到达之间无进程进入 
    			EnterQueue(queue,&pro[pronum]);
    			pronum++; 
    		}
    	}
    	printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n",sum_T_time/(num+0.0),sum_QT_time/(num+0.0));
    }
    void sortWithLongth(program pro[],int start,int end){
    	int len = end - start;
    	if(len == 1) return ;
    	for(int i=1;i<len;i++){
    		for(int j= start;j<end-i;j++){
    			if(pro[j].running_time>pro[j+1].running_time){
    				program temp = pro[j];
    				pro[j] = pro[j+1];
    				pro[j+1] = temp;
    			} 
    		}
    	}
    }
    void SJF(program pro[],int num) {
    	printf("进程 到达时间  服务时间 开始时间 完成时间 周转时间 带权周转时间\n");
    	sortWithEnterTime(pro,num);
    	programQueue* queue = (programQueue*)malloc(sizeof(programQueue));;
    	Queueinit(queue);
    	EnterQueue(queue,&pro[0]);
    	int time = pro[0].enter_time;
    	int pronum=1;    //记录当前的进程 
    	float sum_T_time = 0,sum_QT_time = 0;
    	while(queue->size>0){
    		program* curpro = poll(queue);   //从进程队列中取出进程 
    		if(time<curpro->enter_time)
    			time =  curpro->enter_time;
    		int done_time = time+curpro->running_time;
    		int T_time = done_time - curpro->enter_time;
    		float QT_time = T_time / (curpro->running_time+0.0) ;
    		sum_T_time += T_time;
    		sum_QT_time += QT_time;
    		int pre = pronum;
    		for(int tt = time;tt<=done_time&&pronum<num;tt++){    //模拟进程的执行过程 
    			if(tt>=pro[pronum].enter_time){ // 统计从此任务开始到结束之间有几个进程到达 
    				pronum++;
    			}
    		}
    		sortWithLongth(pro,pre,pronum);//将到达的进程按照服务时间排序
    		for(int i=pre;i<pronum;i++){    //将进程链入队列 
    			EnterQueue(queue,&pro[i]);
    		}
    		pre = pronum;
    		printf("%s\t%d\t%d\t%d\t%d\t%d\t%.2f\n",curpro->name,curpro->enter_time,curpro->running_time,time,done_time
    			,T_time,QT_time);
    		time +=  curpro->running_time;
    		if(queue->size==0&&pronum<num){   //防止出现前一个进程执行完到下一个进程到达之间无进程进入 
    			EnterQueue(queue,&pro[pronum]);
    			pronum++; 
    		}
    	}
    	printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n",sum_T_time/(num+0.0),sum_QT_time/num);
    }
    void sortWithPriority(program pro[],int start,int end){
    	int len = end - start;
    	if(len == 1) return ;
    	for(int i=1;i<len;i++){
    		for(int j= start;j<end-i;j++){
    			if(pro[j].priority>pro[j+1].priority){
    				program temp = pro[j];
    				pro[j] = pro[j+1];
    				pro[j+1] = temp;
    			} 
    		}
    	}
    }
    void HPF(program pro[],int num){
    	printf("进程 到达时间  服务时间 开始时间 完成时间 周转时间 带权周转时间\n");
    	sortWithEnterTime(pro,num);
    	programQueue* queue = (programQueue*)malloc(sizeof(programQueue));;
    	Queueinit(queue);
    	EnterQueue(queue,&pro[0]);
    	int time = pro[0].enter_time;
    	int pronum=1;    //记录当前的进程 
    	float sum_T_time = 0,sum_QT_time = 0;
    	while(queue->size>0){
    		program* curpro = poll(queue);   //从进程队列中取出进程 
    		if(time<curpro->enter_time)
    			time =  curpro->enter_time;
    		int done_time = time+curpro->running_time;
    		int T_time = done_time - curpro->enter_time;
    		float QT_time = T_time / (curpro->running_time+0.0) ;
    		sum_T_time += T_time;
    		sum_QT_time += QT_time;
    		int pre = pronum;
    		for(int tt = time;tt<=done_time&&pronum<num;tt++){    //模拟进程的执行过程 
    			if(tt>=pro[pronum].enter_time){ // 统计从此任务开始到结束之间有几个进程到达 
    				pronum++;
    			}
    		}
    		sortWithPriority(pro,pre,pronum);//将到达的进程按照服务时间排序
    		for(int i=pre;i<pronum;i++){    //将进程链入队列 
    			EnterQueue(queue,&pro[i]);
    		}
    		pre = pronum;
    		printf("%s\t%d\t%d\t%d\t%d\t%d\t%.2f\n",curpro->name,curpro->enter_time,curpro->running_time,time,done_time
    			,T_time,QT_time);
    		time +=  curpro->running_time;
    		if(queue->size==0&&pronum<num){   //防止出现前一个进程执行完到下一个进程到达之间无进程进入 
    			EnterQueue(queue,&pro[pronum]);
    			pronum++; 
    		}
    	} 
    	printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n",sum_T_time/(num+0.0),sum_QT_time/(num+0.0));
    }
    void RR(program pro[],int num){
    	printf("请输入时间片大小"); 
    	int timeslice;scanf("%d",&timeslice);
    	printf("进程 到达时间  服务时间 进入时间 完成时间 周转时间 带权周转时间\n");
    	sortWithEnterTime(pro,num);
    	programQueue* queue = (programQueue*)malloc(sizeof(programQueue));;
    	Queueinit(queue);
    	pro[0].start_time = pro[0].enter_time;
    	EnterQueue(queue,&pro[0]);
    	int time = 0;
    	int pronum = 1;
    	float sum_T_time = 0,sum_QT_time = 0;
    	while(queue->size>0){
    		program* curpro = poll(queue);    // 从队列中取出头节点 
    		if(time<curpro->enter_time)
    			time = curpro->enter_time;
    		if(timeslice >= curpro->running_time){   // 如果剩余时间小于时间片  则此任务完成
    			for(int tt = time;tt<=time+curpro->running_time&&pronum<num;tt++){    // 模拟进程的执行过程 
    				if(tt>=pro[pronum].enter_time){ // 统计从此任务开始到结束之间有几个进程到达 
    					pro[pronum].start_time = tt;
    					EnterQueue(queue,&pro[pronum]);
    					pronum++;
    				}
    			}
    			time += curpro->running_time;
    			curpro->running_time = 0;
    			curpro->done_time = time;
    			int T_time = curpro->done_time-curpro->start_time;
    			float QT_time = T_time / (curpro->copyRunning_time+0.0);
    			sum_T_time += T_time;
    			sum_QT_time += QT_time;
    			printf("%s\t%d\t%d\t  %d\t   %d\t %d\t  %.2f\n",curpro->name,curpro->enter_time,curpro->copyRunning_time,
    				curpro->start_time,curpro->done_time,T_time,QT_time);
    			if(queue->size==0&&pronum<num){   //防止出现前一个进程执行完到下一个进程到达之间无进程进入 
    				pro[pronum].start_time = pro[pronum].enter_time;
    				EnterQueue(queue,&pro[pronum]);
    				pronum++; 
    			}
    			continue; 
    		}
    		for(int tt = time;tt<=time+timeslice&&pronum<num;tt++){    //模拟进程的执行过程 
    			if(tt>=pro[pronum].enter_time){ // 统计从此任务开始到结束之间有几个进程到达 
    				pro[pronum].start_time = tt;
    				EnterQueue(queue,&pro[pronum]);
    				pronum++;
    			}
    		}
    		time += timeslice;
    		curpro->running_time -= timeslice; 
    		EnterQueue(queue,curpro);    //当前程序未完成  继续添加到队列中 
    		if(queue->size==0&&pronum<num){   //防止出现前一个进程执行完到下一个进程到达之间无进程进入 
    			pro[pronum].start_time = pro[pronum].enter_time;
    			EnterQueue(queue,&pro[pronum]);
    			pronum++; 
    		}
    	}
    	printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n\n",sum_T_time/(num+0.0),sum_QT_time/(num+0.0));
    } 
    void choiceMenu(){
    	printf("请选择进程调度算法:\n\n");
    	printf("1.先来先服务算法\n2.短进程优先算法\n3.高优先级优先\n4.时间片轮转算法\n\n"); 
    }
    void menu(){
    	int proNum;
    	printf("请输入进程的个数:");
    	scanf("%d",&proNum);
    	program pro[proNum];
    	inputProgram(pro,proNum);
    	choiceMenu();
    	int choice;
    	while(1){
    		scanf("%d",&choice);
    		switch(choice){
    			case 1:system("cls");FCFS(pro,proNum);choiceMenu();break; 
    			case 2:system("cls");SJF(pro,proNum);choiceMenu();break; 
    			case 3:system("cls");HPF(pro,proNum);choiceMenu();break;
    			case 4:system("cls");RR(pro,proNum);choiceMenu();break;
    			case 5:return;
    		}
    	}
    	
    }
    int main(){
    	menu();
    	return 0;
    } 
    

    结果测试

    在这里插入图片描述

    结果按照完成时间输出

    先来先服务
    在这里插入图片描述
    短进程优先
    在这里插入图片描述
    高优先级优先
    在这里插入图片描述
    时间片轮转 时间片大小为10
    在这里插入图片描述

    展开全文
  • 操作系统——四种进程调度算法模拟实现(C语言

     一、六种进程调度算法的基本思想

    1、先来先服务First-Come-First-Served(FCFS)(作业/进程)调度算法
          FCFS是一种最简单的调度算法,可用于作业或进程调度。此算法的原则是按照作业到达后备作业队列(或进程进入就绪队列)的先后次序来选择作业(或进程)。FCFS算法属于非抢占方式,一旦一个进程占有处理机,它就一直运行下去,直到该进程完成或者因等待某事件而不能继续运行时才释放处理机。

    2、短作业优先调度算法(Shortest Job First, SJF)
         这种调度算法主要用于作业调度,它从作业后备队列中挑选所需运行时间(估计值)最短的作业进入主存运行。这一算法有利于短作业,对长作业不利。
    采用SJF有利于系统减少平均周转时间和平均带权周转时间。

    3、高响应比优先调度算法  (Highest Response Ratio Next, HRRN)    
    按照高响应比优先的原则,在每次选择作业投入运行时,先计算此时后备作业队列中每个作业的响应比R,然后选择其值最大的作业投入运行。R值定义为:
          R =(已等待时间+要求运行时间)/要求运行时间
            =1+已等待时间/要求运行时间
    HRRN算法实际上是FCFS算法和SJF算法的折衷。响应比R不仅是要求运行时间的函数,而且还是等待时间的函数。由于R与要求运行时间成反比,故对短作业是有利的,另一方面,因R与等待时间成正比,故长作业随着其等待时间的增长,也可获的较高的响应比。这就克服了短作业优先的缺点,既照顾了先来者,又优待了短作业,是上述两种算法的一种较好的折中。

    4、时间片轮转Round-Robin(RR)调度算法
           进程调度程序总是选择就绪队列中第一个进程,允许其占有处理机一个时间片的时间。当执行的时间片用完时,调度程序便停止该进程的执行,并将它送就绪队列的末尾,等待分配下一时间片再执行。然后把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片。这样就可以保证就绪队列中的所有进程,在一给定的时间内,均能获得一时间片处理机执行时间。

    5、高优先级调度算法(Priority Scheduling Algorithm, PSA)
           按照进程的优先权大小来调度,使高优先权进程得到优先处理的调度策略称为优先权调度算法。进程的优先权的设置可以是静态的,也可以是动态的。

    6、多级反馈队列调度算法
          多队列调度是根据作业的性质和类型的不同,将就绪队列再分为若干个子队列,所有的作业(或进程)按其性质排入相应的队列中,而不同的就绪队列采用不同的调度算法。
    例如前后台系统可以建立两个就绪队列,批处理作业所建立进程进入后台就绪队列;交互型作业所建立的进程进入前台就绪队列。前台采用时间片轮转算法,进程按FCFS等策略排序,后台采用高优先权的调度算法或者短作业优先的调度算法。

    二、四种进程调度算法模拟实现

    1、进程调度算法模拟程序设计要求

    (1) 编写并调试一个模拟的进程调度程序,以深入探讨进程的概念及进程调度算法.

    (2)分别采用3调度算法对五个进程进行调度。每个进程有一个进程控制块(PCB)表示。进程控制块可以包含如下信息:进程名、到达时间、需要运行时间、已用CPU时间、进程状态等等。

    (3)每个进程的状态可以是就绪W(Wait)、运行R(Run)、或阻塞B(Block)三种状态之一。 每进行一次调度程序都打印一次运行进程、就绪队列、阻塞队列以及各个进程的PCB,以便进行检查。重复以上过程,直到所要进程都完成为止。进程的相关参数即运行时间、I/O需求等自行设定。

    2、C语言源代码:

    #include<bits/stdc++.h>
    using namespace std;
    #define MAXSIZE 30
    typedef struct PCB {
    	char name[20];             // 进程名称(输入)
    	int  arrivetime;           //到达时间 (输入)
    	int  running_time;         //服务时间
    	int  priority;             //优先级
    	int  start_time;           //开始时间
    	int  done_time;            //结束时间
    	int  copyRunning_time;     //用于时间片轮转
    	float zztime;              //记录该进程的周转时间(后期复制用)
    	float dqzztime;            //记录该进程的带权周转时间(后期复制用)
    	PCB* next;
    } Program;
    typedef struct PCBQueue {
    	PCB* firstProg;
    	PCB* LastProg;
    	int size;
    } PCBQueue;
    
    // 函数声明
    void print(PCB pro[], int num);//输出每个进程的到达时间
     
    void inputProgram(PCB pro[], int num); //输入所有进程的具体信息 
    
    void PrintRunningprogram(PCB *pro);//输出正在运行的进程的信息 
    
    void PrintReadyqueue(PCBQueue *ready_queue);//输出就绪队列中的所有进程的信息 
    
    void PrintSortOfRunningprogram(PCB pro1[],int num);//输出进程的运行顺序 
    
    void CopyProgram(PCB *pro1,PCB *pro2);//将进程pro2的信息复制到进程pro1中 
    
    void Queueinit(PCBQueue* queue);//初始化就绪队列 
    
    void EnterQueue(PCBQueue* queue, PCB* pro);//将一个进程插入到就绪队列中 
    
    PCB* poll(PCBQueue* queue);//将一个进程从就绪队列中删除 
    
    void sortWithEnterTime(PCB pro[], int num);//将所有进程按到达时间升序排序 
    
    void EnterQueueOfRuntime(PCBQueue *ready_queue,PCB *program);//将一个进程按运行时间长短插入就绪队列 
    
    void EnterQueueOfPriority(PCBQueue *ready_queue,PCB *program);//将一个进程按优先级插入就绪队列 
    
    void FCFS(PCB pro[], int num);//先来先服务调度算法 
    
    void SJF(PCB pro[],int num);//短作业优先调度算法
     
    void HPF(PCB pro[],int num);//高优先级调度算法 
    
    void RR(PCB pro[], int num);//时间片轮转调度算法 
    
    //具体函数实现 
    void print(PCB pro[], int num) {
    	int i;
    
    	for (i = 0; i < num; i++) {
    		printf("%d ", pro[i].arrivetime);
    	}
    }
    
    void inputProgram(PCB pro[], int num) {
    	int i;
    
    	for (i = 0; i < num; i++) {
    		PCB prog;
    		printf("\t\t\t\t\t请输入第%d个进程的名字,到达时间,服务时间,优先级\n\t\t\t\t\t", i + 1);
    		scanf("%s", prog.name);
    		scanf("%d", &prog.arrivetime);
    		scanf("%d", &prog.running_time);
    		prog.copyRunning_time = prog.running_time;
    		scanf("%d", &prog.priority);
    		pro[i] = prog;
    	}
    }
    
    void PrintRunningprogram(PCB *pro) {
    	printf("\t正在执行》》》进程%s\n",pro->name);
    	printf("\t————————————————————————————————————————————————\n");
    	printf("\t进程名字  到达时间  服务时间  优先级  开始时间  结束时间  周转时间  带权周转时间\n");
    	printf("\t%s\t\t%d\t%d\t%d",pro->name,pro->arrivetime,pro->running_time,pro->priority);
    	printf("\t%d\t%d\t   %5.2f\t%5.2f\n",pro->start_time,pro->done_time,pro->zztime,pro->dqzztime);
    	printf("\t————————————————————————————————————————————————\n\n");
    }
    
    void PrintReadyqueue(PCBQueue *ready_queue) {
    	PCB *p;
    
    	p=ready_queue->firstProg->next;
    	if(!p) {
    		printf("\t无进程处于就绪状态!\n");
    		printf("\t————————————————————————————————————————————————\n\n\n");
    		return ;
    	}
    	printf("\t就绪队列:\n");
    	printf("\t————————————————————————————————————————————————\n");
    	printf("\t进程名字  到达时间  服务时间  优先级\n");
    	while(p) {
    		printf("\t%s\t\t%d\t%d\t%d\n",p->name,p->arrivetime,p->running_time,p->priority);
    		p=p->next;
    	}
    	printf("\t————————————————————————————————————————————————\n");
    	printf("\n\n\n");
    }
    
    void PrintSortOfRunningprogram(PCB pro1[],int num) {
    	int i;
    
    	printf("\t进程运行顺序如下:\n");
    	printf("\t————————————————————————————————————————————————\n");
    	printf("\t进程名字  到达时间  服务时间  优先级  开始时间  结束时间  周转时间  带权周转时间\n");
    	for(i=0; i<num; i++) {
    		printf("\t%s\t\t%d\t%d\t%d",pro1[i].name,pro1[i].arrivetime,pro1[i].running_time,pro1[i].priority);
    		printf("\t%d\t%d\t   %5.2f\t%5.2f\n",pro1[i].start_time,pro1[i].done_time,pro1[i].zztime,pro1[i].dqzztime);
    	}
    	printf("\t————————————————————————————————————————————————\n\n\n");
    }
    
    void CopyProgram(PCB *pro1,PCB *pro2) {
    	memcpy(pro1->name,pro2->name,sizeof(pro2->name));
    	pro1->arrivetime=pro2->arrivetime;
    	pro1->running_time=pro2->running_time;
    	pro1->priority=pro2->priority;
    	pro1->start_time=pro2->start_time;
    	pro1->done_time=pro2->done_time;
    	pro1->zztime=pro2->zztime;
    	pro1->dqzztime=pro2->dqzztime;
    }
    
    void Queueinit(PCBQueue* queue) {
    	if (queue == NULL) {
    		return;
    	}
    	queue->size = 0;
    	queue->LastProg = (PCB*)malloc(sizeof(PCB));
    	queue->LastProg->next=NULL;//注意加了此句
    	queue->firstProg = queue->LastProg;
    }
    
    void EnterQueue(PCBQueue* queue, PCB* pro) {
    	//加入进程队列
    	queue->LastProg->next = (PCB*)malloc(sizeof(PCB));
    	queue->LastProg = queue->LastProg->next;
    	queue->LastProg->arrivetime = pro->arrivetime;
    	memcpy(queue->LastProg->name, pro->name, sizeof(pro->name));
    	queue->LastProg->priority = pro->priority;
    	queue->LastProg->running_time = pro->running_time;
    	queue->LastProg->copyRunning_time = pro->copyRunning_time;
    	queue->LastProg->start_time = pro->start_time;
    	queue->LastProg->next=NULL;//注意加了此句
    	queue->size++;
    }
    
    PCB* poll(PCBQueue* queue) {
    	PCB *temp;
    
    	temp = queue->firstProg->next;
    	if (temp == queue->LastProg) {
    		queue->LastProg = queue->firstProg;
    		queue->LastProg->next=NULL;//注意加了此句
    		queue->size--;
    		return temp;
    	}
    	queue->firstProg->next = queue->firstProg->next->next;
    	queue->size--;
    
    	return temp;
    }
    
    void sortWithEnterTime(PCB pro[], int num) { //将进程按到达时间(arrivetime)全部排序
    	int i,j;
    	PCB temp;
    
    	for (i = 1; i < num; i++) {
    		for (j = 0; j < num - i; j++) {
    			if (pro[j].arrivetime > pro[j + 1].arrivetime) {
    				temp = pro[j];
    				pro[j] = pro[j + 1];
    				pro[j + 1] = temp;
    			}
    		}
    	}
    }
    
    void EnterQueueOfRuntime(PCBQueue *ready_queue,PCB *program) { //按进程的运行时间,找到就绪队列中的相应位置并插入进去
    	PCB *p,*q;
    	p=ready_queue->firstProg->next;
    	q=ready_queue->firstProg;
    
    	while(p) {
    		if(p->running_time>program->running_time) {
    			program->next=p;
    			q->next=program;
    			break;
    		}
    		q=p;
    		p=p->next;
    	}
    	if(!p) { //如果就绪队列为空或该进程的运行时间最长,则将其插入到队尾
    		ready_queue->LastProg->next=program;
    		ready_queue->LastProg=program;
    		program->next=NULL;
    	}
    	ready_queue->size++;
    }
    
    void EnterQueueOfPriority(PCBQueue *ready_queue,PCB *program) {
    	PCB *p,*q;
    	p=ready_queue->firstProg->next;
    	q=ready_queue->firstProg;
    
    	while(p) {
    		if(p->priority<program->priority) { //优先级大的先执行
    			program->next=p;
    			q->next=program;
    			break;
    		}
    		q=p;
    		p=p->next;
    	}
    	if(!p) {
    		ready_queue->LastProg->next=program;
    		ready_queue->LastProg=program;
    		program->next=NULL;
    	}
    	ready_queue->size++;
    }
    
    void FCFS(PCB pro[], int num) {
    	int time,done_time;
    	int i,count,tt,pronum;
    	float sum_T_time,sum_QT_time;
    	PCB *curpro,*temp_PCB;
    
    	printf("\n\t\t\t\t\t先来先服务算法进程调度模拟\n\n");
    	printf("\t————————————————————————————————————————————————\n");
    	count=0;
    	PCB pro2[100];
    	sortWithEnterTime(pro, num);                              //按照进入到达时间顺序排序
    	PCBQueue* queue = (PCBQueue*)malloc(sizeof(PCBQueue));    //定义就绪队列
    	Queueinit(queue);                                        //就绪队列初始化
    	EnterQueue(queue, &pro[0]);                              //将第一个进程送入就绪队列中
    	time = pro[0].arrivetime;                            //记录第一个进程的到达时间
    	pronum = 1;                                          //记录当前的进程数量
    	sum_T_time = 0, sum_QT_time = 0;                   // sum_T_time 记录总的周转时间 ,sum_QT_time 记录总的加权周转时间
    	while (queue->size > 0) {
    		curpro = poll(queue);                           //从进程队列中取出一个进程
    		if (time < curpro->arrivetime){
    			time = curpro->arrivetime;
    		}
    		done_time = time + curpro->running_time;               //  done_time   为该进程的结束时间(开始时间+CPU运行时间)
    		curpro->start_time=time;
    		curpro->done_time=done_time;
    		curpro->zztime = done_time - curpro->arrivetime;//周转时间
    		curpro->dqzztime = curpro->zztime / curpro->running_time;//带权周转时间              
    		sum_T_time += curpro->zztime;                                      //  sum_T_time  总的周转时间更新
    		sum_QT_time += curpro->dqzztime;                                     //  sum_T_time  总的带权周转时间更新
    		for (tt = time; tt <= done_time && pronum < num; tt++) { //模拟进程的执行过程
    			if (tt >= pro[pronum].arrivetime) {
    				EnterQueue(queue, &pro[pronum]);
    				pronum++;
    			}
    		}
    		CopyProgram(&pro2[count],curpro);
    		PrintRunningprogram(&pro2[count]);
    		count++;
    		if(queue->size!=0) {
    			printf("\t就绪队列:\n");
    			printf("\t————————————————————————————————————————————————\n");
    			printf("\t进程 到达时间  服务时间 优先级\n");
    			temp_PCB=queue->firstProg->next;
    			for(i=queue->size; i>0; i--) {
    				printf("\t%s\t%d\t%d\t%d\n",temp_PCB->name,temp_PCB->arrivetime,temp_PCB->running_time,temp_PCB->priority);
    				temp_PCB=temp_PCB->next;
    			}
    			printf("\t————————————————————————————————————————————————\n");
    			printf("\n\n\n");
    		} else {
    			printf("\t无进程处于就绪状态!\n");
    			printf("\t————————————————————————————————————————————————\n\n\n");
    		}
    		time += curpro->running_time;
    		if (queue->size == 0 && pronum < num) {
    			//防止出现前一个进程执行完到下一个进程到达之间无进程进入
    			EnterQueue(queue, &pro[pronum]);
    			pronum++;
    		}
    	}
    	PrintSortOfRunningprogram(pro2,count);
    	//Print(pro2,count);
    	printf("\t平均周转时间为:%.2f\n", sum_T_time /num);
    	printf("\t平均带权周转时间为:%.2f\n",sum_QT_time/num);
    }
    
    void SJF(PCB pro[],int num) {
    	int time,done_time;
    	float sum_T_time,sum_QT_time;
    	int i,pronum;
    	PCBQueue *ready_queue;
    	PCB *curpro,pro1[MAXSIZE];
    
    	printf("\n\t\t\t\t\t短作业优先算法进程调度模拟\n\n");
    	printf("\t————————————————————————————————————————————————\n");
    	sortWithEnterTime(pro, num);
    	ready_queue = (PCBQueue*)malloc(sizeof(PCBQueue));
    	if(!ready_queue) {
    		printf("分配就绪队列头结点空间失败!");
    		exit(1);
    	}
    	Queueinit(ready_queue);
    	EnterQueueOfRuntime(ready_queue,&pro[0]);
    	time = pro[0].arrivetime;
    	pronum = 1;                     //记录当前的进程
    	sum_T_time = 0, sum_QT_time = 0;
    	i=0;
    	while(ready_queue->size>0) {
    		curpro=poll(ready_queue);//就绪队列中的队头进程进入CPU中运行
    		if(time<curpro->arrivetime) { //如果该进程与上一次运行的进程结束时间之间有间隔,则将CPU运行时间变为该进程到达时间
    			time=curpro->arrivetime;
    		}
    		done_time=time+curpro->running_time;
    		curpro->start_time=time;
    		curpro->done_time=done_time;
    		curpro->zztime = done_time - curpro->arrivetime;//周转时间
    		curpro->dqzztime = curpro->zztime / curpro->running_time;//带权周转时间
    		//打印正在运行的进程
    		PrintRunningprogram(curpro);
    		//将curpro的信息复制到pro1[i]中
    		CopyProgram(&pro1[i],curpro);
    		i++;
    		sum_T_time += curpro->zztime;
    		sum_QT_time += curpro->dqzztime;
    		while(pronum<num) { //将在CPU中的进程运行的时间内到达的进程放入就绪队列
    			if(pro[pronum].arrivetime<=done_time) {
    				EnterQueueOfRuntime(ready_queue,&pro[pronum]);
    				pronum++;
    			} else {
    				break;
    			}
    		}
    		//打印就绪队列
    		PrintReadyqueue(ready_queue);
    		time=done_time;
    		if(ready_queue->size==0&&pronum<num) { //防止出现前一个进程执行完到下一个进程到达之间无进程进入
    			EnterQueueOfRuntime(ready_queue,&pro[pronum]);
    			pronum++;
    		}
    	}
    	PrintSortOfRunningprogram(pro1,num);
    	printf("\t平均周转时间为:%.2f\n", sum_T_time / num);
    	printf("\t平均带权周转时间为:%.2f\n",sum_QT_time/num);
    }
    
    void HPF(PCB pro[],int num) {
    	int time,done_time;
    	float sum_T_time,sum_QT_time;
    	int i,pronum;
    	PCBQueue *ready_queue;
    	PCB *curpro,pro1[MAXSIZE];
    
    	printf("\n\t\t\t\t\t高优先级算法进程调度模拟\n\n");
    	printf("\t————————————————————————————————————————————————\n");
    	sortWithEnterTime(pro, num);
    	ready_queue = (PCBQueue*)malloc(sizeof(PCBQueue));
    	if(!ready_queue) {
    		printf("分配就绪队列头结点内存失败!");
    		exit(1);
    	}
    	Queueinit(ready_queue);
    	EnterQueueOfPriority(ready_queue,&pro[0]);
    	time = pro[0].arrivetime;
    	pronum = 1;                   //记录当前的进程
    	sum_T_time = 0, sum_QT_time = 0;
    	i=0;
    	while(ready_queue->size>0) {
    		curpro=poll(ready_queue);//就绪队列中的队头进程进入CPU中运行
    		if(time<curpro->arrivetime) { //如果该进程与上一次运行的进程结束时间之间有间隔,则将CPU运行时间变为该进程到达时间
    			time=curpro->arrivetime;
    		}
    		done_time=time+curpro->running_time;
    		curpro->start_time=time;
    		curpro->done_time=done_time;
    		curpro->zztime = done_time - curpro->arrivetime;//周转时间
    		curpro->dqzztime = curpro->zztime / (curpro->running_time + 0.0);//带权周转时间
    		//打印正在运行的进程
    		PrintRunningprogram(curpro);
    		//将curpro的信息复制到pro1[i]中
    		CopyProgram(&pro1[i],curpro);
    		i++;
    		sum_T_time += curpro->zztime;
    		sum_QT_time += curpro->dqzztime;
    		while(pronum<num) { //将在CPU中的进程运行的时间内到达的进程放入就绪队列
    			if(pro[pronum].arrivetime<=done_time) {
    				EnterQueueOfPriority(ready_queue,&pro[pronum]);
    				pronum++;
    			} else {
    				break;
    			}
    		}
    		//打印就绪队列
    		PrintReadyqueue(ready_queue);
    		time=done_time;
    		if(ready_queue->size==0&&pronum<num) { //防止出现前一个进程执行完到下一个进程到达之间无进程进入
    			EnterQueueOfPriority(ready_queue,&pro[pronum]);
    			pronum++;
    		}
    	}
    	PrintSortOfRunningprogram(pro1,num);
    	printf("\t平均周转时间为:%.2f\n", sum_T_time / num);
    	printf("\t平均带权周转时间为:%.2f\n",sum_QT_time/num);
    }
    void RR(PCB pro[], int num) { //时间片轮转算法
    	int time,done_time,T_time;
    	int i,count,tt,timeslice,pronum;
    	float QT_time,sum_T_time,sum_QT_time;
    	PCB *curpro,*temp_PCB;
    
    	printf("\n\t\t\t\t\t时间片轮转算法进程调度模拟\n\n");
    	printf("\t————————————————————————————————————————————————\n");
    	count=0;
    	PCB pro2[100];
    	printf("\t请输入时间片大小:");
    	scanf("%d", &timeslice);
    	sortWithEnterTime(pro, num);
    	PCBQueue* queue = (PCBQueue*)malloc(sizeof(PCBQueue));
    	Queueinit(queue);
    	pro[0].start_time = pro[0].arrivetime;
    	EnterQueue(queue, &pro[0]);
    	time = 0;
    	pronum = 1;
    	sum_T_time = 0, sum_QT_time = 0;
    	while (queue->size > 0) {
    		curpro = poll(queue);                      // 从就绪队列中取出一个进程
    		if (time < curpro->arrivetime) {
    			time = curpro->arrivetime;                 // 计算开始运行时间
    		}
    		if (timeslice >= curpro->running_time) {        // 如果剩余时间小于时间片  则此任务完成
    			for (tt = time; tt <= time + curpro->running_time && pronum < num; tt++) {  // 模拟进程的执行过程
    				if (tt >= pro[pronum].arrivetime) {     // 统计从此任务开始到结束之间有几个进程到达
    					pro[pronum].start_time = tt;
    					EnterQueue(queue, &pro[pronum]);
    					pronum++;
    				}
    			}
    			time += curpro->running_time;
    			curpro->running_time = 0;
    			curpro->done_time = time;
    			T_time = curpro->done_time - curpro->start_time;
    			QT_time = T_time / (curpro->copyRunning_time + 0.0);
    			sum_T_time += T_time;
    			sum_QT_time += QT_time;
    
    			strcpy(pro2[count].name, curpro->name) ;
    			pro2[count].arrivetime=curpro->arrivetime;
    			pro2[count].running_time= curpro->copyRunning_time;
    			pro2[count].priority=curpro->priority;
    			pro2[count].start_time=curpro->start_time;
    			pro2[count].done_time=curpro->done_time;
    			pro2[count].zztime=T_time;
    			pro2[count].dqzztime=QT_time;
    			count++;
    
    			printf("\n\t执行完成》》》进程%s!\n",curpro->name);
    			printf("\t————————————————————————————————————————————————\n");
    			if(queue->size!=0) {
    				printf("\t就绪队列:\n");
    				printf("\t————————————————————————————————————————————————\n");
    				printf("\t进程 到达时间  服务时间  优先级\n");
    				PCB* temp_PCB=queue->firstProg->next;
    				for(i=queue->size; i>0; i--) {
    					printf("\t%s\t%d\t%d\t   %d\n",temp_PCB->name,temp_PCB->arrivetime,temp_PCB->running_time,temp_PCB->priority);
    					temp_PCB=temp_PCB->next;
    				}
    				printf("\t————————————————————————————————————————————————\n\n\n");
    			} else {
    				printf("\t 无进程处于就绪状态!\n");
    				printf("\t————————————————————————————————————————————————\n\n\n");
    			}
    
    			if (queue->size == 0 && pronum < num) {   //防止出现前一个进程执行完到下一个进程到达之间无进程进入
    				pro[pronum].start_time = pro[pronum].arrivetime;
    				EnterQueue(queue, &pro[pronum]);
    				pronum++;
    			}
    			continue;
    		}
    		for (tt = time; tt <= time + timeslice && pronum < num; tt++) {    //模拟进程的执行过程
    			if (tt >= pro[pronum].arrivetime) { // 统计从此任务开始到结束之间有几个进程到达
    				pro[pronum].start_time = tt;
    				EnterQueue(queue, &pro[pronum]);
    				pronum++;
    			}
    		}
    
    		printf("\n\t正在执行》》》进程%s\n",curpro->name);
    		printf("\t————————————————————————————————————————————————\n");
    		if(queue->size!=0) {
    			printf("\t就绪队列:\n");
    			printf("\t————————————————————————————————————————————————\n");
    			printf("\t进程 到达时间  服务时间  优先级\n");
    			temp_PCB=queue->firstProg->next;
    			for(i=queue->size; i>0; i--) {
    				printf("\t%s\t%d\t%d\t%d\n",temp_PCB->name,temp_PCB->arrivetime,temp_PCB->running_time,temp_PCB->priority);
    				temp_PCB=temp_PCB->next;
    			}
    			printf("\t————————————————————————————————————————————————\n\n\n");
    		} else {
    			printf("\t 无进程处于就绪状态!\n");
    			printf("\t————————————————————————————————————————————————\n\n\n");
    		}
    
    		time += timeslice;
    		curpro->running_time -= timeslice;
    		EnterQueue(queue, curpro);    //当前程序未完成  继续添加到队列中
    
    		if (queue->size == 0 && pronum < num) {   //防止出现前一个进程执行完到下一个进程到达之间无进程进入
    			pro[pronum].start_time = pro[pronum].arrivetime;
    			EnterQueue(queue, &pro[pronum]);
    			pronum++;
    		}
    	}
    	PrintSortOfRunningprogram(pro2,count);
    	printf("\t平均周转时间为:%.2f\n", sum_T_time / num);
    	printf("\t平均带权周转时间为:%.2f\n",sum_QT_time/num);
    }
    
    void menu() {
    	printf("\t\t\t\t\t<<-------------操作系统进程调度算法模拟程序----------——>>\n");
    	printf("\t\t\t\t\t1.先来先服务算法\n");
    	printf("\t\t\t\t\t2.短进程优先算法\n");
    	printf("\t\t\t\t\t3.高优先级算法\n");
    	printf("\t\t\t\t\t4.时间片轮转算法\n");
    	printf("\t\t\t\t\t5.退出\n");
    	printf("\t\t\t\t\t请选择进程调度算法:");
    }
    
    int main() {
    	int n, t = 1;
    	int proNum,  choice;
    	PCB pro[MAXSIZE],temp_pro[MAXSIZE];
    
    	printf("\n\n\t\t\t\t\t<<-------------进程初始化----------——>>\n");
    	printf("\t\t\t\t\t请输入进程的个数:");
    	scanf("%d", &proNum);
    	inputProgram(pro, proNum);
    	while (t) {
    		menu();
    		memcpy(temp_pro, pro, (sizeof(pro) / sizeof(pro[0])) * sizeof(PCB));
    		scanf("%d", &n);
    		while (n <= 0 || n > 5) {
    			printf("\t\t\t指令不正确,请重新输入指令: ");
    			scanf("%d", &n);
    		}
    		system("cls");
    		switch (n) {
    			case 1: {
    				FCFS(temp_pro, proNum);
    				break;
    			}
    			case 2: {
    
    				SJF(temp_pro, proNum);
    				break;
    			}
    			case 3: {
    				HPF(temp_pro, proNum);
    				break;
    			}
    			case 4: {
    				RR(temp_pro, proNum);
    				break;
    			}
    			case 5: {
    				t = 0;
    				break;
    			}
    		}
    		getchar();
    		printf("\n\t按任意键继续.......");
    		getchar();
    		system("cls");
    	}
    	system("cls");
    	printf("\n\n\t\t\t\t\t您已成功退出系统!!!\n");
    
    	return 0;
    }
    

    3、测试结果

    (1)输入进程

     (2)先来先服务调度算法(FSFS)

     (3)短作业优先调度算法(SJF)

     (4)高优先级调度算法

     

    (5)时间片轮转调度算法

    中间还有进程调度的详细过程图片......... (太多,放一两张)

     

    展开全文
  • 使用动态优先权的进程调度算法 C语言模拟实现 含详细源代码和实验结果 题目描述 实现对N个进程采用某种进程调度算法(如动态优先权调度)的调度 每个用来标识进程的进程控制块PCB可用结构来描述,包括以下字段...
  • 操作系统os进程调度,作业调度以及请求分页系统的实现,其中进程调度涉及FCFS算法,时间片轮转法以及多级反馈队列实现。作业调度涉及FCFS以及短作业优先等。有源代码以及文档解释
  • c语言模拟进程调度

    2021-05-22 13:29:00
     //进程调度函数 int pro_running(); int main() { process_init(); printf("The %d process have been ready,we can GO!!\n", N); sleep(1); while(1) { schedule(); pro_running(); } return 0; } int schedule()...
  • C语言模拟进程调度算法

    千次阅读 2019-06-11 09:58:09
    本程序中主要通过7个子函数来实现多个进程并发执行的模拟,分别是加入准备队列函数sort、输入进程函数input、计算准备队列长度函数space、显示进程函数disp、输出正在运行进程和等待中进程的函数check、进程结束函数...
  • 进程调度算法c语言

    万次阅读 多人点赞 2018-12-04 21:34:34
    对一个非抢占式多道批处理系统采用以下算法的任意两种,实现进程调度,并计算进程的开始执行时间,周转时间,带权周转时间,平均周转时间,平均带权周转时间 1.先来先服务算法 2.短进程优先算法 *3.高响应比优先算法 三...
  • 操作系统课程设计报告进程调度算法模拟_毕业论文《操作系统原理及应用》课程设计报告进程调度算法模拟学院(系): 计算机科学与工程学院班 级:学学生姓名:同组人员:时间: 从 2016年 12 月27日 到 2017 年01月03日...
  • 进程调度算法--c语言实现

    万次阅读 多人点赞 2018-12-03 20:15:22
    下面我用c语言模拟实现了FCFS(先来先服务)、SJF(短作业优先)和RR(时间片轮转)的操作系统中的进程调度算法,还有实现结果哦~~  关于这些算法的思想,大家可以去自己找一下,我呢就用结构体数组简单的实现了一下...
  • Linux 进程调度算法c语言描述

    千次阅读 2019-04-17 21:44:08
    进程调度分为: 长程调度,又称作业调度,用于决定把外存上处于后备队列中的哪些作业调入内存,并为它们创建进程、分配...常见的cpu调度算法有先到先服务调度(FCFS)、最短作业优先调度(SJF)、优先级调度(pri...
  • OS短作业优先调度算法C语言 采用短作业优先调度算法调度程序 学 号: 姓 名: 专 业: 指导老师: 日 期: 目录 一、实验题目3 二、课程设计的目的3 三、设计内容3 四、设计要求3 五、主要数据结构及其说明4 六、...
  • 单处理器进程调度算法实现FCFS,RR,SPN,SRT,HRRN,使用C++实现
  • C语言编程实现先来先服务和最短作业优先调度算法(设计型实验)
  • NULL 博文链接:https://touch-2011.iteye.com/blog/1047163
  • //高响应比调度算法 #include<stdio.h> #include<stdlib.h> struct zgxyb{ char name[10]; float arrivetime; float servicetime; float starttime; float finishtime; float zztime; float dqzztime; }; struct ...
  • 先服务调度算法-c语言编程实现

    千次阅读 2021-11-08 16:54:53
    使用c语言编写程序,实现先来先服务调度算法,对作业进行调度。当前时间为0点,时间单位为分钟。程序通过命令行读入作业信息,输入格式见注1。将调度结果输出到屏幕上,输出格式见注2,输出结果包括作业ID、作业开始...
  • 先来先服务FCFS算法进程先进入的先服务。 短作业优先SJF算法:根据当前到来的进程,筛选当前所有进程中所需运行时间最短的进程。 时间片轮转算法:根据时间片的大小,切换进程,直到每个进程都运行完成。 计算出每...
  • 教育资料 xx大学 操作系统 实验报告 姓名 学号 班级 实验日期 实验名称先来先服务FCFS和短作业优先SJF进程调度算法 实验一 先来先服务FCFS和短作业优先SJF进程调度算法 1. 实验目的 通过这次实验理解FCFS和SJF进程...
  • 按照作业提交或进程变为就绪状态的先后次序,分派CPU;当前作业或进程占用CPU,直到执行完成或阻塞才让出CPU(非抢占方式) 优点:先到的进程先服务,比较利于长作业,利于CPU繁忙的作业 缺点:如果先来的进程需要...
  • 本代码实现了五种调度算法 1、 先来先服务 2、 轮转调度 3、 最短作业优先 4、 最短剩余时间优先 5、 最高相应比优先
  • 基于visual C++的进程调度算法模拟(C语言) 功能强大
  • 操作系统--进程调度C语言

    千次阅读 2019-07-08 17:22:05
    #include<stdio.h> #include<stdlib.h> #include #include<malloc.h> using namespace std;... //进程状态 2–表示"执行"状态 1–表示"就绪"状态 0–表示"阻塞"状态 int cpu_t......

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,472
精华内容 7,388
关键字:

进程调度算法c语言