精华内容
下载资源
问答
  • 响应比高者优先算法
    2022-05-15 20:58:13

    高响应比优先算法思想:

    每个进程执行完,都会对就绪队列中的进程进行响应比从高到低计算并排序。(因为是非抢占式)

    第一个到达的进程一定是先执行,并直到执行完毕。

    代码如下:

    #include<iostream>
    #include<queue>
    #include<algorithm>
    #include<string>
    #include<vector>
    #include<map>
    using namespace std;
    struct shuxing{
    	char name;
    	double arriveTime;
    	double serviceTime; 
    	double priority;
    	friend bool operator<(shuxing n1,shuxing n2){ // 自定义比较函数 
    		 if(n1.priority != n2.priority)
    		 return n1.priority < n2.priority;  // 优先按响应比从高到低排序
    		 else
    		 return n1.arriveTime > n2.arriveTime; // 当响应比一样时,按到达时间从低到高排序
    	}
    };
    
    priority_queue<shuxing, vector<shuxing>, less<shuxing> > jincheng; 
    // priority_queue less: from large to small
    priority_queue<shuxing, vector<shuxing>, less<shuxing> > mirror;
    
    vector<char> seq; // 存进程调度的顺序 
    vector<double> ks; // 存开始时间 
    vector<double> wc;	//存完成时间 
    vector<double> zz;	// 存周转时间 
    vector<double> dqzz;	// 存带权周转时间 
    
    double avezz, avedqzz;  // 平均周转时间和平均带权周转时间 
    
    int n;  // 进程的数量 
    
    int main() {	
    	
    	cout << "请输入进程的数量:" << "\n";
    	cin >> n;
    	
    	char x;
    	double y, z;
    	for(int i = 0; i < n; i ++) {
    		cout << "请输入第" << i + 1 << "个进程的名字,到达时间,服务时间 <例如:A,2,1>:" << "\n";
    		cin >> x >> y >> z;
    		shuxing temp;
    		temp.name = x;
    		temp.arriveTime = y;
    		temp.serviceTime = z;
    		temp.priority = -1;   // 一开始响应比都设置为-1,所以在队列中会按到达时间排序
    		jincheng.push(temp);
    	}
    	
    	int k = jincheng.top().arriveTime;  
    // k代表当前时间,一开始的时间设置为最先到达的进程的到达时间
    	
    	while(!jincheng.empty()) {  // 优先队列模拟 
    		shuxing temp = jincheng.top();  
     // 队列中第一个是响应比最高的,或者是第一个到达的进程,出队执行
    		jincheng.pop();
    		seq.push_back(temp.name);
    		ks.push_back(k);
    		k += temp.serviceTime;
    		wc.push_back(k);
    		zz.push_back(k - temp.arriveTime);
    		avezz += (k - temp.arriveTime);
    		dqzz.push_back((k - temp.arriveTime) / temp.serviceTime);
    		avedqzz += ((k - temp.arriveTime) / temp.serviceTime);
    		
    		while(!jincheng.empty()) {   // 先将进程暂存到mirror队列中
    			shuxing temp1 = jincheng.top();
    			jincheng.pop();
    			mirror.push(temp1);    
    		}
    		while(!mirror.empty()) {
    			if(mirror.top().arriveTime <= k) {  // 进程已经到达时
    				shuxing temp2 = mirror.top();
    				mirror.pop();
    				temp2.priority = (k - temp2.arriveTime + temp2.serviceTime) / temp2.serviceTime; 
                    // 对进程的响应比进行计算
    				jincheng.push(temp2);   // 放入优先队列自动按响应比排序
    			}
    			else {                               // 进程未到达
    				shuxing temp3 = mirror.top();
    				mirror.pop();
    				jincheng.push(temp3);  // 也放入优先队列,响应比肯定是-1
    			}
    		}
    	}	
    	
    	cout << "\n执行顺序:\t";	
    	for(int i = 0; i < n; i ++)
    		cout << seq[i] << "\t"; 
    		cout << "\n";
    	
    	cout << "\n开始时间:\t";
    	for(int i = 0; i < n; i ++)
    		cout << ks[i] << "\t";
    		cout << "\n";
    	 
    	cout << "\n完成时间:\t";
    	for(int i = 0; i < n; i ++)
    		cout << wc[i] << "\t";
    		cout << "\n";	
    
    	cout << "\n周转时间:\t";
    	for(int i = 0; i < n; i ++) 
    		cout << zz[i] << "\t"; 
    		cout << "\n";
    		
    	cout << "\n带权周转时间:\t";
    	for(int i = 0; i < n; i ++)
    		printf("%.2lf\t", dqzz[i]);
    		cout << "\n";
    		
    	cout << "\n平均周转时间:";
    	printf("\t\t%.2lf\n", avezz / n);
    	
    	cout << "\n平均带权周转时间:";
    	printf("\t%.2lf", avedqzz / n);
    
    	return 0;
    } 

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

    事先说明:

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

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

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

    理论部分:

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

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

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

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

    优先级=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、计算每一种算法的平均周转时间及平均带权周转时间并比较不同算法的优劣。
  • 使用C#实现响应比高者优先调度代码,关于操作系统。
  • 编写程序完成批处理系统中的作业调度,要求采用响应比高者优先的作业调度算法。实验具体包括:首先确定作业控制块的内容和组织方式;然后完成作业调度;最后编写主函数,对所做工作进行测试。
  • 响应比最高者优先调度算法(HRRF)

    万次阅读 多人点赞 2018-05-10 22:32:29
    响应比最高者优先算法是通过计算输入井后备队列中每个作业的响应比大小,从中选择响应比最高的作业装入主存,这样既考虑了作业的等待时间,又考虑了作业的运行时间。 二、实验要求 假设本系统仍采用单道批处理...

    一、实验目的

           作业调度算法是指依照某种原则或策略从后备作业队列中选取作业的方法。响应比最高者优先算法是通过计算输入井后备队列中每个作业的响应比大小,从中选择响应比最高的作业装入主存,这样既考虑了作业的等待时间,又考虑了作业的运行时间。

    二、实验要求

           假设本系统仍采用单道批处理系统,忽略设备工作时间和系统进行调度所花的时间。要求从键盘输入作业个数N,及每个作业的作业名、作业入井时间、估计运行时间。请编程输出采用响应比最高者优先算法得到的每个作业调度序号、作业名、作业入井时间、开始调度时间、运行时间、结束时间、周转时间,以及所有作业的平均周转时间。

    三、源代码

    #include <stdio.h>
    #define N 10
    
    typedef struct {
        int hour;
        int min;
    }time;
    typedef struct hrrf{
        char hrrf_id[20];
        double hrrf_run;  //运行时间
        time hrrf_entertime; //进入时间
        int enter;
        time hrrf_needtime;  //调度时间
        int needtime;
        time hrrf_endtime;   //结束时间
        int endtime;
        int hrrf_longtime;  //周转时间
        int hrrf_waittime;   //等待时间
        double hrrf_pjlongtime; //平均周转时间
        double hrrf_rate;       //响应比
    
        struct hrrf* next;
    }HRRF;
    //输入作业信息
    void hrrfinput(HRRF s[N],int k)
    {
        printf("\t请输入第%d个作业名:",k+1);
        scanf("%s",&s[k].hrrf_id);
        printf("\t请输入%s作业进入时间:",s[k].hrrf_id);
        scanf("%d:%d",&s[k].hrrf_entertime.hour,&s[k].hrrf_entertime.min);
        s[k].enter=s[k].hrrf_entertime.hour*60+s[k].hrrf_entertime.min;
        printf("\t请输入%s作业运行时间:",s[k].hrrf_id);
        scanf("%lf",&s[k].hrrf_run);
    }
    //计算作业的响应比
    void rate(HRRF s[N],int k,int m)
    {
        double ratenum;
        ratenum = (s[k].hrrf_run+(double)(s[m].endtime-s[k].enter))/(s[k].hrrf_run);
        s[k].hrrf_rate=ratenum;
        printf("\n\t每次算响应比:%s---%f\n",s[k].hrrf_id,s[k].hrrf_rate);
    }
    //按响应比大小对作业进行排序(降序排序)
    void ratesort(HRRF s[N],int k,int m)
    {
        int maxratenum;
        HRRF temp;
        int i,j;
        for(i=k;i<m;i++)         //简单选择排序
        {
            maxratenum=i;
            for(j=i+1;j<m;j++)
                if(s[j].hrrf_rate>s[maxratenum].hrrf_rate)
                    maxratenum=j;
            if(maxratenum!=i)
            {
                temp=s[i];
                s[i]=s[maxratenum];
                s[maxratenum]=temp;
            }
    
        }
    }
    //打印表单
    void print(HRRF s[N],int k)
    {
        printf("\t序号\t作业名\t进入时间\t调度时间\t结束时间\t运行时间\t等待时间\t周转时间\n");
        int i,j;
        for(i=0;i<k;i++)
            printf("\t%d\t%s\t%d:%d\t\t%d:%d\t\t%d:%d\t\t%.0f min\t\t%d\t\t%d min\n",i+1,s[i].hrrf_id,(s[i].enter/60),(s[i].enter%60),(s[i].needtime/60),(s[i].needtime%60),(s[i].endtime/60),(s[i].endtime%60),s[i].hrrf_run,s[i].hrrf_waittime,s[i].hrrf_longtime);
    
    }
    
    //hrrf算法
    void HRRF_run(HRRF s[N],int k)
    {
        int i,j=k,n;
        double sum;
        HRRF temp;
        //按到达时间进行排序
        while(j>1)
        {
            for(i=0;i<j-1;i++)
            {
                if(s[i+1].enter<s[i].enter)
                {
                    temp=s[i];
                    s[i]=s[i+1];
                    s[i+1]=temp;
                }
            }
            j--;
        }
        printf("\n\t--------------------------------------------初始状态------------------------------------------------\n");
        print(s,k);
        j=0;
        //执行
        do{
                if(j==0)
                {
                    s[j].needtime=s[j].enter;
                    s[j].hrrf_waittime=0;
                    s[j].endtime=s[j].enter+s[j].hrrf_waittime+(int)(s[j].hrrf_run);
                    s[j].hrrf_longtime=s[j].endtime-s[j].enter;
                }
                else
                {
                    s[j].needtime=s[j-1].endtime;
                    s[j].hrrf_waittime=s[j-1].endtime-s[j].enter;
                    s[j].endtime=s[j].needtime+(int)(s[j].hrrf_run);
                    s[j].hrrf_longtime=s[j].endtime-s[j].enter;
                }
                j++;  //到了第几个作业
                //计算响应比
                n=j-1;  //此次已经执行完的作业序号-1,因为数组从0开始
                for(i=j;i<k;i++)
                {
                    rate(s,i,n);    //计算响应比
                }
                ratesort(s,j,k);    //按响应比由大到小排序
                printf("\n\t-----------------------------------------每次响应比排序---------------------------------------------\n");
                print(s,k);
    
        }while(j<k);
    
        printf("\n\t--------------------------------------------作业调度------------------------------------------------\n");
        print(s,k);
        for(i=0;i<k;i++)
        {
            sum+=(double)(s[i].hrrf_longtime);
        }
    
        printf("\n\t平均周转时间为:%.2f\n",sum/k);
    }
    
    int main()
    {
        HRRF a[N]={0};
        int i,j;
        printf("请输入创建作业数目:");
        scanf("%d",&i);
        for(j=0;j<i;j++)  //输入作业信息
            hrrfinput(a,j);
        //HRRF算法
        HRRF_run(a,j);
    
        return 0;
    }
    

    四、实验截图

     

    1、输入

     

     

    2、执行过程

     

     

     

    有问题欢迎指正,先谢了~~~

    展开全文
  • 设计内容 编写一个程序完成多道程序的调度 具体要求 只考虑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
    

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

    展开全文
  • 最高响应优先算法(HRRF):最高响应优先算法是介于先来先服务算法(FCFS)和最短作业优先算法(SJF)之间的一种算法,它既考虑了作业的等待时间,又考虑了作业的处理时间。调度规则:响应比最高的作业先运行。...
  • 进程调度一、实验题目与要求编写程序完成批处理系统中的作业调度,要求采用响应比高者优先的作业调度算法。实现具体包括:首先确定作业控制块的内容和组成方式;然后完成作业调度;最后编写主函数,对所做工作进行...
  • 自己做的操作系统的实验,批处理系统的作业调度,采用高响应优先算法,请仔细查看程序,不排除有错误哦
  • 响应优先调度算法 (HRRN)例题

    千次阅读 2021-06-15 11:59:26
    HRRN是介于FCFS(先来先服务算法)与SJF(短作业优先算法)之间的折中算法,既考虑作业等待时间又考虑作业运行时间,既照顾短作业又不使长作业等待时间过长,改进了调度性能。 响应比=作业周转时间/作业处理时间=...
  • 利用高级语言模拟进程的时间片轮转调度算法响应比高者优先调度算法
  • 响应优先算法

    万次阅读 多人点赞 2016-08-30 20:54:20
    优先权 = (等待时间 + 要求服务时间) / 要求服务时间又因为等待时间 + 要求服务时间 = 响应时间优先权 = 响应时间 / 要求服务时间故而称之为,高响应优先算法。那么,这个计算公式,怎么就能体现上面三个综合...
  • 非抢占式的响应比高者进程调度优先算法java
  • #include<cstdio> #include<algorithm> using namespace std; const int maxn = 1e4 + 5; int flag[maxn]; struct { char name[maxn]; ... int arrive, time_sum, start_time, en
  • 操作系统_高响应优先算法_c语言实现

    千次阅读 多人点赞 2021-04-08 20:53:24
    主函数 int main() { int n; //进程数量 scanf_s("%d", &n); ...核心算法响应优先 void hrrf(struct pcb* p, int n) { int finishedcount = 0; //记录已经完成的进程数 int unfini.
  • 响应优先调度算法: 该算法实际上是一种动态优先调度算法,它以相应比作为作业或进程的动态优先权,其目的是既照顾短作业,又考虑到作业的等待时间,使长作业不会长期等待;但每次调度前,都要进行响应比计算,...
  • 操作系统高响应优先模拟算法

    千次阅读 2021-02-26 18:23:10
    这学期刚开始学习操作系统,收到一个作业,百度关于高响应优先(HRRN,HighestResponseRatioNext)的CPU进程调度模拟算法,基本思想:短作业优先调度算法 + 动态优先权机制;既考虑作业的执行时间也考虑作业的等待...
  • 使用响应比高者优先算法 程序采用键盘输入,输入格式为: K TJ1 YS1 …… TJK YSK 其中K是作业数(>0),TJi提交时间,YSi (i=1~K)是作业预计的运行时间(以分钟计)TJ的输入格式是XXYY,其中XX是时,...
  • void hrrn(pcb*a,int n){ //响应比高优先 int i=0; double time=0; double arrayTotalTime=0; //平均周转时间初始化 double arrayWeightTime=0; //平均带权周转时间初始化 int j; for(i=0;i;i++){ j=...
  • C++、高响应优先算法

    千次阅读 2018-12-06 20:55:38
    //计算响应比(优先权),需要考虑到小数的情况。  }  }  for (int i = 0; i ; i++) { //将作业按照优先权,从大到小形成新的队列。  for (int j = i + 1; j ; j++) {  if (job_small[i].sfzx == 0) { //排除...
  • 【单选题】关于第一次工业革命,下列说法不正确的是()。【单选题】下列牌号中,哪一个是可锻铸铁( )【多选题】16. 下列项目中,属于营业外支出的是( )。【单选题】发展动力决定发展速度、效能、可持续性。...
  • 操作系统 高响应优先算法 c++语言版 操作系统 高响应优先算法 c++语言版

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,149
精华内容 459
关键字:

响应比高者优先算法

友情链接: 空气质量实验.zip