操作系统——实验四(处理机通信)

操作系统——实验四(处理机通信)

（1）设计一个按优先数调度算法实现处理器调度的程序。

#include <iostream>
#include <string.h>
#include <stdio.h>
using namespace std;
	//-----------------------
struct _proc//定义一个结构体表示进程的PCB
{
		char name[32];//进程名
		struct _proc* next;//指向下一个PCB的指针
		int run_time;//要求运行的时间
		int priority;//优先数
		int state;//进程状态
};
_proc* root;

//向就绪队列中插入进程,按照降序
void Insert(_proc* pr)
{
		_proc* q=root;
		_proc* p=root->next;
		if(root->state!=0)
		{
			while(p!=NULL)
			{
				if(p->priority>pr->priority)
				{
					q=p;
					p=p->next;
				}
				else
				{
					break;
				}
			}
		}
		pr->next=p;//插入进程结点
		q->next=pr;
		++root->state;//进程个数加1
}

	//创建进程
	_proc Creat(char name[],int priority,int run_time)
	{
		_proc pr;
		strcpy(pr.name,name);
		pr.priority=priority;
		pr.run_time=run_time;
		pr.state=0;
		pr.next=NULL;
		return pr;
	}

	//删除就绪队列中队首进程
	_proc* Delete()
	{
		_proc* pr=root->next;//此时pr为指向结构体的指针，指向队首进程
		root->next=root->next->next;
		--root->state;//进程个数减1
		return pr;//返回被删除进程的地址
	}

	//对就绪队列排序,按照降序
	void Sort()
	{
		if(root->next->run_time==0)//队首进程的要执行时间为0时，从就绪队列中删除该进程
		{
			Delete();
			root->next->state=1;
		}
		else//不为0时，先删除，再根据变化后的优先级，插入到相应位置
		{
			_proc* pr=Delete();
			Insert(pr);
		}
	}

	void OutPut()
	{//取队首的进程，模拟进程执行，输出执行进程名
		cout<<root->next->name<<endl;
		--root->next->priority;//动态改变优先数，优先级减1
		--root->next->run_time;//运行时间减1
	}

	void Solve()
	{//定义根结点，指向第一个进程
		root=new _proc;
		root->state=0;//队列中的进程个数
		root->next=NULL;
		//创建几个进程,并插入就绪队列
		_proc pr1=Creat("p1",2,1);
		Insert(&pr1);
		_proc pr2=Creat("p2",3,5);
		Insert(&pr2);
		_proc pr3=Creat("p3",1,3);
		Insert(&pr3);
		_proc pr4=Creat("p4",2,4);
		Insert(&pr4);
		_proc pr5=Creat("p5",4,2);
		Insert(&pr5);
		printf("处理队列\n");
		while(root->state!=0)
		{
			OutPut();//取队首进程模拟执行一个单位时间数
			Sort();//重新排序
		}
	}
	int main()
	{
		Solve();
		getchar();
		getchar();
		return 0;
	}

结果：

（2）设计一个按时间片轮转法实现处理器调度的程序。

	#include<iostream>
	#include<string.h>
	#include<stdio.h>
	using namespace std;
	//-----------------------
	struct _proc//定义一个结构体表示进程的PCB
	{
		char name[32];//进程名
		struct _proc*next;//指针
		int run_time;//要求运行的时间
		int alloc_time;//已运行的时间
		int state;//进程状态
	};
	_proc* root;

	//向就绪队列中插入进程,按照降序
	void Insert(_proc*pr)
	{
		if(root->next==NULL)
		{
			root=pr;
			pr->next=pr;
			return;
		}
		pr->next=root->next;//插入
		root->next=pr;
		root=pr;
	}

	//创建进程
	_proc Creat(char name[],int run_time,int alloc_time)
	{
		_proc pr;
		strcpy(pr.name,name);//进程名取参数名
		pr.run_time=run_time;//取参数的要求运行时间
		pr.alloc_time=alloc_time;//取参数的已运行时间
		pr.state=0;
		pr.next=NULL;
		return pr;
	}

	//删除就绪队列中对首进程
	void Delete()
	{
		if(root->next==root)
		{//队列已为空
			root=NULL;
			return;
		}
		root->next=root->next->next;
	}

	//输出进程号,模拟进程执行
	void OutPut()
	{
		cout<<root->next->name<<endl;//输出
		++root->next->alloc_time;//已运行时间加1
	}
	void Solve()
	{//定义根结点，指向下一个运行的进程
		root=new _proc;
		root->state=0;//队列中的进程个数
		root->next=NULL;
		//创建几个进程,并插入就绪队列
		_proc pr1=Creat("Q1",2,1);
		Insert(&pr1);
		_proc pr2=Creat("Q2",3,0);
		Insert(&pr2);
		_proc pr3=Creat("Q3",1,0);
		Insert(&pr3);
		_proc pr4=Creat("Q4",2,0);
		Insert(&pr4);
		_proc pr5=Creat("Q5",4,0);
		Insert(&pr5);
		printf("调度序列\n");//输出
		while(root!=NULL)//一直循环遍历
		{
			OutPut();//执行root指向的进程
			if(root->next->alloc_time==root->next->run_time)//执行完毕
			{
				Delete();//从就绪队列中删除该进程
				continue;
			}
			root=root->next;//root指针后移，执行下一个进程做准备
		}
	}
	int main()
	{
		Solve();
		getchar();
		return 0;
	}

结果