⑴ 求一份答案。。。。不知道是什么分类的。
15分要我回答那么多？这些题目3个小时内完成不了的
简单说下吧，这题目比较复杂，涉及到汇编 C 数字逻辑等等方面
1、C D都错了，DB字节型数据H为8位由0~F组成，G在里面错且28位超过16位了
G在里面错
错误答案只有一个吧？语法错误不知道指的什么，应该是C吧
2、答案B，SCAS是扫描指令，将累加器AL（或AX）的内容与目的串（指针为ES:DI）中的字节（或字）进行比较，存储单元(DS:SI)可以自动增加或减少
其余的有高人指点最好，这题目是在太复杂了，没有的话分给我吧
⑵ 华为平板开不了机，充着电，显示着一个红闪电
请观察您的平板故障现象，按照以下对应的方法进行排查：
1、开机时平板黑屏，但是有铃声或振动
可能是屏幕问题，请提前备份好数据（QQ，微信等第三方应用需单独备份）并携带相关购机凭证到附近的华为客户服务中心检修。
2、开机时平板黑屏，无响应，或闪红灯，或亮屏后又立即关机
（1）可能是电量已耗尽，建议您使用标配充电器持续充电30分钟以上，然后再尝试开机。
（2）建议您长按电源键15秒以上，尝试强制重启平板。
（3）如果以上方法未能解决您的问题，请您提前备份好数据（QQ，微信等第三方应用需单独备份）并携带相关购机凭证到附近的华为客户服务中心检修。
3、开机进入Harmony OS界面、EMUI界面、FASTBOOT界面
（1）可能是无意按到了开机键+音量键的组合键进入了特殊模式，建议您长按电源键15秒以上，尝试强制重启平板，即可正常进入手机桌面。
（2）为避免您后续再次出现此情况，建议您检查按键是否容易卡住，或者佩戴的保护壳挤压到了按键。
（3）如果以上方法未能解决您的问题，请您提前备份好数据（QQ，微信等第三方应用需单独备份）并携带相关购机凭证到附近的华为客户服务中心检修。
⑶ 在vxworks中，period命的具体用法是怎样的
嵌入式实时操作系统VxWorks入门嵌入式 Linux 系统是标准 Linux 在嵌入式领域的延伸，其特点和功能与标准 Linux 几乎完全相同。 Linux 系统的稳定性和健壮性已经在真实世界中得到了证明，在工业控制领域也有许多非常成功的应用。但是，在针对一些有较强实时性要求的特定工业应用中， Linux 系统仍然暴露 出 了许多技术缺陷。其主要原因是因为 Linux 系统起初是为 PC 开发的，在功能和性能选择上更多的兼顾了 PC 应用的特点，追求系统的功能完备性和整体性能最优。这一点在 Linux 系统的调度策略上表现的尤为明显，如任务之间采用的是基于 分时技术 ( time-sharing ) 的调度策略，而且不支持内核态抢占式调度，这样系统就无法保证紧急任务总是会被优先执行，且调度延迟不确定，是随机可变的。
因此，有相当多机构和公司都在研究如何提高 Linux 实时性能，并取得了一些富有成效的成果。同时，开源社区也做着同样的事情，那就是 Linux 2.6 版本的开发。开源社区采用的实时化思想是直接对 Linux 内核的调度机制和算法进行修改和优化。 Linux 2.6 内核开发大约是从 2001 年开始，经过三年左右的开发，在 2004 年发布了稳定版本，经过了这几年的测试与改进，已经在桌面 PC 和服务器领域内得到了大量使用，在嵌入式系统上的应用也在不断发展中。 Linux 2.6 版本中与实时性相关的改进主要体现在以下几个方面。
⑴ 调度计算的分散性。 2.6 版本中采用了由 Ingo Molnar 实现的调度算法，该算法将进程优先级的计算分散在多处进行，而不是集中在一个统一的调度函数中，这样不仅提高了计算效率，还减小了 CPU 因集中调度计算所消耗的时间，并且使调度器的时间开销是与系统负载无关，是 O(1) 恒定的。
⑵ 抢占式内核的支持。 2.6 版本中提供了对抢占式内核的支持，而 2.4 内核是不支持内核抢占的。支持抢占式调度是实时操作系统的标志之一，这也是早期 Linux 系统应用于实时应用时最为诟病的地方。
⑶ 系统同步机制的改进。 2.6 内核中则对系统中同步机制的使用进行了优化，大大减小了因同步机制引起的时间消耗。
⑷ 更细的时间粒度。在 2.6 内核中，定时器的频率被定义为 1000Hz ，而 2.4 内核中为 100Hz 。
虽然， Linux 2.6 系统仍然不是严格实时系统，但它的实时性能得到了很大提高却是个不争的事实，有关文献采用统计的方法对 Linux 2.6 和 2.4 内核中任务响应和中断响应的进行了 310 万次测试，然后对平均响应时间和最坏响应时间进行了对比，下图 (a) 和 (b) 给出了时间比较结果。从结果可以看出 2.6 内核的实时响应能力要远高于 2.4 内核，差距至少在十多倍以上。这一结果更增强了用户将 2.6 内核应用到各种非严格实时应用中的信心。
⑷ 求一份烽火S4800基本配置
丰富的业务控制
S4800支持基于不同字段划分VLAN，并支持VLAN映射和基本QinQ，可基于端口、VLAN、流等不同关键字段对包进行分类，实现更加灵活的业务分流和多业务承载。
S4800提供扩展的ACL功能，具备L2～L4包过滤能力，支持带宽限速、优先级调度和映射，以及灵活的队列调度算法，能够通过多样化的方法实现对业务的丰富的管理功能。
S4800支持丰富的组播协议，支持IGMP Snooping、IGMP Proxy、IGMP Fast Leave等。
完备的QoS策略
S4800每个端口支持高达8个优先级队列，支持DiffServ区分服务，能够根据源MAC、目的MAC、源IP、目的IP及TCP/UDP端口等规则智能地区分不同的应用流，并支持基于端口、流、VLAN等的带宽限制，支持SP、WRR、SP +WRR等模式的调度算法及WRED丢弃算法，满足实时多媒体应用的需求，为视频、语音等实时性业务的发展提供网络基础。
可靠的网络质量
S4800支持STP/RSTP/MSTP生成树协议， 支持R-Link、G.8032以太环网保护，构建环型、树型等多种拓扑结构，并可实现以太环网的50毫秒级快速保护倒换，保证高可靠性的网络质量。
完善的安全机制
S4800提供多种安全保护功能，支持防ARP攻击，可以防止因ARP欺骗攻击将交换机ARP表项占满，导致正常用户无法上网。
同时，S4800支持IP Source Guard特性，防止包括MAC 欺骗、IP欺骗、MAC/IP欺骗在内的非法地址仿冒带来的DoS攻击。
S4800支持802.1X认证、RADIUS认证、用户绑定（端口+源MAC+源IP地址访问控制），可有效识别安全用户，防范用户的非法侵入和未经授权的访问。
S4800支持基于端口的源MAC地址学习限制功能，有效防止用户源MAC欺骗冲击设备MAC表项，导致正常用户无法学到MAC表而泛洪的问题等。
S4800还可以通过配置ACL来清除网络流量中的非法攻击，最大程度的保护网络的安全性。
灵活的PoE特性
S4800-PE严格符合IEEE 802.3af 标准及IEEE 802.3at标准，支持30W大功率网络设备长距离供电，很好的满足了用户的大功率供电需求。
此外，S4800-PE支持自动功率调节、分时供电，满足用户灵活供电配置需求。设备高效散热、静音降噪，支持绿色节能。
高效的绿色节能
S4800电口设备采用无风扇设计，大幅降低设备功耗，实现设备运行无噪音，减少机械故障点，同时免除凝露腐蚀和尘土侵害。
S4800采用新一代高集成芯片节能电路设计，散热均衡，支持空闲端口休眠，充分节省电源功耗。
S4800辐射低，达到家用电器标准，对人体无危害。
⑸ 高分急求！ 关于 粒子群解决车间调度的英文文献 ！ ！先50 满意再加50
基于动态双种群粒子群
算法的柔性工作车间调度
摘 要: 针对标准粒子群优化算法存在易陷入局部最优点的缺点,提出了一种基于动态双种群的粒子群
优化算法(DPSO) ·DPSO 算法将种群划分成两个种群规模随进化过程不断变化的子种群,两个子种群分别采
用不同的学习策略进行进化,并在进化过程中相互交换信息·该算法提高了全局寻优能力,有效地避免了早熟
收敛的发生·将以DPSO 算法为基础的排序算法和启发式分配算法(HA) 相结合形成了解决柔性工作车间调
度问题的新方法(DPSO2HA) ·通过对算例的研究和与其他方法的比较表明,该方法是有效可行的·
A Dynamic Double2Population Particle Swarm Optimization
Algorithm for Flexible Job2Shop Scheling
L I Dan , GA O L i2qun , MA Jia , L I Yang
( School of Information Science & Engineering , Northeastern University , Shenyang 110004 , China.
Correspondent : L I Dan , E2mail : lidanneu @163. com)
Abstract : A dynamic double2population particle swarm optimization ( DPSO) algorithm is
presented to solve the problem that the standard PSO algorithm is easy to fall into a locally
optimized point , where the population is divided into two sub2populations varying with their own
evolutionary learning st rategies and the information exchange between them. The algorithm thus
improves it s solvability for global optimization to avoid effectively the precocious convergence.
Then , an ordering algorithm based on DPSO is integrated with the heuristic assignation ( HA)
algorithm to form a new algorithm DPSO2HA so as to solve the flexible job2shop scheling
problem (FJ SP) . The new algorithm is applied to a set of benchmark problems as instances , and
the simulation result s show the effectiveness and feasibility of DPSO2HA algorithm for the flexible
job2shop scheling.
Key words : double population ; PSO(particle swarm optimization) ; learning st rategy ; DPSO2HA
algorithm; flexible job2shop scheling
柔性工作车间调度问题( flexible job2shop
scheling problem , FJ SP) 是经典工作车间调度
问题的一个延伸,它允许工件被给定的有处理能
力的任何机器处理·柔性工作车间调度问题由于
减少了机器约束,扩大了可行解的搜索范围,提高
了问题的复杂性,所以与传统工作车间调度问题
相比更加接近实际生产环境的模拟·
相对于传统工作车间调度,关于柔性工作车
间调度问题的文献还比较少·目前所采用的方法
主要有分枝定界法[1 ] 、多项式算法、分等级法和
传统进化算法( EA) [2 ]等,在近几年中,很多研究
者使用禁忌搜索和遗传算法对FJ SP 进行求
解[3 - 4 ]
·
本文提出一个新的求解柔性工作车间调度问
题的方法———基于动态双种群粒子群优化的分阶
段方法·本方法的主要思想是:将柔性工作车间调
度问题分解成两个有时间顺序的子问题来考虑,
首先考虑工序排序子问题,在获得可行的排序后
再考虑机器分配子问题·本文首先利用动态双种
群粒子群优化算法为工序进行排序,使其满足约
束条件从而获得一个可行解,然后利用文中所提
出的分配算法为每道工序分配合适的机器,形成
可行的调度方案·本文所考虑的优化目标是最小
化最大完工时间(makespan) ·
1 柔性工作车间调度问题描述
柔性工作车间调度问题可描述为将n 个加工
顺序不同的工件在m 台机器上加工完成·每个工
件使用同一台机器可以多于一次,每道工序的加工
过程不允许中断·机器的集合用U 来表示,每个工
件J 包含nj 道工序,各工序之间的顺序不允许改
变·Oij表示工件J 的第i 道工序,它可以在有处理
能力的任何一台机器上被加工·Ti , j , k表示工序Oij
用机器Mk 来加工所需要的时间, 可用集合T =
{ Ti , j , k| 1 ≤j ≤N ;1 ≤i ≤nj ;1 ≤k ≤M}表示, N 为
工件的数量, M 为机器的数量·例如表1 即是一个
实际的柔性工作车间调度加工时间表·
表1 柔性工作车间调度加工时间表
Table 1 Proce ssing schele for FJ SP
工件工序M1 M2 M3 M4
J1
O1 ,1 1 3 4 1
O2 ,1 3 8 2 1
O3 ,1 3 5 4 7
J2
O1 ,2 4 1 1 4
O2 ,2 2 3 9 3
O3 ,2 9 1 2 2
J3
O1 ,3 8 6 3 5
O2 ,3 4 5 8 1
在柔性工作车间调度问题中, 应满足以下假
设:
(1) 所有的机器在时间t = 0 时都是可以使
用的,每个工件都可以在t = 0 时开始加工;
(2) 在给定的时间内, 一台机器只能加工一
道工序,直到加工完此工序后方可加工其他工序,
这就是所谓的资源约束;
(3) 对于每个工件的各道工序只能按照事先
给定的顺序加工,这就是所谓的优先约束·
对于每一道工序Oi , j , 本文用ri , j来表示其
最早开始加工时间, 对不同的工序分别用下式进
行计算:
ri , j =
0 , 1 ≤ j ≤ N ;
ri - 1 , j +γi , j , 2 ≤ i ≤ nj ,1 ≤ j ≤ N ·
式中,γi , j = mink ( Ti , j , k) ,1 ≤i ≤nj ;1 ≤j ≤N·
对于FJ SP 来说一般存在两个难题:第一个
是如何为每道工序选择合适的机器;第二个是如
何计算每道工序的开始加工时间t i , j和结束加工
时间tf i , j·
本文所要研究的FJ SP 的优化目标是,在满
足上述优先约束和资源约束的条件下寻找最优调
度方案,使全部工件的最大完工时间(Makespan)
最短·
2 排序算法———动态双种群粒子群
优化算法
2. 1 标准粒子群优化算法
粒子群优化(particle swarm optimization ,简
称PSO) 算法是由Kennedy 和Eberhart 在1995
年提出·在PSO 系统中,每个潜在解被称为一个
粒子,多个粒子共存、合作寻优,每个粒子根据它
自身的经验在目标搜索空间中向更好的位置飞
行,搜索最优解·由文献[ 5 ]可知,每个粒子根据如
下的公式来更新自己的速度和在解空间的位置·
v ( t +1)
id = w v ( t)
id + c1 r1 p ( t)
id - x ( t)
id +
c2 r2 p ( t)
gd - x ( t)
id , (1)
x ( t +1)
id = x ( t)
id + v ( t +1)
id · (2)
其中, d = 1 ,2 , ⋯, n , i = 1 ,2 , ⋯, m , m 为种群规
模; t 为当前进化代数; r1 和r2 为均匀分布于[0 ,
1]的随机数; w 为惯性权重, 其值由下式来确
定[6 ] :
w = w max -
w max - w min
itermax
×iter · (3)
式中, w max , w min分别是w 的最大值和最小值;
iter ,itermax分别是当前迭代次数和最大迭代次数·
2. 2 粒子群优化算法的学习策略
由标准粒子群优化算法可知,粒子通过跟踪
自己迄今为止所找到的最优解和种群迄今为止所
找到最优解这两个极值来更新自己的速度,从而
更新自己的位置·这种行为也可以理解为,粒子在
借鉴自身和整个群体所取得的成功经验,通过对
以往的成功经验的学习获得有用的信息,指导自
己下一步的行动策略·但人们也常说“失败乃成功
之母”“, 吃一堑,长一智”,可见从一些失败的尝试
中也可以获得有用的信息,基于这一点,提出了新
的粒子群优化算法学习策略,这就是从以往的失
败中获得有价值的信息,使粒子远离粒子本身和
整个群体所找到的最差的位置,从而更新粒子的
速度和位置·粒子在搜索过程中的失败可以表现
为搜索到的具有较差适应值的位置,记第i 个粒
子迄今为止搜索到的最差位置为si = ( si1 , si2 ,
⋯, sin) ,整个粒子群迄今为止搜索到的最差位置
为sg = ( sg1 , sg2 , ⋯, sg n) ,则第i 个粒子的速度和
位置更新公式如下:
v ( t +1)
id = w v ( t)
id + c1 r1 x ( t)
id - s ( t)
id +
c2 r2 x ( t)
id - s ( t)
gd , (4)
x ( t +1)
id = x ( t)
id + v ( t +1)
id · (5)
如果只是利用上述的位置和速度更新公式更
新粒子,也就是说只是从失败中获取经验,这与实
际经验不符·一般来说,还是更多地从成功的经历
中获取信息,而从失败的经历中获得相对少的信
息,基于这一点本文的算法同时从成功和失败的
经历中获取信息来更新粒子·
2. 3 动态双种群粒子群优化算法
由上面的叙述可以知道粒子群中的粒子可以
按照不同的学习策略进行学习,对速度和位置作
出更新·所以本文将一个种群分成两个子种群,每
个子种群选用不同的学习策略,即第一个子种群
中的粒子选用从成功经历中获得学习信息的策
略,更新自己;第二个子种群中的粒子选用从失败
的经历中获得学习信息的策略进行进化·本文可
以设置一个比例系数ρ来控制两个子种群中粒
子的个数·
ρ =
m1
m2
, m1 + m2 = m · (6)
式中, m 为粒子群中的粒子总数; m1 为第一个子
种群中的粒子个数; m2 为第二个子种群中的粒
子个数·
为了使每个粒子都能从自身和群体的经历中
获得充分的学习, 本文规定两个子种群中的粒子
是不断变化的, 即每隔一定的代数后将整个种群
按照比例系数ρ重新随机划分成两个子种群·从
粒子群优化算法的进化过程中知道在优化的初期
粒子的位置比较分散, 得到较优值和较差值的机
会相差不多,所以此时采用上述两种不同学习策
略的粒子的个数应大致相等·在优化搜索的后期
粒子将聚集在最优值的附近,这时将很难出现比
历史最差值更差的值了,第二个子种群将从失败
经历中得不到太多的有价值的信息·此时第二个
子种群中的粒子数应该远远小于第一个子种群中
的粒子个数,直至完全采用跟踪最优值来更新粒
子,即第二个子种群消亡·基于上述原因将ρ设
为一个线性变化的量,其值由下式确定:
ρ = ρmax -
ρmax - ρmin
018 ×itermax
×iterc · (7)
式中,ρmax和ρmin分别是ρ的最大值和最小值;
iterc 和itermax分别是种群重新划分时的进化代数
和最大进化代数·
动态双种群粒子群优化算法的实现步骤如
下:
(1) 设PSO 种群规模为m , 加速常数为c1
和c2 ,惯性权重的最大值和最小值为w max , w min ,
比例系数ρ的最大值和最小值为ρmax ,ρmin ,种群
重新划分代数iterc ,最大进化代数为Tmax·将当前
进化代数置为t = 1 ;
(2) 在解空间中初始化粒子的速度和位置;
(3) 将种群按照比例系数ρ划分为两个子种
群;
(4) 按式(3) 更新惯性权重w , 按式(7) 更新
比例系数ρ, 第一个子种群按式(1) 和(2) 更新粒
子速度和位置,第二个子种群按式(4) 和(5) 更新
子种群中的粒子,从而产生新种群Xt ;
(5) 评价种群Xt·将第i 个粒子当前点适应
值与该粒子迄今找到的最优位置pi (最差位置
si) 的适应值进行比较, 若更优(差) , 则更新pi
( si) ,否则保持pi ( si) 不变,再与种群迄今找到的
最优位置pg (最差位置sg) 的适应值进行比较,若
更优(差) ,则更新pg ( sg) ;否则保持pg ( sg) 不变;
(6) 检查是否满足寻优结束条件, 若满足则
结束寻优, 求出最优解; 否则, 置t = t + 1 , 转至
(3) ;结束条件为寻优达到最大进化代数Tmax·
2. 4 基于动态双种群粒子群优化算法的工序排序
2. 4. 1 粒子的编码和解码
根据第1 节对柔性工作车间调度问题的描
述,本文定义所有工件的总工序数L = 6n
j =1
nj ,把
一个粒子表示为一个L 维的向量·对所有工序进
行连续编号,即为每道工序指定一个固定的编号·
例如可以对表1 所给出的例子中的工序进行编
号,如表2 所示,则粒子的位置向量x [ L ]就是由
一组连续的自然数组成的L 维的向量,自然数的
顺序决定了工序调度的顺序·xi = [1 ,7 ,2 ,4 ,8 ,3 ,
5 ,6 ]就表示了一个满足优先约束的可行的工序排
序·
表2 工序编号
Table 2 Serial numbers of operations
工序O1 ,1 O2 ,1 O3 ,1 O1 ,2 O2 ,2 O3 ,2 O1 ,3 O2 ,3
编号1 2 3 4 5 6 7 8
2. 4. 2 位置向量和速度向量的更新
对每个粒子, 粒子的速度向量可以用v [ L ]
表示·按照上面所述的更新公式对x [ L ] , v [ L ]
进行更新·由于粒子群优化算法经常用在连续空
间上,而柔性工作车间调度问题为整数规划问题
而且有工序先后顺序约束,所以将粒子群算法用
于柔性工作车间调度问题时,在速度和位置更新
方式上要做如下的修改:令粒子i 的当前的位置
为xi = [1 , 7 , 2 , 4 , 8 , 3 , 5 , 6 ] , 在经过一次迭代以
后位置向量变为xi = [ 2. 5 , 6. 7 , 3. 6 , 5. 9 , 8. 5 ,
112 ,4. 1 ,7. 6 ]·位置向量里存放的是工序的编号,
很明显不能为小数, 本文对迭代后的位置向量进
行如下的处理:将更新后的位置向量中各分量的
值按照由小到大的顺序进行排列, 并为其进行重
新编号:1. 2 (1) < 2. 5 (2) < 3. 6 (3) < 4. 1 (4) < 5. 9
(5) < 6. 7 (6) < 7. 6 (7) < 8. 5 (8) ,式中括号内的数
字为该分量的编号, 然后位置向量中各分量用其
获得的相应的编号代替·例如,第一个分量2. 5 用
编号2 代替,第二个分量6. 7 用编号6 代替等等,
此时位置向量变为xi = [2 , 6 , 3 , 5 , 8 , 1 , 4 , 7 ]·但
是这个工序排序不满足优先约束,还要对其进行
调整,使其满足约束条件·例如第一个分量2 代表
的是工序O21 ,第6 个分量1 代表的是工序O11 ,
工序O21应在工序O11之后进行加工, 所以要对
其进行调整·调整的方法为:对属于同一个工件的
工序调换其相应先后位置使其满足约束, 对每个
工件都做相似的处理, 则可以得到满足优先级约
束的位置向量: xi = [1 ,4 ,2 ,5 ,7 ,3 ,6 ,8 ]·
3 启发式分配算法
通过上一节介绍的排序算法本文可以获得一
个满足工序优先约束的可行的工序序列·这一节
通过一个启发式算法为这一工序序列中的每一工
序分配一台合适的机器对其进行加工·
本文所采用的分配算法的主要思想是:选择
一台能使本道工序获得最小完工时间的机器分配
给待加工的工序·可以用如下公式表示选择机器
Mk 分配给待加工的工序以使本道工序的完工时
间最短:
tf i , j = min k ( ri , j + Ti , j , k) ,
ri , j = max ( rpfk , ropf) ·
式中, tf i , j 为工序Oi , j 的完工时间; ri , j 为工序的
开始加工时间; Ti , j , k为工序用机器k 加工消耗的
时间; rpfk为机器Mk 当前状态下所加工的最后一
个工件的完工时间; ropf为待加工工序紧前工序的
完工时间·
利用排序算法和分配算法就可以获得一个满
足优先约束和资源约束的可行的调度方案, 并且
利用分配算法还可以得到目标函数———全部工件
的最大完工时间的值·
将前面介绍的排序算法和分配算法综合起来
便形成本文所采用的处理柔性工作车间调度优化
问题的方法,记为DPSO2HA·该方法将柔性工作
车间调度问题分解为两个子问题———排序问题和
分配问题,在每一次迭代中首先通过动态双种群
粒子群算法获得一个可行的工序序列, 然后利用
分配算法给该序列分配合适的机器并计算目标函
数值,直至达到最大进化代数·
4 算例仿真
4. 1 仿真研究1
本文选用文献[ 7 ]中的一个10 ×10 (10 个工
件,10 台机器) ,30 道工序的柔性工作车间调度问
题来计算最大完工时间·实验参数如下:粒子群的
种群规模为m = 30 , c1 = c2 = 2 ,ρmax = 015 ,ρmin =
0 ,每隔5 代重新划分种群,最大迭代次数Tmax =
150·
实验中采用本文所提出的算法运行10 次,和
传统的GA 方法、文献[8 ]中采用的MSA 算法相
比较,比较结果如表3 所示·
表3 实验结果比较
Table 3 Comparison of te sting re sults
方 法最优值平均值标准偏差
GA 8 11. 5 2. 67
MSA 7 7. 9 0. 97
DPSO2HA 7 7. 1 0. 32
从表3 中可以看出DPSO2HA 求得的平均值
和标准偏差都明显优于GA 和VEGA , 这说明
DPSO2HA 的精度与稳定性明显优于GA 和
VEGA 算法·实验中所获得的一个较优的调度方
案的甘特图如图1 所示·图中方框内的数字“i . j”
表示第j 个工件的第i 道工序·,
（不好意思，图粘贴不下来，要不你告我邮箱）
图1 柔性工作车间调度优化结果
Fig. 1 Optimization solution to the problem
10 ×10 with 30 operations
4. 2 仿真研究2
为了进一步对本文提出的算法的性能加以验
证,选用文献[ 9 ]中所给出的实验数据,利用本文
提出的算法进行求解,并将调度结果与文献[ 9 ]及
文献[ 10 ]中所提算法的调度结果加以比较·比较
结果如表4 所示·
表4 不同方法的调度结果比较
Table 4 Comparison of different scheling re sults
算例描述Brandimarte GENACE DPSO2HA
MK1 10 ×6 42 41 40
MK2 10 ×6 32 29 28
MK4 15 ×8 81 67 61
MK5 15 ×4 186 176 173
MK6 10 ×15 86 68 62
MK7 20 ×5 157 148 141
MK8 20 ×10 523 523 523
MK9 20 ×10 369 328 307
MK10 20 ×15 296 231 207
由上述的比较结果可以看出,本文所提出的
DPSO2HA 方法对上述算例的求解结果较另外两
种方法有了较大的提高·
5 结 论
本文提出了一种动态双种群粒子群优化算法
(DPSO) ·DPSO 将种群划分成两个种群规模随进
化过程不断变化的子种群,两个子种群分别采用
不同的学习策略进行进化,并在进化过程中相互
交换信息·该算法在保持PSO 算法高效简单的基
础上提高了全局寻优能力·将以DPSO 算法为基
础的排序算法和启发式分配算法相结合形成了解
决柔性工作车间调度问题的新方法·通过对算例
的研究和与其他方法的比较表明,该方法是有效
可行的·
参考文献:
[ 1 ] Carlier J , Pinson E. An algorithm for solving the job2shop
problem[J ] . Management Science , 1989 ,35 (2) :164 - 176.
[ 2 ] Reynolds R G. An introction to cultural algorithms[ C] ‖
Proceedings of the Third Annual Conference on Evolutionary
Programming. River Edge : World Scientific , 1994 : 131 -
139.
[ 3 ] Mastrolilli M , Gambardella L M. Effective neighborhood
functions for the flexible job shop problem[ J ] . Journal of
Scheling , 2002 ,3 (1) :3 - 20.
[ 4 ] Kacem I , Hammadi S , Borne P. Pareto2optimality approach
for flexible job2shop scheling problems : hybridization of
evolutionary algorithms and fuzzy logic[J ] . Mathematics and
Computers in Simulation , 2002 ,60 (3) :245 - 276.
[ 5 ] Kennedy J , Eberhart R. Particle swarm optimization [ C] ‖
Proceedings of IEEE International Conference on Neural
Networks. Perth : IEEE Press , 1995 :1942 - 1948.
[ 6 ] Shi Y, Eberhart R C. Empirical study of particle swarm
optimization [ C ] ‖Proceedings of the 1999 Congress on
Evolutionary Computation. Washington , 1999 : 1945 -
1950.
[ 7 ] Xia WJ , Wu Z M. An effective hybrid optimization approach
for multi2objective flexible job2shop scheling problems[J ] .
Computers & Inst rial Engineering , 2005 ,48 (2) :409 -
425.
[ 8 ] Najid N M , Stephane D P , Zaidat A. A modified simulated
annealing method for flexible job shop scheling problem[C]
‖Proceedings of the IEEE International Conference on
Systems , Man and Cybernetics. Hammamet : IEEE Press ,
2002 :89 - 94.
[ 9 ] Brandimarte P. Routing and scheling in a flexible job shop
by tabu search[J ] . A nnals of Operations Research , 1993 ,41
(3) :158 - 183.
[ 10 ] Ho N B , Tay J C. GENACE: an efficient cultural algorithm
for solving the flexible job2shop problem[C] ‖Proceedings of
the IEEE Congress on Evolutionary Computation. Portland :
IEEE Press , 2004 :1759 - 1766.
（do you know）
⑹ 主存空间的分配和回收，
#include "iostream.h"
#include "iomanip.h"
#define nofreearea 2
#define noadequacyarea 3
#define allocated 4
#define noprocess 2
#define nosuchprocess 3
#define reclaimed 4
typedef struct TUN
{
int address;
int size;
char name;
struct TUN *next;
} usedarea , *usedtable;
typedef struct TFN
{
int address;
int size;
struct TFN *next;
} freearea, *freetable;
usedtable usedTable = NULL;
freetable freeTable = NULL;
int alloc( char processname , int processsize )
{
if( freeTable == NULL )
return 1;
freetable p = freeTable;
freetable q = p;
while( p != NULL && p->size < processsize )
{
q = p;
p = p->next;
}
if( p == NULL )
return 3;
usedtable x = new usedarea;
x->address = p->address;
x->size = processsize;
x->name = processname;
x->next = NULL;
if( p->size > processsize )
{
p->size -= processsize;
p->address += processsize;
}
else
{
if( p == freeTable )
freeTable = NULL;
else
q->next = p->next;
delete p;
}
usedtable r = usedTable;
usedtable t = r;
while( r != NULL && r->address < x->address )
{
t = r;
r = r->next;
}
if( usedTable == NULL )
usedTable = x;
else
{
x->next = r;
t->next = x;
}
return 4;
}
int Reclaim( char processname )
{
if( usedTable == NULL )
return 1;
usedtable p = usedTable;
usedtable q = p;
while( p != NULL && p->name != processname )
{
q = p;
p = p->next;
}
if( p == NULL )
return 3;
freetable r = freeTable;
freetable t = r;
freetable x;
while( r != NULL && r->address < p->address )
{
t = r;
r = r->next;
}
x = new freearea;
x->address = p->address;
x->size = p->size;
x->next = NULL;
if( r == freeTable )
{
x->next = r;
freeTable = x;
t = freeTable;
}
else
{
x->next = r;
t->next = x;
}
while( t->next != NULL && t->address + t->size == t->next->address )
{
t->size += t->next->size;
r = t->next;
t->next = t->next->next;
delete r;
}
if( p == usedTable )
{
usedTable = usedTable->next;
}
else
q->next = p->next;
delete p;
return 4;
}
int Init()
{
freeTable = new freearea;
freeTable->address = 0;
freeTable->size = 128;
freeTable->next = NULL;
return 1;
}
void processrequest()
{
char processname;
int processsize;
cout<<"...................."<<endl;
cout<<"作业名: ";
cin >> processname;
cout<<"作业长度: ";
cin >> processsize;
if(processsize<=128)
{int i;
if( alloc( processname , processsize) == 4 )
{
i=i+processsize;
if(i>128)
{cout<<"该作业超出空间"<<endl;
}
if(i<=128)
cout<<"该作业已成功获得所需空间"<<endl;
i=i+processsize;
cout<<"........................................"<<endl;
}
else
cout<<"该作业超出空间,没有获得所需空间"<<endl;
cout<<"........................................"<<endl;
return;
}
if(processsize>128)
{cout<<"该作业超出空间"<<endl;
cout<<"........................................"<<endl;
}
}
void processreclaim()
{
int processname;
cout<<"...................."<<endl;
cout<<"作业名: ";
cin >>processname;
int result = Reclaim( processname );
if( result == 4 )
cout<<"该作业已成功回收"<<endl;
else if( result == 2 || result == 1 )
cout<<"系统没有作业或该作业不存在"<<endl;
cout<<"...................."<<endl;
}
void freeTablePrint()
{
cout<<endl<<endl<<endl<<"***********************************"<<endl;
cout<<setw(10)<<"address"<<setw(10)<<"length"<<setw(10)<<"state"<<endl<<endl;
freetable p = freeTable;
usedtable q = usedTable;
int x , y;
while( p || q )
{
if( p )
x = p->address;
else
x = 0x7fffffff;
if( q )
y = q->address;
else
y = 0x7fffffff;
if( x < y )
{
cout<<setw(10)<<p->address<<setw(10)<<p->size<<setw(10)<<"空闲"<<endl;
p = p->next;
}
if( x > y )
{
cout<<setw(10)<<q->address<<setw(10)<<q->size<<setw(10)<<"已分配"<<setw(10)<<"ID="<<q->name<<endl;
q = q->next;
}
}
cout<<endl<<endl<<endl<<"************************************"<<endl<<endl<<endl;
}
void main()
{
Init();
int choose;
bool exitFlag = false;
while( !exitFlag )
{
cout<<"************************0 - 退出 ************************"<<endl;
cout<<"************************1 - 分配主存 ************************"<<endl;
cout<<"************************2 - 回收主存 ************************"<<endl;
cout<<"************************3 - 显示主存 ************************"<<endl<<endl<<endl;
cout<<"************************选择所要执行的操作:";
cin>>choose;
switch( choose )
{
case 0:
exitFlag = true;
break;
case 1:
processrequest();
break;
case 2:
processreclaim();
break;
case 3:
freeTablePrint();
break;
}
}
}
⑺ 关于操作系统的内存管理问题，100分请高手，答案好的再加100分！急！就今天！请最好用C或C++编写。谢谢！
#include <iostream.h>
#include <stdio.h>
#include <string.h>
struct program
{
char name[30];
long start;
long length;
struct program *next;
};
struct space
{
long start;
long length;
struct space *next;
};
void creat();
void allot();
void back();
void callback(program *r);
void sort(space *L);
void sort(program *S);
void display(space *L);
void display(program *S);
space *L;
program *S;
void creat()
{
L=new space;
space *p=new space;
p->start=0;
p->length=128;
p->next=NULL;
L->next=p;
S=new program;
S->next=NULL;
}
void allot()
{
program *q;
q=new program;
cout<<"请输入进程名和占用空间大小:"<<endl;
cin>>q->name>>q->length;
if(q->length<=0)
{
cout<<"进程空间大小错误."<<endl;
delete q;
return;
}
space *p,*r;
p=L;
r=p;
while(p->next!=NULL&&p->next->length<q->length)
{
r=p;
p=p->next;
}
if(p->next==NULL)
{
cout<<"占用空间过大，分配失败"<<endl;
delete q;
return;
}
else
{
q->start=p->next->start;
q->next=S->next;
S->next=q;
p->next->length-=q->length;
if(p->next->length!=0)
p->next->start+=q->length;
else
{
if(p->next->next!=NULL)
p->next=p->next->next;
else
{
r->next=NULL;
delete p->next;
}
}
}
display(L);
display(S);
}
void back()
{
char name[30];
cout<<"输入要回收的进程名：";
cin>>name;
program *p;
p=S;
while(p->next!=NULL)
{
if(strcmp(p->next->name, name)==0)
{
callback(p);
return;
}
p=p->next;
}
if(p->next==NULL)
cout<<"此进程不存在,内存回收失败"<<endl;
}
void callback(program *t)
{
program *r;
r=t->next;
space *p,*q;
long n;
n=r->length;
if(L->next==NULL)
{
space *w=new space;
w->start=0;
w->length=n;
w->next=NULL;
L->next=w;
t->next=r->next;
delete r;
cout<<"此进程内存回收完毕."<<endl;
display(L);
display(S);
return;
}
p=L->next;
while(p!=NULL&&p->start<r->start)
{
q=p;
p=p->next;
}
if((q->start+q->length==r->start)&&(r->start+n==p->start)) //上下均空
{
q->next=p->next;
q->length=q->length+p->length+n;
t->next=r->next;
delete r;
}
else if(r->start+n==p->start) //下邻空
{
p->start-=n;
p->length+=n;
t->next=r->next;
delete r;
}
else if(q->start+q->length==r->start)
{
q->length+=n;
t->next=r->next;
delete r;
}
else
{
space *sp=new space;
sp->start=r->start;
sp->length=n;
sp->next=L->next;
L->next=sp;
t->next=r->next;
delete r;
}
cout<<"此进程内存回收完毕."<<endl;
display(L);
display(S);
}
void display(space *L)
{
sort(L);
space *p=L->next;
cout<<endl<<"空闲区情况："<<endl;
if(p==NULL)
{ cout<<"无空闲区了."<<endl; return;}
while(p!=NULL)
{
cout<<"起始地址:"<<p->start<<" 长度:"<<p->length<<endl;
p=p->next;
}
}
void display(program *S)
{
sort(S);
program *p=S->next;
cout<<endl<<"进程内存分配情况："<<endl;
if(p==NULL)
{ cout<<"内存中无进程."<<endl; return;}
while(p!=NULL)
{
cout<<"进程名:"<<p->name<<" 起始地址:"<<p->start<<" 长度:"<<p->length<<endl;
p=p->next;
}
cout<<endl;
}
void sort(space *L) //链表排序
{
space *p=L->next, *q, *r;
if(p!=NULL)
{
r=p->next;
p->next=NULL;
p=r;
while(p!=NULL)
{
r=p->next;
q=L;
while(q->next!=NULL&&q->next->start<p->start)
q=q->next;
p->next=q->next;
q->next=p;
p=r;
}
}
}
void sort(program *S) //链表排序
{
program *p=S->next, *q, *r;
if(p!=NULL)
{
r=p->next;
p->next=NULL;
p=r;
while(p!=NULL)
{
r=p->next;
q=S;
while(q->next!=NULL&&q->next->start<p->start)
q=q->next;
p->next=q->next;
q->next=p;
p=r;
}
}
}
void main()
{
creat();
int a;
cout<<" 内存分配与回收模拟"<<endl;
cout<<"1:分配内存"<<endl;
cout<<"2:回收内存"<<endl;
cout<<"0:退出"<<endl;
while(1)
{
cout<<endl<<"请按键选择：";
cin>>a;
if(a>2||a<0)
{
cout<<endl<<"输入错误，请重新输入：";
continue;
}
switch(a)
{
case 1: allot(); break;
case 2: back(); break;
case 0: goto end;
}
}
end:
getchar();
}
#include "iostream.h"
#include "iomanip.h"
#define ERR_NOFREEAREA 1
#define ERR_NOADEQUACYAREA 2
#define ERR_ALLOCATED 4
#define ERR_NOJOBS 1
#define ERR_NOSUCHJOB 2
#define ERR_RECLAIMED 4
typedef struct tagUsedNode
{
long address;
long length;
int flag; //作业名
struct tagUsedNode *next;
} USED_AREA , *USED_TABLE;
typedef struct tagFreeNode
{
long address;
long length;
struct tagFreeNode *next;
} FREE_AREA , *FREE_TABLE;
//空闲区、作业区链表
USED_TABLE usedTable = NULL;
FREE_TABLE freeTable = NULL;
//给作业分配空间
//jobname: 作业名
//jobsize: 作业所需空间大小
int Allocate( int jobname , long jobsize )
{
//如果没有空闲区
if( freeTable == NULL )
return ERR_NOFREEAREA;
FREE_TABLE p = freeTable;
FREE_TABLE q = p;
//找首次适应空闲区
while( p != NULL && p->length < jobsize )
{
q = p;
p = p->next;
}
//如果找不到有足够空间的分区
if( p == NULL )
return ERR_NOADEQUACYAREA;
USED_TABLE x = new USED_AREA;
x->address = p->address;
x->length = jobsize;
x->flag = jobname;
x->next = NULL;
//如果该分区大于作业需求，空间大小减去作业大小
if( p->length > jobsize )
{
p->length -= jobsize;
p->address += jobsize;
}
//如果该分区等于作业大小，删除该分区
else
{
if( p == freeTable )
freeTable = NULL;
else
q->next = p->next;
delete p;
}
//作业加入“作业表”中
USED_TABLE r = usedTable;
USED_TABLE t = r;
while( r != NULL && r->address < x->address )
{
t = r;
r = r->next;
}
if( usedTable == NULL )
usedTable = x;
else
{
x->next = r;
t->next = x;
}
return ERR_ALLOCATED;
}
//回收作业空间
//jobname: 作业名
int Reclaim( int jobname )
{
if( usedTable == NULL )
return ERR_NOJOBS;
USED_TABLE p = usedTable;
USED_TABLE q = p;
while( p != NULL && p->flag != jobname )
{
q = p;
p = p->next;
}
//如果没有该作业
if( p == NULL )
return ERR_NOSUCHJOB;
//回收后的空间加入到空闲区
FREE_TABLE r = freeTable;
FREE_TABLE t = r;
FREE_TABLE x;
while( r != NULL && r->address < p->address )
{
t = r;
r = r->next;
}
x = new FREE_AREA;
x->address = p->address;
x->length = p->length;
x->next = NULL;
if( r == freeTable )
{
x->next = r;
freeTable = x;
t = freeTable;
}
else
{
x->next = r;
t->next = x;
}
//合并分区
while( t->next != NULL && t->address + t->length == t->next->address )
{
t->length += t->next->length;
r = t->next;
t->next = t->next->next;
delete r;
}
//删除该作业
if( p == usedTable )
{
usedTable = usedTable->next;
}
else
q->next = p->next;
delete p;
return ERR_RECLAIMED;
}
int Init()
{
freeTable = new FREE_AREA;
freeTable->address = 0;
freeTable->length = 1024;
freeTable->next = NULL;
return 1;
}
void jobrequest()
{
int jobname;
int jobsize;
cout<<"...................."<<endl;
cout<<"作业名: ";
cin >> jobname;
cout<<"作业长度: ";
cin >> jobsize;
if( Allocate( jobname , jobsize ) == ERR_ALLOCATED )
cout<<"该作业已成功获得所需空间"<<endl;
else
cout<<"该作业没有获得所需空间"<<endl;
cout<<"...................."<<endl;
}
void jobreclaim()
{
int jobname;
cout<<"...................."<<endl;
cout<<"作业名: ";
cin >>jobname;
int result = Reclaim( jobname );
if( result == ERR_RECLAIMED )
cout<<"该作业已成功回收"<<endl;
else if( result == ERR_NOSUCHJOB || result == ERR_NOJOBS )
cout<<"系统没有作业或该作业不存在"<<endl;
cout<<"...................."<<endl;
}
void freeTablePrint()
{
cout<<"........................................"<<endl;
cout<<setw(10)<<"address"<<setw(10)<<"length"<<setw(10)<<"state"<<endl<<endl;
FREE_TABLE p = freeTable;
USED_TABLE q = usedTable;
int x , y;
while( p || q )
{
if( p )
x = p->address;
else
x = 0x7fffffff;
if( q )
y = q->address;
else
y = 0x7fffffff;
if( x < y )
{
cout<<setw(10)<<p->address<<setw(10)<<p->length<<setw(10)<<"空闲"<<endl;
p = p->next;
}
if( x > y )
{
cout<<setw(10)<<q->address<<setw(10)<<q->length<<setw(10)<<"已分配"<<setw(10)<<"ID="<<q->flag<<endl;
q = q->next;
}
}
cout<<"........................................"<<endl;
}
void main()
{
Init();
int choose;
bool exitFlag = false;
while( !exitFlag )
{
cout<<"选择功能项 ( 0 - 退出 1 - 分配主存 2 - 回收主存 3 - 显示主存 )"<<endl;
cout<<"?>";
cin>>choose;
switch( choose )
{
case 0:
exitFlag = true;
break;
case 1:
jobrequest();
break;
case 2:
jobreclaim();
break;
case 3:
freeTablePrint();
break;
}
}
}
⑻ 篮球让分胜负奖金怎么算的
每场比赛赛果的sp乘以本金就是奖金了
比如 ：两场sp都是2.0，本金是2块。就是2×2×2=8
⑼ 东秦的操作系统答案
一、 选择题：（每题1分，共10分）
1、（B）的主要特点是提供即时响应和高可靠性。生产过程的控制、武器系统、
航空订票系统、银行业务就是这样的系统。
A.分时系统 B.实时系统 C.批处理系统 D.分布式系统
2、下列进程状态的转换中，哪一个是不正确的(C)。
A.就绪一运行 B.运行一就绪 C.就绪一阻塞 D.阻塞一就绪
3、利用信号量实现进程的（B），应为临界区设置一个信号量mutex，其初值
为1，表示该资源尚未使用，临界区应置于P（mutex）和V（mutex）原语
之间。
A.同步 B.互斥 C.竞争 D.合作
4、作业调度的关键在于(B)。
A.选择恰当的进程管理程序 B.选择恰当的作业调度算法
C.用户作业准备充分 D.有一个较好的操作环境
5、下列存储管理方案中，不采用动态重定位的是（C）。
A.页式管理 B.可变分区 C.固定分区D.段式管理
6、关于虚拟存储器，以下说法正确的是（D）。
A.可提高计算机运算速度的设备 B.容量扩大了的主存实际空间
C.通过SPOOLING 技术实现的 D.可以容纳和超过主存容量的多个作业
同时运行的一个地址空间
7、下面几个设备中，（C）是共享设备。
A.打印机 B.磁盘 C.读卡机 D.扫描仪
8、文件系统采用多级目录结构的目的,不包括是（B）
A.缩短访问文件的寻找时间 B.节省存储空间
C.解决文件的命名冲突 D.易于实现文件共享
9、磁盘驱动调度算法中（B）算法可能会随时改变移动臂的运动方向。
A.电梯调度 B.先来先服务 C.扫描 D.循环扫描
10、正在运行的进程在信号量S上作P操作之后，当S<0的时候，进程进入信号量的
（A）。
A.等待队列 B.提交队列 C.后备队列 D.就绪队列
二、填空题：（每空1分，共15分）
1、不论是分时系统、实时系统还是批处理系统都具有四个基本特征 并发 、
共享 、 虚拟 、 异步 。
2、特权指令只能在__系统 _态下执行，若在用户态下执行则被认为是非法指令。
3、__PCB______是进程存在的唯一标志。
4、设基址寄存器内容为1000，在采用动态重定位的系统中，当执行指令
“LOAD A,2000”时，操作数的实际地址是__3000_________。
5、按照调度的层次我们把调度分为 高级 、 低级 、 中级 。
6、根据文件的逻辑结构，文件可以分为 有结构文件 和__无结构文件_两类。
7、目前常用的外存分配方法有：连续分配、_链接______分配、 索引 分配。
三、名词解释（每题3分，共12分）
1、操作系统：
操作系统是一组控制和管理计算机硬件和软件资源、合理地对各类作业进行调度、以及方便用户的程序的集合。
2、临界区：
每个进程中访问临界资源的那段代码称为临界区
3、对换：所谓对换，是指把内存中暂不能运行的进程，或暂不用的程序和数据，换出到外存上，以腾出足够的内存空间，把已具备运行条件的进程，或进程所需的程序和数据，换入内存
4、设备独立性：
应用程序独立于具体的物理设备。
四、简单题（每题6分，共24分）
1、比较程序、进程的区别。
进程是动态的，程序是静态的，程序是有序代码的集合；进程是程序的执行；进程是暂时的，程序的永久的，进程是一个状态变化的过程，程序可长久保存；进程与程序的组成不同，进程的组成包括程序、数据和进程控制块（即进程状态信息）；通过多次执行，一个程序可对应多个进程；通过调用关系，一个进程可包括多个程序。
2、什么是死锁？死锁预防的措施有哪些？
所谓死琐，是指多个进程因竞争资源而造成的一种僵局，若无外力作用，这些进程都将永远不能再向前推进。
死锁预防的措施有：屏弃“请求和保持”条件，屏弃“不剥夺”条件，， 摒弃“环路等待”条件。
3、简述分页与分段的主要区别
（1）页是信息的物理单位，已削减内存零头，提高内存利用率为目的，而
不是用户的需求。段是信息的逻辑单位，具有相对完整的意义，是
为了满足用户的需求。
（2）页的大小固定，由系统确定。段的大小不固定，决定于用户编写的程序。
（3）分页的作业地址是一维的。分段的作业地址是二维的。
4、什么是局部性原理？什么是抖动？你有什么办法减少系统的抖动现象？
局部性原理是指在几乎所有程序的执行过程中，在一段时间内，CPU总是集中地访问程序中的某一个部分而不是对程序的所有部分具有平均的访问概率。
抖动是指当给进程分配的内存小于所要求的工作区时，由于内存外存之间交换频繁，访问外存的时间和输入输出处理时间大大增加,反而造成CPU因等待数据而空转,使得整个系统性能大大下降。
在物理系统中，为了防止抖动的产生，在进行淘汰或置换时，一般总是把缺页进程锁住，不让其换出，从而防止抖动的产生。
防止抖动产生的另一个办法是设置较大的内存工作区。
五、应用与计算（共39分）
1、现有一个具有n个缓冲区的缓冲池，Proce进程把它生产的消息放入一个缓冲区，Consumer进程可从一个缓冲区中取得一个消息消费。用信号量实现生产者和消费者之间的同步与互斥。请将下面的生产者和消费者算法补充完整。生产者和消费者对缓冲池互斥访问的信号量为SM，缓冲池的初值SB=n，缓冲池中消息个数初值为SP=0。（本题9分）
初值设置
SM= 1 ；SB=n；sp=0
P生产者：
While(1)
{...
Procer an item
Wait( SB )
Wait(SM)
缓冲操作
Singal(SM
Singal( SB )
…
}
C消费者：
While(1)
{...
Wait(SB )
Wait(SM
缓冲操作
Singal(SM
Singal(SB )
Consume the item
…
}
2、银行家算法中，若出现下述的资源分配情况：
Process Allocation Need Available
P0 0 , 1 , 0 7 , 4 , 3 3 , 3 , 2
P1 2 , 0 , 0 1 , 2 , 4
P2 3 , 0 , 2 6 , 5 , 0
P3 2 , 1 , 1 0 , 1 , 1
P4 0 , 0 , 2 4 , 3 , 1
试问：（1）当前系统状态是否安全？如果安全写出安全序列。（7分）
（2）若进程P1 提出请求 Request ( 1 , 0 , 2 ) 后，系统能否将资源分配给它？（3分）
（1）存在如下进程序列，可使进程顺利执行完毕：
进程 可用资源数
P3：执行完 5 ，4 ，3
P4：执行完 5 ，4 ，5
P1：执行完 7 ，4 ，5
P0：执行完 7 ，5 ，5
P2：执行完 10 ，5 ，7
当前系统是安全的，安全序列是：P3 , P4 , P1 , P0 , P2 . （8分）
(2) 如果将资源分配给进程P1 ,这时所有待执行的进程中就没有满足所需资源数
<=系统可提供资源数条件的，所以系统不可以将资源分配P1（2分）
3、假设一磁道有200个柱面，编号为0 — 199 ，在完成了磁道125处的请求后，当前正在磁道143处为一请求服务，若请求队列的先后顺序为86，147，91，177，94，150，102，175，130。试分别采用FCFS（先来先服务）、SSTF（最短寻道时间优先）算法完成上述请求，写出磁道移动的顺序，并计算磁头移动的总距离。（本题8分）
（1）采用FCFS算法调度，磁头移动顺序为：
143-86-147-91-177-94-150-102-175-130
磁头移动总量为：565（柱面）。（4分）
（2）采用SSTF算法调度，磁头移动顺序为：
143-147-150-130-102-94-91-86-175-177
磁头移动总量为：162（柱面）。（4分）
4、我们打开计算机中的某个word文档，然后通过打印机打印文档中的内容，在这个过程中，操作系统为我们做了什么？试从操作系统功能的角度加以分析。（本题12分）
进程管理：执行时完成调度（2分）
存储管理：为调度的进程分配内存，以及从硬盘中读取文件。（2分）
文件管理：所调度文件的查询与读取（2分）
设备管理：打印机的驱动，以及打印工作的执行。（2分）
用户接口：执行程序时的界面，以及程序进程本身所含的系统调度。（2分）
整个过程是五个功能合作完成。（2分）
菠萝包 15:03:19
一、 选择题：（每题1分，共10分）
1、（B）的主要特点是提供即时响应和高可靠性。生产过程的控制、武器系统、
航空订票系统、银行业务就是这样的系统。
A.分时系统 B.实时系统 C.批处理系统 D.分布式系统
2、下列进程状态的转换中，哪一个是不正确的(C)。
A.就绪一运行 B.运行一就绪 C.就绪一阻塞 D.阻塞一就绪
3、利用信号量实现进程的（B），应为临界区设置一个信号量mutex，其初值
为1，表示该资源尚未使用，临界区应置于P（mutex）和V（mutex）原语
之间。
A.同步 B.互斥 C.竞争 D.合作
4、作业调度的关键在于(B)。
A.选择恰当的进程管理程序 B.选择恰当的作业调度算法
C.用户作业准备充分 D.有一个较好的操作环境
5、下列存储管理方案中，不采用动态重定位的是（C）。
A.页式管理 B.可变分区 C.固定分区D.段式管理
6、关于虚拟存储器，以下说法正确的是（D）。
A.可提高计算机运算速度的设备 B.容量扩大了的主存实际空间
C.通过SPOOLING 技术实现的 D.可以容纳和超过主存容量的多个作业
同时运行的一个地址空间
7、下面几个设备中，（C）是共享设备。
A.打印机 B.磁盘 C.读卡机 D.扫描仪
8、文件系统采用多级目录结构的目的,不包括是（B）
A.缩短访问文件的寻找时间 B.节省存储空间
C.解决文件的命名冲突 D.易于实现文件共享
9、磁盘驱动调度算法中（B）算法可能会随时改变移动臂的运动方向。
A.电梯调度 B.先来先服务 C.扫描 D.循环扫描
10、正在运行的进程在信号量S上作P操作之后，当S<0的时候，进程进入信号量的
（A）。
A.等待队列 B.提交队列 C.后备队列 D.就绪队列
二、填空题：（每空1分，共15分）
1、不论是分时系统、实时系统还是批处理系统都具有四个基本特征 并发 、
共享 、 虚拟 、 异步 。
2、特权指令只能在__系统 _态下执行，若在用户态下执行则被认为是非法指令。
3、__PCB______是进程存在的唯一标志。
4、设基址寄存器内容为1000，在采用动态重定位的系统中，当执行指令
“LOAD A,2000”时，操作数的实际地址是__3000_________。
5、按照调度的层次我们把调度分为 高级 、 低级 、 中级 。
6、根据文件的逻辑结构，文件可以分为 有结构文件 和__无结构文件_两类。
7、目前常用的外存分配方法有：连续分配、_链接______分配、 索引 分配。
三、名词解释（每题3分，共12分）
1、操作系统：
操作系统是一组控制和管理计算机硬件和软件资源、合理地对各类作业进行调度、以及方便用户的程序的集合。
2、临界区：
每个进程中访问临界资源的那段代码称为临界区
3、对换：所谓对换，是指把内存中暂不能运行的进程，或暂不用的程序和数据，换出到外存上，以腾出足够的内存空间，把已具备运行条件的进程，或进程所需的程序和数据，换入内存
4、设备独立性：
应用程序独立于具体的物理设备。
四、简单题（每题6分，共24分）
1、比较程序、进程的区别。
进程是动态的，程序是静态的，程序是有序代码的集合；进程是程序的执行；进程是暂时的，程序的永久的，进程是一个状态变化的过程，程序可长久保存；进程与程序的组成不同，进程的组成包括程序、数据和进程控制块（即进程状态信息）；通过多次执行，一个程序可对应多个进程；通过调用关系，一个进程可包括多个程序。
2、什么是死锁？死锁预防的措施有哪些？
所谓死琐，是指多个进程因竞争资源而造成的一种僵局，若无外力作用，这些进程都将永远不能再向前推进。
死锁预防的措施有：屏弃“请求和保持”条件，屏弃“不剥夺”条件，， 摒弃“环路等待”条件。
3、简述分页与分段的主要区别
（1）页是信息的物理单位，已削减内存零头，提高内存利用率为目的，而
不是用户的需求。段是信息的逻辑单位，具有相对完整的意义，是
为了满足用户的需求。
（2）页的大小固定，由系统确定。段的大小不固定，决定于用户编写的程序。
（3）分页的作业地址是一维的。分段的作业地址是二维的。
4、什么是局部性原理？什么是抖动？你有什么办法减少系统的抖动现象？
局部性原理是指在几乎所有程序的执行过程中，在一段时间内，CPU总是集中地访问程序中的某一个部分而不是对程序的所有部分具有平均的访问概率。
抖动是指当给进程分配的内存小于所要求的工作区时，由于内存外存之间交换频繁，访问外存的时间和输入输出处理时间大大增加,反而造成CPU因等待数据而空转,使得整个系统性能大大下降。
在物理系统中，为了防止抖动的产生，在进行淘汰或置换时，一般总是把缺页进程锁住，不让其换出，从而防止抖动的产生。
防止抖动产生的另一个办法是设置较大的内存工作区。
五、应用与计算（共39分）
1、现有一个具有n个缓冲区的缓冲池，Proce进程把它生产的消息放入一个缓冲区，Consumer进程可从一个缓冲区中取得一个消息消费。用信号量实现生产者和消费者之间的同步与互斥。请将下面的生产者和消费者算法补充完整。生产者和消费者对缓冲池互斥访问的信号量为SM，缓冲池的初值SB=n，缓冲池中消息个数初值为SP=0。（本题9分）
初值设置
SM= 1 ；SB=n；sp=0
P生产者：
While(1)
{...
Procer an item
Wait( SB )
Wait(SM)
缓冲操作
Singal(SM
Singal( SB )
…
}
C消费者：
While(1)
{...
Wait(SB )
Wait(SM
缓冲操作
Singal(SM
Singal(SB )
Consume the item
…
}
2、银行家算法中，若出现下述的资源分配情况：
Process Allocation Need Available
P0 0 , 1 , 0 7 , 4 , 3 3 , 3 , 2
P1 2 , 0 , 0 1 , 2 , 4
P2 3 , 0 , 2 6 , 5 , 0
P3 2 , 1 , 1 0 , 1 , 1
P4 0 , 0 , 2 4 , 3 , 1
试问：（1）当前系统状态是否安全？如果安全写出安全序列。（7分）
（2）若进程P1 提出请求 Request ( 1 , 0 , 2 ) 后，系统能否将资源分配给它？（3分）
（1）存在如下进程序列，可使进程顺利执行完毕：
进程 可用资源数
P3：执行完 5 ，4 ，3
P4：执行完 5 ，4 ，5
P1：执行完 7 ，4 ，5
P0：执行完 7 ，5 ，5
P2：执行完 10 ，5 ，7
当前系统是安全的，安全序列是：P3 , P4 , P1 , P0 , P2 . （8分）
(2) 如果将资源分配给进程P1 ,这时所有待执行的进程中就没有满足所需资源数
<=系统可提供资源数条件的，所以系统不可以将资源分配P1（2分）
3、假设一磁道有200个柱面，编号为0 — 199 ，在完成了磁道125处的请求后，当前正在磁道143处为一请求服务，若请求队列的先后顺序为86，147，91，177，94，150，102，175，130。试分别采用FCFS（先来先服务）、SSTF（最短寻道时间优先）算法完成上述请求，写出磁道移动的顺序，并计算磁头移动的总距离。（本题8分）
（1）采用FCFS算法调度，磁头移动顺序为：
143-86-147-91-177-94-150-102-175-130
磁头移动总量为：565（柱面）。（4分）
（2）采用SSTF算法调度，磁头移动顺序为：
143-147-150-130-102-94-91-86-175-177
磁头移动总量为：162（柱面）。（4分）
4、我们打开计算机中的某个word文档，然后通过打印机打印文档中的内容，在这个过程中，操作系统为我们做了什么？试从操作系统功能的角度加以分析。（本题12分）
进程管理：执行时完成调度（2分）
存储管理：为调度的进程分配内存，以及从硬盘中读取文件。（2分）
文件管理：所调度文件的查询与读取（2分）
设备管理：打印机的驱动，以及打印工作的执行。（2分）
用户接口：执行程序时的界面，以及程序进程本身所含的系统调度。（2分）
整个过程是五个功能合作完成。（2分）
⑽ 怎样计算sp和WRR的优先级调度
QOS优先级队列调度:每端口支持8个优先级队列,3个丢弃优先级,支持SP、WRR、CBWFQ队列调度算法,支持WRED拥塞避免算法,支持流量整形,支持802.1P,DSCP/TOS优先级和重新。