精华内容
下载资源
问答
  • 不可抢占优先级调度
    千次阅读
    2018-11-03 13:23:27
    /*抢占式优先级调度算法*/
    #include <iostream>
    using namespace std;
    struct Num
    {
    	int priority;		//优先级
    	int dt;				//到达时间
    	int st;				//运行时间
    	int need_time;		//还需运行的时间
    }sum[5]={{2,0,3,3},{3,2,2,2},{5,2,5,5},{1,5,3,3},{4,8,1,1}};
    int main()
    {
    	int c=0;			//记录程序的执行个数
    	int time=0;			//记录时间
    	int b=100;		//记录上一个的程序
    	int a=100;
    	while(c<5)
    	{
    		int p=100;	//记录优先级
    
    		for(int i=0;i<5;i++)
    		{
    			if(time>=sum[i].dt)			//判断当前可执行的程序
    			{
    				if(p>sum[i].priority)	//判断优先级
    				{
    					p=sum[i].priority;//更换优先级
    					a=i;				//记录当前可运行的优先级的值	
    				}
    			}
    		}
    		if(a!=b)					//判断当前的时间是否有程序可以运行
    		{								//有
    										//判断运行时间内是否有优先级更高的进来
    			int yxj = p;
    			int a1=a;
    			for(int i=0;i<5;i++)
    			{
    				if(time+sum[a].need_time>sum[i].dt&&a1!=i)	//判断当前可执行的程序
    				{
    					if(yxj>sum[i].priority)		//判断优先级
    					{
    						yxj=sum[i].priority;	//更换优先级
    						a1=i;					//记录当前可运行的优先级的值
    						
    					}
    				}
    			}
    			if(yxj!=p)
    			{									//有优先级更高的	
    				sum[a].need_time-=(sum[a1].dt-time);
    				cout<<"***执行"<<a+1<<",被"<<a1+1<<"打断。"<<a+1<<"还剩"<<sum[a].need_time<<endl; 
    				time=sum[a1].dt;
    				cout<<time<<endl; 
    				b=a;
    			}
    			else
    			{
    				b=a;
    				time+=sum[b].need_time;
    				cout<<"执行程序"<<b+1<<";等待时间:"<<time-sum[b].dt-sum[b].st<<";完成时间:"<<time<<"。"<<endl;
    				sum[a].priority=100;
    				c++;
    			}
    		}
    		else
    		{//找不到时间+1
    			time++;
    		}
    
    	}
    	return 0;
    }	

     

    更多相关内容
  • 操作系统抢占优先级调度In the priority scheduling, the processes are scheduled on the basis of their priority, and not on the basis of their burst time. If the preemptive mode of this scheduling is ...

    操作系统抢占式优先级调度

    In the priority scheduling, the processes are scheduled on the basis of their priority, and not on the basis of their burst time. If the preemptive mode of this scheduling is being followed, then a process with a higher priority than the currently executing process can replace the executing process. This can be well explained with the help of the following example:

    优先级调度中 ,将根据进程的优先级而不是根据突发时间来调度进程。 如果遵循此调度的抢占模式 ,则优先级高于当前正在执行的进程的进程可以替换正在执行的进程。 可以通过以下示例很好地解释这一点:

    Suppose, we have four processes: P1, P2, P3 and P4, and they enter the CPU in the following manner:

    假设我们有四个进程: P1P2P3P4 ,它们以以下方式进入CPU:

    /priority scheduling 2 in OS

    As per the preemptive priority scheduling, the processes will be executed as follows:

    根据抢先优先级调度 ,这些过程将按以下方式执行:

    Gant Chart

    甘特图

    /priority scheduling 2 in OS

    Explanation:

    说明:

    • There is only P1 available at time 0, so it will be executed first irrespective of the priority until some other process with a higher priority is encountered by the OS.

      在时间0只有P1可用,因此它将优先于优先级执行,直到OS遇到其他具有更高优先级的进程为止。

    • At the beginning of the 1st-time unit, we have P2 which has a higher priority than P1, so it replaces P1.

      在第1 -时间单元的开始,我们有P2具有比P1更高的优先级,因此它取代P1。

    • At 2nd time unit, we have the process P3, but its priority is less than the executing process P2, so P2 keeps executing without any replacement.

      第二时间单位,我们有进程P3 ,但是它的优先级小于执行进程P2 ,因此P2继续执行而没有任何替换。

    • At 3rd time unit, our P2 has been completed and till now we have processes P1 and P3 left. So, P1 which has a higher priority than P3 is executed.

      第三个时间单元,我们的P2已完成,到现在为止,我们还有流程P1P3 。 因此,执行优先级高于P3的 P1

    • At 4th time unit, we have process P4 which has the highest priority of them all. So, it replaces P1.

      4 时间单位,我们有进程P4 ,它是所有进程中的最高优先级。 因此,它将替换P1

    • Since now we have no more processes left to arrive, the processes will now run according to their priorities and will complete their execution.

      从现在开始,我们不再需要其他任何流程,这些流程将根据其优先级运行并完成其执行。

    /priority scheduling 2 in OS
        Total Turn-Around Time = 8 + 2 + 9 + 2
                    = 21 milliseconds
        Average Turn-Around Time= Total Turn-Around Time / Total No. of Processes
                    = 21 / 4
                    = 5.25 milliseconds
    
        Total Waiting Time = 4 + 0 + 6 + 0
                    = 10 milliseconds
        Average Waiting Time = Total Waiting Time / Total No. of Processes
                    = 10 / 4
                    = 2.5 milliseconds
    
    
    

    翻译自: https://www.includehelp.com/operating-systems/priority-scheduling-preemptive.aspx

    操作系统抢占式优先级调度

    展开全文
  • 抢占优先级调度算法

    千次阅读 2022-01-12 09:50:31
     优先级调度既有抢占式调度又有非抢占式调度。 在这里, 我们将讨论非抢占优先级调度算法 。 As the name suggests, the scheduling depends upon the priority of the processes rather than its burst time. ...

    Priority scheduling is a type of scheduling algorithm used by the operating system to schedule the processes for execution. The priority scheduling has both the preemptive mode of scheduling and the non-preemptive mode of scheduling. Here, we will discuss the non-preemptive priority scheduling algorithm.

    优先级调度是操作系统用来调度要执行的进程的调度算法。 优先级调度既有抢占式调度又有非抢占式调度。 在这里, 我们将讨论非抢占式优先级调度算法 。

    As the name suggests, the scheduling depends upon the priority of the processes rather than its burst time. So, the processes, in this case, must also have the priority number in its details on the basis of which the OS will schedule it.

    顾名思义,调度取决于进程的优先级,而不是突发时间。 因此,在这种情况下,进程还必须在其详细信息中具有优先级号,操作系统将根据该优先级号对其进行调度。

    For example, suppose we have 4 processes: P1P2P3 and P4 and they enter the CPU as follows:

    例如,假设我们有4个进程: P1 , P2 , P3P4 ,它们按如下方式进入CPU:

    Note: Here, lower the priority number, higher is the priority.

    注意:此处,优先级数字越低,优先级越高。

    priority scheduling in OS

    As per the non-preemptive priority scheduling, the processes will be executed as follows:

    根据非抢先优先级调度 ,将按以下方式执行过程:

    Gant Chart:

    甘特图:

    priority scheduling in OS

    Explanation:

    说明:

    • There is only P1 available at time 0, so it will be executed first irrespective of the priority, and it cannot be preempted in between before its completion.

      在时间0只有P1可用,因此无论优先级如何都将首先执行它,并且在完成之前不能抢占它。

    • When it is completed at 4th-time unit, we have all P2P3, and P4 available. So, they are executed according to their priorities.

      当以第 4 次单位完成时,我们将拥有所有P2 , P3P4 。 因此,将根据优先级执行它们。

    展开全文
  • 操作系统进程调度---优先级调度算法(抢占模式)

    千次阅读 多人点赞 2020-11-05 15:50:04
    最近学习了操作系统内诸多进程调度算法,动手实现了抢占优先级调度算法 知识点 该算法又称为优先权调度算法,他既可以用于作业调度,又用于进程调度。该算法中的优先级用于描述作业运行的紧迫程度。 两种类型: ...

    引言

    最近学习了操作系统内诸多进程调度算法,动手实现了抢占式优先级调度算法

    知识点

    该算法又称为优先权调度算法,他既可以用于作业调度,又可用于进程调度。该算法中的优先级用于描述作业运行的紧迫程度。

    两种类型:

    1. 非剥夺式(非抢占式)优先级调度算法。当一个进程正在处理上运行时,即使有某个更为重要或紧迫的进程进入就绪队列,仍然让正在进行的进程继续运行,直到由于其自身原因而主动让出处理机(任务完成或等待事件),才把处理机分配给更为重要或紧迫的进程。
    2. 剥夺式(抢占式)优先级调度算法。当一个进程正在处理机上运行时,若有某个更为重要或紧迫的进程进入就绪队列,则立即暂停正在运行的进程,将处理机分配给更重要或紧迫的进程。

    两种优先级:

    1. 静态优先级。优先级是在创建进程时确定的,且在进程的整个运行期间保持不变。确定静态优先级的主要依据有进程类型、进程对资源的要求、用户要求。
    2. 动态优先级。在进程运行过程中,根据进程情况的变化动态调整优先级。动态调整优先级的主要依据有进程占有 CPU 时间的长短、就绪进程等待 CPU 时间的长短。

    一般来说,进程优先级的设置有下面几点原则:

    1. 系统进程 > 用户进程。系统进程作为系统的管理者,理应拥有更高的优先权。
    2. 交互型进程 > 非交互型进程。与用户进行交互的进程需要被优先处理,即要有更高的优先级。
    3. I/O型进程 > 计算型进程。频繁使用 I/O 设备的进程称为 I/O 型进程,I/O 设备的处理速度要比 CPU慢很多,所以将 I/O 型进程的优先级设置得更高,就有可能让 I/O 设备尽早开始工作,进而提升系统的整体效率。

    代码实现(C++)

    本程序使用两个栈,分别储存运行进程和进程优先级。
    使用栈是为了解决一个进程被另一个进程抢占后的恢复问题,之所以 不用一个栈来存储,是为了避免配有相同优先级但不同进程相遇的情况。

    #include<iostream>
    #include<string>
    #include<windows.h>
    #include<stack>		//  用来存储优先权 
    #include<list>		//	使用list存储PCB,考虑到无法模拟事件的顺序发生,故不使用队列 
    
    #define MAXNUM 1000 
    
    using namespace std;
    
    typedef struct pcb {
    	int pID;			//	进程编号
    	int level;			//	进程优先权
    	float needTime;		// 	需要运行时间	 
    	float reachTime;	//	到达时间
    	float leftTime;		//	剩余运行时间 
    }PCB;
    	
    void createProcess(int n, list<PCB> &plist) {		//	创建一个进程队列
    	cout<<"请输入相应进程的进程编号、优先权、到达时间、运行时间(类似:1 1 0 4)"<<endl;
    	
    	for(int i=0;i<n;i++) {
    		PCB p;
    		cout<<"请输入第"<<i+1<<"个进程的信息:"; 
    		cin>>p.pID>>p.level>>p.reachTime>>p.needTime;
    		plist.push_front(p);
    	}
    }	
    
    int getWholeTime(list<PCB> &plist) {	//	获取所有任务的总时间 
    	list<PCB>::iterator i;
    	int sumTime = 0;
    	
    	for(i=plist.begin();i!=plist.end();i++) {
    		sumTime += i->needTime;
    	}
    	
    	return sumTime;
    }
    
    void runProcess(int n, list<PCB> &plist) {		//	运行进程 
    	int Clocker = 0;	//	定义一个计时器 
    	stack<int> id_stack;	//	定义一个存放进程ID的栈 
    	stack<int> level_stack;	//	定义一个存放优先权的栈 
    	level_stack.push(0);
    	id_stack.push(0);
    	int sumTime = getWholeTime(plist); 	//	获取总共运行时间 
    
    	cout<<endl;
    	while(Clocker<sumTime) {
    		cout<<"时间片轮转一个单位..."<<endl;
    		
    		//	遍历找出当前时刻优先权最高的进程 
    		list<PCB>::iterator i;
    		for(i = plist.begin();i != plist.end();i++) {
    			if(i->reachTime<=Clocker && i->level>=level_stack.top() && i->needTime>0) {
    				if(i->pID != id_stack.top()) {
    					id_stack.push(i->pID);
    					level_stack.push(i->level);	
    				}
    				
    				i->needTime--;	//	剩余运行时间减少1个单位 
    				if(i->needTime == 0) {	//	若运行结束,对应优先权出栈 
    					level_stack.pop();
    					id_stack.pop();
    				}
    				
    				cout<<"本次执行了进程: "<<i->pID<<endl;
    				cout<<endl;
    				break;
    			} 
    		}
    		
    		Sleep(1500);
    		Clocker++;	
    	}
    }
    	
    /*
    	测试用例:
    		pID   level   reachTime   needTime
    		1		2		  0			 3
    		2		4		  2			 1
    		3		1		  4			 3
    		4		3		  6			 2
    */	
    	
    int main() {
    	cout<<"请输入进程数量:";
    	int n;
    	cin>>n;
    	
    	if(n>MAXNUM) {		//过热保护 
    		cout<<"CPU 即将爆炸,倒计时..."<<endl;
    		Sleep(1000);
    		cout<<"3..."<<endl;
    		Sleep(1000);
    		cout<<"2..."<<endl;
    		Sleep(1000);
    		cout<<"1..."<<endl;
    		Sleep(1000);
    		cout<<"喵~"<<endl; 
    		return 0;
    	}
    	
    	list<PCB> plist;
    
    	createProcess(n,plist);
    	runProcess(n,plist);
    	
    	cout<<"结束!"<<endl; 
    	return 0;
    }
    
    展开全文
  • 抢占:进程进入就绪队列,进行优先级比较,优先级大的可抢占正在运行的进程。 动态优先级:进程进入就绪队列一定时间未获取cpu,则提升优先级。 进程类 package process; /** * 进程类 */ public class Process ...
  • /*非抢占优先级调度算法*/ #include &lt;iostream&gt; using namespace std; struct Num { int priority; //优先级 int dt; //到达时间 int st; //运行时间 }sum[5]={{2,0,3},{3,2,2},{5,2,5},{...
  • 1. 前言 Schedulerx2.0是一套分布式的任务调度+计算框架。作为一套分布式计算引擎,用户经常需要资源管理的需求,当前schedulerx仅仅支持单个任务实例的管控(比如单机子任务...这一点和schedulerx还是一样的,sch
  • 明确先来先服务FCFS、时间片轮转RR、优先级三种常用的调度算法的实现思想,并在此基础上计算周转时间、带权周转时间、平均周转时间和平均带权周转时间。(一)先来先服务先来先服务(First-Come,First-Served,FCFS)...
  • 一、调度算法 (一)时间片轮转(RR, Round-Robin) 例题:各进程到达就绪队列的时间、需要的运行时间如下表所示。使用时间片轮转调度算法,分析时间片大小分别是2、5时的进程运行情况。 常用于分时操作系统,更...
  • 上一篇文章我们介绍了的...而在操作系统中,调度分为三个层级,分别是高级调度(也称作业调度),中级调度(也称内存调度),低级调度(也称进程调度)。高级调度,也称作业调度。它是一个按照某种规则,将作业从...
  • 优先级调度抢占,主要概念有: Priority Preemption 首先来看一下调度过程提到的四个特点,我们如何做到集群的合理利用? 当集群资源足够的话,只需要通过基础调度能力就能组合出合理的使用方式。 但是假如...
  • 一个单核CPU按优先级调度进程,进程的优先级用进程编号n(1≦n≦20)表示,编号越小则优先级越高。现给出进程个数N(2≦N≦5),以及它们的到达时间t(0≦t≦100)和所需的运行时间T(1≦T≦50),求进程的执行顺序...
  • 公平地、轮流地为各个进程服务,让每个进程在一定时间间隔内都可以得到响应。按照各进程到达就绪队列的顺序,轮流让各个进程执行一个时间片,若进程未在...用于作业调度,也用于进程调度,还可以用于I/O调度抢占
  • 十五、优先级调度算法

    千次阅读 2020-05-24 09:43:21
    十五、优先级调度算法 算法:将处理机分配给就绪队列中优先级最高的进程 优先级 *静态优先级 在进程创建时确立,确定后运行期间保持不变。确立依据有:进程的类型、进程对资源的需求、用户申请的优先级 优点...
  • 抢占调度算法是指挑选一个进程,直到这个进程进入阻塞态或者执行结束,才会从就绪进程中挑选一个进行执行. 抢占调度算法指挑选一个进程,让这个进程只运行某段时间,然后在该时间段结束后,该进程仍旧在运行时,将...
  • 优先级抢占

    2021-09-10 09:45:40
    1.线程优先级 ThreadX 具有 32 个优先级,范围从优先级 0 到优先级 31(TX_MAX_PRIORITIES-1)。 数值越小,优先级越高。 通过协作调度或时间切片,多个线程...抢占是为了支持优先级更高的线程而暂时中断正在执...
  • 在本篇文章中,我再来为你讲解一下 Kubernetes 调度器里的另一个重要机制,即:优先级(Priority )和抢占(Preemption)机制。 首先需要明确的是,优先级抢占机制,解决的是 Pod 调度失败时该怎么办的问题。 正常...
  • 介绍 前段时间比较忙,没有更新,这次的也是操作系统的一个实践作业 C++实现非抢占式多级反馈队列优先级调度算法,希望可以帮到你们。 问题介绍 这里我用课件里的内容 1.应设置多个就绪队列,并为每个队列赋予不同...
  • 觉得自己编程在无法移植系统的情况下能能自己设计个模块呢?就有了标题中的思想。以下是我在论坛上发的。今天我也来个凑热闹讲讲操作系统,理论嘛,人人都懂,所以讲了。首先想问大家,平时在8位机上会用到操作...
  • Java操作系统进程调度算法——优先级调度(HPF)算法 文章目录Java操作系统进程调度算法——优先级调度(HPF)算法前言一、算法思想二、数据结构1.定义(PCB)进程控制块2.实现思路三、流程图四、完整代码运行结果1、输入...
  • 文章目录背景CPU调度调度时间调度准则调度策略程序执行模型比较调度算法的准则吞吐量 VS 延迟公平的目标调度算法实时调度实时系统可调度行单调数据(RM)截止日期最早优先(EDF)多处理器调度优先级反转背景CPU调度上...
  • 题目二:设计一个按照优先级调度算法实现处理机调度的程序 优先级调度算法实现处理机调度的程序设计提示如下: (1) 假设系统有n个进程,每个进程用一个进程控制块(PCB)来代表。进程控制块的格式如下表所示,且...
  • 实时操作系统中各个任务的优先级是不同的,而且经常会遇到超负荷的情况.。在这种超载情况下,使任务集内各任务满足各自的时限,嵌入式操作系统必须保证在确定的时间内对事件进行处理,因此必须要有一个良好的任务...
  • 操作系统(五):FCFS/SJF/非抢占优先级/RR

    千次阅读 多人点赞 2019-09-22 20:17:12
    操作系统(五):FCFS/SJF/非抢占优先级/RR 一、题目1(书上170页5.7) 5.4 5.4 Consider the following set of processes, with the length of the CPU burst time given in milliseconds: The processes are ...
  • 即不同负载对应不用的优先级,同时允许集群中的所有负载所需的资源超过集群提供的资源,在这种情况下,当发生资源不足的情况下时,系统可以选择性释放一些重要的负载(优先级最低的),保证最重要的负载能够获取...
  • 在这种情况下,当发生资源不足的情况时,系统可以选择释放一些重要的负载(优先级最低的),保障最重要的负载能够获取足够的资源稳定运行。 Kubernetes 1.8版本引入了基于Pod优先级抢占(Pod Priority Preemption...
  • 简单介绍几种调度算法:先来先服务调度算法(FCFS)、短作业(进程)优先调度算法(SJ(P)F)、 优先级调度算法、高响应比优先调度算法、时间片轮转法(RR)、多级反馈队列调度算法。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 36,408
精华内容 14,563
热门标签
关键字:

不可抢占优先级调度