操作系统の以优先级调度算法的实现

设计优先级调度算法的要求如下：

 (1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表，进程控制块的格式为：

进程名

指针

要求运行时间

优先数

状态

其中，

进程名—————作为进程的标识，假设五个进程的进程名分别为P₁，P₂，P₃，P₄，P₅。

指针——————按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程中的指针为“0”。

要求运行时间——假设进程需要运行的单位时间数。

优先数—————赋予进程的优先数，调度时总是选取优先数大的进程先执行。

状态——————可假设有两种状态，“就绪”状态和“结束”状态。五个进程的初始状态都为“就绪”，用“R”表示，当一个进程运行结束后，它的状态为“结束”，用“E”表示。

(2) 在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”和“要求运行时间”。

(3) 为了调度方便，把五个进程按给定的优先数从大到小连成队列。用一单元指出队首进程，用指针指出队列的连接情况。例：

  队首标志

         K₂    

K1	P1	K2	P2	K3	P3	K4	P4	K5	P5
	0		K4		K5		K3		K1
	2		3		1		2		4
	1		5		3		4		2
	R		R		R		R		R
	PCB1		PCB2		PCB3		PCB4		PCB5

 

(4) 处理器调度总是选队首进程运行。采用动态改变优先数的办法，进程每运行一次优先数就减“1”。由于本实验是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：

优先数-1

要求运行时间-1

来模拟进程的一次运行。

提醒注意的是：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行结束。在这里省去了这些工作。

(5) 进程运行一次后，若要求运行时间¹0，则再将它加入队列（按优先数大小插入，且置队首标志）；若要求运行时间=0，则把它的状态修改成“结束”（E），且退出队列。

(6) 若“就绪”状态的进程队列不为空，则重复上面（4）和（5）的步骤，直到所有进程都成为“结束”状态。

(7) 在所设计的程序中应有显示或打印语句，能显示或打印每次被选中进程的进程名以及运行一次后进程队列的变化。

(8) 为五个进程任意确定一组“优先数”和“要求运行时间”，启动所设计的处理器调度程序，显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。

代码及注释如下：

#define _CRT_SECURE_NO_WARNINGS 1
///模拟处理器调度
#include<iostream>
#include<string>
using namespace std;

enum State
{
	R,//正在运行
	E,//运行结束
};
//该程序使用C++实现，将进程控制块PCB作为私有成员
class PCB
{
public:
	//构造函数初始化成员
	PCB()
		:processName("N")
		, nextPtr(NULL)
		, runTime(rand()%7)
		, priority(rand()%7)
		, state(R)
	{}
	void Display()
	{
		cout << processName << "\t " << runTime << "\t\t " << priority;
		if (state == E)
		{
			cout << "\tE " << endl;
		}
		else
		{
			cout << "\tR " << endl;
		}
	}
	friend class queuePCB;//将队列设为PCB友元，为了使用PCB的成员
private:
	string processName;//进程名
	PCB* nextPtr;		   //指针指向队列中的下一个进程
	int runTime; //运行时间
	int priority;      //优先级
	State state;         //状态
};

//再定义一个队列存有PCB,
class queuePCB
{
public:
	queuePCB()
		:head(NULL)
		, p(NULL)
	{}
	PCB* Insert(PCB& pb)
	{
		//如果进程的名字没有初始化，直接输入
		if (pb.processName == "N")
		{
			cout << "请输入进程名：";
			string name;
			cin >> name;
			pb.processName = name;
		}
		p = head;
		//如果指针不为空，说明已指向队列
		if (head != NULL)
		{
			//如果队首指针的下一个指针为空，说明当前只有一个队列
			if (head->nextPtr == NULL)
			{
				//判断当前优先级是否低于下一个进程的优先级，如果低于则交换
				if (pb.priority > head->priority)
				{
					pb.nextPtr = head;
					head->nextPtr = NULL;
					head = &pb;
					Show();
					return p;
				}
				else
				{
					head->nextPtr = &pb;
					pb.nextPtr = NULL;
					Show();
					return p;
				}
			}
			//下一个指针不为空，则比较优先级
			else
			{
				if (pb.priority > head->priority)
				{
					pb.nextPtr = p;
					head = &pb;
					Show();
					return p;
				}
				while (p->nextPtr != NULL)
				{
					if (pb.priority > (p->nextPtr->priority))
					{
						pb.nextPtr = p->nextPtr;
						p->nextPtr = &pb;
						Show();
						return p;
					}
					p = p->nextPtr;
				}
				p->nextPtr = &pb;
				pb.nextPtr = NULL;
				Show();
				return p;
			}
		}
		//如果head==NULL，则当前没有队列，pb为第一个进程队列
		else
		{
			head = &pb;
			head->nextPtr = NULL;
			Show();
		}
		return p;
	}
	//进程运行
	void Run(PCB* pb)
	{
		cout << "运行进程为" << endl;
		pb->Display();
		cout << endl;
		pb->priority--; //运行一次优先级-1
		pb->runTime--;  //运行一次时间-1
		//如果时间片完成则把状态置为E
		if (pb->runTime == 0)
		{
			pb->state = E;
		}

	}
	//调度进程
	void Dispatch()
	{
		while (head != NULL)
		{
			Run(head);
			//如果状态为E，则移出进程队列
			if (head->state == E)
			{
				head = head->nextPtr;
				Show();
			}
			else
			{
				p = head;
				head = head->nextPtr;
				Insert(*p);
			}
		}
	}

	//展示进程的信息
	void Show()
	{
		PCB* tmp;
		tmp = head;
		if (tmp != NULL)
		{
			cout << "进程名" << '\t' << "所需运行时间" << '\t' << "优先级 " << '\t' << "状态" << endl;
		}
		while (tmp != NULL)
		{
			tmp->Display();
			tmp = tmp->nextPtr;
		}
	}

private:
	PCB* head;//指向队首的指针
	PCB* p;
};

int main()
{
	queuePCB qPCB;
	PCB arr[5];
	for (size_t i = 0; i < 5; i++)
	{
		qPCB.Insert(arr[i]);
	}
	cout << "进程已就绪" << endl;
	qPCB.Dispatch();
	cout << "进程运行已结束" << endl;

	system("pause");
	return 0;
}

运行结果如下：

//运行初值/

//运行结果/