【课设】模拟优先数调度算法-非抢占式

原创 2016年06月02日 12:48:01

优先数调度算法分为抢占式和非抢占式。

非抢占式:进程按优先数大小进行排列,优先数高的程序先运行。直到发生某种情况或运行完成才结束。

抢占式:进程按优先数大小进行排列,优先数高的程序先运行。每运行一次(优先数-1),即重新判断进程序列的优先数大小。只要有优先数更大的,便进行新的最大的优先数的进程

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <iostream>
using namespace std;
struct PCB//定义PCB结构体 
{
	int PN;//进程名称 
	struct PCB *next;//指向下一个进程 
	int run_time;//执行时间 
	int power;//优先数 
	bool state;	//进程的状态 
}; 
void time_random(int *t)//定义取时间随机数 
{ 	
	int i,number=0;
	srand((unsigned) time(NULL)); //用时间做种,每次产生随机数不一样,但还是可能会相同 
	for (i=0; i<5; i++)//取五个随机数,放入数组t中 
	{	
		number = rand() % 21;//对21取余 
		while(number==0)//若余数为0,则一直取到不为0为止 
			number = rand() % 21; //产生1-20的随机数
		t[i]=number; //将随机数赋给数组 
	} 
} 
//初始化五个进程 
void Init_PCB(int number,PCB *p)
{		
	int power[10]={5,3,1,2,4,5,3,1,2,4};
	int t[5]={0};
	time_random(t);
	cout<<"开始初始化进程"<<endl;
	for(int i=0; i<5;i++)
	{	
		p[i].PN = i+1;
		p[i].run_time = t[i];
	    p[i].next=NULL;
     	p[i].state = 0;
		p[i].power=	power[i+number];
		cout<<"- - - - - - - ->\n";
	}
	cout<<"初始化完成!"<<endl;
}
//打印 
void Print(PCB *p)
{	
	for(int i = 0;i<5;i++)
	{
	cout<<"======================="<<endl;
	cout<<"进程名称: "<<p[i].PN<<endl;
	cout<<"下一个进程:"<<p[i].next<<endl;
	cout<<"运行时间: "<<p[i].run_time<<endl;
	cout<<"优先数:   " <<p[i].power<<endl;
	cout<<"状态:     "<<p[i].state<<endl; 
	}
}
//根据优先数将其连起来 
void Link(int number,PCB *q,PCB *p)
{
	switch(number)
	{
		case 0:
			q->next=&p[0];
			p[0].next=&p[4];//5,3,1,2,4
			p[4].next=&p[1];
			p[1].next=&p[3];
			p[3].next=&p[2];
			p[2].next=NULL;
			break;
		case 1:
			q->next=&p[4];
			p[4].next=&p[3];//3,1,2,4,5
			p[3].next=&p[0];
			p[0].next=&p[2];
			p[2].next=&p[1];
			p[1].next=NULL;
			break;
		case 2:
			q->next=&p[3];
			p[3].next=&p[2];//1,2,4,5,3
			p[2].next=&p[4];
			p[4].next=&p[1];
			p[1].next=&p[0];
			p[0].next=NULL;
			break;
		case 3:
			q->next=&p[2];
			p[2].next=&p[1];//2,4,5,3,1
			p[1].next=&p[3];
			p[3].next=&p[0];
			p[0].next=&p[4];
			p[4].next=NULL;
			break;
		case 4:
			q->next=&p[1];
			p[1].next=&p[0];//4,5,3,1,2
			p[0].next=&p[2];
			p[2].next=&p[4];
			p[4].next=&p[3];
			p[3].next=NULL;
			break;
	}
}

void run(PCB *q) 
{	
	printf("\n");
	for(q=q->next;q;q=q->next)
	{		
		printf("\np[%d]运行结束,运行时间%2d",q->PN,q->run_time--);
	}
}
void Print_End(PCB *p)
{
	while(p->next)
	{
		printf("p%d->",p->PN);
		p=p->next;
	}
}
int main()
{	
	PCB p[5];

	PCB *q; 
	PCB *c;

	int i = 0;
	int number = 0;
	srand((int)time(NULL));
	number = rand()%5;
	//初始化五个进程 
	Init_PCB(number,p);
	
	//根据number取余数来链到一起 
	Link(number,q,p);
	c=q; //把链好的Q赋值给c 

 	//打印所有进程信息 
	Print(p); 
 
 	//输出进程序列 
	printf("=======================\n");
	printf("进程序列:pi\n");
	for(q=q->next;q!=NULL;q=q->next)
	{
		printf("p%d(%d)",q->PN /*,q->power,*/,q->run_time);
		if(q->next)
			printf("->");
	}	//开始运行
	run(c);

	return 0;
} 


版权声明:本文由 皓皓松博客 创作,转载请附带链接,有问题欢迎交流。 举报

相关文章推荐

非抢占的高响应比优先调度算法

模拟操作系统进程调度算法流程图测试数据进程名: A B C D E 需要运行时间: 3 6 4 5 2代码实现#include #inc...

线程的调度方式——抢占式、非抢占式

在一个进程里,线程的调度有抢占式或者非抢占的模式。 在抢占模式下,操作系统负责分配CPU时间给各个进程,一旦当前的进程使用完分配给自己的CPU时间,操作系统将决定下一个占用CPU时间的是哪一个线...

精选:深入理解 Docker 内部原理及网络配置

网络绝对是任何系统的核心,对于容器而言也是如此。Docker 作为目前最火的轻量级容器技术,有很多令人称道的功能,如 Docker 的镜像管理。然而,Docker的网络一直以来都比较薄弱,所以我们有必要深入了解Docker的网络知识,以满足更高的网络需求。

基于优先级抢占和周期调度的进程调度算法的模拟程序设计

这是我们系统级编程SSD6的大作业,问题是一个基于优先级抢占和周期调度的进程调度算法的模拟程序。虽然并不太熟悉,没有读过如Linux,Windows,等等操作系统的书籍,在不断的讨论和查阅中也简单地向...

QNX操作系统优先级以及调度策略

一、优先级分别以及任务抢占 Neutrino 提供了一个基于优先级驱动的抢占式的设计理念。优先级驱动意味着,我们可以为每个线程分配一个优先级,它将可以根据优先级调度策略获取CPU资源。如果一个低优先...

线程的调度有抢占式或者非抢占

在一个进程里,线程的调度有抢占式或者非抢占的模式。 在抢占模式下,操作系统负责分配CPU时间给各个进程,一旦当前的进程使用完分配给自己的CPU时间,操作系统将决定下一个占用CPU时间的是哪一个线程。...

关于基于优先级的抢占式调度

对于有一定操作系统基础的朋友看到“抢占式”调度一定不会陌生吧。 我参考了Linux内核、eCos以及Windows内核对于抢占式调度的处理,感觉虽然细节上有点差别,但都挺有意思。        ...

可抢占的优先级调度算法算例:CPU利用率

某多道程序设计系统配有一台处理器和两台外设IO1、IO2,现有3个优先级由高到低的作业J1、J2和J3都已装入了主存,它们使用资源的先后顺序和占用时间分别是:J1:IO2(30 ms),CPU(10m...

linux设备驱动归纳总结(四):3.抢占和上下文切换

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 上一节介绍了进程调度...

C语言模拟最高优先数优先进程调度算法

进程在运行中存在三种基本状态,分别是运行状态、就绪状态和阻塞状态。 采用最高优先数优先的调度算法来模拟调度进程的PCB块来调度进程。

优先权调度算法

#include #include #include #include #include using namespace std; #define maxn 100 int time=0; ...
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)