精华内容
下载资源
问答
  • 短作业优先
    2021-12-16 17:39:41

    一、说明

    作业/进程调度算法 – 短作业优先算法

    1. 算法思想:追求最少的平均等待时间,最少的平均周转时间、最少的平均带权周转时间。
    2. 算法规则: 服务时间最短的作业/进程优先得到服务。
    3. 抢占式版本:最短剩余时间优先算法(SRTN)
    4. 缺点:对短作业有利,对长作业不利。如果源源不断地有短作业/进程到来,可能使长作业/进程长时间得不到服务,产生“饥饿”现象。

    二、代码

    #include <string>
    #include <algorithm>
    #include <iostream>
    #include <iomanip>
    using namespace std;
    
    // 就绪队列最大长度
    const int MAX = 100;
    // 就绪态
    #define W "waitting"
    // 运行态
    #define R "running"
    // 完成态
    #define F "finished"
    
    struct WORK
    {
    	// 进程名称
    	string work_name;
    	// 到达时间
    	int arrive_time;
    	// 剩余服务时间
    	int serve_time;
    	// 服务时间
    	int r_serve_time;
    	// 进程状态
    	string work_state;
    	// 结束时间
    	int end_time;
    	// 周转时间
    	int turnover_time;
    };
    
    // 就绪队列
    WORK work[MAX]; 
    // 进程数量
    int n; 
    
    
    void init() {
    	cout << "请输入需要调度的进程数: ";
    	cin >> n;
    	for (int i = 1; i <= n; ++i) {
    		cout << "请输入进程" << i << "的名称、到达时间、服务时间: ";
    		cin >> work[i].work_name >> work[i].arrive_time >> work[i].r_serve_time;
    		// 进程状态
    		work[i].work_state = W;
    		// 结束时间
    		work[i].end_time = -1;
    		// 剩余服务时间
    		work[i].serve_time = work[i].r_serve_time;
    		// 周转时间
    		work[i].turnover_time = -1;
    	}
    }
    
    void show() {
    	cout << "进程初始状态:" << endl;
    	cout << "    进程名    " << "    到达时间    " << "    服务时间    " << "    当前状态    " << endl;
    	for (int i = 1; i <= n; ++i) {
    		cout << setw(8) << work[i].work_name << setw(16)
    			<< work[i].arrive_time << setw(13) << work[i].serve_time
    			<< setw(21) << work[i].work_state << endl;
    	}
    	cout << endl;
    }
    
    bool SJFsort(const WORK &x, const WORK &y)
    {
    	// 服务时间不同,短作业优先
    	if (x.serve_time != y.serve_time) 
    		return x.serve_time < y.serve_time;
    	// 服务时间相同,先来先服务
    	else 
    		return x.arrive_time < y.arrive_time;
    }
    
    int count_work(int t) 
    {
    	int cnt = 0;
    	for (int i = 1; i <= n; ++i) {
    		if (work[i].arrive_time <= t)
    			++cnt;
    	}
    	return cnt;
    }
    
    void update_work(int num, int c_time)
    {
    	// 记录剩余时间最短的进程的下标
    	int index = 0;
    
    	for (int i = 1; i <= num; ++i) {
    		// 进程已经结束
    		if (work[i].serve_time == 0)
    			work[i].work_state = F;	// 状态设置为Finished
    		// 进程还没结束
    		else if (work[i].serve_time > 0)
    		{
    			// 剩余服务时间-1
    			--work[i].serve_time;
    			// 状态设置为Running
    			work[i].work_state = R;
    			index = i;
    			break;
    		}
    	}
    
    	// 更新各进程状态
    	for (int i = 1; i <= n; ++i) {
    		if (i != index) {
    			// 对于不处于Finshed状态的进程
    			if (work[i].work_state != F)
    				// 状态设置为Waiting
    				work[i].work_state = W;
    		}
    		// 记录刚完成的进程的结束时间
    		if (work[i].work_state == F && work[i].end_time == -1)
    			work[i].end_time = c_time;
    	}
    }
    
    bool judge_over() 
    {
    	for (int i = 1; i <= n; ++i)
    		if (work[i].work_state != F)
    			return false;
    	return true;
    }
    
    void run() {
    	cout << "进程调度情况如下:" << endl;
    	// 已到达的进程数
    	int arrive_num = 0; 
    	// 当前时间
    	int current_time = 0; 
    	// 进程是否全部完成标志
    	bool is_over = false;
    
    	while (!is_over)
    	{
    		cout << "    时刻    " << "    作业名    " << "    到达时间    " << "    剩余服务时间    " << "    当前状态    " << endl;
    		// 计算该时刻已到达的进程数
    		arrive_num = count_work(current_time);
    		// 所有已经到达的进程再次排序
    		sort(work + 1, work + 1 + arrive_num, SJFsort);
    		// 更新各进程状态
    		update_work(arrive_num, current_time);
    
    		// 输出此时刻已到达的各进程的信息
    		for (int i = 1; i <= arrive_num; i++)
    		{
    			cout << setw(6) << current_time << setw(13) << work[i].work_name
    				<< setw(15) << work[i].arrive_time << setw(15) << work[i].serve_time
    				<< setw(24) << work[i].work_state << endl;
    		}
    		// 时间+1
    		++current_time;
    		// 判断所有进程是否全部运行结束
    		is_over = judge_over();
    		cout << endl;
    	}
    }
    
    void display() {
    	cout << "各进程的周转时间和带权周转时间如下:" << endl;
    	cout << "    作业名    " << "    周转时间    " << "    带权周转时间    " << endl;
    	for (int i = 1; i <= n; ++i)
    	{
    		// 周转时间
    		work[i].turnover_time = work[i].end_time - work[i].arrive_time;
    		// 带权周转时间
    		double wight_time = 1.0 * work[i].turnover_time / work[i].r_serve_time;
    
    		cout << setw(6) << work[i].work_name << setw(15) << work[i].turnover_time << setw(18);
    		//控制浮点数的输出精度
    		cout.precision(4);
    		cout << wight_time << endl;
    	}
    }
    
    int main()
    {
    	// 初始化就绪队列
    	init();
    	// 按到达时间从小到大排序
    	sort(work + 1, work + 1 + n,
    		[](const WORK& x, const WORK& y) 
    			{ return x.arrive_time < y.arrive_time; });
    	// 显示进程初始状态
    	show();
    	// 实际运行阶段
    	run();
    	// 显示各进程的周转时间和带权周转时间
    	display();
    	system("pause");
    	return 0;
    }
    
    
    
    更多相关内容
  • 本实验实现了短进程优先的进程调度操作,但因为是非抢占式,所以实现起来比较简单。...在把短作业优先调度算法用于作业调度时,它将从外存的作业后备队列中选择若干个估计运行时间最短的作业,优先将它们调入内存运行。
  • 这是用C语言写的3个作业调度算法,包括先来先服务,短作业优先,最高响应比优先。这是用C语言写的3个作业调度算法,包括先来先服务,短作业优先,最高响应比优先。
  • 一个使用C#简单实现短作业优先调度的代码,是关于操作系统的实验内容。
  • 短作业优先短作业优先调度算法(SJF)是指对短作业或短进程优先调度的算法。 目的:有效的降低作业的平均等待时间,提高系统吞吐量。
  • 1、对于给定的一组作业, 给出其到达时间和运行时间 2、分别用先来先服务算法、短作业优先和响应比高者优先三种算法给出作业的调度顺序。 3、计算每一种算法的平均周转时间及平均带权周转时间并比较不同算法的优劣。
  • 作业分配内存时:从分区链中找到第一个未分配且大于作业大小的节点,先为剩余空间分配一个新节点,并插入到此节点后面,再修改该节点的id和大小.  3.撤销作业释放内存时:找到作业所在节点,修改id=-1,若前后存在...
  • 操作系统 先到先服务和短作业优先java代码
  • 通过Java实现常用调度算法中的先来先服务和短作业优先
  • 实验一短作业优先算法.java
  • E2Q
  • 关键字:多道程序 进程调度 短作业优先(SJF)调度算法 非抢占式
  • 操作系统实验一 先来先服务FCFS和短作业优先SJF进程调度算法(内含源代码和详细实验报告),详细介绍:http://blog.csdn.net/xunciy/article/details/79239096
  • 短作业优先调度算法

    2019-05-12 18:43:40
    模拟实现短作业调度算法,具体如下: 1、 设置作业体:作业名,作业的到达时间,服务时间,作业间的链接指针; 2、 进程初始化:由用户输入作业名、作业的到达时间和服务时间进行初始化; 3、 显示函数: 显示当前...
  • 计算机操作系统实验代码(6个实验)包括先来先服务FCFS和短作业优先SJF进程调度算法等。 计算机操作系统实验代码(6个实验)。 计算机操作系统实验代码,包括先来先服务FCFS和短作业优先SJF进程调度算法、时间片轮转...
  • 中国地质大学北京 操作系统原理 实习报告 实习题目 1 2 实习人员 学号 姓名组长 学号 姓名 中国地质大学北京 课程名称操作系统原理 一题目分析 成绩 在批处理系统中短作业优先算法是一种比较好的算法其主要的不足 之...
  • OS短作业优先调度算法C语言 采用短作业优先调度算法调度程序 学 号: 姓 名: 专 业: 指导老师: 日 期: 目录 一、实验题目3 二、课程设计的目的3 三、设计内容3 四、设计要求3 五、主要数据结构及其说明4 六、...

    41528d3028836879cd698677c3999917.gifOS短作业优先调度算法C语言

    采用短作业优先调度算法调度程序 学 号: 姓 名: 专 业: 指导老师: 日 期: 目录 一、实验题目3 二、课程设计的目的3 三、设计内容3 四、设计要求3 五、主要数据结构及其说明4 六、程序运行结果5 七、流程图7 八、源程序文件9 九、实验体会13 十、参考文献13 摘要 在多道程序环境下,主存中有着多个进程,其数目往往多于处理机数目。这就要求系统能按某种算法,动态地把处理机分配给就绪队列中的一个进程,使之执行。分配处理机的任务是由处理机调度程序完成的。由于处理机是最重要的计算机资源,提高处理机的利用率及改善系统性能(吞吐量、响应时间),在很大程度上取决于处理机调度性能的好坏,因而,处理机调度便成为操作系统设计的中心问题之一。 在多道程序系统中,一个作业被提交后必须经过处理机调度后,方能获得处理机执行。对于批量型作业而言,通常需要经历作业调度和进程调度两个过程后方能获得处理机。作业调度是对成批进入系统的用户作业,根据作业控制块的信息,按一定的策略选取若干个作业使它们可以去获得处理器运行的一项工作。而对每个用户来说总希望自己的作业的周转时间是最小的,短作业优先(SJF)便是其中一种调度方法。 本次课程设计主要是模拟短作业优先(SJF)调度算法。 一、实验题目 采用短作业优先算法的的进程调度程序 二、课程设计的目的 l 操作系统课程设计是计算机专业重要的教学环节,它为学生提供了一个既动手又动脑,将课本上的理论知识和实际有机的结合一起,独立分析和解决实际问题的机会。 l 进一步巩固和复习操作系统的基础知识。 l 培养学生结构化程序、模块化程序设计的方法和能力。 l 提高学生调试程序的技巧和软件设计的能力。 l 提高学生分析问题、解决问题以及综合利用C语言进行程序设计的能力。 三、设计内容 设计并实现一个采用短作业优先算的进程调度算法演示程序 四、设计要求 1. 每一个进程有一个PCB,其内容可以根据具体情况设定。 2. 进程数、进入内存时间、要求服务时间、优先级等均可以在界面上设定 3. 可读取样例数据(要求存放在外部文件中)进行进程数、进入内存时间、时间片长度、进程优先级的初始化 4. 可以在运行中显示各进程的状态:就绪、执行 (由于不要求设置互斥资源与进程间同步关系,故只有两种状态) 5. 采用可视化界面,可在进程调度过程中随时暂停调度,查看当前进程的状态以及相应的阻塞队列 五、主要数据结构及其说明 算法的基本概念和原理:本次课程设计主要是采用短作业优先算法进程的进程调度过程。短作业优先调度算法,是指对短作业或短进程优先调度的算法。他们可以分别用于作业调度和进程调度,短作业优先的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业,将他们调入内存运行。而短进程优先调度算法则是从就绪队列中选出一个估计运行时间最短的进程,将处理机分配给他,使它立即执行并一直执行到完成,或发生某事件而被阻塞放弃处理机时再度重新调度。本程序采用了非抢占式短作业优先调度。而非抢占式这种方式,一旦把处理机分配给某进程后,便让该进程一直执行,直至该进程完成或发生某事件而被阻塞时,才再把处理机分配给其它进程,决不允许某进程抢占已经分配出去的处理机。这种调度方式的优点是实现简单,系统开销小,适用于大多数的批处理系统环境。但它难以满足紧急任务的要求——立即执行,因而可能造成难以预料的后果。因此,在要求比较严格的实时系统中,不宜采用这种调度方式。本课程设计主要是在满足要求多道单处理机的情况下进行短作业的优先调度。 算法的简要说明:短作业(进程)优先调度算法SJ(P)F,是指对短作业或短进程优先调度的算法。它们可以分别用于作业调度和进程调度。短作业优先(SJF)的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业,将它们调入内存运行。而短进程(SPF)调度算法则是从就绪队列中选出一个估计运行时间最短的进程,将处理机分配给它,使它立即执行并一直执行到完成,或发生某事件而被阻塞放弃处理机再重新调度。优点是SJ(P)F调度算法能有效地降低作业(进程)的平均等待时间,提高系统吞吐量。缺点是该算法对长作业不利;完全未考虑作业的紧迫程度,因而不能保证紧迫性作业(进程)长期不被调度;由于作业(进程)的长短只是根据用户所提供的估计执行时间而定的,而用户又可能会有意或无意地缩短其作业的估计运行时间,致使该算法不一定能真正做到短作业游戏那调度。 该程序定义了一个进程数据块(struct Process_),该数据块有进程名(name)、到达时间(arrivetime)、服务时间(servicetime)、开始执行时间(starttime)、完成时间(finishtime)、周转时间(zztime)、带权周转时间(dqzztime)、执行顺序(order)。用到的公式有:完成时间=到达时间+服务时间;周转时间=完成时间+到达时间;带权周转时间=周转时间/服务时间;(第一次执行的进程的完成时间=该进程的到达时间;下一个进程的开始执行时间=上一个进程的完成时间)。运行进程的顺序需要对进程的到达时间和服务时间进行比较。如果某一进程是从0时刻到达的,那么首先执行该进程;之后就比较进程的服务时间,谁的服务时间短就先执行谁(如果服务时间相同则看它们的到达时间,到达时间短的先执行);如果到达时间和服务时间相同,则按先来先服务算法执行。 六、程序运行结果 1 进入操作界面如下 2输入进程的信息 3 各时刻进程的状态 4 进程信息 5 平均带权周转时间界面 七、流程图 本次课程设计主要是通过比较各个进程的优先级以及各进程所需要占用的CPU时间来确定哪个作业优先运行,短作业优先调度算法除了能保证优先级更高的作业优先运行外,还能使相同优先级的前提下,所需CPU时间最短的那个作业优先运行,次外,本次课程设计还增加了阻塞时间和被阻塞时间来对个进程的运行加以控制。 此次课程设计的总体流程图如下: 开 始 输入进程的个数:num r 队列中是否只有一个进程? 执行时间处理函数:Time() Y 结 束 Sort() 输入进程的信息:name starttime servicetime N 执行判断函数:Run() 输

    展开全文
  • Operating system short job first algorithm
  • 作业调度程序(包括先来先服务、短作业优先、最高响应比优先)
  • 操作系统短作业优先算法java实现

    短作业优先(SJF)算法

    SJF概念

    以运行作业的时间长短来决定计算的优先级,作业运行时间越短,优先级越高。

    SJF算法展示(java)

    首先我们先来创建一个Process类来模拟作业

    package com.xu.demo.ytu;
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class Process {
        //作业名
        private String ProcessName;
        //到达时间
        private int InterTime;
        //运行时间
        private int WorkTime;
        //开始时间
        private int StartTime;
        //完成时间
        private int FinishTime;
        //周转时间
        private int TurnTime;
        //带权周转时间
        private float PowerTurnTime;
        //用于接收用户输入并赋值
        public Process(String processName, int interTime, int workTime) {
            ProcessName = processName;
            InterTime = interTime;
            WorkTime = workTime;
        }
    
        @Override
        public String toString() {
            return
                    "作业名:" + ProcessName  +
                    "   到达时间:" + InterTime +
                    "   运行时间:" + WorkTime +
                    "   开始时间:" + StartTime +
                    "   完成时间:" + FinishTime +
                    "   周转时间:" + TurnTime +
                    "   带权周转时间:" + PowerTurnTime
                    ;
        }
    }
    
    

    这里我使用了lombk来自动创建有参无参方法(等同于手动生成),toString方法为了显示结果明显我重写了一下,这样作业类就创建完毕

    问题分析&创建SJF算法

    算法过程分析

    1. 当一组作业进入集合的时候,如果我们要采用SJF算法的时候需要根据他们的进入时间进行排序,无论第一个作业执行时间的长短,第一个到达的永远是被第一个执行的

    2. 当第一个被执行后我们就要选择出下一个被执行的作业

    3. 然后我们根据剩余作业的运行时间进行排序,获得运行时间最短的作业

    4. 当我们和获得了运行时间最短的作业后还需要对运行时间最短的作业进行判断,假定根据运行时间排序后的第一作业是我们要处理的作业,然后我们拿已将执行完的上一个作业的完成时间与当前作业的到达时间做比较,如果上一个作业的完成时间>=当前作业的到达时间,那这个假定是成立的,那这个作业就要被处理。

    5. 如果上一个作业的完成时间<当前作业的到达时间,就说明这个作业还没有到达,就算它的运行时间短,它没到达也不会被执行。假设不成立,继续找第下一个作业,直到找打符合的作业并处理它。

    SJF算法

    1. 首先进行初始化,执行第一个作业
     //进行初始化,在这个时候第一个作业无论时间长短都是第一个执行的
        public static Map<String, List<Process>> initSJF(List<Process> list, List<Process> finishList) {
            //根据进入时间对作业进行排序
            list.sort(new Comparator<Process>() {
                @Override
                public int compare(Process p1, Process p2) {
                    int num = p1.getInterTime() - p2.getInterTime();
                    return num == 0 ? p1.getWorkTime() - p2.getWorkTime() : num;
                }
            });
            //执行第一个作业
            list.get(0).setStartTime(list.get(0).getInterTime());
            list.get(0).setFinishTime(list.get(0).getStartTime() + list.get(0).getWorkTime());
            list.get(0).setTurnTime(list.get(0).getFinishTime() - list.get(0).getInterTime());
            list.get(0).setPowerTurnTime(((float) list.get(0).getTurnTime() /(float)  list.get(0).getWorkTime()));
            //执行结束,将第一作业对象放入最后不会改变的数组
            finishList.add(list.get(0));
            //将第一个作业对象在原数组移除
            list.remove(0);
            Map<String, List<Process>> map = new HashMap<>();
            map.put("todo", list);
            map.put("finish", finishList);
            //返回一个map
            return map;
        }
    
    1. 选取下一个要处理的作业
     public static void doProcess(List<Process> list, List<Process> finishList) {
            //根据工作时间排序
            list.sort(new Comparator<Process>() {
                @Override
                public int compare(Process p1, Process p2) {
                    int num = p1.getWorkTime() - p2.getWorkTime();
                    return num == 0 ? p1.getInterTime() - p2.getInterTime() : num;
                }
            });
            for (Process process : list) {
                //已经操作完成的集合的最后一个与初始化后的依次比较
                if (process.getInterTime() <= finishList.get(finishList.size() - 1).getFinishTime()) {
                    process.setStartTime(finishList.get(finishList.size() - 1).getFinishTime());
                    process.setFinishTime(process.getStartTime() + process.getWorkTime());
                    process.setTurnTime(process.getFinishTime() - process.getInterTime());
                    process.setPowerTurnTime( ((float) process.getTurnTime() / (float) process.getWorkTime()));
                    finishList.add(process);
                    //只处理一个作业
                    break;
                }
            }
            //取差集 也就是比较之后不符合条件的
            list.removeAll(finishList);
            //根据进入时间对作业进行排序
            list.sort(new Comparator<Process>() {
                @Override
                public int compare(Process p1, Process p2) {
                    int num = p1.getInterTime() - p2.getInterTime();
                    return num == 0 ? p1.getWorkTime() - p2.getWorkTime() : num;
                }
            });
            //如果差集不为空且差集的第一作业进入时间<=finishList最后一个作业的结束时间
            //就继续对方法本身进行递归找符合条件的
            if (!list.isEmpty() && list.get(0).getInterTime() <= finishList.get(finishList.size() - 1).getFinishTime()) {
                SJF.doProcess(list, finishList);
            }
            //如果上面的不符就说明差集的所有作业到达时间都>finishList最后一个作业的结束时间
            //对差集进行初始化进行递归直到差集为空,所有作业都被处理
            if (!list.isEmpty()) {
                initSJF(list, finishList);
                SJF.doProcess(list, finishList);
            }
        }
    

    这样的话就处理了所有作业

    完整代码&测试

    作业实体开头已经展示

    SJF类

    package com.xu.demo.ytu;
    
    import java.util.*;
    public class SJF {
    
        //进行初始化,在这个时候第一个作业无论时间长短都是第一个执行的
        public static Map<String, List<Process>> initSJF(List<Process> list, List<Process> finishList) {
            //根据进入时间对作业进行排序
            list.sort(new Comparator<Process>() {
                @Override
                public int compare(Process p1, Process p2) {
                    int num = p1.getInterTime() - p2.getInterTime();
                    return num == 0 ? p1.getWorkTime() - p2.getWorkTime() : num;
                }
            });
            //执行第一个作业
            list.get(0).setStartTime(list.get(0).getInterTime());
            list.get(0).setFinishTime(list.get(0).getStartTime() + list.get(0).getWorkTime());
            list.get(0).setTurnTime(list.get(0).getFinishTime() - list.get(0).getInterTime());
            list.get(0).setPowerTurnTime(((float) list.get(0).getTurnTime() /(float)  list.get(0).getWorkTime()));
            //执行结束,将第一作业对象放入最后不会改变的数组
            finishList.add(list.get(0));
            //将第一个作业对象在原数组移除
            list.remove(0);
            Map<String, List<Process>> map = new HashMap<>();
            map.put("todo", list);
            map.put("finish", finishList);
            //返回一个map
            return map;
        }
    
        //
        public static void doProcess(List<Process> list, List<Process> finishList) {
            //根据工作时间排序
            list.sort(new Comparator<Process>() {
                @Override
                public int compare(Process p1, Process p2) {
                    int num = p1.getWorkTime() - p2.getWorkTime();
                    return num == 0 ? p1.getInterTime() - p2.getInterTime() : num;
                }
            });
            for (Process process : list) {
                //已经操作完成的集合的最后一个与初始化后的依次比较
                if (process.getInterTime() <= finishList.get(finishList.size() - 1).getFinishTime()) {
                    process.setStartTime(finishList.get(finishList.size() - 1).getFinishTime());
                    process.setFinishTime(process.getStartTime() + process.getWorkTime());
                    process.setTurnTime(process.getFinishTime() - process.getInterTime());
                    process.setPowerTurnTime( ((float) process.getTurnTime() / (float) process.getWorkTime()));
                    finishList.add(process);
                    //只处理一个作业
                    break;
                }
            }
            //取差集 也就是比较之后不符合条件的
            list.removeAll(finishList);
            //根据进入时间对作业进行排序
            list.sort(new Comparator<Process>() {
                @Override
                public int compare(Process p1, Process p2) {
                    int num = p1.getInterTime() - p2.getInterTime();
                    return num == 0 ? p1.getWorkTime() - p2.getWorkTime() : num;
                }
            });
            //如果差集不为空且差集的第一作业进入时间<=finishList最后一个作业的结束时间
            //就继续对方法本身进行递归找符合条件的
            if (!list.isEmpty() && list.get(0).getInterTime() <= finishList.get(finishList.size() - 1).getFinishTime()) {
                SJF.doProcess(list, finishList);
            }
            //如果上面的不符就说明差集的所有作业到达时间都>finishList最后一个作业的结束时间
            //对差集进行初始化进行递归直到差集为空,所有作业都被处理
            if (!list.isEmpty()) {
                initSJF(list, finishList);
                SJF.doProcess(list, finishList);
            }
        }
    }
    

    测试类

    package com.xu.demo.ytu;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    import java.util.Scanner;
    
    public class test {
        public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
            List<Process> list = new ArrayList<Process>();
            List<Process> finishList = new ArrayList<Process>();
            System.out.print("请输入作业数量:");
            int processNums=new Scanner(System.in).nextInt();
            for (int n=0;n<processNums;n++){
                System.out.print("作业名:");
                String processName=new Scanner(System.in).next();
                System.out.print("作业到达时间:");
                int interTime=new Scanner(System.in).nextInt();
                System.out.print("作业运行时间:");
                int workTime=new Scanner(System.in).nextInt();
                Process p=new Process(processName,interTime,workTime);
                list.add(p);
            }
            //初始化
            Map<String, List<Process>> map = SJF.initSJF(list, finishList);
            //执行方法
            SJF.doProcess(map.get("todo"), map.get("finish"));
            //输出结果
            System.out.println("-------------------执行先后顺序-----------------------");
            for (Process process : finishList) {
                System.out.println(process);
            }
        }
    }
    
    

    运行结果
    在这里插入图片描述在这里插入图片描述

    展开全文
  • 操作系统调度算法(先来先服务,短作业优先,时间片轮转,响应比优先)
  • 这是一篇操作系统关于短作业优先算法的进程调度的程序源代码
  • #include //定义一个结构体 ... printf("------短作业优先调度算法------\n"); printf("input the process's number:\n"); scanf("%d",&N); input(a,N); sjf *b=a; sjf *c=a; sjff(b,N);//调用sjff函数 }
  • 短作业优先

    2015-06-27 13:36:02
    实验二课程设计题目:短作业优先 JSF 学生姓名:柳建斌专 业:软件工程 班 级:1321804学 号:201320180421指导教师:吴建东 2015 年 6 月 12 日一、实验目的 模拟单处理器系统的进程调度,采用短作业优先的进程调度...
  • 短作业优先算法的简单模拟。可以改成由键盘输入要模拟的进程数量。
  • 操作系统课程设计 ,时间片轮转和短作业优先程序
  • 短作业优先(SJF)调度算法(Java实现)

    千次阅读 多人点赞 2021-05-23 09:13:00
    文章目录前言一、短作业优先(SJF)算法是什么?二、短作业优先(SJF)算法分析三、代码实现1.引入库2.读入数据总结 前言 在实现了先来先服务(FCFS)算法之后能够明显的感觉到先来先服务算法将当前处于就绪队列队首的...


    前言

    在实现了先来先服务(FCFS)算法之后能够明显的感觉到先来先服务算法将当前处于就绪队列队首的那个进程调度到运行状态。也就是说,先来先服务算法只考虑作业或进程进入就绪队列的时间先后,而不考虑它的下一个CPU周期的长短等其他因素。虽然先来先服务算法简单易行并且是一种非抢占式策略,但性能却不大好导致平均周转时间特别长。因此,在先来先服务的算法基础上提出了短作业优先(SJF)算法来改进先来先服务算法,来减少平均周转时间。本文将介绍如何用Java来简单实现短作业优先调度算法


    提示:以下是本篇文章正文内容,下面案例可供参考

    代码实现

    假设当前有四个进程先后到达系统进行调度:

    作业名到达时间服务时间
    A020
    B515
    C105
    D1510

    经过计算可得到如下结果:

    作业名到达时间服务时间完成时间周转时间带权周转时间
    A02020201
    B51550453
    C10525153
    D151035202

    平均周转时间: ( 20 + 15 + 20 + 45 ) / 4 = 25
    平均带权周转时间:( 20 / 20 + 15 / 5 + 20 / 10 + 45 / 15 ) / 4 = 2.25

    接下来编写Java程序,输出以上计算结果

    1、作业类

    代码如下(示例):

    class ProcessData {
        // 到达时间
        public int arriveTime;
        // 服务时间
        public int serviceTime;
        // 完成时间
        public int finishTime;
        // 周转时间
        public int turnTime;
        // 带权周转时间
        public double powerTime;
    
        public ProcessData(int arriveTime, int serviceTime) {
            this.arriveTime = arriveTime;
            this.serviceTime = serviceTime;
        }
    
        @Override
        public String toString() {
            return arriveTime + "\t" +
                    serviceTime + "\t" +
                    finishTime + "\t" +
                    turnTime + "\t" +
                    powerTime;
        }
    }
    

    2、算法实现类

    代码如下(示例):

    public class ProcessProject {
        // 平均周转总时间
        public static double avgTotalTime;
        // 平均带权周转时间
        public static double avgPowerTime;
    
        public static void main(String[] args) {
            ProcessData[] processData = new ProcessData[4];
    
            // 定义四个作业
            processData[0] = new ProcessData(0, 20); // 作业A
            processData[1] = new ProcessData(5, 15); // 作业B
            processData[2] = new ProcessData(10, 5); // 作业C
            processData[3] = new ProcessData(15, 10); // 作业D
            // 短作业优先
            SJF(processData);
        }
    
        // 短作业优先算法
        private static void SJF(ProcessData[] processData) {
            int preFinished = 0; // 前一个作业的完成时间即下一个作业的开始时间
            avgTotalTime = 0;    // 平均周转时间
            avgPowerTime = 0;    // 平均带权周转时间
    
            for (int i = 0; i < processData.length; i++) {
                processData[i].finishTime = 0; // 设置完成时间为0
                processData[i].turnTime = 0; //周转时间
                processData[i].powerTime = 0; //平均周转时间
            }
    
            int number = 0;  // 定义作业号
            // 定义双层for循环用于比较作业的完成时间和服务时间
            for (int i = 0; i < processData.length; i++) {
                int min = 8888;
                for (int j = 0; j < processData.length; j++) {
                    /**
                     *  1. 如果服务时间小于最小时间
                     *  2. 到达时间小于等于前一个作业的完成时间
                     *  3. 完成时间为0代表着还没有进行服务
                     *  最核心的地方就在于有完成时间限制着作业不会继续重复进入循环
                     */
                    if (processData[j].serviceTime < min && processData[j].arriveTime <= preFinished && processData[j].finishTime == 0) {
                        min = processData[j].serviceTime; // 将目前服务时间最短的作业的服务时间赋值给作业的最小完成时间
                        number = j; // 将下一个进行调度的作业号赋值给number
                    }
                }
                processData[number].finishTime = preFinished + processData[number].serviceTime;  // 当前作业的完成时间等于上一个作业的完成时间加当前作业的服务时间
                preFinished = processData[number].finishTime; // 将上一个作业的完成时间赋值为当前作业的完成时间
                processData[number].turnTime = processData[number].finishTime - processData[number].arriveTime;  // 周转时间 = 完成时间 - 到达时间
                processData[number].powerTime = processData[number].turnTime / processData[number].serviceTime;  // 带权周转时间 = 周转时间 / 服务时间
            }
            System.out.println("短进程优先算法:");
            Display(processData);
        }
    	// 该方法用于将作业的各种信息进行打印
        private static void Display(ProcessData[] processData) {
            System.out.println("到达时间\t" + "服务时间\t" + "完成时间\t" + "周转时间\t" + "带权周转时间\t");
            for (int i = 0; i < processData.length; i++) {
                System.out.println(processData[i]);
                avgTotalTime += processData[i].turnTime; // 求总周转时间,此时avgTotalTime中存储的值为总周转时间
                avgPowerTime += processData[i].powerTime; // 求总带权周转时间,此时avgPowerTime中存储的值为总带权周转时间
            }
    
            avgTotalTime = avgTotalTime / processData.length; // 平均周转时间
            avgPowerTime = avgPowerTime / processData.length; // 平均带权周转时间
    
            System.out.println("平均周转时间:" + avgTotalTime);
            System.out.println("平均带权周转时间:" + avgPowerTime);
        }
    }
    

    3、运行结果

    在这里插入图片描述


    总结

    以上便是短作业优先调度算法的Java实现,短作业优先算法的核心在于当系统中正在调度一个作业时,在当前作业调度完成之前到达系统的作业将会进行服务时间的比较,服务时间短的作业将在当前作业调度完成后优先进行调度。

    展开全文
  • Java进行先来先服务FCFS和短作业优先SJF进程调度算法的开发

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,486
精华内容 8,994
关键字:

短作业优先

友情链接: Proteus Isis7 Tutorial.rar