精华内容
下载资源
问答
  • 华北科技学院计算机系综合性实验报告 操作系统 实验题目 进程调度算法模拟 一实验目的 通过对进程调度算法的模拟进一步理解进程的基本概念加深对进程运行状态和进程调度 过程调度算法的理解 二设备与环境 1硬件设备 ...
  • 目录前言先来先服务调度算法短作业优先调度算法时间片轮转法多级队列反馈优先权调度算法非抢占式优先权算法抢占式优先权调度算法Unix、Linux与Windows进程调度策略的比较LinuxUnixWindows 前言 是进程调度算法,是...

    前言

    是进程调度算法,是进程调度算法,是进程调度算法。

    先来先服务调度算法

    顾名思义,谁先来的谁就先获取cpu,一直运行。就像队列一样,谁先来的队列,谁就开始运行,运行完,执行下一个线程。

    短作业优先调度算法

    顾名思义,从队列中,挑选出一个运行时间最短的作业,调入内存中进行运行。

    时间片轮转法

    按照就绪进程先来先服务的原则排成一个队列,每次调度的时候,cpu分配给队首进程,并且执行一个时间片。时间片的大小从几ms到几百ms,当执行的执行片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪的队列的末尾。然后再运行队列第一个进程,如同上。换言之,系统能在指定的范围内响应所有用户的请求。

    多级队列反馈

    设置多个就绪队列,每个队列的优先级不同,当然优先级不同分到的时间片长度就越长,反之亦然。

    当一个新进程进入内存后,首先将它放入第一队列的末尾,按FCFS原则排队等待调度。当轮到该进程执行时,如它能在该时间片内完成,便可准备撤离系统;如果它在一个时间片结束时尚未完成,调度程序便将该进程转入第二队列的末尾,再同样地按FCFS原则等待调度执行;如果它在第二队列中运行一个时间片后仍未完成,再依次将它放入第三队列,……,如此下去,当一个长作业(进程)从第一队列依次降到第n队列后,在第n队列便采取按时间片轮转的方式运行。

    优先权调度算法

    系统从队列中选出优先权最高的作业装载入内存,当用于进程调度时,该算法是把处理机分配给就绪队列中优先权最高的进程,这时,又可进一步把该算法分成如下两种。

    非抢占式优先权算法

    在这种方式下,系统一旦把处理机分配给就绪队列中优先权最高的进程后,该进程便一直执行下去,直至完成;或因发生某事件使该进程放弃处理机时,系统方可再将处理机重新分配给另一优先权最高的进程。这种调度算法主要用于批处理系统中;也可用于某些对实时性要求不严的实时系统中。

    抢占式优先权调度算法

    在这种方式下,系统同样是把处理机分配给优先权最高的进程,使之执行。但在其执行期间,只要又出现了另一个其优先权更高的进程,进程调度程序就立即停止当前进程(原优先权最高的进程)的执行,重新将处理机分配给新到的优先权最高的进程。因此,在采用这种调度算法时,是每当系统中出现一个新的就绪进程i时,就将其优先权Pi与正在执行的进程j的优先权Pj进行比较。如果Pi≤Pj,原进程Pj便继续执行;但如果是Pi>Pj,则立即停止Pj的执行,做进程切换,使i进程投入执行。显然,这种抢占式的优先权调度算法能更好地满足紧迫作业的要求,故而常用于要求比较严格的实时系统中,以及对性能要求较高的批处理和分时系统中。

    Unix、Linux与Windows进程调度策略的比较

    无论在批处理还是分时系统中,用户进程数远远大于Cpu处理机数,这将导致他们会争夺资源。另外,系统的运行也需要cpu资源,也就要求进程调度按一定的策略。,动态把处理机制分配给就绪队列中的进程。

    进程调度的实质是资源的分配,如何使系统能够保持较短的响应时间和较高的吞吐量,如何在多个可运行的进程中选取一个最值得运行的进程投入运行是调度器的主要任务。进程调度包括两个方面的内容:何时分配CPU 时间(调度时机)即调度器什么时候启动;如何选择进程(调度算法)即调度器该怎么做。进程调度主要可以分为非剥夺方式与剥夺方式两种。

    非剥夺方式:调度程序一旦把处理机分配给某进程后便让它一直运行下去,直到进程完成或发生某事件而阻塞时,才把处理机分配给另一个进程。

    剥夺方式:当一个进程正在运行时,系统可以基于某种原则,剥夺已分配给它的处理机,将之分配给其它进程。剥夺原则有:优先权原则、短进程优先原则、时间片原则。

    Linux

    Linux 从整体上区分实时进程和普通进程,因为实时进程和普通进程度调度是不同的,它们两者之间,实时进程应该先于普通进程而运行,然后,对于同一类型的不同进程,采用不同的标准来选择进程。对普通进程的调度策略是动态优先调度,对于实时进程采用了两种调度策略,FIFO(先来先服务调度)和RR(时间片轮转调度)。

    Unix

    UNIX系统是单纯的分时系统,所以没有设置作业调度。UNIX系统的进程调度采用的算法是,多级反馈队列调度法。其核心思想是先从最高休先级就绪队列中取出排在队列最前面的进程,当进程执行完一个时间片仍未完成则剥夺它的执行,将它放入到相应的队列中,取出下一个就绪进程投入运行,对于同一个队列中的各个进程,按照时间片轮转法调度。多级反馈队列调度算法即能使高优先级的作业得到响应又能使短作业(进程)迅速完成。但是它还是存在某些方面的不足,当不断有新进程到来时,则长进程可能饥饿。

    Windows

    Windows 系统其调度方式比较复杂,它的处理器调度的调度单位是线程而不是进程,是基于优先级的抢占式多处理器调度,依据优先级和分配时间片来调度。而且Windows 2000/XP在单处理器系统和多处理器系统中的线程调度是不同的线程调度机制,Windows操作系统的调度系统总是运行优先级最高的就绪线程。在同一优先级的各线程按时间片轮转算法进行调度。如果一个高优先级的线程进入就绪状态,当前运行的线程可能在用完它的时间片之前就被抢占处理机。

    展开全文
  • 谈谈Linux/Windows 中使用的调度算法 如何评价调度算法的性能谈谈下面每对指标间的关系 aCPU利用率和响应时间 b平均周转时间和最大等待时间 cI/O设备利用率和CPU利用率 CPU使用率其实就是你运行的程序占用的CPU资源...
  • 进程调度算法模拟

    2011-12-04 02:58:23
    用qt做的操作系统课程设计进程调度算法,可以用到Iinux和Windows上。
  • 进程调度算法

    2016-01-08 18:46:22
    基于windows操作系统的进程问题,利用c语言编写模拟进程的调用环境.doc
  • 利用C 语言开发基于Windows环境的进程调度算法辅助教学软件,同时采用MFC库设计与实现GUI界面。该软件实现了先来先服务调度算法、短进程优先调度算法、优先级调度算法,时间片轮转调度算法和高响应比优先调度算法;...
  • 进程调度算法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:进程调度算法 #include <bits/stdc++.h> #include<windows.h> #define P_NUM 5 #define P_TIME 50 using namespace std; enum state{ ready, execute, block, finish };//定义...

    不多说直接上代码

    #include <bits/stdc++.h>
    #include<windows.h> 
    #define P_NUM 5
    #define P_TIME 50
    using namespace std;
    
    enum state{
        ready,
        execute,
        block,
        finish
    };//定义进程状态
    
    struct pcb{
        char name[4];   //进程名
        int priority;   //优先权
        int cputime;    //cpu运行时间
        int needtime;   //进程运行所需时间
        int count;      //进程执行次数
        int round;      //时间片轮转次数
        state process;  //进程状态
        pcb * next;     //指针
    };   //定义进程PCB
    
    pcb * get_process(){
        pcb *q;
        pcb *t;
        pcb *p;
        int i=0;
        cout<<"输入名字和时间:"<<endl;
        while (i<P_NUM){
            q=(struct pcb *)malloc(sizeof(pcb));
            cin>>q->name;
            cin>>q->needtime;
            q->cputime=0;
            q->priority=P_TIME-q->needtime;
            q->process=ready;
            q->next=NULL;
            if(i==0){
                p=q;
                t=q;
            } else{
                t->next=q; //创建就绪进程队列
                t=q;
            }
            i++;
        }
        return p;
    }  //输入模拟测试的进程名和执行所需时间,初始设置可模拟5个进程的调度
    
    void display(pcb *p){
        cout<<"名字="<<"  "<<"cputime"<<" "<<"needtime"<<"    "<<"priority"<<"    "<<"state"<<endl;
        while (p){
            cout<<p->name<<"    ";
            cout<<p->cputime<<"    ";
            cout<<p->needtime<<"    ";
            cout<<p->priority<<"    ";
            switch (p->process) {
                case ready: cout<<"ready"<<endl;break;
                case execute: cout<<"execute"<<endl;break;
                case block: cout<<"block"<<endl;break;
                case finish: cout<<"finish"<<endl;break;
            }
            p=p->next;
        }
    }  //显示模拟结果,包含进程名、cpu时间、运行所需时间以及优先级
    
    
    int process_finish(pcb *q){
        int b1=1;
        while (b1&&q){
            b1=b1&&q->needtime==0;
            q=q->next;
        }
        return b1;
    }  //结束进程,即将队列中各进程的所需时间设置为0
    
    void cpuexe(pcb *q){
        pcb *t=q;
        int tp=0;
        while (q){
            if(q->process!=finish){
                q->process=ready;
                if(q->needtime==0){
                    q->process=finish;
                }
            }
            if(tp=q->priority&&q->process!=finish){
                tp=q->priority;
                t=q;
            }
            q=q->next;
        }
        if(t->needtime!=0){
            t->priority=3;
            t->needtime--;
            t->process=execute;
            t->cputime++;
        }
    }  //选择某一进程,给它分配CPU
    //计算进程优先级
    
    void priority_cal(){
        pcb *p;
        system("cls");
        //clrscr();
        p=get_process();
        int cpu=0;
        system("cls");
        //clrscr();
        while (!process_finish(p)){
            cpu++;
            cout<<"cputime:"<<cpu<<endl;
            cpuexe(p);
            display(p);
            Sleep(2);
            //
            //
        }
        cout<<"All process have finished,press any key to exit"<<endl;
        getchar();
    }
    
    void display_menu(){
        cout<<"CHOOSE THE ALGORITHM:"<<endl;
        cout<<"1 PRIORITY"<<endl;
        cout<<"2 ROUNDROBIN"<<endl;
        cout<<"3 EXIT"<<endl;
    } //显示调度简单算法菜单,可提供用户选择优先权调度算法和时间片轮转调度算法
    
    pcb * get_process_round(){
        pcb *q;
        pcb *t;
        pcb *p;
        int i=0;
        cout<<"input name and time"<<endl;
        while (i<P_NUM){
            q=(struct  pcb *)malloc(sizeof(pcb));
            cin>>q->name;
            cin>>q->needtime;
            q->cputime=0;
            q->round=0;
            q->count=0;
            q->process=ready;
            q->next=NULL;
            if(i==0){
                p=q;
                t=q;
            }
            else{
                t->next=q;
                t=q;
            }
            i++;
        }
        return p;
    } //时间片轮转调度算法创建就绪队列进程队列
    
    void cpu_round(pcb *q){
        q->cputime+=2;
        q->needtime-=2;
        if(q->needtime<0){
            q->needtime=0;
        }
        q->count++;
        q->round++;
        q->process=execute;
    } //采用时间片轮转调度算法执行某一进程
    
    pcb * get_next(pcb * k,pcb *head){
        pcb * t;
        t=k;
        do{
            t=t->next;
        }
        while (t&&t->process==finish);
        if(t==NULL){
            t=head;
            while (t->next!=k && t->process==finish){
                t=t->next;
            }
        }
        return t;
    }
    
    void set_state(pcb *p){
        while (p){
            if(p->needtime==0){
                p->process=finish; //如果所需执行时间为0;则设置运行状态为结束
    
            }
            if(p->process==execute){
                p->process=ready;   //如果为执行状态则设置为就绪
            }
            p=p->next;
        }
    }   //设置队列中进程为执行状态
    
    void display_round(pcb *p){
        cout<<"NAME"<<" "<<"CPUTIME"<<" "<<"NEEDTIME"<<"    "<<"COUNT"<<"   "<<"ROUND"<<"   "<<"STATE"<<endl;
        while (p){
            cout<<p->name<<"    ";
            cout<<p->cputime<<"    ";
            cout<<p->needtime<<"    ";
            cout<<p->count<<"    ";
            cout<<p->round<<"    ";
            switch (p->process) {
                case ready: cout<<"ready"<<endl;break;
                case execute: cout<<"execute"<<endl;break;
                case finish: cout<<"finish"<<endl;break;
            }
            p=p->next;
        }
    } //时间片轮转调度算法输出调度信息
    
    
    void round_cal(){
        pcb *p;
        pcb *r;
        system("cls");
        p=get_process_round();
        int cpu=0;
        system("cls");
        r=p;
        while (!process_finish(p)){
            cpu+=2;
            cpu_round(r);
            r=get_next(r,p);
            cout<<"cpu"<<cpu<<endl;
            display_round(p);
            set_state(p);
            Sleep(5);
        }
    } //时间片轮转调度算法计算轮次及输出调度信息
    
    int main() {
        display_menu();
        int k;
        cin>>k;
        switch (k) {
            case 1: priority_cal();break;
            case 2: round_cal();break;
            case 3: break;
            display_menu();
            cin>>k;
        }
        return 0;
    }
    
    展开全文
  • 1)用C语言(或其它语言,如Java)实现对N个进程采用某种进程调度算法(如 动态优先权调度)的调度。 (2)每个用来标识进程的进程控制块PCB可用结构来描述,包括以下字段:  进程标识数ID。  进程优先数...
  • 模拟操作系统进程调度算法

    千次阅读 2015-11-09 21:25:47
    先来先服务算法: 1.链表存储 2.输入要有先后顺序(没有设计排序算法)#include #include ...#include <windows.h> using namespace std;#define NULL 0 int N = 0;//全局变量N,节点个数//进程节点 type

    先来先服务算法:
    1.链表存储
    2.输入要有先后顺序(没有设计排序算法)

    #include<iostream>
    #include <conio.h>
    #include<stdlib.h>
    #include<string.h>
    #include<time.h>
    #include <windows.h>
    using namespace std;
    
    #define NULL 0
    int N = 0;//全局变量N,节点个数
    
    //进程节点
    typedef struct node
    {
        char name;//进程名
        int arriveTime;//到达时间
        int startTime;//开始时间
        int myTime;//服务时间
        int flag;//记录进程状态,等待0 或者 执行1
        int ready;//记录进程已经进入就绪状态
        struct node *next;//存储下一个进程节点
    }Node;
    
    //进程调度类
    class Process
    {
    public:
        Process();
        void menu();//菜单
        void create();//创建进程
        Node *delet(Node *p);//删除进程
        void show();//显示进程
        void suanfa();//先来先服务算法
        int getAllTime();//得到总时间
        int getcount();//取的当前进程个数
        void showResult();//显示结果
        void sort();//排序算法,根据时间排序
    private:
        struct node *Head, *New, *Tail;
        int C;//进程状态
        int count;//节点个数
        int Time ;//时间点
        int EndTime;//记录每个进程结束的时间
    
        char Name[20];//开始顺序
        int arriveTime[20];//到达时间
        int myTime[20];//服务时间
        int endTime[20];//结束时间
        int zhouTime[20];//周转时间
    };
    //////////////////构造函数////////////////////////////
    Process::Process()
    {
        Head = New = Tail = NULL;
        count = C = 0;
        Time = EndTime = 0;
    }
    //////////////////菜单///////////////////////////
    void Process::menu()
    {
        cout<<endl<<endl;
        cout<<"\t  "<<"进程调度模拟程序"<<endl<<endl;
        cout<<"\t"<<"1.输入作业情况"<<endl<<endl;
        cout<<"\t"<<"2.显示作业情况"<<endl<<endl;
        cout<<"\t"<<"3.先来先服务算法"<<endl<<endl;
        cout<<"\t"<<"0.退出"<<endl<<endl<<endl;
        cout<<"请输入选择:";
    }
    //////////////////得到总时间///////////////////////////
    int Process::getAllTime()
    {
        int time = 0;
        Node *p = Head->next;
        for(p; p != NULL; p = p->next)
        {
            time = time + p->myTime;
        }
        return time;
    }
    //////////////////创建进程////////////////////////////
    void Process::create()
    {
        cout<<"输入作业个数:";
        cin>>N;
        while(count < N)
        {
            New = new Node;
            count++;
            cout<<"进程"<<count<<endl;
            cout<<"进程名:";
            cin>>New->name;
            cout<<"到达时间:";
            cin>>New->arriveTime;
            cout<<"服务时间:";
            cin>>New->myTime;
            New->flag = 0;//处于等待状态
            New->ready = 0;//未就绪状态
            cout<<endl<<endl;
            if(count == 1)
            {
                Head = Tail = New;
            }
            else
            {
                Tail->next = New;
                Tail = New;
            }
        }
        Tail->next = NULL;//为节点置空
    
        New = new Node;//添加空的头节点
        New->next = Head;
        Head = New;
    
        New = NULL;
        system("cls");
    
    }
    //////////////////删除进程////////////////////////////
    Node * Process::delet(Node *p)
    {
        Node *q = Head;
        for(q; q->next != p; q = q->next){}
        q->next = p->next;
        free(p);
        count--;
        return q;
    }
    //////////////////显示进程////////////////////////////
    void Process::show()
    {
        system("cls");
        struct node *p = Head->next;//Head->next 为第一个存储进程的节点
        int i = 0;
    
        cout<<endl<<endl<<"\t"<<"进程名:\t";
        for(i = count; i > 0 ;i--)
        {
            cout<<p->name<<"\t";
            p = p->next;
        }p = Head->next;
    
        cout<<endl<<endl<<"\t"<<"到达时间:\t";
        for(i = count; i > 0 ;i--)
        {
            cout<<p->arriveTime<<"\t";
            p = p->next;
        }p = Head->next;
    
        cout<<endl<<endl<<"\t"<<"服务时间:\t";
        for(i = count; i > 0 ;i--)
        {
            cout<<p->myTime<<"\t";
            p = p->next;
        }
        cout<<endl<<endl<<endl;
    }
    //////////////////先来先服务算法/////////////////////
    void Process::suanfa()
    {
        system("cls");
        show();//显示进程
        Node *p= Head->next;
        int i, j, k, n, x, y; 
        i = j = k = n = x = y = 0;
    
        for(Time; ; Time++)
        {
            Sleep(300);
            for(p = Head->next; p != NULL; p = p->next)
            {
                if(p->flag == 0)//flag == 0处于未执行状态
                {
                    if(p->ready == 0)//ready == 0处于就绪状态
                    {
                        if(Time == p->arriveTime)
                        {
                            p->ready = 1;
                            cout<<"\t"<<"第"<<Time<<"S"<<"   进程"<<p->name<<"到达内存"<<endl<<endl;
                            arriveTime[x++] = p->arriveTime;
                        }
                    }
                }
                if(C == 0||p->flag == 1)
                {
                    if(p->flag == 0&&p->ready == 1)
                    {
                        p->flag = 1; C = 1;
                        cout<<"\t"<<"第"<<Time<<"S"<<"   进程"<<p->name<<"开始执行"<<endl<<endl;
                        p->startTime = Time;
                        Name[n++] = p->name;
                        myTime[y++] = p->myTime;    
                    }
                    if((p->myTime == Time - p->startTime)&&(p->ready == 1))
                    {
                        C = 0;
                        cout<<"\t"<<"第"<<Time<<"S"<<"   进程"<<p->name<<"结束!"<<endl<<endl;
                        EndTime = Time;         
                        endTime[j++] = EndTime;
                        zhouTime[k++] = EndTime - p->arriveTime;
    
                        Node *q = p;
                        p = delet(q);
                    }
                }
            }
            if(count == 0)
            {
                Time = 0;
                return;
            }
        }
    }
    //////////////////取得返回结果///////////////////////
    void Process::showResult()
    {
        cout<<"\t进程名  到达时间  服务时间  完成时间  周转时间"<<endl;;
        int i= 0;double allZhouTime = 0;
        for(i = 0; i < N ;i++)
        {
            allZhouTime = allZhouTime + zhouTime[i];
            cout<<"\t  "<<Name[i]<<" \t   "
                <<arriveTime[i]<<"\t      "
                <<myTime[i]<<"\t\t"
                <<endTime[i]<<"\t  "
                <<zhouTime[i]<<endl;
        }
        cout<<endl;
        cout<<" \t平均周转时间:"<<allZhouTime/N<<endl<<endl;
    }
    //////////////////主函数////////////////////////////
    int main()
    {
        Process pr;
        int chance = 0;
        while(true)
        {
            system("cls");
            pr.menu();
            cin>>chance;
            switch(chance)
            {
            case 1:
                pr.create();
                cout<<endl<<endl<<"按任意键继续......";
                break;
            case 2:
                pr.show();
                cout<<endl<<endl<<"按任意键继续......";
                getch();break;
            case 3:
                pr.suanfa();
                pr.showResult();
                cout<<endl<<endl<<"进程处理完毕!重新输入作业......";
                cout<<endl<<endl<<"按任意键继续......"<<endl;
                getch();break;
            case 0:
                break;
            }
            if(chance == 0)
                break;
        }   
        cout<<endl;
        system("pause");
        return 0;
    }
    
    
    展开全文
  • 这是我们系统级编程SSD6的大作业,问题是一个基于优先级抢占和周期调度的进程调度算法的模拟程序。虽然并不太熟悉,没有读过如Linux,Windows,等等操作系统的书籍,在不断的讨论和查阅中也简单地向操作系统底层进程...
  • 用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解。 二、 实验工具 Windows10操作系统、VC++6.0 三、 实验步骤 本实验采用最高优先数优先的调度算法(即把处理机分配给优先数最高的...
  • (1)目的:了解并掌握作业调度的功能,熟悉并掌握各种作业调度算法。 (2)任务:模拟实现先来先服务或者短作业优先调度算法。 (3)实验环境:安装eclipse 环境的Windows10 X64 操作系统。 内容、要求与安排 (1)实验...
  • 定义: 操作系统(Operating System, OS)是指控制和管理整个计算机系统的硬件和软件资源,并合理的组织调度计算机的工作和资源的分配,以提供给用户和其他软件方便的接口和环境的程序集合。 在操作系统的发展过程中...
  • <br />#include <iostream><br />#include <stdio.h><br />#include <string><br />//#include <windows.h> using namespace std; //hyugtyftydrtdtrdrrtrdrt struct Node {  ...
  • 操作系统进程调度实现算法(c语言版)

    万次阅读 多人点赞 2018-06-21 19:20:09
    #include &lt;stdio.h&gt;...windows.h&gt; //包含sleep函数#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFESIBLE -1#define OVERFLOW -2struct PCB{ char...
  • 实验二 进程调度 ...3. 掌握先来先服务的进程调度算法。 4. 掌握短进程优先的进程调度算法。 5. 掌握时间片轮转的进程调度算法。  二、 实验设备 1. 安装windows或者linux操作系统的PC机 2. 
  • 2) 短进程优先调度算法和时间片轮转调度算法; 3) 先入先出调度算法和时间片轮转让调度算法。 选择-一个调度算法,实现处理机调度。(2)功能实现 o输入提示选择哪种算法,例如:输入“0”--HPF,输入“1”--RR; ) ...
  • 用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解。 二、 实验工具 Windows系统 + VisuaStudio2019 三、 实验步骤 (1)进程调度程序要求 进程调度算法:采用最高优先数优先的调度...
  • Windows等操作系统下,使用的VC、VB、java或C等编程语言,利用相应的WIN32 API函数,编写程序实现进程或作业先来先服务、高优先权、按时间片轮转调度算法
  • 操作系统-进程调度

    2021-03-16 14:10:34
    进程调度LinuxWindows 先来先服务调度算法 短作业(进程)优先调度算法 最短剩余时间优先算法 时间片轮转法 多级反馈队列调度算法(设置多个就绪队列,对应不同的优先级,在优先权愈高的队列中,为每个进程所规定的...
  • 操作系统|进程调度

    2019-12-02 22:34:39
    因此在三种类型的OS(DOS、Windows、Linux),都无一例外地配置了进程调度。此外它也是对系统性能影响最大的一种处理机调度。 进程调度的任务 保存处理机的现场信息。在进行调度时首先需要保存当前进程的处理机的...
  • 通过本实验,加深对进程调度算法原理和过程的理解。 实验要求: (1) 对调度算法进行详细分析,在仔细分析的基础上,完全理解主要数据结构和过程的作用,给出主要数据结构的说明及画出主要模块的流程图。 (2) 根据...
  • OS回顾---进程调度

    2021-03-13 20:02:35
    短作业(进程)优先调度算法 最短剩余时间优先算法 时间片轮转法 多级反馈队列调度算法(设置多个就绪队列,对应不同的优先级,在优先权愈高的队列中,为每个进程所规定的执行时间片就愈小) 优先级调度算法 Linux 将...
  • 实验项目一:单处理机系统的进程调度 4学时 (一)实验目的要求 通过模拟进程控制方法和单处理机系统下的进程调度,了解进程的结构、进程的创建与撤销,进程的...本实验为单机模拟进程调度算法,在程序设计时不...
  • (2)理解五种常用的进程调度算法(FCFS、SJF、HRRF、HPF、RR),区分算法之间的差异性,并用C语言模拟实现各算法。 (3)了解操作系统中高级调度、中级调度和低级调度的区别和联系。 二、实验环境 硬件环境:计算机...
  • 磁盘调度算法的模拟与实现

    千次阅读 2019-01-05 22:20:46
    这是一个用IDEA为工具、Java为编程语言在Windows10为环境而实现模拟先来先服务算法(FCFS)、最短寻道时间优先算法(SSTF)、 扫描算法(SCAN)的一个模拟磁盘调度程序。 系统设计的内容 1.先来先服务算法(FCFS) 该...
  • 处理机调度算法1 实验内容及要求2 实验环境3 实验设计3.1 基本思想3.2 数据结构4 源代码5 运行结果 1 实验内容及要求 1、模拟先来先服务算法(FCFS)、短作业优先算法(SJF)和高响应比优先算法(HRRN); 2、能输入...
  • (一)实验目的要求 通过模拟进程控制方法和单处理机系统下的进程调度,了解进程的结构、进程...本实验为单机模拟进程调度算法,在程序设计时不需真正地建立线程或进程。 程序要求:为了清楚地观察诸进程的调度过程...
  • 进程调度模拟

    2015-11-09 11:46:28
    实验平台:windows 7,vs2010 实验目标:模拟短作业优先算法,时间片轮转算法,和优先数算法,并动态画出Grant图,计算每个进程的响应时间和周转时间

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 214
精华内容 85
关键字:

windows进程调度算法