模拟进程调度算法-时间片轮转算法

/*
进程调度模拟实验代码实现
我采用的是时间片轮转调度算法  
*/ 

#include<iostream>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<cstdlib> 
#include<iomanip>
#include<algorithm>
#define N 25
#define NN 110

using namespace std;

int num; // 进程的数量 

//p结构体数组存放临时数据；
//res结构体数组存放最后结果
 
struct Node{
	string str_name; // 名字 
	int time_arrive; // 到达时间 
	int time_serve; // 服务时间 
	int	time_surplus; // 剩余服务时间 
	int time_begin; // 开始时间 
	int time_finish; // 完成时间 
	int time_revolve; // 周转时间
	double weight;  // 带权 
	int flag_finish; // 标识位(看有无进程) 
}p[N], res[NN];  

//输入 
void input(int u){
	for(int i=0;i<u;i++){
		cout << "请输入进程名, 到达时间, 服务时间" << endl;
		cin >> p[i].str_name;
		cin >> p[i].time_arrive;
		cin >> p[i].time_serve;
		// 输入的数据同时也放在res结构体数组中
		res[i].str_name = p[i].str_name; 
		res[i].time_arrive = p[i].time_arrive;
		res[i].time_serve = p[i].time_serve;
	}
}

//输出 
void output(int u){
	cout << endl;
	cout << endl;
	cout << "结果数据: " << endl;
	cout << "        ";
	cout << "进程名" << setw(10) 
		 << "到达时间" << setw(10) 
		 << "服务时间" << setw(10) 
		 << "开始时间" << setw(10) 
		 << "完成时间" << setw(10)
		 << "周转时间" << setw(10)
		 << "带权时间" << endl; 
	
	for(int i=0;i<u;i++){
		cout << "        ";
		cout << setw(3) << res[i].str_name
			 << setw(10) << res[i].time_arrive
			 << setw(10) << res[i].time_serve
			 << setw(10) << res[i].time_begin
			 << setw(10) << res[i].time_finish
			 << setw(10) << res[i].time_revolve
			 << setw(13) << res[i].weight << endl;
	}
}

//按照到达时间将进程从小到大排序 
bool cmp(Node a, Node b){
	return a.time_arrive < b.time_arrive;
}


void convert_to_res(int m, int n){
	// 开始时间(从前往后遍历) 
	for(int i=0;i<m;i++){
		for(int j=0;j<n;j++){
			if(res[i].str_name == p[j].str_name){
				res[i].time_begin = j;
				break;
			}
		}
	}
	
	//完成时间(从后往前)
	for(int i=0;i<m;i++){
		for(int j=n-1;j>=0;j--){
			if(res[i].str_name == p[j].str_name){
				res[i].time_finish = j + 1;
				break;
			}
		}
	}
	
	// 周转时间(完成 - 到那)
	for(int i=0;i<m;i++){
		if(i <= 1){
			res[i].time_revolve = res[i].time_finish - res[i].time_begin;
		}else{
			res[i].time_revolve = (res[i].time_finish - res[i].time_begin) + (i - 1);
		}
	} 
	
	// 带权(周转/服务)
	for(int i=0;i<m;i++){
		res[i].weight = double(res[i].time_revolve) / double(res[i].time_serve);
	}
}

void Main(int u){
	
	cout << "请输入时间片长度：" << endl;
	int m;
	cin >> m;
	
	int flag = 1;//标志队列中是否还有进程
	int Count_finish = 0;//完成的进程数
	
	cout << "过程数据: " << endl; 
	cout << "        ";
	cout << "进程名称" << setw(15)
		 << "开始时间" << setw(15)
		 << "运行时间" << setw(15) 
		 << "剩余服务时间" << setw(15)
		 << "结束时间" << endl;
	
	int time;  //记录现在时间
	int c = 0; // 计数器(记录次数) 
	while(Count_finish < u){ // 完成的进程没有达到进程的数量 
		flag = 0; // 表示就绪队列里没有进程
		for(int i=c;i<u;i++){
			sort(p, p+u, cmp); // 按照进程到达时间从小到大排序 
			p[i].time_surplus = p[i].time_serve;
			p[i].time_begin = p[i-1].time_finish; //上一个作业结束时间
			
			/*
				判断该进程的开始时间与到达时间的关系
				1、如果开始时间小于到达时间，那么开始时间 == 到达时间；
				2、否则开始时间 == 上一个进程的完成时间 
			*/ 
			if(p[i].time_begin < p[i].time_arrive){
				p[i].time_begin = p[i].time_arrive;
			}else{
				p[i].time_begin = p[i-1].time_finish;
			}
			
			time = p[i].time_begin; // 当前时间为当前进程的开始时间 
			if (p[i].flag_finish == 1){ //表示当前进程已完成 
				continue;
			}else{
				if(p[i].time_surplus <= m && time >= p[i].time_arrive){
					flag = 1;
					time = time + p[i].time_surplus;
					p[i].flag_finish = 1;//该进程完成
					p[i].time_finish = time;
					cout << "      ";
					cout  << setw(8) << p[i].str_name
						  << setw(13) << (p[i].time_finish - p[i].time_surplus) 
						  << setw(15) << p[i].time_surplus 
						  << setw(16) << 0
						  << setw(18) << p[i].time_finish << endl;
						
					p[i].time_surplus = 0;  //进程完成后剩余时间为0 
				}else if(p[i].time_surplus > m && time >= p[i].time_arrive){
					// 如果该进程的剩余时间 > 时间片并且当前时间 > 该进程的到达时间 
					flag = 1;
					time += m; // 自然当前时间要加上时间片
					p[i].time_surplus -= m; // 剩余时间要减去时间片 
					p[i].time_finish = time; // 完成的时间就是当前的时间 
				
					cout << "      ";
					cout << setw(8) << p[i].str_name
						 << setw(13) << (time - m)
						 << setw(15) << m
						 << setw(16) << p[i].time_surplus
						 << setw(18) << p[i].time_finish << endl;
					 
					p[u].str_name = p[i].str_name;
					p[u].time_arrive = time;
					p[u].time_serve = p[i].time_surplus;
					u++;
				}
				if(p[i].flag_finish == 1){
					Count_finish ++;  //一个进程完成加一
				}
			}
			c++;
		}
		break;
		if(flag == 0 && Count_finish < u){
			//没执行完且没进入就绪队列
			for(int i=0;i<u;i++){
				if(p[i].flag_finish == 0){
					time = p[i].time_arrive;
					break;
				}
			}
		}
	}
	
//临时的数据输出 
//	output(u);
//	cout << endl;
	
//	cout << "c is : " << c << endl;
//	cout << "u is : " << u << endl;	

// 将数据存放在res结构体数组中
	int ans = num;
	convert_to_res(ans, u);	
}

int main () {
	int n;
	cout << "请输入进程的数量：";
	cin >> n;
	num = n; 
	
//	cout << n << endl;
	input(n); // 输入 
	Main(n); // 执行时间片轮转算法 
	output(n); // 输出结果
	
	return 0;
}


// 样例
/*
输入：
p1 0 3
p2 2 6
p3 4 4 
p4 6 5 
p5 8 2 
时间片：1 
*/ 

/*
输出：
过程结果：这里只写进程顺序
		  p1p1p2p1p2p3p2p4p3p2p5p4p3p2p5p4p3p2p4p4 
最后结果表：
 
进程名    到达时间    服务时间     开始时间    完成   周转  带权 
  p1         0           3            0         4      4     4/3(浮点数显示)
  p2         2           6            2         18     16    16/6
  p3         4           4            5         17     13    13/4
  p4         6           5            7         20     15    15/5
  p5         8           2            10        15     8     8/2 

*/

运行结果

更多推荐

进程调度模拟-时间片轮转算法代码实现