计算机操作系统的进程调度的五种算法


计算机操作系统进程调度五种算法为:1.先来先服务算法  2.短作业优先算法 3.高响应比优先算法 4.时间片轮转法  5.多级反馈队列算法

public class jcdu {
	String name;
	int id;
	int enter_time;
	int ser_time;
	jcdu(){}
	void setname(String aname){
		this.name=aname;
	}
	void setenter_time(int time){
		this.enter_time=time;
	}
	void setser_time(int time){
		this.ser_time=time;
	}
	void setid(int id){
		this.id=id;
	}
	String getname(){
		return this.name;
	}
	int getenter_time(){
		return this.enter_time;
	}
	int getser_time(){
		return this.ser_time;
	}
	int getid(){
		return this.id;
	}
}

1.先来先服务算法:主要为每次调度作业就是从后备的就绪队列中就是选择一个或者多个最先进入该队列的作业。可以设置一个静态变量,让静态变量逐渐递增,用一个List容器判断每秒中进入就绪队列中的作业。当一个作业执行完毕,再从List容器选出第一个进入该队列的作业。一直循环到所有作业执行完毕。

/*先来先服务*/  class test{
	public static int run_time=0;
	
	public static void main(String[] args) {
	    jcdu [] temp=new jcdu[5];
		Scanner in=new Scanner(System.in);
		int pro_count=0;
		int do_time=0;
		int en_time;
		int do_id=0;
		String name=null;
		System.out.println("请输入进程信息:");
		for(int i=0;i<5;i++){
			System.out.println("进程id"+i);
			temp[i]=new jcdu();
			temp[i].setid(i);
			System.out.print("进程名:");
			temp[i].setname(in.next());
			System.out.print("到达时间:");
			temp[i].setenter_time(in.nextInt());
			System.out.print("服务时间:");
			temp[i].setser_time(in.nextInt());
			
		}
		List <jcdu>li=new ArrayList<jcdu>();
		for(jcdu x:temp){
			li.add(x);
		}
		while(true){
			int j;
			en_time=Integer.MAX_VALUE;
			for(jcdu x:li){
				if(x.getenter_time()< en_time){      //找出一个执行进程
					do_id=x.getid();
					do_time=x.getser_time();
					name=x.getname();
					en_time=x.getenter_time();
				
				}
			}
			if(en_time>run_time){
				System.out.println("当前没有进程到达");
				run_time++;
			}
			else{
				for(j=0;j<do_time;j++){             
					for(jcdu x:li){
						if(x.getenter_time()==run_time){
							System.out.println("进程"+x.getname()+"在第"+run_time+"秒到达");
						}
					}
					
					System.out.println("第"+run_time+"秒"+"执行进程"+name);
					try {
					Thread.currentThread().sleep(1000);
						}
					catch (InterruptedException e) {
						e.printStackTrace();
					}
					
					run_time++;
					
					
					}
				if(j==do_time){
				System.out.println(name+"进程执行结束");
					}
				pro_count++;
				for(int i=0;i<li.size();i++){
				if(li.get(i).getid()==do_id){
					li.remove(i);
					}	
				}
				if(pro_count==5)
				break;
				}
			}
		try {
			Thread.currentThread().sleep(1000);
				}
			catch (InterruptedException e) {
				e.printStackTrace();
			}
		 System.out.println("进程信息");
		 show(temp);
		
		}
	public static void show(jcdu [] other){
     	System.out.printf("%-5s %-5s %-5s %-5s\n","进程id","进程名","到达时间","服务时间");
	   for(jcdu x:other){
		System.out.printf("%-5d  %-5s  %-5s  %-5s\n",x.getid(),x.getname(),x.getenter_time(),x.getser_time());
	 }
	}
}

2.短作业优先算法:主要为每次调度作业就是从后备的就绪队列中就是选择一个或者多个要求服务时间最短的作业。可以设置一个静态变量,让静态变量逐渐递增,用一个List容器判断每秒中进入就绪队列中的作业。当一个作业执行完毕,再从List容器选出服务时间最短的进入该队列的作业。一直循环到所有作业执行完毕。

class test{
	public static int run_time=0;
	
	public static void main(String[] args) {
	    jcdu [] temp=new jcdu[5];
		Scanner in=new Scanner(System.in);
		int pro_count=0;
		int ser_time;
		int en_time=0;
		int do_id=0;
		String name=null;
		System.out.println("请输入进程信息:");
		for(int i=0;i<5;i++){
			System.out.println("进程id"+i);
			temp[i]=new jcdu();
			temp[i].setid(i);
			System.out.print("进程名:");
			temp[i].setname(in.next());
			System.out.print("到达时间:");
			temp[i].setenter_time(in.nextInt());
			System.out.print("服务时间:");
			temp[i].setser_time(in.nextInt());
			
		}
		List <jcdu>li=new ArrayList<jcdu>();
		for(jcdu x:temp){
			li.add(x);
		}
		while(true){
			int j;
			ser_time=Integer.MAX_VALUE;
			for(jcdu x:li){
				if(x.getenter_time()<=run_time && x.getser_time()< ser_time){      //找出一个执行进程
					do_id=x.getid();
					ser_time=x.getser_time();
					name=x.getname();
					en_time=x.getenter_time();
				}
			}
			if(en_time>run_time){
				System.out.println("当前没有进程到达");
				run_time++;
			}
			else{
				for(j=0;j<ser_time;j++){             //根据执行时间 
					for(jcdu x:li){
						if(x.getenter_time()==run_time){
							System.out.println("进程"+x.getname()+"在第"+run_time+"秒到达");
						}
					}
					System.out.println("第"+run_time+"秒"+"执行进程"+name);
					try {
					Thread.currentThread().sleep(1000);
						}
					catch (InterruptedException e) {
						e.printStackTrace();
					}
					run_time++;
					
					}
				if(j==ser_time){
				System.out.println(name+"进程执行结束");
					}
				pro_count++;
				for(int i=0;i<li.size();i++){
				if(li.get(i).getid()==do_id){
					li.remove(i);
					}	
				}
				if(pro_count==5)
				break;
				}
			}
		try {
			Thread.currentThread().sleep(1000);
				}
			catch (InterruptedException e) {
				e.printStackTrace();
			}
		 System.out.println("进程信息");
		 show(temp);
		
		}
	public static void show(jcdu [] other){
     	System.out.printf("%-5s %-5s %-5s %-5s\n","进程id","进程名","到达时间","服务时间");
	   for(jcdu x:other){
		System.out.printf("%-5d  %-5s  %-5s  %-5s\n",x.getid(),x.getname(),x.getenter_time(),x.getser_time());
	 }
	}
}

3.高响应比优先算法:主要为每次调度作业就是从后备的就绪队列中就是选择一个或者多个响应比最高的作业。可以设置一个静态变量,让静态变量逐渐递增,用一个List容器判断每秒中进入就绪队列中的作业,并且每秒计算该作业的响应比{(等待时间+要求服务时间)/要求服务时间}。当一个作业执行完毕,再从List容器选出响应比最高的作业。一直循环到所有作业执行完毕。

class test{
	public static int run_time=0;
	
	public static void main(String[] args) {
	    jcdu [] temp=new jcdu[5];
		Scanner in=new Scanner(System.in);
		int pro_count=0;
		int ser_time=0;
		int en_time=0;
		int do_id=0;
		
		String name=null;
		System.out.println("请输入进程信息:");
		for(int i=0;i<5;i++){
			System.out.println("进程id"+i);
			temp[i]=new jcdu();
			temp[i].setid(i);
			System.out.print("进程名:");
			temp[i].setname(in.next());
			System.out.print("到达时间:");
			temp[i].setenter_time(in.nextInt());
			System.out.print("服务时间:");
			temp[i].setser_time(in.nextInt());
			
		}
		List <jcdu>li=new ArrayList<jcdu>();
		for(jcdu x:temp){
			li.add(x);
		}
		while(true){
			int j;
			double wei=Double.MIN_VALUE;
			for(jcdu x:li){
				x.setweight(run_time);
			}
			for(jcdu x:li){
				if(x.getenter_time()<=run_time && x.getweight()>wei){      //找出一个执行进程
					do_id=x.getid();
					ser_time=x.getser_time();
					name=x.getname();
					en_time=x.getenter_time();
					wei=x.getweight();
				}
			}
			if(en_time>run_time){
				System.out.println("当前没有进程到达");
				run_time++;
			}
			else{
				for(j=0;j<ser_time;j++){             //根据执行时间 
					for(jcdu x:li){
						if(x.getenter_time()==run_time){
							System.out.println("进程"+x.getname()+"在第"+run_time+"秒到达");
						}
					}
					System.out.println("第"+run_time+"秒"+"执行进程"+name);
					try {
					Thread.currentThread().sleep(1000);
						}
					catch (InterruptedException e) {
						e.printStackTrace();
					}
					run_time++;
					
					}
				if(j==ser_time){
				System.out.println(name+"进程执行结束");
					}
				pro_count++;
				for(int i=0;i<li.size();i++){
				if(li.get(i).getid()==do_id){
					li.remove(i);
					}	
				}
				if(pro_count==5)
				break;
				}
			}
		try {
			Thread.currentThread().sleep(1000);
				}
			catch (InterruptedException e) {
				e.printStackTrace();
			}
		 System.out.println("进程信息");
		 show(temp);
		
		}
	public static void show(jcdu [] other){
     	System.out.printf("%-5s %-5s %-5s %-5s\n","进程id","进程名","到达时间","服务时间");
	   for(jcdu x:other){
		System.out.printf("%-5d  %-5s  %-5s  %-5s\n",x.getid(),x.getname(),x.getenter_time(),x.getser_time());
	 }
	}
}

4.时间片轮转算法:主要为每次调度作业就是从后备的就绪队列中就是选择一个或者多个最先进入该队列的作业。每次給队列首元素分配时间片,当时间片执行完毕时,再把进程放到队尾。一直循环到所有作业执行完毕。

class test{
	public static int run_time=0;
	public static void main(String[] args) {
	    jcdu [] temp=new jcdu[5];
		Scanner in=new Scanner(System.in);
		int pro_count=0;
		int en_time=0;
		int time_p=0;
		String name=null;
		System.out.println("请输入进程信息:");
		for(int i=0;i<5;i++){
			System.out.println("进程id"+i);
			temp[i]=new jcdu();
			temp[i].setid(i);
			System.out.print("进程名:");
			temp[i].setname(in.next());
			System.out.print("到达时间:");
			temp[i].setenter_time(in.nextInt());
			System.out.print("服务时间:");
			temp[i].setser_time(in.nextInt());
			
		}
		System.out.println("请输入时间片的长度 :");
		time_p=in.nextInt();
		List <jcdu>li=new ArrayList<jcdu>();
		while(true){
		     int j;
		     int i;
		     int q=0;
		     for(i=0;i<temp.length;i++)
		         {
		    	 if(temp[i].getenter_time() == run_time)      //判读是否有进程进入队列
		    		  {
		    		    System.out.println(run_time+"进程"+temp[i].getname()+"进入就绪队列");
				        li.add(temp[i]);
		    	      }		        
		         }
		     if(li.isEmpty())
		         {
		    	   System.out.println(run_time+"没有可执行性进程");
		         }
		     else
		         {
		    	 jcdu te=li.get(0);
		    	 li.remove(0);
		    	 for(j=0;j<time_p;j++)
		    	        {
		    		    name=te.getname();
						System.out.println("第"+run_time+"秒"+"执行进程"+name);
						te.setdoingtime();
						try {
							Thread.currentThread().sleep(1000);
								}
							catch (InterruptedException e) {
								e.printStackTrace();
							}
						if(te.com())
						    {
							pro_count++;
							System.out.println("第"+run_time+"秒"+"进程"+name+"执行结束");
							if(li.isEmpty())
							    {
								System.out.println("就绪队列为空");
								for(i=0;i<temp.length;i++)
						            {
						    	 if(temp[i].getenter_time() == run_time)      //判读是否有进程进入队列
						    		     {
						    		    System.out.println(run_time+"进程"+temp[i].getname()+"进入就绪队列");
								        li.add(temp[i]);
						    	         }		        
						           }
							    }
							else
							   {
								te=li.get(0);
								li.remove(0);
							   }
						    }
						run_time++;
						System.out.print("就绪队列:");
							for(jcdu x:li){
								   System.out.print(x.getname()+" ");
							   }
							System.out.println(" ");
		    	        }
		    	 if(!te.com())
		    		 li.add(te);
		    	 System.out.println("时间片执行完毕");
				    System.out.println();
		         }
		     if(pro_count==5)
				    break;
			
		}
                      /*int j;
			int q=0;
			double wei=Double.MIN_VALUE;
			en_time=Integer.MAX_VALUE;
			for(int i=0;i<temp.length;i++){
					if(temp[i].getenter_time() == run_time){      //判读是否有进程进入队列
				        for(jcdu x:li){
						   if(x.getname()!=temp[i].getname())
					           q++;		   
						}
				        if(q==li.size()){
				        	li.add(temp[i]);
				        }
			       }
		    System.out.print("就绪队列:");
			for(jcdu x:li){
				   System.out.print(x.getname()+" ");
			   }
			System.out.println(" ");
			if(li.isEmpty()){
			    System.out.println("当前就绪队列为空");
				run_time++;
			    }
			else{
				jcdu te=li.get(0);
				li.remove(0);                     //取出当前执行的队首元素
			    for(j=0;j<time_p;j++){
					name=te.getname();
					System.out.println("第"+run_time+"秒"+"执行进程"+name);
					try {
						Thread.currentThread().sleep(1000);
							}
						catch (InterruptedException e) {
							e.printStackTrace();
						}
					te.setdoingtime();            //已经执行的时间
				    if(te.com()){                 //已经执行完毕   重新选取队首元素
					   System.out.println(name+"进程执行结束");
					   pro_count++;
					   if(li.isEmpty()){
				        System.out.println("就绪队列已空");
				            }
				       else{
				          te=li.get(0);
				          li.remove(0);
				         }
					   }
				    run_time++;
				    for(int pi=0;pi<temp.length;pi++){
						if(temp[pi].getenter_time() == run_time){      //判读下一秒是否有进程进入队列
					        System.out.println("第"+run_time+"秒到达"+temp[pi].getname());
							li.add(temp[pi]);
							}
				         } 
			      }
			    if(!te.com())                //如果时间片结束进程还没有执行行结束从新放入队尾元素
				     li.add(te); 
			     
			   }
			  if(pro_count==5)
				    break;
			     
			  }
		 }*/
			
	}
	public static void show(jcdu [] other){
     	System.out.printf("%-5s %-5s %-5s %-5s\n","进程id","进程名","到达时间","服务时间");
	   for(jcdu x:other){
		System.out.printf("%-5d  %-5s  %-5s  %-5s\n",x.getid(),x.getname(),x.getenter_time(),x.getser_time());
	     }
    }
}

5.多级反馈队列算法:设置多个队列,每个队列的时间片长度不同,当队列1中作业未执行完毕时,在放入二级队列依次类推。一直循环到所有作业执行完毕。

class test{
	public static int run_time=0;    //运行时间
	static int pro_count=0;          //进程完成数
	int ser_time=0;                  //要求服务时间
	int en_time;                     //到达时间
	String name=null;
    static	jcdu [] temp={
    	new jcdu("A",1,0,3),new jcdu("B",2,2,6),
    	new jcdu("C",3,4,4),new jcdu("D",4,6,5),
    	new jcdu("E",5,8,2)};
    public static void main(String[] args) {
		duojiqueue();
		}
	public static void duojiqueue(){
		List <jcdu> li1=new ArrayList<jcdu> ();
		List <jcdu> li2=new ArrayList<jcdu> ();
		Map<Integer,List <jcdu> > tmap=new HashMap<Integer,List <jcdu>>();  
	    tmap.put(2,li1);
	    tmap.put(4,li2);
	    while(pro_count!=5){
	    	for(int i=0;i<temp.length;i++)
	    	{
	    		if(temp[i].getenter_time() == run_time)      //判读是否有进程进入队列
	    		{
	    			System.out.println(run_time+"秒进程"+temp[i].getname()+"进入就绪队列1");
	    			li1.add(temp[i]);
	    		}	
	    		
	    	}
	    	Set<Integer> keys=tmap.keySet();
	  	    Iterator<Integer> i=keys.iterator();
	  	    while(i.hasNext()){
	  	    	int key=i.next();
	  	    	List <jcdu> li=tmap.get(key);
	  	    	System.out.print("就绪队列"+key/2);
	  	    	if(!li.isEmpty())
	  		         {
	  	    		  for(jcdu r:li)
	  	    			  System.out.print(r.getname());
	  		         }
	  	    	System.out.println();
	  	    }
	  	  while(!li1.isEmpty()){
	  	    	jcdu r=li1.get(0);
	  	    	li1.remove(r);
	  	    	for(int j=0;j<2;j++)
	  	    	{
	  	    		System.out.println("当前时间片执行进程"+r.getname());
	    			  r.addser_time();
	    			   try {
						Thread.currentThread().sleep(1000);
							}
						catch (InterruptedException e) {
							e.printStackTrace();
						}
	    			  if(r.isequ()){
	    				  System.out.println("进程执行结束"+r.getname());
	    				  pro_count++;
	    				  break;
	    			  }
	    		   run_time++;
	    		   for(int w=0;w<temp.length;w++)
		  	    	    {
		  	    		if(temp[w].getenter_time() == run_time)      //判读是否有进程进入队列
		  	    		    {
		  	    			System.out.println(run_time+"进程"+temp[w].getname()+"进入就绪队列1");
		  	    			li1.add(temp[w]);
		  	    		    }	
		  	    		}
	  	    	}
	  	    	if(!r.isequ()){
	  	    		li2.add(r);
	  	    	}
	  	    	keys=tmap.keySet();
		  	    i=keys.iterator();
		  	    while(i.hasNext()){
		  	    	int key=i.next();
		  	    	List <jcdu> li=tmap.get(key);
		  	    	 System.out.print("就绪队列"+key/2);
		  	    	if(!li.isEmpty())
		  		         {
		  	    		  for(jcdu rw:li)
		  	    			  System.out.print(rw.getname());
		  		         }
		  	    	System.out.println();
		  	    }
	  	    }	
	  	 while(!li2.isEmpty()){
	  	    	jcdu r=li2.get(0);
	  	    	li2.remove(r);
	  	    	for(int j=0;j<4;j++)
	  	    	{
	  	    		System.out.println("当前时间片执行进程"+r.getname());
	    			  r.addser_time();
	    			   try {
						Thread.currentThread().sleep(1000);
							}
						catch (InterruptedException e) {
							e.printStackTrace();
						}
	    			  if(r.isequ()){
	    				  System.out.println("进程执行结束"+r.getname());
	    				  pro_count++;
	    				  break;
	    			  }
	    		   run_time++;
	    		   for(int w=0;w<temp.length;w++)
		  	    	    {
		  	    		if(temp[w].getenter_time() == run_time)      //判读是否有进程进入队列
		  	    		    {
		  	    			System.out.println(run_time+"进程"+temp[w].getname()+"进入就绪队列1");
		  	    			li1.add(temp[w]);
		  	    		    }	
		  	    		}
	  	    	}
	  	    	
	  	    	if(!r.isequ()){
	  	    		li2.add(r);
	  	    	}
	  	    	keys=tmap.keySet();
		  	    i=keys.iterator();
		  	    while(i.hasNext()){
		  	    	int key=i.next();
		  	    	List <jcdu> li=tmap.get(key);
		  	    	System.out.print("就绪队列"+key/2);
		  	    	if(!li.isEmpty())
		  		         {
		  	    		  for(jcdu rw:li)
		  	    			  System.out.print(rw.getname());
		  		         }
		  	    	System.out.println();
		  	    }
	  	    }  		      	 
	   }
	    System.out.println(run_time);
   }
}



进程调度算法模拟。通过对进程调度算法的模拟,进一步理解进程的基本概念,加深对进程运行状态和进程调度过程、调度算法的理解。 (1) 用C、C++、Java语言编程实现对5个进程采用动态优先权调度算法进行调度的过程。数据如下: 5个进程的到达时刻和服务时间见下表,忽略I/O以及其它开销时间,使用动态优先权算法进行调度,优先权初始值为100,请输出各个进程的完成时刻、周转时间、带权周转时间。 进程 到达时刻 服务时间 A 0 3 B 2 6 C 4 4 D 6 5 E 8 2 (2)每个用来标识进程的进程控制块PCB可用结构来描述,包括以下字段(用不到的字段可以不定义)。  进程标识数ID。  进程优先数PRIORITY,并规定优先数越大的进程,其优先权越高。  进程已占用CPU时间CPUTIME。  进程还需占用的CPU时间ALLTIME。当进程运行完毕时,ALLTIME变为0。  进程的阻塞时间STARTBLOCK,表示当进程再运行STARTBLOCK个时间片后,进程将进入阻塞状态。  进程被阻塞的时间BLOCKTIME,表示已阻塞的进程再等待BLOCKTIME个时间片后,将转换成就绪状态。  进程状态STATE。  队列指针NEXT,用来将PCB排成队列。 (3)优先数改变的原则:  进程在就绪队列中呆一个时间片,优先数增加1。  进程每运行一个时间片,优先数减3。 (4)为了清楚地观察每个进程的调度过程,程序应将每个时间片内的进程的情况显示出来,包括正在运行的进程,处于就绪队列中的进程和处于阻塞队列中的进程。 (5)分析程序运行的结果,谈一下自己的认识。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值