作业调度
作业调度的评价指标
作业调度的评价指标
作业调度是指在计算机系统中,针对各个作业的特点和运行要求,通过一定的算法和策略,将它们按照一定的顺序和时间安排到系统资源中,以实现高效的资源利用和作业运行,从而提高计算机系统的整体性能。
作业调度的好坏不仅影响系统的性能和效率,而且关系到用户的体验和用户满意度。
因此,作业调度的评价指标是非常重要的,下面分别介绍几个常见的指标:
1. 资源利用率:资源利用率是指系统中各种资源的使用情况,包括CPU、内存、磁盘、网络等。
良好的作业调度应该能够合理地分配和利用系统资源,以达到最大化利用的目的。
2. 响应时间:响应时间是指从用户提交作业到作业完成的时间间隔,是用户感受系统性能的直接指标。
好的作业调度应该能够尽量减少用户的等待时间,提高系统的响应速度。
3. 吞吐量:吞吐量是系统能够处理的作业数量,也是系统的处理能力和效率的重要指标。
作业调度应该能够合理地安排各个作业的顺序和时间,以提高系统的吞吐量。
4. 稳定性与可靠性:作业调度应该具有良好的稳定性和可靠性,即在出现异常情况时,能够采取正确的处理方式,防止系统崩溃或数据丢失等问题。
5. 灵活性与可扩展性:作业调度应该具有灵活性和可扩展性,即能够根据系统的需求和变化,随时调整作业调度策略和算法,以适应不同的应用场景和任务需求。
综上所述,作业调度的评价指标涵盖了资源利用率、响应时间、吞吐量、稳定性与可靠性、灵活性与可扩展性等多个方面,每个指标都具有重要的意义和作用,需要根据具体的情况和需求进行综合考虑和权衡。
作业调度算法
作业调度算法先来先服务算法是最简单的调度算法之一、它按照作业到达的先后顺序进行调度,即先到达的作业先执行,后到达的作业后执行。
这种算法的优点是实现简单,适用于一些简单的场景。
然而,它的缺点也很明显,即平均等待时间较长,可能会导致长作业时间的作业一直占用CPU,造成资源浪费。
短作业算法是一种基于作业的执行时间长度进行调度的算法。
它会优先执行执行时间最短的作业。
这种算法的优点是能够最大程度地减少平均等待时间,使得短作业能够快速得到执行。
然而,缺点是可能会导致长作业长时间等待,造成长作业的响应时间增长。
这两种算法在不同的场景下有着不同的应用。
先来先服务算法适用于任务到达时间相对较为平均的场景,能够保证公平性,使得每个作业都有机会得到执行。
而短作业算法适用于任务执行时间差距较大的场景,能够尽可能减少平均等待时间,并且能够提升系统的响应速度。
需要注意的是,这两种算法都存在一种问题,即长作业会一直占用CPU,可能造成短作业长时间等待。
为了解决这个问题,可以引入抢占式调度算法,例如短作业剩余时间优先算法(Shortest Remaining Time Next,SRTN)。
SRTN算法在执行过程中会动态地检测作业的执行时间,一旦有更短的作业到达,就会抢占当前的作业,提高了系统的性能。
总的来说,先来先服务算法和短作业算法都是作业调度中常用的算法。
在实际应用中,可以根据具体情况选择合适的算法,或者结合多种算法来获取更好的调度效果。
作业调度算法的选择对于系统的性能和资源利用率具有重要的影响,需要根据实际需求进行综合权衡。
操作系统——作业调度
操作系统——作业调度实验⼆作业调度模拟程序⼀、⽬的和要求 1. 实验⽬的 (1)加深对作业调度算法的理解; (2)进⾏程序设计的训练。
2.实验要求 ⽤⾼级语⾔编写⼀个或多个作业调度的模拟程序。
单道批处理系统的作业调度程序。
作业⼀投⼊运⾏,它就占有计算机的⼀切资源直到作业完成为⽌,因此调度作业时不必考虑它所需要的资源是否得到满⾜,它所运⾏的时间等因素。
作业调度算法: 1) 采⽤先来先服务(FCFS)调度算法,即按作业到达的先后次序进⾏调度。
总是⾸先调度在系统中等待时间最长的作业。
2) 短作业优先 (SJF) 调度算法,优先调度要求运⾏时间最短的作业。
3) 响应⽐⾼者优先(HRRN)调度算法,为每个作业设置⼀个优先权(响应⽐),调度之前先计算各作业的优先权,优先数⾼者优先调度。
RP (响应⽐)=作业周转时间 / 作业运⾏时间=1+作业等待时间/作业运⾏时间每个作业由⼀个作业控制块JCB表⽰,JCB可以包含以下信息:作业名、提交(到达)时间、所需的运⾏时间、所需的资源、作业状态、链指针等等。
作业的状态可以是等待W(Wait)、运⾏R(Run)和完成F(Finish)三种之⼀。
每个作业的最初状态都是等待W。
⼀、模拟数据的⽣成 1.允许⽤户指定作业的个数(2-24),默认值为5。
2. 允许⽤户选择输⼊每个作业的到达时间和所需运⾏时间。
3.(**)从⽂件中读⼊以上数据。
4.(**)也允许⽤户选择通过伪随机数指定每个作业的到达时间(0-30)和所需运⾏时间(1-8)。
⼆、模拟程序的功能 1.按照模拟数据的到达时间和所需运⾏时间,执⾏FCFS, SJF和HRRN调度算法,程序计算各作业的开始执⾏时间,各作业的完成时间,周转时间和带权周转时间(周转系数)。
2. 动态演⽰每调度⼀次,更新现在系统时刻,处于运⾏状态和等待各作业的相应信息(作业名、到达时间、所需的运⾏时间等)对于HRRN算法,能在每次调度时显⽰各作业的响应⽐R情况。
作业调度功能介绍
作业调度功能介绍
⼀、概述
作业调度的⽬的在于在对与系统资源进⾏交互的⽤户造成最低影响的同时,确保批处理流程的成功执⾏.
作业调度的主要活动包括批处理运⾏⽅式的监控、分析、调优和实现.
作业调度定义的内容如下:
作业对象:注册作业对象.
作业调度:根据业务需求,按照时间周期(每⽇、每周、每⽉、每年) 对作业对象进⾏调度,
作业优先级:根据⼯作计划、运⾏优先级和作业之间的相互依赖关系来执⾏作业.
涉及到的业务范围包括:
√⾃动备份数据
√⾃动数据库与数据库之间的数据传输
√⾃动与淘宝⽹进⾏数据传输
√⾃动与拍拍⽹进⾏数据传输.
⼆、注册作业对象
进⼊[作业调度]-[作业对象注册]
点增加按纽出现界⾯
注意:业务对象名必须事先中定义好.⽬前系统已经预留了三个作业:数据库备份,淘宝拍拍作业,数据传输作业三、作业计划
进⼊[作业计划]
点增加:
如果调度频率为每周,界⾯如下:
如果调度频率为每⽉,界⾯如下:
说明如下:
计划编号:对本次作业定义⼀个编号
计划名称:对本次作业定义⼀个名称
调度对象:选择已注册的作业对象
优先级:优先顺序
停⽌使⽤:是否停⽌,打勾以后,此计划不⽣效
调度频率:发⽣频率是按天,还是按周,还是按⽉
每天:每天都发⽣,可以定义每天发⽣⼀次,也可以定义,发⽣多次。
按周:可以定义⼀周内⼀个或多个星期发⽣,当定义发⽣的星期后,再定义当天的发⽣频率
按⽉:可以定义⼀⽉内某天,或按星期定义某天,再按天定义频率.⾃定义属性1:备⽤字段
⾃定义属性2:备⽤字段
备注:计划说明。
作业调度实验报告
作业调度实验报告一、实验目的本次作业调度实验的主要目的是深入理解和掌握作业调度的基本原理和算法,通过实际编程和模拟实验,分析不同调度策略对系统性能的影响,从而为优化作业调度提供理论依据和实践经验。
二、实验环境本次实验在 Windows 10 操作系统下进行,使用 Python 语言作为主要的编程工具。
实验中所需的相关库包括`numpy`、`matplotlib` 等。
三、实验原理作业调度是操作系统中的一个重要组成部分,其主要任务是根据一定的调度策略,从就绪队列中选择作业并分配处理机资源,以实现系统资源的高效利用和作业的快速执行。
常见的作业调度算法包括先来先服务(FCFS)、短作业优先(SJF)、优先级调度、高响应比优先调度等。
先来先服务算法按照作业到达的先后顺序进行调度,先到达的作业先执行。
这种算法简单直观,但可能导致长作业长时间等待,影响系统的平均周转时间。
短作业优先算法优先调度执行时间短的作业,能够有效地减少作业的平均等待时间,但可能会导致长作业饥饿。
优先级调度根据作业的优先级来决定执行顺序,优先级高的作业先执行。
然而,确定合理的优先级是一个复杂的问题。
高响应比优先调度综合考虑了作业的等待时间和执行时间,通过计算响应比来决定作业的执行顺序,在一定程度上避免了长作业饥饿的问题。
四、实验内容(一)算法实现1、先来先服务算法```pythondef fcfs_scheduling(jobs):start_time = 0 len(jobs)finish_time = 0 len(jobs)waiting_time = 0 len(jobs)turnaround_time = 0 len(jobs)current_time = 0for i in range(len(jobs)):start_timei = current_timefinish_timei = current_time + jobsiturnaround_timei = finish_timei 0current_time = finish_timeireturn waiting_time, turnaround_time```2、短作业优先算法```pythondef sjf_scheduling(jobs):sorted_jobs = sorted(jobsitems(), key=lambda x: x1) start_time = 0 len(sorted_jobs)finish_time = 0 len(sorted_jobs)waiting_time = 0 len(sorted_jobs)turnaround_time = 0 len(sorted_jobs)current_time = 0for i in range(len(sorted_jobs)):start_timei = current_timefinish_timei = current_time + sorted_jobsi1turnaround_timei = finish_timei 0current_time = finish_timeireturn waiting_time, turnaround_time```3、优先级调度算法```pythondef priority_scheduling(jobs):sorted_jobs = sorted(jobsitems(), key=lambda x: x2, reverse=True) start_time = 0 len(sorted_jobs)finish_time = 0 len(sorted_jobs)waiting_time = 0 len(sorted_jobs)turnaround_time = 0 len(sorted_jobs)current_time = 0for i in range(len(sorted_jobs)):start_timei = current_timefinish_timei = current_time + sorted_jobsi1turnaround_timei = finish_timei 0current_time = finish_timeireturn waiting_time, turnaround_time```4、高响应比优先调度算法```pythondef hrrn_scheduling(jobs):response_ratio =for i in range(len(jobs)):waiting_time = 0for j in range(i):waiting_time += jobsjresponse_ratioappend((waiting_time + jobsi) / jobsi)sorted_jobs = job for _, job in sorted(zip(response_ratio, jobs),reverse=True)start_time = 0 len(sorted_jobs)finish_time = 0 len(sorted_jobs)waiting_time = 0 len(sorted_jobs)turnaround_time = 0 len(sorted_jobs)current_time = 0for i in range(len(sorted_jobs)):start_timei = current_timefinish_timei = current_time + sorted_jobsiwaiting_timei = current_timeturnaround_timei = finish_timei 0current_time = finish_timeireturn waiting_time, turnaround_time```(二)实验数据生成为了模拟不同的作业情况,生成了三组具有不同特点的作业数据,分别是:1、作业执行时间均匀分布的数据。
作业调度
作业调度:从输入井中选中后备作业装入主存储器的过程,称为作业调度进程调度:从就绪队列中选中一个进程占用处理器运行作业调度的必要条件:系统现有尚未分配的资源可以满足被选中作业的资源要求。
作业调度算法的原则:公平性、平衡资源使用、极大的流量作业调度算法1、先来先服务算法按照作业进入输入井的先后次序来挑选作业,进入的作业优先被选中。
但是要注意,不是先进入的一定被选中,只有满足“必要条件”的作业才可能被选中。
一个先进入的作业,如果它所需要的资源或其中一部分资源已被在它先前的作业占用且尚未归还,那么这个作业将被推迟,而去选择在它之后进入的资源能满足的作业。
一旦有作业执行结束归还了资源后,作业调度再次选择作业时,仍要按照进入输入井的次序去挑选,刚刚被推迟的作业有可能被优先选中。
例子:假设用户使用的主存空间为100KB,作业调度和进程调度均采用先来先服务算法,进入输入井时间如下表:当作业调度是,A,B作业首先依次被选中装入主存,但作业C到达输入井后,由于不能满足它对主存量的要求,只能让它在输入井中等待,对随后到达输入井的作业D和E,作业D的主存需求可以得到满足,于是选中D装入主存。
于是A,B,C 总共占用85KB主存,还剩余15KB的空闲区,不够装入作业E,因此C,E均被推迟,在输入井中等待。
随后A被执行完,释放了15KB的主存,目前存储器有两个15KB的空闲区,仍不能装入C或E。
随后在11.3刻时间,B执行完,释放60K 的主存空间和A作业释放的15KB合并后成75KB的空闲区。
满足C和E的需求,因此C,E在11.3刻同时被装入主存。
优点:算法简单容易实现,具有一定的公平性缺点计算时间短的作业可能周转时间很长,从而增加了系统平均周转时间,降低了系统的吞吐率2、计算时间短的作业优先算法作业调度根据在输入井中的作业提出的计算时间为标准,优先选择计算时间短且资源能得到满足的作业。
由于作业是依次进入输入井的,所以该算法仍将像先来先服务算法一样,会依次把作业A,B,D先装入主存,调度进程按装入的次序让他们依次占用处理器。
作业调度和进程调度的区别
作业调度和进程调度的区别先打条⼴告,这是我的新博客,, 会经常更新,欢迎⼤家光顾~先看⾼程中的⼀道题⽬:⼀个有两个作业管理进程的批处理系统,作业调度采⽤最⾼响应⽐优先的算法,进程调度采⽤基于优先数(优先数⼤者优先)的算法,有以下作业序列。
作业名到达时间估计运⾏时间(分) 优先数A 10:00 50 5B 10:20 60 7C 10:50 40 3D 11:20 80 8E 11:40 30 6F 12:00 70 9计算每个作业的完成时间。
先⼤概了解下:作业调度(响应⽐)按⼀定的算法从磁盘上的“输⼊井”中选择资源能得到满⾜的作业装⼊内存,使作业有机会去占⽤处理器执⾏。
但是,⼀个作业能否占⽤处理器,什么时间能够占⽤处理器,必须由进程调度来决定。
所以,作业调度选中了⼀个作业且把它装⼊内存时,就应为该作业创建⼀个进程,若有多个作业被装⼊内存,则内存中同时存在多个进程,这些进程的初始状态为就绪状态,然后,由进程调度(优先数)来选择当前可占⽤处理器的进程,进程运⾏中由于某种原因状态发⽣变化,当它让出处理器时,进程调度就再选另⼀个作业的进程运⾏。
因此,作业调度与进程调度相互配合才能实现多道作业的并⾏执⾏。
简单来说:⽐如两个作业管理进程的批处理系统。
内存中⼀个作业运⾏,⼀个作业就绪。
不是每个作业都有就绪的机会,想等到这个机会,等待的⼏个作业必须⽐较⼀下。
打个⽐⽅:⼩诊所⾥⾯补⽛,⼀个⼈补着,⼏个⼈在屋⼦⾥等着,⼏个⼈在门⼝等着。
屋外的想进去,⼤家先来争(响应⽐:Rp=1+(已经等的时间) / 拔⽛⼤概需要的时间),⽐完后,⼏个幸运⼉进屋了,谁先补呢?再来⽐。
这些⼈⾥⾯有个医⽣认识的领导,那领导先来,送红包的第⼆个,其他⼈等着(这就是优先数,⼤者享受优先待遇)。
接下来研究这道题,不着急,慢慢想,借⽤⼀段CSDN前辈的分析过程:10:00 作业A到达,被作业调度程序调度进⼊系统,被进程调度程序调度开始运⾏。
10:20 作业A运⾏20分钟,剩余30分钟,由于A的优先数⼩于B的优先数,被进程调度程序调度处于就绪状态。
《作业车间调度》课件
生产制造领域的应用
生产计划制定:根据订单需求和生产能力制定生产计划 生产进度监控:实时监控生产进度,及时发现和解决问题 资源优化配置:优化生产资源配置,提高生产效率 质量控制:监控产品质量,确保生产质量符合要求 成本控制:优化生产成本,提高生产效益 设备维护:合理安排设备维护,保证生产设备正常运行
物流企业背景: 某大型物流企业, 拥有多个作业车 间
调度问题:订单 量大,作业车间 调度困难
解决方案:采用 智能调度系统, 优化调度策略
效果:提高了作 业效率,降低了 成本,提升了客 户满意度
某高科技企业的作业车间调度案例
企业背景:某高科技企业,生产高科技电子 产品
生产流程:包括原材料采购、生产、质检、 包装、发货等环节
提高员工素质:提高员工 素质,提高生产效率和质 量
作业车间调度的优化算法
遗传算法:通 过模拟生物进 化过程,寻找
最优解
模拟退火算法: 通过模拟金属 冷却过程,寻 找全局最优解
蚁群算法:通 过模拟蚂蚁觅 食过程,寻找
最优路径
粒子群优化算 法:通过模拟 鸟群飞行过程,
寻找最优解
调度方法的评价标准
效率:调度 方法的执行 效率,包括 时间、资源
护,减少停机时间
实时监控:通过物联网技术 实时监控作业车间的生产情 况,提高生产效率
优化生产:利用物联网技术 优化生产流程,提高产品质
量和生产效率
智能优化算法在作业车间调度中的发展
智能优化算法:基于人工智能 和机器学习的优化算法
应用领域:作业车间调度、生 产计划、库存管理等
发展趋势:智能化、自动化、 高效化
调度目标与原则
提高生产效率:通过合理安排 生产任务,提高生产效率
各类作业调度算法
各类作业调度算法作业调度是计算机系统中的重要问题,涉及到如何合理地分配和调度系统资源,以最大化系统的吞吐量和性能。
针对不同的应用场景和需求,有多种不同的作业调度算法。
本文将介绍几种常见的作业调度算法,包括先来先服务调度算法(FCFS)、最短作业优先调度算法(SJF)、优先级调度算法、轮转调度算法(RR)和最高响应比优先调度算法(HRRN)。
先来先服务调度算法(FCFS)是最简单的一种调度算法。
它按照作业的到达时间顺序为其分配资源,即先来的作业先执行,后来的作业后执行。
这种算法的优点是实现简单,公平性好,但是缺点也很明显,它无法考虑作业的执行时间,如果一个长作业在前面执行,可能会导致后面的短作业等待时间过长,从而影响整个系统的效率。
最短作业优先调度算法(SJF)是一种根据作业执行时间的长短来分配资源的算法。
它会选择剩余执行时间最短的作业来执行,从而最大程度上减少作业的等待时间。
这种算法可以很好地提高系统的性能,但是需要事先知道每个作业的执行时间,而且无法应对作业执行时间波动较大的情况。
优先级调度算法主要根据作业的优先级来决定资源的分配顺序。
每个作业都有一个对应的优先级,具有较高优先级的作业会被优先调度执行。
不同作业的优先级可以通过用户设置或者系统自动派发来确定。
这种算法可以灵活地应对不同的需求,但是需要合理设置优先级,否则可能导致资源被一直分配给优先级较高的作业,而忽略其他作业。
轮转调度算法(RR)是一种按照时间片轮流分配资源的算法。
每个作业都有一个固定的时间片,当一个作业的时间片用完后,就将资源分配给下一个作业。
这种算法可以平衡各个作业的等待时间,对于长作业和短作业都能有一定的公平性,但是如果时间片设置得过长,可能导致系统响应时间较长。
最高响应比优先调度算法(HRRN)是根据作业的响应比来决定资源分配顺序的算法。
响应比由作业的等待时间与执行时间之比计算得出,作业的响应比越高,代表其等待时间相对较长,应该优先进行资源分配。
作业调度实验报告
实验二作业调度一.实验题目1、编写并调试一个单道处理系统的作业等待模拟程序。
作业调度算法:分别采用先来先服务(FCFS),最短作业优先(SJF)、响应比高者优先(HRN)的调度算法。
(1)先来先服务算法:按照作业提交给系统的先后顺序来挑选作业,先提交的先被挑选。
(2)最短作业优先算法:是以进入系统的作业所提出的“执行时间”为标准,总是优先选取执行时间最短的作业。
(3)响应比高者优先算法:是在每次调度前都要计算所有被选作业(在后备队列中)的响应比,然后选择响应比最高的作业执行。
2、编写并调度一个多道程序系统的作业调度模拟程序。
作业调度算法:采用基于先来先服务的调度算法。
可以参考课本中的方法进行设计。
对于多道程序系统,要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求。
二.实验目的:本实验要求用高级语言(C语言实验环境)编写和调试一个或多个作业调度的模拟程序,了解作业调度在操作系统中的作用,以加深对作业调度算法的理解三 .实验过程<一>单道处理系统作业调度1)单道处理程序作业调度实验的源程序: zuoye.c执行程序: zuoye.exe2)实验分析:1、由于在单道批处理系统中,作业一投入运行,它就占有计算机的一切资源直到作业完成为止,因此调度作业时不必考虑它所需要的资源是否得到满足,它所占用的 CPU 时限等因素。
2、每个作业由一个作业控制块JCB 表示,JCB 可以包含如下信息:作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。
作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。
每个作业的最初状态总是等待W 。
3、对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间,以及这组作业的平均周转时间及带权平均周转时间。
3)流程图:二.最短作业优先算法三.高响应比算法图一.先来先服务流程图4)源程序:#include <stdio.h>#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type))#define NULL 0int n;float T1=0,T2=0;int times=0;代替代替struct jcb //作业控制块{char name[10]; //作业名int reachtime; //作业到达时间int starttime; //作业开始时间int needtime; //作业需要运行的时间float super; //作业的响应比int finishtime; //作业完成时间float cycletime; //作业周转时间float cltime; //作业带权周转时间char state; //作业状态struct jcb *next; //结构体指针}*ready=NULL,*p,*q;typedef struct jcb JCB;void inize() //初始化界面{printf("\n\n\t\t******************************************* **\t\t\n");printf("\t\t\t\t实验二作业调度\n");printf("\t\t*********************************************\t\t\n");printf("\n\n\n\t\t\t\t\t计算机学院软件四班\n");printf("\t\t\t\t\t蓝小花\n");printf("\t\t\t\t\t完成日期:2006年11月17号");printf("\n\n\n\t\t请输入任意键进入演示过程\n");getch();}void inital() //建立作业控制块队列,先将其排成先来先服务的模式队列{int i;printf("\n输入作业数:");scanf("%d",&n);for(i=0;i<n;i++){p=getpch(JCB);printf("\n输入作业名:");scanf("%s",p->name);getch();p->reachtime=i;printf("作业默认到达时间:%d",i);printf("\n输入作业要运行的时间:");scanf("%d",&p->needtime);p->state='W';p->next=NULL;if(ready==NULL) ready=q=p;else{q->next=p;q=p;}}}void disp(JCB* q,int m) //显示作业运行后的周转时间及带权周转时间等{if(m==3) //显示高响应比算法调度作业后的运行情况{printf("\n作业%s正在运行,估计其运行情况:\n",q->name);printf("开始运行时刻:%d\n",q->starttime);printf("完成时刻:%d\n",q->finishtime);printf("周转时间:%f\n",q->cycletime);printf("带权周转时间:%f\n",q->cltime);printf("相应比:%f\n",q->super);getch();}else // 显示先来先服务,最短作业优先算法调度后作业的运行情况{printf("\n作业%s正在运行,估计其运行情况:\n",q->name); printf("开始运行时刻:%d\n",q->starttime);printf("完成时刻:%d\n",q->finishtime);printf("周转时间:%f\n",q->cycletime);printf("带权周转时间:%f\n",q->cltime);getch();}}void running(JCB *p,int m) //运行作业{if(p==ready) //先将要运行的作业从队列中分离出来{ready=p->next;p->next=NULL;}else{q=ready;while(q->next!=p) q=q->next;q->next=p->next;}p->starttime=times; //计算作业运行后的完成时间,周转时间等等p->state='R';p->finishtime=p->starttime+p->needtime;p->cycletime=(float)(p->finishtime-p->reachtime); p->cltime=(float)(p->cycletime/p->needtime);T1+=p->cycletime;T2+=p->cltime;disp(p,m); //调用disp()函数,显示作业运行情况times+=p->needtime;p->state='F';printf("\n%s has been finished!\npress any key to continue...\n",p->name);free(p); //释放运行后的作业getch();}void super() //计算队列中作业的高响应比{JCB *padv;padv=ready;do{if(padv->state=='W'&&padv->reachtime<=times)padv->super=(float)(times-padv->reachtime+padv->needtime)/p adv->needtimepadv=padv->next;}while(padv!=NULL);}void final() //最后打印作业的平均周转时间,平均带权周转时间{float s,t;t=T1/n;s=T2/n;getch();printf("\n\n作业已经全部完成!");printf("\n%d个作业的平均周转时间是:%f",n,t);printf("\n%d个作业的平均带权周转时间是%f:\n\n\n",n,s); }void hrn(int m) //高响应比算法{JCB *min;int i,iden;system("cls");inital();for(i=0;i<n;i++){p=min=ready;iden=1;super();do{if(p->state=='W'&&p->reachtime<=times)if(iden){min=p;iden=0;}else if(p->super>min->super) min=p;p=p->next;}while(p!=NULL);if(iden){i--;times++;//printf("\ntime=%d:\tno JCB submib...wait...",time);if(times>1000){printf("\nruntime is too long...error...");getch();}}else{running(min,m); //调用running()函数}} //forfinal(); //调用running()函数}void sjf(int m) // 最短作业优先算法{JCB *min;int i,iden;system("cls");inital();for(i=0;i<n;i++)p=min=ready;iden=1;do{if(p->state=='W'&&p->reachtime<=times)if(iden){min=p;iden=0;}else if(p->needtime<min->needtime) min=p;p=p->next;}while(p!=NULL) ;if(iden) {i--; //printf("\ntime=%d:\tno JCB submib...wait...",time);times++;if(times>100){printf("\nruntime is too long...error");getch();}}else{running(min,m); //调用running()函数}} //forfinal(); //调用running()函数void fcfs(int m) //先来先服务算法{int i,iden;system("cls");inital();for(i=0;i<n;i++){p=ready;iden=1;do{if(p->state=='W'&&p->reachtime<=times) iden=0; if(iden)p=p->next;}while(p!=NULL&&iden) ;if(iden){i--;printf("\n没有满足要求的进程,需等待");times++;if(times>100){printf("\n时间过长");getch();}}else{running(p,m); //调用running()函数}}final(); //调用running()函数}void mune(){int m;system("cls");printf("\n\n\t\t******************************************* **\t\t\n");printf("\t\t\t\t作业调度演示\n");printf("\t\t*********************************************\t \t\n");printf("\n\n\n\t\t\t1.先来先服务算法.");printf("\n\t\t\t2.最短作业优先算法.");printf("\n\t\t\t3.响应比高者优先算法");printf("\n\t\t\t0.退出程序.");printf("\n\n\t\t\t\t选择所要操作:");scanf("%d",&m);switch(m){case 1:fcfs(m);getch();system("cls"); mune();break;case 2:sjf(m);getch();system("cls"); mune();break;case 3:hrn(m);getch();system("cls"); mune();break;case 0:system("cls"); break;default:printf("选择错误,重新选择.");getch();system("cls");mune();}}main() //主函数{inize();mune();}5)调试结果:1.选择操作的界面2.输入操作初始信息:3.先来先服务算法作业调度结果: (调度顺序:a->b->c->d->e)4.最短作业优先算法作业调度结果(调度顺序: a->d->b->e->c)5.高响应比算法作业调度结果: (调度顺序 a->b->d->c->e)<二>多道处理系统作业调度1)多道处理程序作业调度实验的源程序: duodao.c执行程序: duodao.exe2)实验分析:采用多道程序设计方法的操作系统,在系统中要经常保留多个运行的作业,以提高系统效率。
常用于作业调度
常用于作业调度
常用于作业调度的几种调度算法有:
1. 先来先服务(FCFS):按照作业提交的先后顺序进行调度。
2. 短作业优先(SJF):优先调度执行时间最短的作业。
3. 优先级调度:根据作业的优先级进行调度,优先级高的作业先执行。
4. 最短剩余时间优先(SRTF):每次选择执行时间最短的作业,如果有新作业提交,且其执行时间比当前正在执行的作业更短,则中断当前作业,执行新作业。
5. 高响应比优先(HRRN):根据作业的等待时间和执行时间
的比值(响应比)进行调度,响应比越高的作业优先级越高。
6. 时间片轮转(RR):将CPU时间分为固定的时间片,每个
作业轮流执行一个时间片,如果一个作业在一个时间片内没有执行完,则排到队列的末尾等待下一轮调度。
以上是常见的几种作业调度算法,根据不同的需求和场景,选择合适的调度算法可以提高作业的执行效率和系统的响应性能。
调度作业安全管理制度
第一章总则第一条为加强调度作业安全管理,确保调度作业安全、高效、有序进行,保障人员生命财产安全,根据国家有关安全生产法律法规,结合我单位实际情况,制定本制度。
第二条本制度适用于我单位所有调度作业,包括电力、通信、交通、物流等领域的调度作业。
第三条调度作业安全管理遵循“安全第一、预防为主、综合治理”的原则。
第二章组织机构与职责第四条成立调度作业安全领导小组,负责调度作业安全管理的全面工作。
1. 组长:由单位主要负责人担任。
2. 副组长:由分管安全工作的领导担任。
3. 成员:由相关部门负责人及安全管理人员组成。
第五条调度作业安全领导小组的主要职责:1. 制定调度作业安全管理制度和操作规程。
2. 审批重大调度作业方案。
3. 监督检查调度作业安全措施的落实情况。
4. 组织调度作业安全培训和教育。
5. 处理调度作业安全事故。
第六条调度部门负责调度作业的具体实施,其主要职责:1. 严格执行调度作业安全管理制度和操作规程。
2. 落实调度作业安全措施,确保作业安全。
3. 定期对调度作业设备进行检查和维护。
4. 及时报告调度作业中发生的安全隐患。
第三章安全管理措施第七条调度作业前,必须进行安全风险分析,制定相应的安全措施。
第八条调度作业人员必须经过专业培训,取得相应的操作资格证书。
第九条调度作业现场必须配备必要的安全防护设施和器材。
第十条调度作业人员必须穿戴符合要求的安全防护用品。
第十一条调度作业过程中,必须严格遵守操作规程,严禁违章操作。
第十二条调度作业现场必须设置安全警示标志,明确警示内容。
第十三条调度作业结束后,必须对现场进行清理,消除安全隐患。
第四章安全教育与培训第十四条定期对调度作业人员进行安全教育和培训,提高安全意识和操作技能。
第十五条新员工入职后,必须进行岗前安全培训,合格后方可上岗。
第十六条定期组织安全知识竞赛和应急演练,提高调度作业人员的应急处置能力。
第五章安全检查与事故处理第十七条定期对调度作业进行安全检查,及时发现和消除安全隐患。
关于作业调度算法
关于作业调度算法作业调度算法是一种用来管理计算机系统中作业的执行顺序的方法。
在计算机系统中,有很多不同的作业需要执行,作业调度算法可以根据不同的策略和需求,确定作业的执行顺序,以提高系统的效率和性能。
作业调度算法的目标是尽量减少作业的等待时间和系统的响应时间,同时以最小化系统资源的使用为前提。
通过合理的作业调度算法,可以充分利用计算机系统的资源,提高系统的吞吐量和效率。
常见的作业调度算法包括先来先服务(FCFS)、短作业优先(SJF)、最高优先级优先(HPF)、时间片轮转(RR)等。
这些算法根据不同的原则和需求,选择适合的作业执行顺序。
先来先服务(FCFS)是一种最简单的作业调度算法,它按照作业的提交顺序进行调度。
这种算法适用于作业的执行时间相对较均匀的情况,但如果有长时间的作业阻塞其他作业的执行,就可能导致系统的响应时间变长。
短作业优先(SJF)算法则根据作业的执行时间进行排序,在每次调度时选择执行时间最短的作业。
这种算法可以最大限度地减少作业的等待时间,但如果有一些长时间的作业等待执行,可能会导致长作业等待时间过长。
最高优先级优先(HPF)算法根据作业的优先级确定执行顺序,优先级越高的作业越先执行。
这种算法可以根据作业的重要性进行调度,但如果有一些优先级较低的作业等待执行,可能会导致长时间的等待。
时间片轮转(RR)算法将系统的时间片分配给每个作业,每个作业在一个时间片内执行一定的时间,然后切换到下一个作业。
这种算法可以均衡地利用系统的资源,但如果一些作业需要很长的时间完成,可能会导致其他作业的等待时间变长。
除了这些常见的作业调度算法,还有一些其他的算法,如多级反馈队列调度(MLFQ)、最短剩余时间优先(SRTF)等。
这些算法根据具体的系统需求和性能目标,选择适合的调度策略。
总之,作业调度算法是计算机系统中非常重要的一部分,它可以根据不同的策略和需求,对作业的执行顺序进行管理,提高系统的效率和性能。
作业车间调度问题的几种模型
作业车间调度问题是指如何合理地安排工件在不同工序间的加工顺序,以达到最优的生产效率和成本控制。
针对这一主题,我将从几种常见的模型出发,深入探讨作业车间调度问题,旨在为您提供一篇有价值的文章。
一、传统作业车间调度模型1.1 单机调度模型在单机调度模型中,工件依次经过一个加工机器的加工过程。
我们需要考虑如何安排加工顺序、加工时间等因素,以最大程度地减少工件的等待时间和加工时间,提高生产效率。
1.2 流水车间调度模型流水车间调度模型是指在多台加工机器之间,工件按照特定的加工顺序依次进行加工。
我们需要考虑如何合理安排工件的加工顺序,以减少生产中的瓶颈和待机时间,提高整个流水线的生产效率。
1.3 作业车间调度的经典排序问题这种模型主要关注如何将待加工的工件按照特定的规则进行排序,以便在加工过程中最大程度地降低总加工时间和成本。
以上是传统作业车间调度问题的一些经典模型,它们都是针对不同的生产场景和加工流程所提出的解决方案。
接下来,我将对每种模型进行更深入的探讨,以便更好地理解作业车间调度问题。
二、作业车间调度问题的多种解决方法2.1 基于启发式算法的调度方法启发式算法是一种基于经验和规则的算法,它能够快速、高效地求解作业车间调度问题。
常见的启发式算法包括遗传算法、模拟退火算法等,它们能够在短时间内找到较优的解,并且适用于各种不同规模和复杂度的生产场景。
2.2 基于数学规划的调度方法数学规划方法是指利用数学建模和优化理论,对作业车间调度问题进行严格的数学求解。
通过建立数学模型,我们可以利用线性规划、整数规划等方法,对作业车间调度问题进行最优化求解,得到最优的生产调度方案。
2.3 基于仿真的调度方法仿真方法是指利用计算机模拟生产场景,通过模拟实际的生产过程,找到最优的调度方案。
通过仿真,我们可以更加真实地模拟生产现场的情况,找到最优的生产调度策略,提高生产效率和降低成本。
以上是作业车间调度问题的多种解决方法,它们都能够根据不同的生产场景和需求,找到最优的调度方案。
调度会是什么意思
调度会是什么意思调度,作为一个名词,可以有多种不同的含义,具体取决于所讨论的领域。
在不同的背景中,调度会有着不同的含义和作用。
在本文中,我们将探讨调度的常见含义,包括项目调度、作业调度和交通调度等。
一、项目调度项目调度是指在一个项目中,根据任务的性质、要求和资源的可用情况,合理安排各项任务的时间、顺序和资源分配的过程。
项目调度在项目管理中扮演着至关重要的角色,可以协调整个项目的运作,确保项目在规定的时间内完成,并达到预期的质量标准。
项目调度的目标是充分利用可用的资源,以最高效率地完成项目。
它需要综合考虑各项任务的复杂性、关联关系和依赖性,合理地安排任务的开始和结束时间,并确保资源的合理分配。
在项目调度过程中,经常需要对任务的工期、关键路径、工作量和资源需求等进行评估和优化,以实现最佳的项目调度方案。
二、作业调度作业调度是指根据作业的属性和要求,合理地安排作业的执行顺序和资源分配的过程。
作业调度广泛应用于计算机系统和信息技术领域中,用于管理和控制作业的执行。
在计算机系统中,作业调度是指根据作业的资源需求、优先级、执行时间和系统的负载情况,合理地安排作业的执行次序。
作业调度的目标是提高系统的吞吐量、资源利用率和响应速度,减少作业的等待时间和延迟。
作业调度算法是作业调度的核心内容,常见的调度算法包括先来先服务(FCFS)、最短作业优先(SJF)、最高优先权优先(HPF)和时间片轮转(RR)等。
这些算法根据不同的权衡考虑因素选择合适的作业调度策略,以满足系统的调度需求。
三、交通调度交通调度是指在交通管理中合理安排交通流量和交通工具的运行,以提高道路的通行能力和交通安全的过程。
交通调度广泛应用于交通运输、公共交通和城市交通管理等领域,旨在提供高效、安全、便捷的交通服务。
在城市交通管理中,交通调度包括交通信号灯的控制、交通流量的调节和交通事故的调查处理等。
交通调度的目标是最大限度地减少交通拥堵、提高道路的通行能力和安全性。
作业车间调度问题 例题
作业车间调度问题例题作业车间调度问题是生产调度中常见的一个重要问题,其目的是合理安排生产作业车间的生产任务,以最大化生产效率,降低生产成本,提高生产质量。
在实际生产中,作业车间调度问题通常涉及到多台机器和多个作业任务,需要合理分配资源,调度作业顺序,以确保生产计划的顺利执行。
一般来说,作业车间调度问题可以分为单机调度和多机调度两种情况。
单机调度是指在一个作业车间只有一台机器的情况下,需要合理安排作业任务的顺序,以最小化总生产时间或最大化生产效率。
而多机调度则是在一个作业车间有多台机器的情况下,需要合理分配作业任务到不同的机器,以最小化总生产时间或最大化生产效率。
在实际生产中,作业车间调度问题通常受到多种约束条件的限制,如作业任务之间的先后关系、机器之间的技术约束、作业任务的优先级等。
因此,对作业车间调度问题的求解需要综合考虑这些约束条件,设计合适的调度算法来优化生产计划。
一种常见的求解作业车间调度问题的方法是利用启发式算法,如遗传算法、蚁群算法、模拟退火算法等。
这些算法可以在较短的时间内找到较优的调度方案,帮助生产企业提高生产效率,降低生产成本。
除了启发式算法,还有一些经典的作业车间调度问题的求解方法,如Johnson算法、NEH算法、SAW算法等。
这些算法在特定的作业车间调度问题中有较好的表现,可以帮助生产企业解决实际生产中的调度问题。
总的来说,作业车间调度问题在生产调度中扮演着重要的角色,合理的调度方案可以帮助企业提高生产效率,降低生产成本,提高生产质量。
通过合适的算法求解作业车间调度问题,可以为生产企业创造更大的价值,提升竞争力。
因此,对作业车间调度问题的研究和求解具有重要的实际意义,值得生产企业重视和关注。
名词解释-作业调度
作业调度(Job Scheduling)是指对计算机系统中的作业进行安排和调度的过程。
在计算机领域中,作业是指要在计算机上执行的任务或程序。
作业调度的目的是合理地分配计算机系统的资源和任务,以最大程度地提高计算机系统的利用率和效率。
作业调度的主要任务包括确定作业的执行顺序、分配合适的处理器和内存资源、管理作业的优先级和时间限制等。
作业调度需要考虑以下因素:
作业的优先级:根据作业的重要性、紧急程度、资源需求等因素,为作业分配适当的优先级,以确保重要任务的优先执行。
资源管理:根据作业的资源需求,分配计算机系统中的处理器、内存、磁盘等资源,以确保作业能够正常执行并充分利用系统资源。
作业之间的依赖关系:对于有依赖关系的作业,需要按照一定的顺序和时序要求进行调度,以确保前置作业完成后再执行后续作业。
时间限制:对于有时间限制的作业,如实时任务或紧急任务,需要优先调度,确保在规定的时间内完成。
负载平衡:对于多个计算节点或多个处理器系统,需要根据当前系统负载情况,进行作业调度以实现负载均衡,避免资源过度利用或闲置。
作业调度算法的选择和设计是作业调度的关键。
常见的作业调度算法包括先来先服务(FCFS)、最短作业优先(SJF)、优先级调度、轮转调度(Round-Robin)等。
不同的作业调度算法根据不同的考虑因素和优化目标,适用于不同的场景和需求。
通过合理的作业调度,可以提高计算机系统的资源利用率,提高任务执行的效率,实现任务的平衡分配和系统的高效运行。
作业调度 分支限界
作业调度分支限界
作业调度是操作系统的重要组成部分,它的主要任务是根据作业的特性和系统资源的状况,对作业进行合理的分配和调度,以提高系统的性能和效率。
而分支限界法是一种用于解决搜索问题的算法,它通过限制搜索的范围,避免无谓的搜索,提高搜索效率。
在作业调度中,可以使用分支限界法来优化作业的分配和调度。
具体来说,可以使用以下步骤:
1. 定义问题:将作业调度问题转化为一个搜索问题,即在给定的作业集合中,找到最优的作业调度方案。
2. 建立搜索树:根据作业的特性和系统资源的状况,建立一个搜索树,树的每个节点表示一个可能的作业调度方案。
3. 确定搜索策略:根据搜索树的结构和问题的特点,确定搜索策略,如深度优先搜索、广度优先搜索等。
4. 应用分支限界法:在搜索过程中,应用分支限界法来限制搜索的范围,避免无谓的搜索。
例如,可以根据作业的优先级、执行时间等因素来限制搜索的范围。
5. 选择最优方案:在搜索结束后,选择最优的作业调度方案作为结果。
通过使用分支限界法,可以有效地提高作业调度的效率和性能,减少不必要的搜索,提高系统的资源利用率。
作业调度实验报告
作业调度实验报告1. 实验目的通过本次实验,使学生了解作业调度算法的基本原理和实现方法,掌握作业调度的实际应用,提高计算机系统的作业吞吐量和系统效率。
2. 实验环境•操作系统:Linux•编程语言:Python•实验工具:CPU模拟器3. 实验原理作业调度是操作系统中的一个重要环节,主要负责将用户提交的作业按照一定的策略分配到CPU上执行。
作业调度的主要目标是提高CPU的利用率,缩短作业的平均等待时间,提高系统的吞吐量。
常用的作业调度算法有先来先服务(FCFS)、短作业优先(SJF)、最短剩余时间优先(SRT)等。
4. 实验内容本次实验主要分为两个部分:一是实现作业调度算法,二是对不同算法进行性能分析。
4.1 作业调度算法实现以先来先服务(FCFS)算法为例,实现作业调度如下:```pythonclass Job:def __init__(self, job_id, arrival_time, execute_time):self.job_id = job_idself.arrival_time = arrival_timeself.execute_time = execute_timeclass JobScheduler:def __init__(self):self.jobs = []def add_job(self, job):self.jobs.append(job)def schedule(self):start_time = 0finish_time = 0for job in self.jobs:if job.arrival_time >= start_time:start_time = job.arrival_timefinish_time = start_time + job.execute_timeprint(f"Job {job.job_id} arrives at {start_time} and finishes a t {finish_time}")start_time = finish_timeif name== “main”:scheduler = JobScheduler()scheduler.add_job(Job(1, 0, 5))scheduler.add_job(Job(2, 1, 3))scheduler.add_job(Job(3, 3, 8))scheduler.schedule()4.2 性能分析通过对不同作业调度算法的模拟运行,分析其性能指标,如平均等待时间、平均响应时间、吞吐量等。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实习九 作业调度一、实习内容模拟批处理多道操作系统的作业调度。
二、实习目的每个用户请求计算机计算的一个计算任务叫做一个作业。
一个作业从输入初始数据到得到计算结果,要经过若干个步骤的相继执行。
例如,编辑、编译、运行等,其中每一个步骤称作一个作业步。
用户向系统提出作业加工步骤的方式称作业控制方式,作业控制方式有两种:终端控制方式(又称直接控制方式或联机控制方式)和批处理控制方式(又称自动控制方式或脱机控制方式)。
在批处理控制方式下,用户采用系统提供的作业控制语言(JCL )写好作业说明书,说明作业加工的步骤。
操作员把一批作业组织成输入流,通过“预输入”手段使每个作业的信息(包括作业说明书、源程序、初始数据等)暂存在辅助存储器的“输入井”中。
批处理多道操作系统的作业管理有两个任务:作业调度和作业控制。
采用多道程序设计方法的操作系统,在系统中要经常保留多个运行的作业,以提高系统效率。
作业调度从系统已接纳的暂存在输入井中的一批作业中挑选出若干个可运行的作业,并为这些被选中的作业分配所需的系统资源。
对被选中运行的作业必须按照它们各自的作业说明书规定的步骤进行控制。
本实习要求学生模拟作业调度的实现,了解作业调度在操作系统中的作用。
三、实习题目采用先来先服务算法和运行时间最短者优先算法模拟设计作业调度程序。
[提示]:(1) 作业调度程序负责从输入井选择若干个作业进入主存,为它们分配必要的资源,当它们能够被进程调度选中时,就可占用处理器运行。
作业调度选择一个作业的必要条件是系统中现有的尚未分配的资源可满足该作业的资源要求。
但有时系统中现有的尚未分配的资源既可满足某个作业的要求也可满足其它一些作业的要求,那么,作业调度必须按一定的算法在这些作业中作出选择。
先来先服务算法是按照作业进入输入井的先后次序来挑选作业,先进入输入井的作业优先被挑选,当系统中现有的尚未分配的资源不能满足先进入输入井的作业时,那么顺序挑选后面的作业。
运行时间最短者优先算法总是按作业要求运行的时间来选择作业,每次挑选要求运行时间短且资源要求能满足的作业先进入主存执行。
(2) 为了表示暂存在输入井中的各个作业的情况(作业信息在输入井中的位置、作业的资源要求等),常常采用二级目录结构:作业表和预输入表。
例如:作业表预输入表“预输入”程序为每个作业在作业表中占一登记栏,且把作业信息存放到输入井中并按文件(源程序文件、数据文件等)登记在预输入表中。
“预输入”程序工作时还把作业控制语句集中,作为作业说明书文件存放在输入井并登记在预输入表的第一栏中,同时把用户在作业说明书中提出的资源要求登记在作业表中。
本实习模拟作业调度,所以可不考虑有关“预输入”程序的工作。
假定“预输入”程序已经把一批作业的信息存放在输入井了,并为它们建立了如下的作业表:其中状态分三种:收容状态——作业已在输入井,但尚未被选中执行;执行状态——作业被选中,正在执行;完成状态——作业执行结束。
(3) 假定主存中可容纳多道作业同时执行,那么作业调度按调度算法和资源分配情况查作业表,从中选择若干作业,对每个被选中的作业创建一个作业控制进程且使它们处于就绪状态,同时把选中作业的作业说明书读入主存。
处理器调度按调度策略选择作业调度进程或作业控制进程轮流占有处理器(处理器调度参见实习二)。
作业控制进程按作业说明书控制作业执行,当一个作业执行结束后,作业调度再从输入井中选择一个作业进入主存,直到输入井中的作业都执行结束,通知操作员再预输入一批作业。
本实习主要模拟作业调度,所以对处理器调度、作业控制过程简化。
用输入随机数模拟处理器调度,用输入“用户名、作业名”模拟一个作业已经执行结束。
于是,本实习的模拟流程可参考图11-1。
(4) 假定某系统可供用户使用的主存空间共100k,并有5台磁带机。
主存分配采用可变分区分配方式且主存中信息不允许移动(参考实习四),对磁带机采用静态分配策略,主存中可同时执行的作业限定为两道,作业调度分别采用先来先服务算法和运行时间最短者优先算法,参考图11-1设计模拟作业调度的程序。
假定作业表的初值如提示(2),分别在两种算法控制下运行设计的程序,依次显示被选中作业的用户名和作业名。
比较两种作业调度算法选择作业的次序。
在模拟作业执行结束输入被撤离作业的用户名、作业名时,应根据已在主存中的作业需运行的时间来决定撤离的先后次序。
图11-1 作业调度模拟流程四、数据结构及其说明1.一个结构体数组:typedef struct work{char username[10]; //用户名char workname[10]; //作业名float time; //作业运行时间char state; //状态R为收容,A表示执行状态,T为完成int store; //主存int tape; //磁带 }WORK;WORK w[N]; //工作数组2.初始化操作3.算法选择函数:int choice()4.先来先服务函数(FCFS):int FCFS()5.短作业优先服务函数(SFJ):int SFJ()6. 随机数算法操作7.撤离作业算法操作8.主功能函数:void Administer()五、源程序及注解#include<stdio.h>#include<stdlib.h>#include<string.h>#include<time.h>#define N 5//job number#define T 5//tap number#define S 100//main memory sizetypedef struct work{char username[10];char workname[10];float time;char state;int store;int tap;}WORK;int SJF();//shortest job firstint FCFS();//First come first serveint choseWork();void Administer();int t=T;//t为磁带中剩余数量int s=S;//S为主存剩余大小WORK w[N];int choseWork(){int i;char c;getchar();printf("用先来先服务算法,或者用运行时间最短者优先算法F or S:");scanf("%c",&c);switch(c){case'F':i=FCFS();break;case'S':i=SJF();break;}return(i);}int FCFS()//先来先服务{int i;for(i=0;i<N;i++)//查找工作状态为收容的资源量可满足的作业if(w[i].state=='R'&&w[i].store<=s&&w[i].tap<=t)break;if(i>0&&i<N)else return -1;}int SJF(){int i,j=-1;float k=100;//k为任意一个可大于最长作业时间的数for(i=0;i<N;i++)//查找工作状态为收容的资源量可满足的作业if(w[i].state=='R'&&w[i].store<=s&&w[i].tap<=t&&w[i].time<k){k=w[i].time;j=i;}return j;}int main(){int i;printf("初始化:\n");for(i=0;i<N;i++){printf("--请输入第%d个作业的信息--\n",i+1);printf("第%d个作业用户名:",i+1);scanf("%s",w[i].username);printf("第%d个作业作业名:",i+1);scanf("%s",w[i].workname);printf("第%d个作业运行时间:",i+1);scanf("%f",&w[i].time);printf("第%d个作业状态(状态Z表示执行,R表示收容,W为完成):",i+1);scanf("%s",&w[i].state);while(w[i].state!='Z'||w[i].state!='R'||w[i].state!='W'){printf("请重新输入第%d个作业状态(状态Z表示执行,R表示收容,W为完成):",i+1);scanf("%s",&w[i].state);}printf("第%d个作业主存:",i+1);scanf("%d",&w[i].store);printf("第%d个作业磁带:",i+1);scanf("%d",&w[i].tap);}Administer();}void Administer(){int i,j,f;int n=0;//主存中的作业数for(i=0;i<N;i++)if(w[i].state=='Z'){t=t-w[i].tap;s=s-w[i].state;n++;if(s<0||t<0||n>2){printf("初始化失败,退出系统\n");return;}char workname[10];char username[10];for(;;){float p;int k;int q;char b;getchar();time_t t;srand((unsigned)time(&t));printf("电脑随机数是:\n");for(k=0;k<1;k++)q=rand()%10;p=q*0.1;printf("%f\n",p);if(p>0.5)printf("随机数大于0.5,转入作业表\n");elseprintf("随机数小于0.5,转入主存\n");printf("继续(N)、返回(B)、显示当前著作业状态(D)还是退出系统(Q) :"); scanf("%s",&b);if(b=='N'){if(p>0.5&&p<=1){f=0;for(i=0;i<N;i++)if(w[i].state=='R')f=1;if(f==1)//主存中尚有未被选中的作业{if(t>0&&s>0)//主存中还能装入作业{j=choseWork();if(j<0)//未选到{printf("等待作业执行结束归还资源.\n");continue;}else //为作业分配资源{t=t-w[j].tap;s=s-w[j].store;w[j].state='Z';n++;if(n>2){t=t+w[j].tap;s=s-w[j].store;w[j].state='R';n++;printf("主存无法正常运行,返回\n");continue;}printf("--显示被调入主存的作业的用户名和作业名--\n");printf("%s %s\n",w[j].username,w[j].workname);continue;}}else{printf("主存中作业满载.\n");continue;}}elseprintf("请操作员输入作业。