操作系统原理轮转法

---

前言

开始把存的东西往csdn上丢..

---

一、 题目要求

设RQ(就绪队列)分为RQ1和RQ2，RQ1采用轮转法，时间q=7.RQ1>RQ2，RQ2采用短进程优先调度算法。测试数据如下：RQ1: P1-P5, RQ2: P6-P10　
进程 P1 P2 P3 P4 P5 P6 P7 P8 P9 P10
运行时间 16 11 14 13 15 21 18 10 7 14
已等待时间6 5 4 3 2 1 2 3 4 5
（RQ1，RQ2最好从文件中读）
输出进程的周转时间。

二、 程序功能及设计思路

需求分析：
1、 RQ1中的五个进程使用轮转法进行调度。
2、 RQ2中的五个进程使用短进程优先调度算法进行调度。
3、 RQ1，RQ2的读取来自文件。
4、 输出进程的周转时间
所以设计的程序功能必须含有轮转法和短进程优先调度算法。
设计思路：因为RQ具有进程名，运行时间，已等待时间等信息，所以采取vector来存储RQ。
而轮转法需要对已等待时间进行比较，选择等待队列中等待时间最长的进行轮转，所以从文件中读取RQ1后，将RQ1根据等待时间进行降序排列。然后开始进行轮转法，记录如果需等待时间大于时间片，进程一个周期减少一个时间片，如果小于则直接消耗完需等待时间，并将该进程从就绪队列中剔除。为了输出进程的周转时间，需采取客观的系统时间记录每个进程的开始时间和结束时间，两者相减得到的结果便是进程的周转时间。
短进程优先调度算法相比就比较简单，排序后直接根据从小到大的运行时间调度，且进程的周转时间就等于进程的已等待时间。

三、数据结构及算法设计

（1）设计：数据结构
因为进程具有进程名，所需时间，已等待时间，周转时间，运行次数，第一次开始运行时间等性质，所以采用了结构体（struct PCB）来构造。同时为了利用其信息进行排序等操作，选择了PCB类型的vector的容器。
struct PCB {
string name;//进程名
int needtime;//所需时间
int waittime;//已等待时间
int turn;//周转时间
int count=0; //运行次数
int endtime=0; //结束时间
int first_starttime=0;//第一次开始运行时间(用来计算周转时间)
int starttime=0; //开始运行时间
};
vectorRQ1;
vectorRQ2;
（2）算法设计
读取就绪队列

void createRQ() {
	ifstream infile("RQ1.txt");
	string s1; int need, wait,turntime;
	if (infile) {
		while (!infile.eof()) {
			infile >> s1 >> need >> wait>>turntime;
			PCB rq1;
			rq1.name = s1;
			rq1.needtime = need;
			rq1.waittime = wait;
			rq1.turn = turntime;
			RQ1.push_back(rq1);
		}
	}
}

轮转法

void round_robin() {
	createRQ();
	int tag = 5;
	for (int i = 1; i <= RQ1.size() - 1; i++) {
		for (int j = 1; j < RQ1.size() - i; j++) {
			if (RQ1[j - 1].waittime < RQ1[j].waittime) { //等待时间较长的应先进入轮转
				PCB a;
				a.turn = RQ1[j - 1].turn;
				a.needtime = RQ1[j - 1].needtime;
				a.name = RQ1[j - 1].name;
				a.waittime = RQ1[j - 1].waittime;//用a暂存前者
				RQ1[j - 1].turn = RQ1[j].turn;
				RQ1[j - 1].needtime = RQ1[j].needtime;
				RQ1[j - 1].name = RQ1[j].name;
				RQ1[j - 1].waittime = RQ1[j].waittime;//用后者覆盖前者
				RQ1[j].turn = a.turn;
				RQ1[j].needtime = a.needtime;
				RQ1[j].name = a.name;
				RQ1[j].waittime = a.waittime;//完成交换
			}
		}//RQ1.size()=6
	}
	RQ1.erase(RQ1.begin() + 5);
	int q = 7;//时间片
	int over = 0;
	int size = RQ1.size();
	while (over!=size)
	{
		int num = 0;
		vector<PCB>::iterator p = RQ1.begin();

		
		p->starttime = clock;
		if (p->needtime > q)//
		{
			clock =clock+ q;
			p->needtime =p->needtime- q;
		;
			(p->count)++;
			if (p->count == 1)
			{
				p->first_starttime = p->starttime;//记录第一次开始运行的时间
			}
			PCB temp;
			temp = *RQ1.begin();
			RQ1.erase(RQ1.begin());
			p = RQ1.begin();
 			RQ1.push_back(temp);//插入到尾部
	
		}
		if(p->needtime<=7)
		{
			clock =clock+ p->needtime;
			p->endtime = clock;//记录结束时间
			(p->count)++;
			cout << "进程"<<p->name<<"的周转时间 : "	<< p->endtime - p->first_starttime  << endl;
			p->needtime = 0;
			PCB temp;
			temp = *RQ1.begin();
			RQ1.erase(RQ1.begin());
			p = RQ1.begin();
			over++;
		}
	}
	cout << endl;
}

短进程优先调度算法

	for (size_t i = 1; i <=RQ2.size() - 1; i++) {
		for (size_t j = 1; j < RQ2.size() - i; j++) {
		    if (RQ2[j - 1].needtime > RQ2[j].needtime) { //前者比后者大
		    PCB a;  
			a.needtime = RQ2[j - 1].needtime;
			a.name = RQ2[j - 1].name;
			a.waittime =RQ2[j - 1].waittime;//用a暂存前者
			RQ2[j - 1].needtime = RQ2[j].needtime;
			RQ2[j - 1].name = RQ2[j].name;
			RQ2[j - 1].waittime = RQ2[j].waittime;//用后者覆盖前者
			RQ2[j].needtime = a.needtime;
			RQ2[j].name = a.name;
			RQ2[j].waittime = a.waittime;//完成交换
			}
		}
	}//冒泡排序

	for (int i = 0; i < RQ2.size()-1; i++) {
		cout << "进程" << RQ2[i].name << "的周转时间为" << RQ2[i].needtime << endl;
	}

四、程序运行情况