精华内容
下载资源
问答
  • 操作系统实验 短作业优先进程算法 基于优先级进程调度算法 先来先服务进程算法
  • Xen的调度算法主要负责对各个客户虚拟机进行CPU时间片的分配,从而使 得硬件资源在各个客户虚拟机之间合理分配。在客户虚拟机启动之初,Xen会配 置其的CPU个数,这里的CPU称之为虚拟处理器,即VCPU。Xen的虚拟机...
    Xen的调度算法主要负责对各个客户虚拟机进行CPU时间片的分配,从而使
    
    得硬件资源在各个客户虚拟机之间合理分配。在客户虚拟机启动之初,Xen会配
    
    置其的CPU个数,这里的CPU称之为虚拟处理器,即VCPU。Xen的虚拟机调度
    
    算法以VCPU为调度单位,而非以客户虚拟机为粒度进行调度,将VCPU动态的
    
    分配到各个真实的物理CPU上执行,同一时间内只可能有物理CPU数量的VCPU
    
    在执行。将调度算法粒度控制在VCPU级别的好处在于可以使得整个虚拟系统的
    
    处理吞吐量增大,因为每个VCPU可以根据真实物理CPU的负载程度进行核间的
    
    迁移,从而让系统的处理能力的利用率达到最大。如果以客户虚拟机为调度单位,
    
    当遇到有多个VCPU的客户虚拟机时,需要同样多数目的物理CPU才能完成多
    
    VCPU的同步调度,不仅降低了整体的性能,同时也不利于系统的扩展。
    

    capacity CS,
    replenishment period TS, and jitter JS.
     A server’s capacity is the maximum amount of execution time that may be consumed by the server in a single invocation. 
    The replenishment period is the minimum time before the server’s capacity is available again.
    The server’s jitter is the difference between the minimum and maximum time that can elapse between replenishment of the server’s capacity and that capacity starting to be consumed 
    given no higher priority interference
    a server’s worst-case response
     time RS, is the longest possible time from the server being replenished to its capacity being exhausted,given that there are tasks ready to use all of the server’s capacity.
    System Idle Process" 中的 idle 是“空闲”的意思 "System Idle Process" 即“系统空闲进程“
    实际上System Idle Process 是WIN2000/XP以及Vista/WIN7操作系统都有的一个进程,其作用都是一样的。就是在CPU空闲的时候,发出一个IDLE命令,使CPU挂起(暂时停止工作),可有效的降低CPU内核的温度,在操作系统服务里面,都没有禁止它的选项;默认它是占用除了当前应用程序所分配的处理器(CPU)百分比之外的所有占用率;一旦应用程序发出请求,处理器会立刻响应的。在这个进程里出现的CPU占用数值并不是真正的占用而是体现的CPU的空闲率,也就说这个数值越大CPU的空闲率就越高,反之就是CPU的占用率越高。如果在刚刚开机的情况下就发现System Idle Process的CPU占用值很低的话应该就注意后台有什么大的程序在运行或者感染病毒了。
      当“System Idle Process”进程占用资源为2%时,说明机器目前只有2%的资源是空闲的,即机器可能感染了病毒或被其他程序占用了98%的资源。换句话说,“System Idle Process”进程占用资源占用资源越大则系统可用资源越多,其字面意思是“系统空闲进程”


    实时调度算法 可分为固定优先级的调度算法和动态优先级的调度算法
    实时系统根据其对于实时性要求的不同,可以分为软实时硬实时两种类型。
    硬实时系统指系统要有确保的最坏情况下的服务时间,即对于事件的响应时间的截止期限是无论如何都必须得到满足。比如航天中的宇宙飞船的控制等就是现实中这样的系统。
    其他的所有有实时特性的系统都可以称之为软实时系统。如果明确地来说,软实时系统就是那些从统计的角度来说,一个任务(在下面的论述中,我们将对任务和进程不作区分)能够得到有确保的处理时间,到达系统的事件也能够在截止期限到来之前得到处理,但违反截止期限并不会带来致命的错误,像实时多媒体系统就是一种软实时系统
    根据建立调度表和可调度性分析是脱机还是联机实现分为静态调度动态调度

    单处理器实时调度

    RMS(Rate-Monotonic Scheduling)调度算法

    任务按单调速率优先级分配(RMPA)的调度算法,称为单调速率调度(RMS)。RMPA是指任务的优先级按任务周期T来分配。它根据任务的执行周期的长短来决定调度优先级,那些具有小的执行周期的任务具有较高的优先级,周期长的任务优先级低。

    EDF

    最早截止时间优先算法(EDF)也称为截止时间驱动调度算法(DDS),是一种动态调度算法。EDF指在调度时,任务的优先级根据任务的截止时间动态分配。截止时间越短,优先级越高。

    LLF

    最短空闲时间优先算法(LLF)也是一种动态调度算法。LLF指在调度时刻,任务的优先级根据任务的空闲时间动态分配。空闲时间越短,优先级越高。空闲时间=deadline-任务剩余执行时间。LLF可调度条件和EDF相同。
    多处理器实时调度

    静态调度

    问题描述:一组具有优先级关系的任务在m个处理器上运行,任务优先级关系用“<”表示,即如果两个任务(t1,t2)存在优先关系t1< t2,则t1必须在t2开始运行前完成。任务优先关系可用一个无环图来表示,称为计算图G,如图1.表示任务集S={t1,t2,t2,t4,t5}中任务存在优先关系<={(t1,t2),(t1,t3),(t1,t4),(t2,t6),(t3,t6),(t4,t5),(t5,t6)}。多处理其调度就是要找出长度最短的调度表。

    动态调度

    问题描述:到达时间不确定而计算时间c和截止时间D已知的n个任务,运行在m个处理器上,n不确定,动态调度的目标是使系统能够对变化的环境做出迅速的反应。

    展开全文
  • 模拟进程调度中的高优先级优先调度算法
  • 1.编写程序模拟动态优先级进程调度算法,初始设置模拟5个进程调度,假设每个进程可有四种状态,分别为ready, running, waiting及terminated状态,并假定初始状态为ready状态。 2、在优先级调度算法中,各个进程的...
    
    
    

    java语言实现的时间片轮转调度算法和动态优先级调度算法


    贪方便用java实现老师的作业,虽然写的乱七八糟的,但是也想发出来给人看看,评论喷我吧!。

    一、代码:

    作业要求是:时间片轮转调度
    1.编写程序模拟动态优先级进程调度算法,初始设置模拟5个进程调度,假设每个进程可有四种状态,分别为ready, running, waiting及terminated状态,并假定初始状态为ready状态。
    2、在优先级调度算法中,各个进程的优先数的初始值由随机函数给定,范围为4050的整数,每个进程所需的CPU运行时间亦由随机函数给定,范围为13的整数。每次进程调度时,从就绪队列中选择优先级最高的进程执行,进程每执行一次,该进程的优先数减3,占用的CPU时间加1,进程还需要的时间片数减1。
    3、在时间片轮转调度算法中,采用固定时间片2,即每执行一次进程,该进程的执行时间片数为已执行了2个单位(cputime+2),而进程尚须执行的时间(neededtime-2),进程已经执行的次数count+1,而进程的轮转次数round+1;

    //程序调用
    import java.util.Scanner;
    
    public class Client {
    	
    	private static Scanner str = new Scanner(System.in);
    	
    	//程序入口函数
    	public static void main(String[] args) {
    		menuChose();
    		int choose = str.nextInt();
    		switch (choose) {
    		case 1:
    			RunPriority();
    			break;
    		case 2:
    			roundCal();
    			break;
    		case 3:
    			break;
    		case 0:
    			System.out.println("程序结束运行");
    			break;
    		default:
    			break;
    		}
    	}
    	
    	public static void menuChose(){
    		System.out.println("CHOOSE THE ALGORITHM");
    		System.out.println("1   PRIORITY");
    		System.out.println("2   ROUNDBIN");
    		System.out.println("3   FIFS");
    		System.out.println("0 exit");
    	}
    	
    	public static void RunPriority(){
    		
    		PriorityCal pcb = new PriorityCal();
    		System.out.println("Priority scheduling,input name and needtime:");
    		pcb.input();
    		System.out.println("ready process queue");
    		pcb.showProcess();
    		System.out.println();
    		for(int i = 0;i<10;i++){
    			System.out.println("cputime="+(i+1));
    			pcb.judgeProcess();
    		}
    		System.out.println("all process have finished!");
    	}
    	
    	public static void roundCal(){
    		RoundCal cal = new RoundCal();
    		System.out.println("Priority scheduling,input name and needtime:");
    		cal.input();
    		System.out.println("ready process queue");
    		cal.showProcess();
    		int result = 0;
    		int num = 2;
    		for (int i = 1; i <= 10; i++) {
    			System.out.println("cputime="+(i*num));
    			if(result<3){
    				cal.roundTime(result);
    			}else{
    				result = 0;
    				cal.roundTime(result);	
    			}
    			result++;
    		}
    	}
    
    package demo;
    
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Random;
    import java.util.Scanner;
    
    public class PriorityCal {
    	
    	Scanner str= new Scanner(System.in);
    	
    	private List<ProcessObj>processList = new LinkedList<ProcessObj>();
    	private List<String> listStateCode = new LinkedList<String>();
        private Random rand = new Random();
    	
        //初始化状态码
    	public void initStateCode(){
    		listStateCode.add("ready");
    		listStateCode.add("running");
    		listStateCode.add("waiting");
    		listStateCode.add("terminated");
    	}
    	
    	//输入进程块
    	public void input(){
    		for(int i =0 ;i<5;i++){
    			System.out.println("输入第"+(i+1)+"进程的信息:");
    			ProcessObj obj = new ProcessObj();
    			obj.setName(str.next());
    			obj.setNeedtime(str.nextInt());
    			initStateCode();
    			obj.setState(listStateCode.get(0));
    			int value = rand.nextInt(11)+40;
    			obj.setPriority(value);	
    			processList.add(obj);
    			//System.out.println(obj.getName()+"\t"+obj.getNeedtime()+"\t"+obj.getPriority()+"\t"+obj.getState()+"\t"+obj.getCuptime());
    		}
    		
    	}
    	
    	//程序进程优先级运行
    	public int priorControl(){
    		/*
    		 * 读取prior数值最大的对象进cup调度
    		 */
    		int max = 0;
    		int i =0 ;
    		while(i<processList.size()){
    			if(!("terminated".equals(processList.get(i).getState()))){
    				int index = processList.get(max).getPriority()>=processList.get(i).getPriority()?max:i;
    				i= i+1;
    				max = index;
    			}else{
    				i=i+1;
    			}
    		}
    		return max;
    	}
    	
    	public void showProcess()
    	{
    		System.out.println("name  cuptime  needtime priority state");
    		for (ProcessObj obj : processList) {
    			System.out.println(obj.getName()+"\t"+obj.getCuptime()+"\t"+
    					obj.getNeedtime()+"\t"+obj.getPriority()+"\t"+obj.getState()
    					);
    		}
    	}
    	
    	public void judgeProcess(){
    		/*
    		 * 优先级-3 needtime-1 cputime+1 先到先运行策略
    		 * 可有四种状态,分别为ready, running, waiting及terminated状态,并假定初始状态为ready状态。
    		 * 运行时为 running needtime为0时 为 terminated
    		 */
    		
    		int maxPrior = priorControl();
    		ProcessObj tmp = processList.get(maxPrior);
    		
    		if(tmp.getNeedtime()>0){
    			tmp.setState(listStateCode.get(1));
    			int needtime = tmp.getNeedtime()-1;
    			int cputime = tmp.getCuptime()+1;
    			int priortime = tmp.getPriority()-3;
    			tmp.setCuptime(cputime);
    			tmp.setNeedtime(needtime);
    			tmp.setPriority(priortime);
    			processList.set(maxPrior, tmp);
    			showProcess();
    		}
    		
    		tmp.setState(listStateCode.get(2));
    		processList.set(maxPrior, tmp);
    		
    		if(tmp.getNeedtime()==0){
    			tmp.setState(listStateCode.get(3));
    			processList.set(maxPrior, tmp);
    		}
    	}
    	
    }
    
    package demo;
    
    public class ProcessObj {
    	private String name ;
    	private int cuptime = 0;
    	private int needtime;
    	private int priority;
    	private String state;
    	public ProcessObj(String name, int cuptime, int needtime, int priority,
    			String state) {
    		super();
    		this.name = name;
    		this.cuptime = cuptime;
    		this.needtime = needtime;
    		this.priority = priority;
    		this.state = state;
    	}
    	public ProcessObj() {
    		super();
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getCuptime() {
    		return cuptime;
    	}
    	public void setCuptime(int cuptime) {
    		this.cuptime = cuptime;
    	}
    	public int getNeedtime() {
    		return needtime;
    	}
    	public void setNeedtime(int needtime) {
    		this.needtime = needtime;
    	}
    	public int getPriority() {
    		return priority;
    	}
    	public void setPriority(int priority) {
    		this.priority = priority;
    	}
    	public String getState() {
    		return state;
    	}
    	public void setState(String state) {
    		this.state = state;
    	}
    	
    }
    
    package demo;
    
    public class ReProcessObj {
    	
    	private String name ;
    	private int needtime;
    	private int cputime=0;
    	private String state;
    	private int round = 0;
    	private int count = 0;
    	
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getNeedtime() {
    		return needtime;
    	}
    	public void setNeedtime(int needtime) {
    		this.needtime = needtime;
    	}
    	public int getCputime() {
    		return cputime;
    	}
    	public void setCputime(int cputime) {
    		this.cputime = cputime;
    	}
    	public String getState() {
    		return state;
    	}
    	public void setState(String state) {
    		this.state = state;
    	}
    	public int getRound() {
    		return round;
    	}
    	public void setRound(int round) {
    		this.round = round;
    	}
    	public int getCount() {
    		return count;
    	}
    	public void setCount(int count) {
    		this.count = count;
    	}
    	
    	public ReProcessObj(String name, int needtime, int cputime, String state, int round, int count) {
    		super();
    		this.name = name;
    		this.needtime = needtime;
    		this.cputime = cputime;
    		this.state = state;
    		this.round = round;
    		this.count = count;
    	}
    	
    	public ReProcessObj() {
    		super();
    	}
    	
    	@Override
    	public String toString() {
    		return  name + "\t" + cputime + "\t" + needtime + "\t" + round
    				+ "\t" + count + "\t" + state;
    		
    	}
    }
    
    
    package demo;
    
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Random;
    import java.util.Scanner;
    
    public class RoundCal {
    	private Scanner str= new Scanner(System.in);
    	private static int NUM = 3;
    	private  int cycle = 0;
    	
    	private List<ReProcessObj>processList = new LinkedList<ReProcessObj>();
    	private List<String> listStateCode = new LinkedList<String>();
        private Random rand = new Random();
        
        //初始化状态码
       	public void initStateCode(){
       		listStateCode.add("ready");
       		listStateCode.add("running");
       		listStateCode.add("waiting");
       		listStateCode.add("terminated");
       	}
       	
       	//输入进程块
       	public void input(){
       		for(int i =0 ;i<NUM;i++){
       			System.out.println("输入第"+(i+1)+"进程的信息:");
       			ReProcessObj obj = new ReProcessObj();
       			obj.setName(str.next());
       			int value = rand.nextInt(10)+1;
       			obj.setNeedtime(value);
       			initStateCode();
       			obj.setState(listStateCode.get(0));
       			processList.add(obj);
       			//System.out.println(obj.toString());
       		}		
       	}
       	
       	public void roundTime(int i){
       		
       		ReProcessObj obj = processList.get(i);
       		if(obj.getNeedtime()!=0){
       			int value = (obj.getNeedtime()-2)>0?(obj.getNeedtime()-2):0;
       	   		obj.setNeedtime(value);
       	   		obj.setCount((obj.getCount()+1));
       	   		obj.setRound((obj.getRound()+1));
       	   		obj.setCputime((obj.getCputime()+2));
       	   		obj.setState(listStateCode.get(1));
       	   		processList.set(i, obj);
       			showProcess();
       			if(obj.getNeedtime()==0){
       				obj.setState(listStateCode.get(3));
       			}else{
       				obj.setState(listStateCode.get(0));
       			}
    	   		processList.set(i, obj);
       			return;
       		}
       		
    		if(obj.getNeedtime()==0){
       			obj.setRound((obj.getRound()+1));
       			processList.set(i, obj);
       			showProcess();
       	   		}
       		
       	}
       	
       	public void showProcess()
    	{
    		System.out.println("name  cuptime  needtime  round  count  state");
    		for (ReProcessObj obj : processList) {
    			System.out.println(obj.toString());
    		}
    	}
    }
    

    二、程序运行演示

    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述

    总结

    敲了一个下午终于完成了,还是有点高兴的。尝试了下用c++完成,不过是真的很难。指针和引用做着做着完全蒙了!希望看到的能指点下。
    展开全文
  • 进程调度算法有很多,例如先来先服务调度算法(FCFS),短作业优先算法(SJF),时间片轮转算法(RR)和优先级算法,这里我将通过代码的方式主要介绍轮转调度算法(RR)和动态优先级调度算法.  首先介绍下轮转调度算法

             在多道程序环境下,内存中着多个进程,进程数目往往多于处理机数目,这时候我们就要针对该问题设计某种算法,动态地将处理机分配给处于就绪状态的一个进程。进程的调度算法有很多,例如先来先服务调度算法(FCFS),短作业优先算法(SJF),时间片轮转算法(RR)和优先级算法,这里我将通过代码的方式主要介绍轮转调度算法(RR)和动态优先级调度算法.

           首先介绍下轮转调度算法:

            A.轮转法的基本原理:

               在轮转法(RR)法中,系统将所有的就绪进程按FCFS策略排成一个就绪队列。系统可设置每隔一定时间(如30ms)便产生一次中断,去激活进程调度程序进行调度,把CPU分配给队首进程,并令其执行一个时间片。当它运行完毕后,又把处理机分配给就绪队列中新的队首进程,也让其执行一个时间片片。这样,就可以保证就绪队列中的所有进程在确定的时间段内,都能获得一个时间片的处理机时间。

           B.进程切换时机:

              在轮转调度算法中,应在何时进行进程的切换,可分成两种情况:1.若一个时间片尚未用完,正在运行的进程便已经完成,就立即激活调度程序,将它从就绪队列中删除,在调度就绪队列中队首的进程运行,并启动一个新的时间片。2.在一个时间片用完时,计时器中断处理程序被激活。如果进程尚未运行完毕,调度程序将把它送往就绪队列的末尾。

           C.时间片大小的确定:

              在轮转算法中,时间片的大小对系统性能有着很大的影响。若选择很小的时间内片,将有利于短作业,因为它能在该时间片内完成。但时间片小,意味着会频繁地执行进程调度和进程上下文的切换,这无疑会增加系统的开销。反之,若事件片选择的太长,且为使每个进程都能在一个时间片内完成,轮转算法便退化为FCFS算法,无法满足短作业和交互式用户的需求。一个较为可取的时间片大小是略大于一次典型的交互所需要的时间,使大多数交互式进程能在一个时间片内完成,从而可以获得很小的响应时间。

            D.算法流程图:

                                     

             E.实现代码:

    class PCBRR{
    	public int id;
    	public int everyTimeCount;
        public int alreadyCpuTime;
        public int stillNeedCpuTime;
        
        public PCBRR(int id, int everyTimeCount, int alreadyCpuTime, int stillNeedCpuTime) {
    		super();
    		this.id = id;
    		this.everyTimeCount = everyTimeCount;
    		this.alreadyCpuTime = alreadyCpuTime;
    		this.stillNeedCpuTime = stillNeedCpuTime;
    	}
        
        @Override
    	public String toString() {
    		return "进程号:" + this.id + " 已占有的CPU时间:" + this.alreadyCpuTime + " 还需的CPU时间:"
    	         + this.stillNeedCpuTime+" 每次轮转的时间片数:"+this.everyTimeCount;
    	}
    }
    
    
    
    private static void RoundRobin() {
    		LinkedList<PCBRR> pcbs = new LinkedList<PCBRR>();
    		System.out.println("请输入进程数目:");
    		int num = scanner.nextInt();
    		System.out.println("系统为这" + num + "个进程随机分配优先级数和运行所需的CPU数.以下是进程的详细情况:");
    		for (int i = 0; i < num; i++) {
    			//产生n个进程(id号,每次轮转的时间片数,已占用的CPU时间片数,仍需要的时间片数)
    			pcbs.addLast(new PCBRR(i,random.nextInt(5) + 1, 0, random.nextInt(30) + 1));
    		}
    		Iterator iterator = pcbs.iterator();
    		while (iterator.hasNext()) {
    			System.out.println(iterator.next());
    		}
    		System.out.println();System.out.println();
    		System.out.println("下面开始进行轮转法进程调度算法---------------");
    		LinkedList<Integer> donePCB = new LinkedList<Integer>();
    		int current = 1;
    		while(pcbs.size()>0)
    		{
    			System.out.println("当前正在执行第" + (current++) + "次时间片");
    			PCBRR pcbrr=pcbs.removeFirst();
    			System.out.println("将要执行的进程为 ----"+pcbrr);
    			pcbrr.alreadyCpuTime++;
    			pcbrr.stillNeedCpuTime--;
    			if(pcbrr.stillNeedCpuTime<=0)    //进程总体运行结束
    			{
    				donePCB.addLast(pcbrr.id);
    			}
    			else if(pcbrr.alreadyCpuTime>=pcbrr.everyTimeCount)
    			{         //进程已经运行完其所分配的每次轮转时间片,将其放在轮转队尾
    				pcbrr.alreadyCpuTime=0;
    				pcbs.addLast(pcbrr);
    			}
    	//进程位运行完其所分配的每次轮转时间片,下面仍将继续运行该进程
    			else {
    				pcbs.addFirst(pcbrr);
    			}
    			System.out.println("执行完这个时间片后系统轮转队列中的所有进程的情况如下:");
    			if(pcbs.size()>0)
    			{
    				Iterator temp = pcbs.iterator();
    				while (temp.hasNext()) {
    					System.out.println(temp.next());
    				}
    			}
    			else
    				System.out.println("空");
    			
    			
    			System.out.println("已经完成的进程有:(用进程号表示)");
    			Iterator itera = donePCB.iterator();
    			if (!itera.hasNext()) {
    				System.out.println("无");
    		       System.out.println();System.out.println();
    			   System.out.println();System.out.println();
    			   continue;
    			}
    			
    			while (itera.hasNext()) {
    				System.out.print(itera.next()+" ");
    			}
    			System.out.println();System.out.println();
    			System.out.println();System.out.println();
    		}
    		System.out.println("轮转法进程调度算法结束---------------");
    	}

             接下来介绍动态优先级调度算法:

                A.基本原理;               

         动态优先级调度算法是指在创建进程之初,先赋予其一个优先级,然后其值随着进程的推进或等待时间的增加而改变,以便获得更好的调度性能。例如,可以规定在就绪队列中的进程随其等待的时间的正常,使其优先级相应提高。若所有的进程都具有相同的优先级初值,则最先进入就绪队列的进程会因为其优先级变得最高,而优先获得处理机,这相当于FCFS算法。若所有的就绪进程具有各不相同的优先级初值,那么对于优先级初值低的进程,在等待了足够的时间后,也可以获得处理机。

                B.算法流程图:

                                            

                     C.实现代码:

    class PCBPM implements Comparable {
     	public int id;
    	public int pority;
    	public int cputime;
    
    	public PCBPM(int id, int pority, int cputime) {
    		super();
    		this.id = id;
    		this.pority = pority;
    		this.cputime = cputime;
    	}
    	@Override
    	public int compareTo(Object obj) {
    		PCBPM pcb = (PCBPM) obj;
    		if (pcb.pority >= this.pority)
    			return 1;
    		return -1;
    	}
    	@Override
    	public String toString() {
    		return "进程号:" + this.id + " 优先级:" + this.pority + " 所需的CPU时间:" + this.cputime;
    	}
    }
    
    private static void PriorityMethod() {
    		TreeSet<PCBPM> pcbs = new TreeSet<PCBPM>();
    		System.out.println("请输入进程数目:");
    		int num = scanner.nextInt();
    		System.out.println("系统为这" + num + "个进程随机分配优先级数和运行所需的CPU数.以下是进程的详细情况:");
    		for (int i = 0; i < num; i++) {
    			pcbs.add(new PCBPM(i, random.nextInt(60) + 1, random.nextInt(20) + 1));
    		}
    		Iterator iterator = pcbs.iterator();
    		while (iterator.hasNext()) {
    			System.out.println(iterator.next());
    		}
    		System.out.println();System.out.println();
    		System.out.println("下面开始进行优先权进程调度算法---------------");
    		int current = 1;
    		LinkedList<Integer> donePCB = new LinkedList<Integer>();
    		while (pcbs.size() > 0) {
    			System.out.println("当前正在执行第" + (current++) + "次时间片");
    			PCBPM pcb = pcbs.pollFirst();
    			System.out.println("将要执行的进程为 ----" + pcb);
    			pcb.cputime--;
    			pcb.pority -= 3;
    			if (pcb.cputime <= 0)
    				donePCB.addLast(pcb.id);
    			else
    				pcbs.add(pcb);
    			System.out.println("执行完这个时间片后系统优先进程队列中的所有进程的情况如下:");
    			if (pcbs.size() > 0) {
    				Iterator temp = pcbs.iterator();
    				while (temp.hasNext()) {
    					System.out.println(temp.next());}}
    			else
    				System.out.println("空");
    			System.out.println("已经完成的进程有:(用进程号表示)");
    			Iterator itera = donePCB.iterator();
    			if (!itera.hasNext()) {
    				System.out.println("无");
    		       System.out.println();System.out.println();
    			   System.out.println();System.out.println();
    			   continue;
    			}
    			while (itera.hasNext()) {
    				System.out.print(itera.next()+" ");
    			}
    			System.out.println();System.out.println();
    			System.out.println();System.out.println();
    		}
    		System.out.println("优先权进程调度算法结束
    ---------------");}
    
                   


        接下来是一些整合工作,我按照以下的流程方式将两种调度算法进行整合:

          程序入口和相关静态对象的代码如下:

            public static Scanner scanner = new Scanner(System.in);
    	public static Random random = new Random();
    
    	public static void main(String[] args) {
    
    		System.out.println("请选择进程调度的方法:");
    		System.out.println("1).优先权法          2).轮转法");
    		int choice = scanner.nextInt();
    		if (choice == 1)
    			PriorityMethod();
    		else
    			RoundRobin();
    	}


          实验结果截图:

             1).对于轮转调度算法:

    。。。。。。。(由于截图过多,这里仅显示开头和结尾数据)



            2).对于动态优先级调度算法:

      


    。。。。。。。(由于截图过多,这里仅显示开头和结尾数据)




    PS:自发表了第一篇的银行家算法的博文,慢慢有了阅读量,小小的成就感爆棚,之后就顺手写下操作系统中比较重要的两种进程调度算法,动手写代码,对算法的理解肯定是有帮助的。最后,还是那句话,博客小白还望各位大佬不吝赐教~

    展开全文
  • 普通进程:采用动态优先级调度调度程序周期性地修改优先级(避免饥饿)实时进程:采用静态优先级调度由用户预先指定,以后不会改变静态优先级进程创建时指定或由用户修改。动态优先级:在进程运行期间可以按调度...

    普通进程:

    采用动态优先级来调度

    调度程序周期性地修改优先级(避免饥饿)

    实时进程:

    采用静态优先级来调度

    由用户预先指定,以后不会改变

    静态优先级:

    进程创建时指定或由用户修改。

    动态优先级:

    在进程运行期间可以按调度策略改变。

    非实时进程采用动态优先级,由调度程序计算

    只要进程占用CPU,优先级就随时间流失而不断减小。

    task_struct的counter表示动态优先级

    调度策略(结合task_struct结构)

    task_struct ->policy指明进程调度策略

    #define SCHED_OTHER  //普通的分时进程

    #define SCHED_FIFO  //实时进程

    #define SCHED_RR  //实时进程

    实时进程:

    SCHED_FIFO(先进先出):

    当前实时进程一直占有CPU直至退出或堵塞或被抢占

    堵塞后再就绪时被添加到同优先级队列的末尾

    SCHED_RR(时间片轮转):

    与其它实时进程以Round-Robin方式共同使用CPU。

    确保同优先级的多个进程能共享CPU

    非实时进程(普通进程):

    SCHED_OTHER(动态优先级)

    counter成员表示动态优先级

    调度策略的改变:

    系统调用sched_setscheduler()改变调度策略

    实时进程的子孙进程也是实时进程

    进程调度的依据

    task_struct:

    policy:

    进程的调度策略,用来区分实时进程和普通进程

    SCHED_OTHER(0) || SCHED_FIFO(1) || SCHED_RP(2)

    priority:

    进程(包括实时和普通)的静态优先级

    rt_priority:

    实时进程特有的优先级:rt_priority+1000

    counter:

    进程能连续运行的时间

    动态优先级与counter:

    counter值的含义:

    进程能连续运行的时间,单位是时钟滴答tick

    时钟中断周期tick为10ms,若counter = 60,则能连续运行600ms

    较高优先级的进程一般counter较大

    一般把counter看作动态优先级

    counter的初值与priority有关

    普通进程创建时counter的初值为priority的值

    counter的改变:

    时钟中断tick时,当前进程的counter减1,直到为0被堵塞

    子进程创建的时候counter:

    创建子进程的counter是父进程的一半

    调度时机:

    中断处理过程中直接调用schedule()

    时钟中断,I/O中断,系统调用和异常

    内核被动调动的情形

    中断处理过程返回用户态时直接调用schedule()

    必须根据need_resched标记

    内核线程可直接调用schedule()进行进程切换

    内核主动调度的情形

    用户态进程只能通过陷入内核后在中断处理过程中被动调度

    必须根据need_resched标记

    进程切换:

    概念:

    内核挂起当前CPU上的进程并恢复之前挂起的某个进程

    任务切换,上下文切换

    与中断上下文的切换有差别:

    中断前后在同一程序上下文中,只是用户态转向内核态执行

    进程上下文包含了进程执行需要的所有信息:

    用户地址空间:包括程序代码。数据,用户堆栈

    控制信息:进程描述符,内核堆栈等

    硬件上下文(注意中断也要保存硬件上下文只是保存的方法不同)

    进程调度和切换的流程:

    schedule()函数:

    选择新进程next = pick_next_task(rq,prev);//进程调度算法

    调用宏context_swittch(rq,prev,next); //切换进程上下文

    prev:当前进程,next:被调度的新进程

    调用switch_to(prev,next) 切换上下文

    两个进程A,B切换的基本过程:

    1.正在运行的用户态进程A

    2.发生中断(譬如时钟中断)

    保存current当前进程的cs:eip/esp/eflags到内核堆栈

    从内核堆栈装入ISR中断服务列程的cs:eip和ss:esp

    3.SAVE_ALL //保存现场,已进入内核中断处理过程

    4.中断处理过程中或中断返回前调用了schedule()

    其中的switch_to做了进程上下文切换

    5.运行用户态进程B(B曾经通过以上步骤被切换出去)

    6.RESTORE_ALL //恢复现场

    7.iret //中断返回 pop cs:eip/ss:esp/eflags

    8.继续运行用户态进程A

    标签:优先级,中断,counter,调度,Linux,进程,SCHED

    来源: https://www.cnblogs.com/beautiful7/p/12709627.html

    展开全文
  • 动态优先级进程进入就绪队列一定时间未获取cpu,则提升优先级进程类 package process; /** * 进程类 */ public class Process implements Comparable<Process>{ // 进程标识管理器 private static ...
  • 采用动态优先数。即进程的优先数在创建进程时可以给定一个初始值,并且可以按一定原则修改优先数:在进程获得一次CPU后就将其优先数...“最高优先数优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程
  • c语言版本,使用数据结构简单实现抢占式动态优先级调度算法
  • 优先级调度算法动态优先级We are already familiar with what Priority Scheduling is. It is one of the most used process scheduling algorithm used in operating systems, in which every process is assigned ...
  • /*非抢占式优先级调度算法*/ #include <iostream> using namespace std; struct Num { int priority; //优先级 int dt; //到达时间 int st; //运行时间 }su...
  • 进程优先级调度算法

    2018-06-22 18:49:01
    《计算机与操作系统(第四版)》进程优先级调度算法 1.时间片轮转调度算法 2.多级反馈队列调度算法 3.高响应比优先调度算法
  • 进程调进程调度算法进程调度算法进程调度算法进程调度调度算法进程调度算法进程调度算法
  • “最高优先数优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。 (1). 静态优先数是在创建进程时确定的,并在整个进程运行期间不再改变。 (2). 动态优先数是指进程的优先数在创建进程时可以给定...
  • 操作系统进程调度中,优先级调度算法模拟,模拟进程调度,采用优先级调度算法,非抢占式,资源分配,资源分配。
  • Java操作系统进程调度算法——优先级调度(HPF)算法 文章目录Java操作系统进程调度算法——优先级调度(HPF)算法前言一、算法思想二、数据结构1.定义(PCB)进程控制块2.实现思路三、流程图四、完整代码运行结果1、输入...
  • 用java语言来描述基于优先级进程调度算法
  • 模拟进程优先级调度算法,是进程调度模拟程序中的一种实现算法
  • 动态优先级调度算法的实现 学校的一个处理机调度实验,可能有的细节做的不是很好,但能运行出想要的结果,希望能够帮助有需要的人。 #include<stdio.h> #include<stdlib.h> typedef struct PCB { /*...
  • 在采用优先级进程调度时,运行进程是否一定是系统中优先级最高的进程?为什么? 不一定。因为高优先级的进程有可能正处在阻塞队列中,进程调度就从就绪队列中选一个进程占用CPU,这个被选中的进程可能优先级较低。 .....
  • 操作系统动态优先级调度算法C语言实现

    万次阅读 多人点赞 2018-05-27 10:48:53
    动态优先级算法 动态优先数是指在进程创建时先确定一个初始优先数, 以后在进程运行中随着进程特性的改变不断修改优先数,这样,由于开始优先数很低而得不到CPU的进程,就能因为等待时间的增长而优先数变为最高而...
  • 先来先服务调度算法每次调度都是从后备作业队列中选择一个...动态优先权调度算法是指在创建进程时赋予的优先权,并且该优先权随进程的推进或等待时间的增加而改变,调度时把处理机分配给就绪队列中优先权最高的进程
  • 操作系统实验课程中进程优先级调度算法利用C语言实现程序
  • 最高优先级进程调度

    2007-12-27 13:41:57
    定义优先级、需要运行时间、完成时间、等信息。采用最高优先级调度进程,在优先级相同的情况下采用FCFS算法调度
  • 试验名称:进程调度模拟算法 ...调度算法:采用最高优先数优先的调度算法。每个进程由一个进程控制块(PCB)表示。进程控制块可以包含以下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间,进程状态等。
  • 优先级队列调度算法

    千次阅读 2008-10-31 15:58:00
    一、多优先级队列调度算法的描述该算法有多个队列,同一个队列中的进程优先级相同,不同队列中进程优先级不同;最高优先级上的进程运行1个时间片,次高优先级上的进程运行2个时间片,再下一级运行4个时间片,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 47,977
精华内容 19,190
关键字:

动态优先级进程调度算法