精华内容
下载资源
问答
  • 使用C#实现响应比高者优先调度代码,关于操作系统。
  • 非抢占式的响应比高者进程调度优先算法java
  • 1、对于给定的一组作业, 给出其到达时间和运行时间 2、分别用先来先服务算法、短作业优先和响应比高者优先三种算法给出作业的调度顺序。 3、计算每一种算法的平均周转时间及平均带权周转时间并比较不同算法的优劣。
  • 编写程序完成批处理系统中的作业调度,要求采用响应比高者优先的作业调度算法。实验具体包括:首先确定作业控制块的内容和组织方式;然后完成作业调度;最后编写主函数,对所做工作进行测试。
  • 利用高级语言模拟进程的时间片轮转调度算法,响应比高者优先调度算法。
  • 采用动态改变响应比的办法,进程每运行一次重新计算各进程的响应比。由于本实验是模拟处理器调度,所以,对被选中的进程并不实际的启动运行,而是执行:要求运行时间-1、等待时间为0。其它进程等待时间+1,重新计算...
  • 响应比高者优先算法,也是在作业到达的基础上,如果有多个作业都已经到达,计算他们的优先级,优先级高的作业先计算。 优先级=1+(等待时间 / 要求服务时间) 代码: #include #include #include #include #include ...

    事先说明:

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

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

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

    理论部分:

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

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

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

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

    优先级=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
    

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

    展开全文
  • 【单选题】关于第一次工业革命,下列说法不正确的是()。【单选题】下列牌号中,哪一个是可锻铸铁( )【多选题】16. 下列项目中,属于营业外支出的是( )。【单选题】发展动力决定发展速度、效能、可持续性。...

    【单选题】关于第一次工业革命,下列说法不正确的是()。

    【单选题】下列牌号中,哪一个是可锻铸铁( )

    【多选题】16. 下列项目中,属于营业外支出的是( )。

    【单选题】发展动力决定发展速度、效能、可持续性。请问( )是引领发展的第一动力。

    【单选题】我国的文化建设必须以马克思主义为指导,这是由 决定的

    【单选题】电 路 如 图 所 示, R F 引 入 的 反 馈 为 ( ) 。

    【多选题】18. 以下项目中,应计入“营业外支出”账户的是( )。

    【单选题】电路如图所示为 ( ) 。

    【单选题】电路如图所示,运算放大器的电源电压为 ± 12V , 硅稳压管的稳定电压为 4V , 正向导通电压为 0.6V ,当输入电压 u i =2V 时,输出电压 u O 应为 ( ) 。

    【单选题】研究铁碳合金状态图时,图中最大含碳量为 ( )

    【判断题】明细账一般使用活页式账簿,以便于根据实际需要随时添加空白账页。

    【多选题】15.按照费用的经济内容分类,可分为( )等。

    【单选题】生产大型锻件时应选用的锻造方法为( )。

    【判断题】走向生态文明新时代,是实现民族复兴中国梦的重要内容。

    【单选题】冷铁配合冒口形成定向凝固,能防止铸件( )

    【多选题】文化强国是指一个国家具有强大的文化力量。这种力量既表现为()

    【判断题】中国机制铜币制造起始于1900年的“大清铜币” 。

    【单选题】下列不属于罗马帝国的成就是()。

    【单选题】电路如图所示,运算放大器的饱和电压为 ± 12V , 稳压管的稳定电压为 8V , 正向压降为 0.7 V ,当输入电压 u i =-0.1V 时,则输出电压 u O 等于 ( ) 。

    【单选题】比萨斜塔位于哪个国家:()

    【单选题】21.计算营业利润不应考虑的项目是( )。

    【单选题】下列是整体热处理的是 ( )

    【单选题】电路如图所示,运算放大器的饱和电压为 ± 12V , 稳压管的稳定电压为 6V , 设正向压降为零,当输入电压 u i =-1V 时,则输出电压 u O 等于 ( ) 。

    【单选题】近代科学中,实验传统的来源是()。

    【多选题】下列属于宁波钱庄首创的制度有( )

    【判断题】在十一届三中全会以前,党对我国社会发展阶段的认识都处于不清醒状态。

    【单选题】铁素体F是( ).

    【单选题】13.企业发生的开办费应计入( )。

    【单选题】共晶转变的产物是( )

    【单选题】14.企业销售部门发生的业务招待费用计入( )。

    【单选题】现需要制造一直径25mm的连杆,要求整个截面上具有良好的综合力学性能,应采用( )。

    【单选题】根据Cu-Ni二元匀晶相图,50%Cu+50%Ni的合金在1500°C时处于( )

    【单选题】理 想 运 算 放 大 器 的 开 环 输 出 电 阻 r o 是 ( ) 。

    【单选题】( )是民生安全网。

    【单选题】光量子也同时具有波动性和粒子性,光的波动性的典型表现是什么?()

    【单选题】面对全面建成小康社会决胜阶段复杂的国内外形势,面对经济社会发展的新趋势、新机遇和新矛盾、新挑战,党的十八届五中全会坚持以人民为中心的发展思想,鲜明提出了新发展理念,以下不属于新发展理念的是( )。

    【多选题】10.企业确定合同完工进度时可以选用的方法有( )。

    【多选题】1.下列关于提供劳务交易的说法中,正确的有( )。

    【判断题】中国现代商业保险制度是由我国古代保险的雏形与萌芽演变而来的。

    【多选题】当代保险监管核心价值理念是( )

    【单选题】在我国社会主义初级阶段发展进程中,( )是兴国之要。

    【判断题】每做一件事都能想到会有更好的方法,这有利于培养创新的习惯。()

    【单选题】18.企业车间发生的间接费用,应先归集在( )账户。

    【多选题】宋代发行过的纸币有:( )

    【单选题】电路如图所示,运算放大器的饱和电压为 ± 15V , 二极管D 为理想元件, 当 u i =1V 时 , 输 出 电 压 u O 等于 ( ) 时 输 出 电 压。

    【单选题】希腊人认为天上的世界恰恰是最接近理念世界样本的,这一观点的直接理由是()。

    【判断题】清代晚期建立起纸币本位制代替银两本位制度。

    【单选题】钢的热处理过程是:( )

    【判断题】黄金刚被发现和掌握后,最初就被当做货币使用了。

    【判断题】当铺一般不收土地、房屋等不动产,但可以用契约文书抵押。

    展开全文
  • 实验四 模拟处理机 HRRN 调度算法 一实验目的用 ...N 个进程的平均周转时间 三HRRN最高响应比调度算法原理 最高响应比调度在每次调度作业时先计算后备队 中每个作业的响应比然后挑选响应比高者投入运行 响应比 R 定义
  • 实验四 模拟处理机 HRRN 调度算法 一实验目的 用 c++...2 计算这 N 个进程的平均周转时间 三 HRRN 最高响应比调度算法原理 最高响应比调度在每次调度作业时先计算后备队 中每个作业的响应比 然后挑选响应比高者投入运行
  • 具体的要求是这样的:编写程序完成批处理系统中的作业调度,要求采用响应比高者优先的作业调度算法。实验具体包括:首先确定作业控制块的内容,作业控制块的组成方式;然后完成作业调度;最后编写主函数对所作工作...

    具体的要求是这样的:编写程序完成批处理系统中的作业调度,要求采用响应比高者优先的作业调度算法。实验具体包括:首先确定作业控制块的内容,作业控制块的组成方式;然后完成作业调度;最后编写主函数对所作工作进程测试。

    下面是代码:

    JOB类:

    package com.wk.job;

    public class JOB {

    public JOB() {

    super();

    }

    // 作业名

    String name = null;

    // 作业长度,所需主存大小

    int length = 0;

    // 作业执行所需打印机的数量

    int printer = 0;

    // 作业执行所需磁带机的数量

    int tape = 0;

    // 作业估计执行时间

    float runtime = 0;

    // 作业在系统中的等待时间

    float waittime = 0;

    public int getLength() {

    return length;

    }

    public String getName() {

    return name;

    }

    public int getPrinter() {

    return printer;

    }

    public float getRuntime() {

    return runtime;

    }

    public int getTape() {

    return tape;

    }

    public float getWaittime() {

    return waittime;

    }

    public void setLength(int length) {

    this.length = length;

    }

    public void setName(String name) {

    this.name = name;

    }

    public void setPrinter(int printer) {

    this.printer = printer;

    }

    public void setRuntime(float runtime) {

    this.runtime = runtime;

    }

    public void setTape(int tape) {

    this.tape = tape;

    }

    public void setWaittime(float waittime) {

    this.waittime = waittime;

    }

    }

    这是Client测试类:

    package com.wk.client;

    import java.io.BufferedReader;

    import java.io.IOException;

    import java.io.InputStreamReader;

    import java.util.ArrayList;

    import java.util.Collections;

    import java.util.List;

    import com.wk.job.*;

    public class Client {

    // 定义装载作业的容器

    static List jobs = new ArrayList();

    // 记录响应比

    static float xk = 0;

    // 记录当前的作业记录相应时间比

    static float k = 0;

    // 作业调度函数

    static void shedule(JOB job, long memory, int tape, int printer) {

    // 系统可用资源是否满足作业需求

    if (job.getLength() <= memory && job.getTape() <= tape

    && job.getPrinter() <= printer) {

    xk = job.getWaittime() / job.getRuntime();

    // 如果这是第一个进入容器的作业

    if (jobs.size() == 0) {

    k = xk;

    jobs.add(job);

    } else {

    if (k > xk) { // 如果这不是第一个进入容器的作业,则和第一个作业比较

    jobs.add(job);

    } else {

    k = xk;

    jobs.add(job);

    Collections.swap(jobs, 0, jobs.size()-1); // 交换两个作业的执行顺序

    }

    }

    } else {

    System.out.println("error");

    }

    }

    public static void main(String[] args) {

    // 系统可容纳作业的个数

    int n = 3;

    // 定义一个作业集

    // List jobs = new ArrayList();

    // 系统中磁带机数量

    int tape = 4;

    // 系统打印机的数量

    int printer = 3;

    // 系统内存

    long memory = 65536;

    // 定义一个作业

    JOB job = null;

    // 定义输入流

    BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));

    for (int i = 0; i < n; i++) {

    try {

    //实例化一个作业

    job = new JOB();

    System.out.println("------------------");

    job.setName(bf.readLine());

    System.out.println("输入作业名称:" + job.getName());

    job.setLength(Integer.parseInt(bf.readLine()));

    System.out.println("输入作业使用内存大小:" + job.getLength());

    job.setTape(Integer.parseInt(bf.readLine()));

    System.out.println("输入作业使用磁带机数:" + job.getTape());

    job.setPrinter(Integer.parseInt(bf.readLine()));

    System.out.println("输入作业打印机数:" + job.getPrinter());

    job.setWaittime(Integer.parseInt(bf.readLine()));

    System.out.println("输入作业等待时间:" + job.getWaittime());

    job.setRuntime(Integer.parseInt(bf.readLine()));

    System.out.println("输入作业估计执行时间:" + job.getRuntime());

    // 调用函数

    Client.shedule(job, memory, tape, printer);

    } catch (IOException e) {

    System.out.println("输入内容不允许为空!!");

    }

    }

    System.out.println("当前执行的程序为1:" + jobs.get(0).getName());

    // 为第一个作业分配资源

    memory = memory - jobs.get(0).getLength();

    System.out.println("系统剩余内存:" + memory);

    tape = tape - jobs.get(0).getTape();

    System.out.println("系统剩余磁带机:" + tape);

    printer = printer - jobs.get(0).getPrinter();

    System.out.println("系统剩余打印机:" + printer);

    }

    }

    经过测试上面的代码是没有错误的!!下面说一下自己在写代码的时候的感想:

    1.好多东西想的总是好的,但是真正的用着二十四个英文字母表达的时候是很费力的。所以建议向我们这样的初学者要经常敲代码,经常写东西。这样自己才能进步更快。

    2.向List容器插入数据时,是按顺序逐步插入的。检点通俗点说就是按插入的顺序谁先插入谁占第一个位置。好像很简单,但是在写这个东西时,自己是不知道的。相信还有好多人也不太清楚。

    展开全文
  • 操作系统的三大作业调度 短作业优先 先来先服务 响应比高者优先 包含:作业名 开始时间 完成时间 周转时间 带权时间 平均带权时间
  • 使用响应比高者优先算法 程序采用键盘输入,输入格式为: K TJ1 YS1 …… TJK YSK 其中K是作业数(>0),TJi提交时间,YSi (i=1~K)是作业预计的运行时间(以分钟计)TJ的输入格式是XXYY,其中XX是时,...
  • 在采用响应比高者优先调度算法时,其平均周转时间为T为()小时? 计算 周转时间=作业完成时间-作业提交时间 响应比=(作业等待时间+作业执行时间)/作业执行时间 当提交J1时,只有J1作业,执行J1,J1的
  • 具体的要求是这样的:编写程序完成批处理系统中的作业调度,要求采用响应比高者优先的作业调度算法。实验具体包括:首先确定作业控制块的内容,作业控制块的组成方式;然后完成作业调度;最后编写主函数对所作工作...
  • 编写程序完成批处理系统中的作业调度,要求采用响应比高者优先的作业调度算法。实验具体包括:首先确定作业控制块的内容,作业控制块的组成方式;然后完成作业调度;最后编写主函数对所作工作进程测试。 4.提示与...
  • 具体的要求是这样的:编写程序完成批处理系统中的作业调度,要求采用响应比高者优先的作业调度算法。实验具体包括:首先确定作业控制块的内容,作业控制块的组成方式;然后完成作业调度;最后编写主函数对所作工作...
  • 12.假设一个系统中有 5 个进程 它们到达的实践依次为 02468服务时间依次为 3 6 4 5 2忽略 I/O 以及其他时间开销若分别按响应比高者优先时间片轮转时间 片为 1先来先服务非抢占短进程优先抢占短进程优先调度算法调度 ...
  • 操作系统----作业管理

    2009-04-21 11:56:30
    响应比高者优先算法,很简单啊 适于初学者 A
  • 进程管理代码

    2013-05-21 21:13:31
    利用高级语言模拟进程的时间片轮转调度算法,响应比高者优先调度算法
  • 操作系统作业调度

    2014-01-03 15:50:23
    操作系统实验--作业调度,采用先来先服务和响应比高者优先算法
  • java实现的简易单道批处理,包括先来先服务(FCFS)、最短作业优先(SJF)、响应比高者优先(HRN)的调度算法。
  • 先到先运行,短作业优先,响应比高者优先三种算法,附运行结果

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 122
精华内容 48
关键字:

响应比高者