精华内容
下载资源
问答
  • 利用高级语言模拟进程的时间片轮转调度算法,响应比高者优先调度算法
  • 处理器调度总是选队首进程运行。采用动态改变响应比的办法,进程每运行一次重新计算各进程的响应比。由于本实验是模拟处理器调度,所以,对被选中的进程并不实际的启动运行,而是执行:要求运行时间-1、等待时间为0...
  • 非抢占式的响应比高者进程调度优先算法java
  • 编写程序完成批处理系统中的作业调度,要求采用响应比高者优先的作业调度算法。实验具体包括:首先确定作业控制块的内容和组织方式;然后完成作业调度;最后编写主函数,对所做工作进行测试。
  • 事先说明: 本代码为原创,转载请附原博地址。 代码可以运行,但是运算结果并不知道对错(感觉第三个有问题),凌晨两点写的,大脑并不清醒,欢迎交流修改。...短作业优先算法,是在作业到达的基础上,如果有多...

    事先说明:

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

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

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

    理论部分:

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

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

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

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

    优先级=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、对于给定的一组作业, 给出其到达时间和运行时间 2、分别用先来先服务算法、短作业优先和响应比高者优先三种算法给出作业的调度顺序。 3、计算每一种算法的平均周转时间及平均带权周转时间并比较不同算法的优劣。
  • ******##1这是课程作业的简单分享 ******##2肯定会有地方对特殊的数据没有考虑到,欢迎改进 ******##3使用的 java version "1.8.0_131",eclipse上编辑 ...编写一个程序完成多道程序的调度 具体要求 只...
    ******##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
    

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

    展开全文
  • 编写程序完成批处理系统中的作业调度,要求采用响应比高者优先的作业调度算法。实验具体包括:首先确定作业控制块的内容,作业控制块的组成方式;然后完成作业调度;最后编写主函数对所作工作进程测试。 4.提示与...
  • 操作系统关于系统调度算法的实验报告:包括先来先服务调度算法、短作业优先调度算法和响应比高者优先调度算法在单道以及多道环境下的优劣势比较。
  • CPU 调度算法

    千次阅读 2019-03-24 22:19:47
    先来先服务调度(First Come First Serve) 效率不高,只考虑等候时间,而没考虑作业的长短,不利于短作业情况。 ...响应比高者优先调度算法 兼顾响应时间和等待时间,计算作业的响应时间和运行...
    1. 先来先服务调度(First Come First Serve)
      效率不高,只考虑等候时间,而没考虑作业的长短,不利于短作业情况。

    2. 短作业优先调度 (Short Job First)
      参考运行时间,选取运行时间最短的作业投入运行
      效率不高,忽视了作业等待时间,容易出现长作业长时间得不到调度,出现资源 “饥饿” 现象

    3. 响应比高者优先调度算法
      兼顾响应时间和等待时间,计算作业的响应时间和运行时间的比值,选择比值最高的作业运行。
      响应比 = 响应时间/运行时间 = (等待时间 + 运行时间)/ 运行时间 = 1 + 等待时间 / 运行时间

    4. 优先数调度算法
      根据进程优先数,把CPU 分为最高的进程
      进程优先数 = 静态优先数(进程创建时建立的,不可更改) + 动态优先数(在运行期间可以改变)

      静态优先数的确定:
      基于进程所需的资源多少、基于程序运行时间的长短、基于进程的类型(IO/CPU,前台/后台,核心/用户)

      动态优先数的确定:
      当使用CPU超过一定时长时、当进行I/O操作后、当进程等待时间超过一定时长时

    5. 循环轮转调度法(Round-Robin)
      把所有就绪的进程按先进先出的原则排成队列,进程以时间片q位单位轮流使用CPU,进程循环轮转使用CPU。

      优点:
      公平性:每个就绪进程有平等机会获得CPU
      交互性:每个进程等待(N-1)*q 的时间就可以重新获得CPU

      时间 q 的大小:如果q太大,则交互性差,设置退化位FCFS调度方法;如果q太小,进程切换频繁,系统开销增加。

    展开全文
  • 在采用响应比高者优先调度算法时,其平均周转时间为T为()小时? 计算 周转时间=作业完成时间-作业提交时间 响应比=(作业等待时间+作业执行时间)/作业执行时间 当提交J1时,只有J1作业,执行J1,J1的

    单道批处理系统中有4个作业,J1的提交时间8.0,运行时间为2.0;J2的提交时间8.6,运行时间为0.6;J3提交时间8.8,运行时间为0.2;J4的提交时间9.0,运行时间为0.5。在采用响应比高者优先调度算法时,其平均周转时间为T为()小时?

    计算

    周转时间=作业完成时间-作业提交时间
    响应比=(作业等待时间+作业执行时间)/作业执行时间

    当提交J1时,只有J1作业,执行J1,J1的周转时间为2,此时时间为10.
    J2、J3、J4提交时,由于正在执行J1,因此等待。
    当J1执行完毕(此时时间为10),J2、J3、J4的等待时间分别为:1.4,1.2,1,其响应比分别为:3.33,7,3,因此执行J3,J3的周转时间为1.2+0.2=1.4
    当J3执行完毕(此时时间为10.2),J2和J4的等待时间分别为1.6,1.2,其响应比分别为:3.66,3.4,因此执行J2,J2的周转时间为1.6+0.6=2.2
    执行J2完毕后时间为10.8,接下来执行J4,执行完后时时间为11.3,J4的周转时间为2.3
    于是平均周转时间为(2+1.4+2.2+2.3)/4=1.975

    这里写图片描述

    展开全文
  • 编程实现先来先服务、短作业优先、响应比高者优先调度算法的作业 调度程序。 要求:在单道程序系统中,用所编写的作业调度程序来确定: 作业的调度顺序, 平均周转时间T的值, 平均带权周转时间W的值。 ...
  • 调度算法

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

    2013-12-30 10:29:40
    作业调度算法: 分别使用先来先服务(FCFS),最短作业优先(SJF)、响应比高者优先(HRN)的调度算法。c语言完成。
  • 响应比高者优先调度算法 优先数调度算法 循环轮转调度算法 Linux 进程调度 Linux 进程类型 普通进程 实时进程 Linux 进程的优先级 静态优先级: 动态优先级: 调度策略 (task_struct->policy) 实时...
  • 12.假设一个系统中有 5 个进程 它们到达的实践依次为 02468服务...程的调度顺序计算各进程的平均周转时间和平均带权周转时间 解 1响应比高者优先调度算法 进程 运行时间 到达时间 开始时间 结束时间 周转时间 带权周
  • 该资源是操作系统课程设计中作业调度算法的源程序,程序中主要用三种作业调度算法来实现一次作业调度,三种算法分别为:先来先服务算法、短作业优先算法、响应比高者优先算法。程序简单易懂,包含大量注释。
  • 使用响应比高者优先算法 程序采用键盘输入,输入格式为: K TJ1 YS1 …… TJK YSK 其中K是作业数(>0),TJi提交时间,YSi (i=1~K)是作业预计的运行时间(以分钟计)TJ的输入格式是XXYY,其中XX是时,...
  • 响应比高者优先(HRRF)调度算法4. 优先权高者优先(Highest-Priority-First,HPF)调度算法作业的数据结构:重要函数说明实验代码 基本调度算法 1. 先来先服务(First-Come First-Served,FCFS)调度算法 先来先...
  • 先到先运行,短作业优先,响应比高者优先三种算法,附运行结果
  • 进程管理代码

    2013-05-21 21:13:31
    利用高级语言模拟进程的时间片轮转调度算法,响应比高者优先调度算法
  • 2.决定接纳哪些作业:取决于调度算法:(FCFS)先来先服务调度算法、(SJF)短作业/(SPF)短进程优先调度算法、基于优先级的调度算法、响应比高者优先调度算法 分时系统和实时系统中不需要作业调度,因为作业调度只适用于...
  • 操作系统---处理器调度

    千次阅读 2020-04-26 12:51:41
    文章目录一、作业与进程的区别二、处理器调度1、三个调度级别2、评价进程调度算法的优劣3、先来先服务调度算法4、短作业优先调度算法5、响应比高者优先调度算法(1)在作业调度中(2)在进程调度中6、综合实例三、...
  •  作业调度算法:分别采用先来先服务(FCFS),最短作业优先(SJF)、响应比高者优先(HRRN)的调度算法。  对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间,以及这组作业的平均...
  • 作业调度(vc3586458)

    2010-06-07 23:10:24
    本实验要求学生用高级程序设计语言编写和调试一个简化的作业调度程序,模拟实现的调度算法包括:先来先服务调度算法,短作业优先调度算法,响应比高者优先调度算法等,并对这些算法的性能做比较和评价。以加深学生对...

空空如也

空空如也

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

响应比高者优先调度算法