精华内容
下载资源
问答
  • 事先说明: 本代码为原创,转载请附原博地址。 代码可以运行,但是运算结果并不知道对错(感觉第三个有问题),凌晨两点写的,大脑并不清醒,欢迎交流修改。...短作业优先算法,是在作业到达的基础上,如果有多...

    事先说明:

    本代码为原创,转载请附原博地址。

    代码可以运行,但是运算结果并不知道对错(感觉第三个有问题),凌晨两点写的,大脑并不清醒,欢迎交流修改。

    如果我的老师查重的时候看到这篇,请你看一下交作业时间和博客时间来确定这是我本人写的~

    理论部分:

    简单地说一下吧,毕竟书上应该都有。

    先来先服务算法,就非常简单地按照作业到达先后进行计算。

    短作业优先算法,是在作业到达的基础上,如果有多个作业都已经到达,选择运行时间短的作业先计算。

    响应比高者优先算法,也是在作业到达的基础上,如果有多个作业都已经到达,计算他们的优先级,优先级高的作业先计算。

    优先级=1+(等待时间 / 要求服务时间)

    代码:

    #include<iostream>
    #include<algorithm>
    #include<cstring>
    #include<cmath>
    #include<vector>
    using namespace std;
    struct zy//每个作业
    {
    	int gettime;//到达时间
    	int runtime;//运行时间
    	int k;//标记有没有被用过(用于第二个算法)
    	int y;//优先级(第三个算法)
    };
    bool cmp(zy a, zy b)//按照到达时间进行排序
    {
    	return a.gettime < b.gettime;
    }
    bool cmp2(zy a, zy b)//按照运行时间进行排序
    {
    	return a.runtime < b.runtime;
    }
    bool cmp3(zy a, zy b)//按照优先级排序
    {
    	return a.y > b.y;
    }
    int main()
    {
    	/*输入数据*/
    	int n;
    	cout << "请输入有几组:";
    	cin >> n;
    	zy z[100];
    	cout << "输入每个作业的到达时间和运行时间" << endl;
    	for (int i = 0; i < n; i++)
    	{
    		cin >> z[i].gettime >> z[i].runtime;
    		z[i].k = 0;
    	}
    
    	int overtime[100];//结束时间
    	int starttime[100];//开始时间
    	int zhouzhuan[100];//周转时间
    	double dq[100];//带权周转时间
    
    	/*先来先服务算法*/
    	sort(z, z + n, cmp);
    	for (int i = 0; i < n; i++)
    	{
    		if(i==0)starttime[i] = z[i].gettime;
    		else starttime[i] = z[i].gettime + overtime[i - 1];
    		overtime[i] = starttime[i] + z[i].runtime;
    		zhouzhuan[i] = overtime[i] - z[i].gettime;
    		dq[i] = zhouzhuan[i]*1.0 / z[i].runtime;
    	}
    	double T=0, W=0;
    	for (int i = 0; i < n; i++)
    	{
    		T = T + zhouzhuan[i];
    		W = W + dq[i];
    	}
    	T = T / n*1.0;
    	W = W / n*1.0;
    	cout << "先来先服务算法的平均时间是: " << T << " 带权平均周转时间是:" << W << endl;
    
    	/*短作业优先算法*/
    	memset(overtime, 0, sizeof(overtime));
    	memset(starttime, 0, sizeof(starttime));
    	memset(zhouzhuan, 0, sizeof(zhouzhuan));
    	memset(dq, 0, sizeof(dq));
    	T = 0, W = 0;
    	sort(z, z + n, cmp);
    	for (int i = 0; i < n; i++)
    	{
    		if (i == 0) {
    			starttime[i] = z[i].gettime;
    			overtime[i] = starttime[i] + z[i].runtime;
    			zhouzhuan[i] = overtime[i] - z[i].gettime;
    			dq[i] = zhouzhuan[i]*1.0 / z[i].runtime;
    			z[i].k = 1;
    		}
    		else {
    			for (int j = 0; j < n; j++)//找最短时间的作业
    			{
    				if (z[j].k == 0 && z[j].gettime <= overtime[i - 1]) {//如果没有使用过且在结束时间内
    					starttime[i] = z[j].gettime;
    					overtime[i] = starttime[i] + z[j].runtime;
    					zhouzhuan[i] = overtime[i] - z[i].gettime;
    					dq[i] = zhouzhuan[i]*1.0 / z[j].runtime;
    					z[j].k = 1;
    					break;
    				}
    			}
    		}
    		sort(z, z + n, cmp2);
    	}
    	for (int i = 0; i < n; i++)
    	{
    		T = T + zhouzhuan[i];
    		W = W + dq[i];
    	}
    	T = T / n*1.0;
    	W = W / n*1.0;
    	cout << "短作业优先算法的平均时间是: " << T << " 带权平均周转时间是:" << W << endl;
    
    	/*高响应比优先算法*/
    	memset(overtime, 0, sizeof(overtime));
    	memset(starttime, 0, sizeof(starttime));
    	memset(zhouzhuan, 0, sizeof(zhouzhuan));
    	memset(dq, 0, sizeof(dq));
    	T = 0, W = 0;
    	sort(z, z + n, cmp);
    	for (int i = 0; i < n; i++)
    	{
    		if (i == 0) {
    			starttime[i] = z[i].gettime;
    			overtime[i] = starttime[i] + z[i].runtime;
    			zhouzhuan[i] = overtime[i] - z[i].gettime;
    			dq[i] = zhouzhuan[i] * 1.0 / z[i].runtime;
    		}
    		else {
    			int g;//标记最后一个在上一个结束时间内的作业
    			for (int j = i; j < n; j++)
    			{
    				if (z[j].gettime <= overtime[i])g = j;
    				else break;
    			}
    			if (g - i == 1) {//只有一个作业可执行
    				starttime[i] = z[i].gettime + overtime[i - 1];
    				overtime[i] = starttime[i] + z[i].runtime;
    				zhouzhuan[i] = overtime[i] - z[i].gettime;
    				dq[i] = zhouzhuan[i] * 1.0 / z[i].runtime;
    			}
    			else {//需要计算优先级
    				for (int j = i; j <= g; j++)
    				{
    					z[j].y = 1 + (overtime[i - 1] - z[j].gettime) / z[j].runtime;
    				}
    				sort(z+i, z + g, cmp3);
    				starttime[i] = z[i].gettime + overtime[i - 1];
    				overtime[i] = starttime[i] + z[i].runtime;
    				zhouzhuan[i] = overtime[i] - z[i].gettime;
    				dq[i] = zhouzhuan[i] * 1.0 / z[i].runtime;
    			}
    		}
    	}
    	for (int i = 0; i < n; i++)
    	{
    		T = T + zhouzhuan[i];
    		W = W + dq[i];
    	}
    	T = T / n*1.0;
    	W = W / n*1.0;
    	cout << "高响应比优先算法的平均时间是: " << T << " 带权平均周转时间是:" << W << endl;
    	system("pause");
    	return 0;
    }

    运行结果:

    展开全文
  • 设计内容 编写一个程序完成多道程序的调度 具体要求 只考虑1个CPU的资源,其他资源不考虑 使用响应比高者优先算法 程序采用键盘输入,输入格式为: K TJ1 YS1 …… TJK YSK 其中K是作业数(>0),TJi提交时间,YSi...
    ******##1这是课程作业的简单分享
    ******##2肯定会有地方对特殊的数据没有考虑到,欢迎改进
    ******##3使用的 java version "1.8.0_131",eclipse上编辑
    

    设计要求

    1. 用可视化编程工具编制程序,在机器上调试运行,并通过上机考核。
    2. 要求界面设计美观,功能完整,使用方便,能运行通过。
    

    设计内容

    编写一个程序完成多道程序的调度
    

    具体要求

    只考虑1个CPU的资源,其他资源不考虑 使用响应比高者优先算法 程序采用键盘输入,输入格式为:
       K
       TJ1    YS1
       …… 
       TJK    YSK
    
    其中K是作业数(>0),TJi提交时间,YSi(i=1~K)是作业预计的运行时间(以分钟计)TJ的输入格式是XXYY, 其中XX是时,YY是分, 如10点28
    分,输入为1028。但内部计算要以60进制来算。要求输出按照作业调度的先后次序输出结果,每行为一个作业状态,从左到右分别是调度次序,作业
    号,调度时间,周转时间和带权周转时间最后一行输出两个数,第一为平均周转时间,第二为平均带权周转时间(带权周转时间=周转时间/运行时间)。
    

    Java实现代码

    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.util.*;
    import javax.swing.*;
    
    class Task implements Comparable{       //定义任务的class同时implements Comparable使得可使用ArrayList
    	public String name;
    	private float Entime;
    	private float Retime;
    	public Task(String name, float Entime, float Retime) {
    		this.name = name;
    		this.Entime = Entime;
    		this.Retime = Retime;
    	    }
    	    public String getName() {
    	        return name;
    	    }
    	    public void setName(String name) {
    	        this.name = name;
    	    }
    	    public float getEntime() {
    	        return Entime;
    	    }
    	    public void setEntime(float Entime) {
    	        this.Entime = Entime;
    	    }
    	    public float getRetime() {
    	        return Retime;
    	    }
    	    public void setRetime(float Retime) {
    	        this.Retime = Retime;
    	    }
    	    public int compareTo(Object o){               //排队条件
    	        Task s = (Task)(o);
    	        if(this.Entime >= s.Entime) {
    	    	    return 1;
    	    	}
    	    	return -1;
    	    } 
    }
    
    class Pframe{                  //简单界面,左侧为输入框,右侧为测试结果框
    	JFrame frame;
    	JButton start;      
    	JTextArea Prarea, Rearea;    
    	JLabel label1, label2;
    	JButton work;
    	JPanel panel;
    	Pframe(String title){
    		frame = new JFrame(title);
    		frame.setSize(800,600);
    		frame.setLayout(null);
    		Prarea = new JTextArea(5,20);
    		Rearea = new JTextArea(6,20);
    		label1 = new JLabel("请输入测试数据:");		
    		label2 = new JLabel("测试结果:");
    		work = new JButton("Examining");
    		frame.add(Rearea);
    		frame.add(Prarea);
    		frame.add(label1);
    		frame.add(label2);
    		label1.setBounds(50, 50, 120, 30);
    		label2.setBounds(300, 50, 120, 30);
    		Prarea.setBounds(300, 80, 430, 250);
    		Rearea.setBounds(50, 80, 220, 250);
    		frame.add(work);
    		work.setBounds(250, 400, 100, 40);
    		frame.setVisible(true);
    		work.addActionListener(new ButtonEvent());
    	}
    	class ButtonEvent implements ActionListener{           //按钮Examining的响应
    		public void actionPerformed(ActionEvent e){
    			Prarea.setText("");
    			Scanner In = new Scanner(Rearea.getText());
    			int num = In.nextInt();
    			int ordernum = 0;
    			String Taskname;
    			float Entime;float Retime;
    			ArrayList<Task> arr = new ArrayList<>();
    			
    			for(int i = 0; i < num; i++) {           //读入数据
    			    Taskname = In.next();
    			    Entime=In.nextFloat();
    			    Entime= (int)(Entime/100)*60 + Entime%100;        //得到时间转化为10进制
    			    Retime=In.nextFloat();
    			    Task task = new Task(Taskname, Entime, Retime);
    			    arr.add(task);
    			}
    			In.close();
    			
    			Collections.sort(arr);                  //按照进入时刻排序
    			Prarea.append("调度次序\t作业号\t调度时间\t周转时间\t带权周转时间");
    			float CurrentTime = arr.get(0).getEntime();		
    			float sum1 = 0, sum2 = 0;
    			float retime = 0;
    			float entime = 0;
    			
    			for(int i = 0;i<num;i ++) {                 //选取能在时间进行调度的Task
    			    List<Task> newarr = new ArrayList<>();
    			    for(int j = 0;j < arr.size();j ++) {
    			    	if(arr.get(j).getEntime()<=CurrentTime) {
    			    		newarr.add(arr.get(j));
    			    		}
    			    }
    			    if(newarr.size() == 0 && arr.size() != 0) {   //空转,当没有任务的时候
    			    	i--;
    			    	CurrentTime++;
    			    	continue;
    			    }
    			    
    			    for(int j=1;j<newarr.size();j++) {              //确定作业号Task,最高响应比确定,并将其放在0号arr单元
    			    	if((CurrentTime-newarr.get(j).getEntime())/newarr.get(j).getRetime()>=(CurrentTime-newarr.get(0).getEntime())/newarr.get(0).getRetime()) {
    			    		if((CurrentTime-newarr.get(j).getEntime())/newarr.get(j).getRetime() == (CurrentTime-newarr.get(0).getEntime())/newarr.get(0).getRetime()) {
    			    			if(newarr.get(0).getRetime() > newarr.get(j).getRetime())     //相应比相同的比较需要执行的时间
    			    				newarr.set(0, newarr.get(j));
    			    		}
    			    		else
    			    			newarr.set(0, newarr.get(j));
    			    	}
    			    }
    			   
    			    arr.remove((Task)newarr.get(0));                  //移除作业号进行此次调度的输出操作
    			    retime = newarr.get(0).getRetime();
    			    entime = newarr.get(0).getEntime();                //对于输出 调度时间的输出是60进制,周转时间和带权周转时间的输出为10进制
    			   
    			    //输出
    			    Prarea.append("\n"+(++ordernum)+"\t"+newarr.get(0).getName()+"\t");
    			    
    			    int a1 = (int)CurrentTime/60;       //对调度时间的输出才去时间的输出格式
    			    int a2 = (int)CurrentTime%60;
    			    if(a1>=10) {
    			    	Prarea.append(a1+":");
    			    	if(a2>=10) {
    			    		Prarea.append(a2+"");
    			    	}
    			    	else Prarea.append("0"+a2);
    			    }
    			    else {
    			    	Prarea.append("0"+a1+":");
    			    	if(a2>=10) {
    			    		Prarea.append(a2+"");
    			    	}
    			    	else Prarea.append("0"+a2);
    			    }
    			    
    			    Prarea.append("\t"+(int)(CurrentTime-entime+retime)+"min"+"\t"+((retime+CurrentTime-entime)/retime));
    			    sum2+=(CurrentTime-entime+retime)/retime;
    			    sum1 += CurrentTime-entime+retime;
    			    CurrentTime = CurrentTime+retime;
    			}
    			Prarea.append("\n"+"平均周转时间为"+String.format("%.2f", sum1/num)+"min"+"        "+"平均带权周转时间为"+String.format("%.2f", sum2/num)+"min");
    
    		}
    	}	
    }
    
    public class processing {
    	public static void main(String arg[]){
    		new Pframe("多道批处理作业");
    	}
    }
    

    输入测试数据1:

    6
    1 1028	6
    2 1029	6
    3 1029	8
    4 1034	12
    5 1032	7
    6 1033	5
    

    显示:
    在这里插入图片描述
    输入测试数据2:

    5
    1 0830 20
    2 0900 30
    3 0900 20
    4 0910 10
    5 0920 20
    

    显示
    在这里插入图片描述
    每次输入测试数据只需在左侧文本框修改即可,欢迎探讨。

    展开全文
  • 利用高级语言模拟进程的时间片轮转调度算法响应比高者优先调度算法
  • 编写程序完成批处理系统中的作业调度,要求采用响应比高者优先的作业调度算法。实验具体包括:首先确定作业控制块的内容和组织方式;然后完成作业调度;最后编写主函数,对所做工作进行测试。
  • 1、对于给定的一组作业, 给出其到达时间和运行时间 2、分别用先来先服务算法、短作业优先和响应比高者优先三种算法给出作业的调度顺序。 3、计算每一种算法的平均周转时间及平均带权周转时间并比较不同算法的优劣。
  • 非抢占式的响应比高者进程调度优先算法java
  • 采用动态改变响应比的办法,进程每运行一次重新计算各进程的响应比。由于本实验是模拟处理器调度,所以,对被选中的进程并不实际的启动运行,而是执行:要求运行时间-1、等待时间为0。其它进程等待时间+1,重新计算...
  • 使用响应比高者优先算法 程序采用键盘输入,输入格式为: K TJ1 YS1 …… TJK YSK 其中K是作业数(>0),TJi提交时间,YSi (i=1~K)是作业预计的运行时间(以分钟计)TJ的输入格式是XXYY,其中XX是时,...
  • 编写程序完成批处理系统中的作业调度,要求采用响应比高者优先的作业调度算法。实验具体包括:首先确定作业控制块的内容,作业控制块的组成方式;然后完成作业调度;最后编写主函数对所作工作进程测试。 4.提示与...
  • 该资源是操作系统课程设计中作业调度算法的源程序,程序中主要用三种作业调度算法来实现一次作业调度,三种算法分别为:先来先服务算法、短作业优先算法、响应比高者优先算法。程序简单易懂,包含大量注释。
  • 调度算法

    2020-06-17 17:41:31
    响应比高者优先算法;优先级算法;多队列循环算法;资源搭配算法。 先来先服务:总是把当前处于就绪队列之首的那个进程调度到运行状态。 多级队列算法:既能使高优先级的作业得到响应又能使短作业(进程)迅速完成...

    作业调度算法是作业调度的关键,直接影响到系统的效率。

    主要的调度算法有:先来先服务算法短作业优先算法响应比高者优先算法优先级算法多队列循环算法资源搭配算法

    先来先服务:总是把当前处于就绪队列之首的那个进程调度到运行状态。

    多级队列算法:既能使高优先级的作业得到响应又能使短作业(进程)迅速完成。

    优先级算法:1)非抢占式优先权调度算法:系统一旦把处理机分配给优先权最高的进程后,便一直执行下去,至完成。
    2)抢占式优先权调度算法:只要系统中出现一个新的就绪进程,就进行优先权比较 。若出现优先权更高的进程,则立即停止当前执行,并将处理机分配给新到的优先权最高的进程。

    短作业优先调度:参考运行时间,选取运行时间最短的作业投入运行。

    响应比高者优先调度:计算每个作业的响应比(响应时间/运行时间),选择响应比最高的作业优先投入运行。

    优先数调度算法:根据进程优先数(静态优先数+动态优先数),把CPU分配给最高的进程。

    循环轮转调度算法:把所有就绪进程按先进先出的原则排成队列,新来进程加入队列末尾,进程以时间片为单位轮流使用CPU,刚刚运行一个时间片的进程排到队列末尾,等候下一轮运行。

    鸵鸟算法,可以称之为不是办法的办法。在计算机科学领域中,鸵鸟算法是一个忽略潜在问题的一种算法。这种算法对程序可能出现的问题采取无视态度(类似于鸵鸟在遇到危险时将头埋在地里,装作看不见)。鸵鸟算法的使用前提是,问题出现的概率很低。

     

    展开全文
  • 操作系统----作业管理

    2009-04-21 11:56:30
    响应比高者优先算法,很简单啊 适于初学者 A
  • 操作系统作业调度

    2014-01-03 15:50:23
    操作系统实验--作业调度,采用先来先服务和响应比高者优先算法
  • 3 响应比高者优先算法 此算法综合考虑等待时间和计算时间,我们把响应比定义为: 响应比 = 等待时间 / 计算时间 由于把计算时间作为分母, 显然是有利于小作业的。一个计算时间短的作业容易得到较高的响应比, ...

    本文 接 上篇内容 批处理作业的调度算法

    3 响应比高者优先算法

    此算法综合考虑等待时间和计算时间,我们把响应比定义为:

    响应比 =  等待时间 / 计算时间

    由于把计算时间作为分母, 显然是有利于小作业的。一个计算时间短的作业容易得到较高的响应比, 所以能被优先选中。 但由于等待时间在分子上, 使得一个大作业在等待了相当长的时间后,也能获得较高的响应比而被选中,不会因源源不断地有小作业进入输入井而使大作业无限制地被推迟。

    采用此算法进行调度时, 必须先计算出输入井资源能得到满足的所有作业的响应比, 然后从中选择响应比最高者优先装入主存储器。

    例如, 某单道程序设计系统中有3个作业A、B、C, 它们到达输入井的时间及需要的计算时间如表1 所示

    当这三个作业全部到达输入井后,  若系统以响应比高者优先调度算法选择作业,忽略调度所用的时间, 则作业被选中的次序应是怎样的呢?

    由于进行作业调度的时间是在作业全部到达输入井之后, 即在9:30开始进行调度, 此时作业 A、B、C分别等待了40分钟、30分钟、0分钟, 因而它们的响应比为:

    A:  40/90= 4/9
    B: 30/24 = 5/4

    C: 0/60=0

    可见作业B的响应比最高, 当然优先选择作业B装入主存储器执行。 作业B执行结束后, 又要进行调度, 由于等待时间发生了变化, 故应重新计算响应比。 此时的计算结果如下:

    A:    64/90=32/45

    B:    24/60=2/5

    显然作业A 的响应比高于作业C的响应比, 因而先选择作业A执行, 最后再让作业C进入主存储器执行。

    4  优先级调度算法

    为每一个作业确定一个优先级, 资源能满足且优先级高的作业优先被选取, 当几个作业有相同优先级时,对这些具有相同优先级的作业再按照先来先服务原则进行调度。

    怎样确定作业的优先级呢? 一种方法是由用户来提出自己作业的优先级。优先级越高收费也越高,以作限制。

    另一种方法是由操作系统根据作业的缓急程度、作业估计的计算时间、作业的类型、 资源申请情况等因素综合考虑。分析这些因素在实现系统设计目标中的影响,决定各因素的比例, 综合得出作业的优先级。

    5 均衡调度算法

    根据作业对资源的要求进行分类, 作业调度从各类作业中去挑选, 尽可能地使得使用不同资源的作业同时执行。 这样不仅可使系统的各种资源都在被使用, 而且可以减少作业等待使用相同资源的时间, 从而加快作业的执行。

    展开全文
  • 此实验模拟批处理系统中的作业调度,并采用响应比高者优先算法作为作业调度算法。
  • 包含单、多道批处理先来先服务算法,单、多道批处理最短作业优先调度算法,单道响应比高者优先算法,源代码流程图齐全
  • 本资源是操作系统课程设计中的作业调度设计,文档中描述了三种作业调度算法:先来先服务算法、短作业优先算法、响应比高者优先算法,并且给出了三种算法的数据分析比较。
  • 批处理系统中作业调度 操作系统实验 C++ 此实验模拟批处理系统中的作业调度,并采用响应比高者优先算法作为作业调度算法。
  • 在采用响应比高者优先调度算法时,其平均周转时间为T为()小时? 计算 周转时间=作业完成时间-作业提交时间 响应比=(作业等待时间+作业执行时间)/作业执行时间 当提交J1时,只有J1作业,执行J1,J1的
  • 磁盘调度实现了最短寻道优先、电梯调度算法和先来先服务算法,作业调度算法实现了先来先服务、短作业优先和响应比高者优先算法,内存管理实现了内存可变分区的内存分配和回收及紧凑算法,页面调度算法实现了FIFO、...
  • 操作系统关于系统调度算法的实验报告:包括先来先服务调度算法、短作业优先调度算法响应比高者优先调度算法在单道以及多道环境下的优劣势比较。
  • 先到先运行,短作业优先,响应比高者优先三种算法,附运行结果
  • 具体的要求是这样的:编写程序完成批处理系统中的作业调度,要求采用响应比高者优先的作业调度算法。实验具体包括:首先确定作业控制块的内容,作业控制块的组成方式;然后完成作业调度;最后编写主函数对所作工作...
  • 作业调度算法

    2013-12-30 10:29:40
    作业调度算法: 分别使用先来先服务(FCFS),最短作业优先(SJF)、响应比高者优先(HRN)的调度算法。c语言完成。

空空如也

空空如也

1 2 3 4 5 6
收藏数 106
精华内容 42
关键字:

响应比高者优先算法