银行家算法习题

⑴ 操作系统-银行家算法问题

1)剩余：A:1 B:5 C:2 D:0
因为P1已经满足最大需求数，则P1资源最终是可回收，则可看做剩余：A:1 B:5 C3 D:2

2)是安全状态；因为按照剩余：A:1 B:5 C3 D:2（此时P1已经结束）分别按照顺序满足各进程的最大需求是可以把全部进程完成的（顺序可为：P3 --> P4 --> P5 --> p2）
3)系统会去满足；若此时去满足，则剩余资源为：A:1 B:1 C1 D:2
此时，各进程的状态：
已占有资源 最大需求数
A B C D A B C D
P1 0 0 0 0 0 0 1 2 （已结束）
P2 1 4 2 0 1 7 5 0
P3 1 3 5 4 2 3 5 6
P4 0 6 3 2 0 6 5 2
P5 0 0 1 4 0 6 5 6
按照各进程状态以及剩余资源，可以知道之后P3，即可回收已分配的资源，即处安全状态。

这是本人的理解，如有错，请包涵指出。

⑵ 1．考虑某一系统，它有4类资源R1,R2,R3,R4，有5个并发进程P0,P1,P2,P3,P4，按照银行家算法回答下列问题。

P0->P2->P3->P1->P4

⑶ 操作系统原理与应用之 银行家算法问题

1、T0时刻是安全状态，P5->P4->P3->P2->P1。
2、不能实施资源分慧大配，以为剩余的三种资源誉碧锋数为（2,3,3），P2请求不能庆晌得到满足。
有啥不明白还可以继续提问。

⑷ 操作系统题目 ：在银行家算法中，若出现下述资源分配情：

1、这是安全状态

P3所需的资源数Need（0 0 1 2）小于可分配资源数Available（1 5 1 2），满足P3需求后，完成P3

回收资源，Avaliable 变为（1 5 1 2）+ （0 1 3 2）= （1 6 4 4）

这时P0可分配资源，即Need（0 6 4 2） < Avaliable（1 6 4 4），分配资源给P0，完成P0回收资源变为（1 6 4 4） + （0 3 3 2） = （1 9 7 6）

这时P1可分配，回收资源后可用资源为（1 9 7 6） + （1 0 0 1）= （2 9 7 7）

这时P2可分配，回收资源后可用资源为（2 9 7 7） + （1 3 5 4）= （3 12 12 11）

这时P4可分配，回收资源后可用资源为（3 12 12 11） + （0 0 1 4）= （3 12 12 15）

2、P2提出 Request（1 2 0 0） < Avaliable( 1 5 1 2)，可以将资源分配给它。
补充：分配后可用资源变为 （1 5 1 2）- （1 2 0 0） = （0 3 1 2），按照上题的分析方法步骤，状态就不安全了。

(4)银行家算法习题扩展阅读：

我国国有商业银行由专业银行演变而来，这种转化是基于整个社会经济运行体制由计划经济向市场经济转变的宏观背景下产生的，相应的资源配置方法由计划配置逐渐向以市场配置为主、计划调控为辅的模式转变。

(一)资产结构不合理，资产负债比例过高在国有商业银行的资产中，无效资产和不良资产的占比较高，致使创利水平不高，而资产负债比例过高又增大了经营的风险。

(二)组织结构不合理网点布局追求铺摊子，不结合实际情况，势必使信贷资源、资本资源、人力资源、固定资产等各方面资源的配置分散，导致营运成本增加，人均创利水平不高。

(三)地区发展不平钨东部地区与西部地区之间、城市行与县行资源配置比例失调。总体而言，东部地区的资源配置效率较高，西部地区的资源配置效率较低，如某西部地区2002年到2006年四年时间，工、农、中、建、交五行存款增长了1200亿元，贷款仅增长了69亿元。

新增存款是新增贷款的17倍，存贷比由73.4%降到46%，存贷差与贷款余额之比由2002年的37%上升到2006年的l 1 5%。这意味着，每100元存款中没有作为贷款发放出去的已从37元上升到全部无法投放，金融市场环境不佳，难以支持业务的快速发展。

⑸ 操作系统(死锁避免)----银行家算法解题

死锁：是指两个以上的进程都因要求对方已经占有的资源，导致无法运行下去的现象，死锁是系统的一种出错状态，不仅浪费大量的系统资源，甚至会导纤贺余致整个系统的崩溃，所以死锁是尽量预防和避免的。

产生死锁的四个条件：

死锁的处理

银行家算法是死锁避免的重要算法。

银行家算毁滚法：资源==钱；收回资源==收回贷款；收不回资源==不会放贷；

例题：假设系统中有三类互斥资源R1，R2，R3。可用资源分别是9,8,5.在T0时刻系统有P1，P2，P3，P4，P5五个进程，这些进程最大的需求和已分配的资源如下所示，如果按_执行，那么系统的状态是安全的。

解：第一步：根据可用资源，可以求得剩余资源。

R1=9-(1+2+2+1+1)=2

R2=8-(2+1+1+2+1)=1

R3=5-(1+1+0+0+3)=0

第二拍纳步：根据剩余资源求得还需要的资源数。

公式：还需资源（Need）=最大需求（Max）-已分配资源（Allocation）。

第三部，根据剩余资源数，求出安全序列。

根据剩余资源可得，p2可以执行（条件：每个值都必须≦剩余资源）

由此可见安全序列为P2-->p4-->p5-->p1-->p3。

其实安全序列不是唯一的，这是为什么呢？

大家可以看出来，现有资源要大于需要资源的情况下是有多种选择的，因此安全序列不唯一。

⑹ 2019年7月全国自学考试操作系统概论试题答案

《操作系统》练习题及参考答案一、单项选择题（每小题1分，共15分）

1.操作系统是一种（）

A.系统软件B.系统硬件C.应用软件D.支援软件

2.MS—DOS的存贮管理采用了（）

A.段式存贮管理B.段页式存贮管理C.单用户连续存贮管理D.固定式分区存贮管理

3.用户程序在目态下使用特权指令将引起的中断是属于（）

A.硬件故障中断B.程序中断C.外部中断D.访管中断

4.MS—DOS中用于软盘整盘复制的命令是（）

A.COMP B.DISKCOPY C.SYS D.BACKUP

5.位示图方法可用于（）

A.盘空间的管理B.盘的驱动调度C.文件目录的查找D.页式虚拟存贮管理中的页面调度

6.下列算法中用于磁盘移臂调度的是（）

A.时间片轮转法B.LRU算法C.最短寻找时间优先算法D.优先级高者优先算法

7.在以下存贮管理方案中，不适用于多道程序设计系统的是（）

A.单用户连续分配B.固定式分区分配C.可变式分区分配D.页式存贮管理

8.已知，作业的周转时间=作业完成时间－作业的到达时间。现有三个同时到达的作业J1，J2和J3，它们的执行时间分别是T1，T2和T3，且T1

A.T1＋T2＋T3 B.（T1＋T2＋T3）C.T1＋T2＋T3 D. T1＋T2＋T3

9.任何两个并发进程之间（）

A.一定存在互斥关系B.一定存在同步关系C.一定彼此独立无关D.可能存在同步或互斥关系

10.进程从运行状态进入就绪状态的原因可能是（）

A.被选中占有处理机B.等待某一事件C.等待的事件已发生D.时间片用完

11.用磁带作为文件存贮介质时，文件只能组织成（）

A.顺序文件B.链接文件C.索引文件D.目录文件

12.一作业8：00到达系统，估计运行时间为1小时，若10：00开始执行该作业，其响应比是（）

A.2 B.1 C.3 D.0.5

13.多道程序设计是指（）

A.在实时系统中并发运行多个程序B.在分布系统中同一时刻运行多个程序C.在一台处理机上同一时刻运行多个程序D.在一台处理机上并发运行多个程序

14.文件系统采用多级目录结构后，对于不同用户的文件，其文件名（）

A.应该相同B.应该不同C.可以相同，也可以不同D.受系统约束

15.在可变式分区分配方案中，某一作业完成后，系统收回其主存枝则告空间，并与相邻空闲区合并，为此需修改空闲区表，造成空闲区数减1的情况是（）

A.无上邻空闲区，也无下邻空闲区B.有上邻空闲区，但无下邻空闲区C.有下邻空闲区，但无上邻空闲区D.有上邻空闲区，也有下邻空闲区

二、双项选择题（每小题2分，共16分）

1.能影响中断响应次序的技术是（）和（）。

A.时间片B.中断C.中断优先级D.中断屏蔽E.特权指令

2.文件的二级目录结构由（）和（）组成。

A.根目录B.子目录C.主文件目录D.用户文件目录E.当前目录

3.驱动调度算法中（）和（）算法可能会随时改变移动臂的运动方向。

A.电梯调度B.先来先服务C.扫描D.单向扫描E.最短寻找时间优先

4.有关设备管理概念的下列叙述中，（）和（）是不正确的。

A.通道是处理输入、输出的软件B.所有外围设备的启动工作都由系统统一来做C.来自通道的I/O中断事件由设备管理负责处理D.编制好的通道程序猛明是存放在主存贮器中的E.由用户给出的设备编号是设备的绝对号

5.一进程刚获得三个主存块的使用权，若该进程访问页面的次序是{1321215123}.当采用先进先出调度算法时，发生缺页次数是（）次，而采用LRU算法时，缺页数是（）次。

A.1 B.3 C.4 D.5 E.6

6.作业与进程的主盯誉要区别是（）和（）。

A.前者是由用户提交，后者是由系统自动生成B.两者执行不同的程序段C.前者以用户任务为单位，后者是操作系统控制的单位D.前者是批处理的，后者是分时的E.后者可并发执行，前者则不行

7.下述MS—DOS的文件中（）和（）是有关设备管理的程序。

A.BOOT B.COMMAND.COM C.IBMBIO.COM D.IBMDOS.COM E.ROMBIOS

8.MS—DOS的文件类型为（）和（）的文件是不可执行的。

A……OBJ B……EXE C……COM D……BAK E……BAT

三、填空题（每空1分，共15分）

1.用户程序使用_____________请求操作系统服务。

2.存贮管理应实现的功能是：主存空间的分配与保护，_________，主存空间的共享和___________.

3.分页式存贮管理中，页表是用来指出作业的____________与_____________的对应关系。

4.每个索引文件都至少有一张索引表，其中的每一个表项应包括能标识该记录的_______________和该记录的_____________.

5.分时系统必须为用户提供__________以实现_________控制方式。

6.斯普林系统中，作业执行时，从磁盘上的__________中读取信息，并把作业的执行结果暂时存放在磁盘上的____________中。

7.并发进程中涉及到___________的程序段称为临界区，两个进程同时进入相关的临界区会造成的错误。

8.MS—DOS中有三个文件：DOSIP.EXE，DOSIP.DAT和DOSZP.COM，____________若使用系统提供的替代符‘＊’和‘？’，则这三个文件可统一表示为___________.

9.拼音码是一种汉字__________码。

四、改错题（每小题2分，共10分）

1.以批处理方式和交互方式控制作业运行都需要注册（LOGON）。

2.分时系统中，时间片越小越好。

3.银行家算法是防止死锁发生的方法之一。

4.若无进程处于运行状态，则就绪队列和等待队列均为空。

5.作业控制语言是供用户编写程序以实现某项计算任务。

五、简答题（每小题4分，共20分）

1.程序状态字包含哪些主要内容？

2.什么是记录的成组和分解？

3.进程间同步和互斥的含义是什么？

4.什么是输入输出操作？什么是通道？

5.为实现分页式虚拟存贮，页表中至少应含有哪些内容？

六、综合题（每小题8分，共24分）

1.假定在某移动臂磁盘上，刚刚处理了访问75号柱面的请求，目前正在80号柱面读信息，并且有下述请求序列等待访问磁盘：

试用：（1）电梯调度算法

（2）最短寻找时间优先算法

分别列出实际处理上述请求的次序。

2.有三个进程P1，P2和P3并发工作。进程P1需用资源S3和S1；进程P2需用资源S1和S2；进程P3需用资源S2和S3.回答：

（1）若对资源分配不加限制，会发生什么情况？为什么？

（2）为保证进程正确工作，应采用怎样的资源分配策略？为什么？

3.某车站售票厅，任什么时候刻最多可容纳20名购票者进入，当售票厅中少于20名购票者时，则厅外的购票者可立即进入，否则需在外面等待。若把一个购票者看作一个进程，请回答下列问题：

（1）用PV操作管理这些并发进程时，应怎样定义信号量，写出信号量的初值以及信号量各种取值的含义。

（2）根据所定义的信号量，把应执行的PV操作填入下述方框中，以保证进程能够正确地并发执行。

COBEGIN PROCESS PI（I=1，2，……）

begin；

进入售票厅；

购票；

退出；

end；

COEND

（3）若欲购票者最多为n个人，写出信号量可能的变化范围（最大值和最小值）。

参考答案一、单项选择题（每题1分，共15分）

1.（1）2.（3）3.（2）4.（2）5.（1）6.（3）7.（1）8.（3）

9.（4）10.（4）11.（1）

12.（3）13.（4）14.（3）15.（4）

二、双项选择题（每题2分，共16分）

1.（3）（4）2.（3）（4）3.（2）（5）4.（1）（5）5.（5）（4）

次序不可交换6.（1）（3）7.（3）（5）8.（1）（4）

三、填空题（每空格1分，共15分）

1.访管指令（或系统调用）

2.主存空间的重定位，主存的扩充

3.逻辑页号，主存块号（可交换）

4.关键字（或记录号），存放地址（或存放位置）

5.操作控制命令，交互（或联机）

6.输入＃，输出＃

7.共享变量，与时间有关

8.DOS？P.＊（或DOS？P.？？？）

9.输入

四、改错题（每题2分，共10分，若只作简单否定，不能给分）

1.批处理方式是按用户使用作业控制语言书写的。

作业说明书控制作业运行，不需注册。

或交互方式控制作业运行需要注册。

2.当时间片过小时，进程调度时间所占比重加大。

若仅回答：

时间片越小，响应时间可能加大，给1分。

3.银行家算法是避免死锁的方法之一。

4.就绪队列为空，等待队列可能不空。

5.作业控制语言是供书写作业说明书的，以控制作业的执行（不同于编程语言）。

五、简答题（每题4分，共20分）

1.（1）程序基本状态（2分）

（2）中断码（1分）

（3）中断屏蔽位（1分）

2.（1）把若干逻辑记录合并成一组，存入一个物理块的工作称为记录的成组。（1分）

（2）从一组中把一个逻辑记录分离出来的工作称为记录的分解。（2分）

3.同步：并发进程之间存在的相互制约和相互依赖的关系。（2分）

互斥：若干进程共享一资源时，任什么时候刻只允许一个进程使用。（2分）

4.主存与外围设备之间的信息传送操作称为输入输出操作。（2分）

通道可称为输入输出处理机。（2分）

5.页号（1分）

标志（1分）

主存块号（1分）

磁盘上的位置（1分）

六、综合题（每题8分，共24分）

1.（1）电梯调度算法的处理次序为：

5 8 1 4 3 6 2 7（得4分）

若写出5 8（得1分）

若写出5 8 1 4 3（得2分）

（2）最短寻找时间优先算法的处理次序为：

5 8 6 2 7 1 4 3（得4分）

若写出5 8（得1分）

若写出5 8 6 2 7（得2分）

亦即：前2个对（得1分）

前5个对（得2分）

2.（1）可能会发生死锁（2分）

例如：进程P1，P2和P3分别获得资源S3，S1和S2后再继续申请资源时都要等待（2分），这是循环等待。

（或进程在等待新源时均不释放已占资源）

（2）可有几种答案：

A.采用静态分配（2分）

由于执行前已获得所需的全部资源，故不会出现占有资源又等待别的资源的现象（或不会出现循环等待资源现象）。（2分）

或B.采用按序分配（2分）

不会出现循环等待资源现象。（2分）

或C.采用银行家算法（2分）

因为在分配时，保证了系统处于安全状态。（2分）

3.（1）定义一信号量S，初始值为20.（1分）

意义：

S>0 S的值表示可继续进入售票厅的人数（1分）

S=0表示售票厅中已有20名顾客（购票者）（1分）

⑺ 操作系统题目,好的追加高分,感谢大虾

http://tieba..com/f?kz=588380474

http://blog.163.com/mqt_signature/blog/static/1049595722009429104343122/

或者看看这个，可是你需要的

《操作系统--银行家算法》
课程设计报告

1 课程设计目的 …………………………………………………… 1
2 课程设计的要求 ………………………………………………… 1
3 课程设计题目描述 ……………………………………………… 2
4 课程设计之银行家算法原理 …………………………………… 2
5 源程序结构分析及代码实现 …………………………………… 4
6 课程设计总结 …………………………………………………… 25
一、课程设计的目的
操作系统是计算机系统的核心系统软件，它负责控制和管理整个系统的资源并组织用户协调使用这些资源，使计算机高效的工作。《操作系统课程设计》是《操作系统》理论课的必要补充，是复习和检验所学课程的重要手段，本课程设计的目的是综合应用学生所学知识，通过实验环节，加深学生对操作系统基本原理和工作过程的理解，提高学生独立分析问题、解决问题的能力，增强学生的动手能力。
二、课程设计的要求
1．分析设计内容，给出解决方案（要说明设计实现的原理，采用的数据结构）。
2．画出程序的基本结构框图和流程图。
3．对程序的每一部分要有详细的设计分析说明。
4．源代码格式要规范。
5．设计合适的测试用例，对得到的运行结果要有分析。
6．设计中遇到的问题，设计的心得体会。
7．按期提交完整的程序代码、可执行程序和课程设计报告。

三、课程设计题目描述
银行家算法是一种最有代表性的避免死锁的算法。
要解释银行家算法，必须先解释操作系统安全状态和不安全状态。
安全状态：如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。安全状态一定是没有死锁发生。
不安全状态:不存在一个安全序列。不安全状态不一定导致死锁。
那么什么是安全序列呢？
安全序列：一个进程序列{P1，…，Pn}是安全的，如果对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。
银行家算法：
我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。若超过则拒绝分配资源，若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配。

四、课程设计之银行家算法原理
1．银行家算法的思路
先对用户提出的请求进行合法性检查，即检查请求的是不大于需要的，是否不大于可利用的。若请求合法，则进行试分配。最后对试分配后的状态调用安全性检查算法进行安全性检查。若安全，则分配，否则，不分配，恢复原来状态，拒绝申请。

2．银行家算法中用到的主要数据结构
可利用资源向量 int Available[j] j为资源的种类。
最大需求矩阵 int Max[i][j] i为进程的数量。
分配矩阵 int Allocation[i][j]
需求矩阵 int need[i][j]= Max[i][j]- Allocation[i][j]
申请各类资源数量 int Request i[j] i进程申请j资源的数量
工作向量 int Work[x] int Finish[y]

3．银行家算法bank()
进程i发出请求申请k个j资源，Request i[j]=k
(1)检查申请量是否不大于需求量：Request i[j]<=need[i,j],若条件不符重新输入，不允许申请大于需求量。
(2)检查申请量是否小于系统中的可利用资源数量：Request i[j]<=available[i,j]，若条件不符就申请失败，阻塞该进程，用goto语句跳转到重新申请资源。
(3)若以上两个条件都满足，则系统试探着将资源分配给申请的进程，并修改下面数据结构中的数值：
Available[i,j]= Available[i,j]- Request i[j]；
Allocation[i][j]= Allocation[i][j]+ Request i[j]；
need[i][j]= need[i][j]- Request i[j]；
(4)试分配后，执行安全性检查，调用safe()函数检查此次资源分配后系统是否处于安全状态。若安全，才正式将资源分配给进程；否则本次试探分配作废，恢复原来的资源分配状态，让该进程等待。
(5)用do{…}while 循环语句实现输入字符y/n判断是否继续进行资源申请。

4．安全性检查算法（safe()函数）
(1)设置两个向量：
工作向量Work，它表示系统可提供给进程继续运行所需的各类资源数目，在执行安全性算法开始时，Work= Available。
Finish，它表示系统是否有足够的资源分配给进程，使之运行完成。开始时先做Finish[i]=0；当有足够的资源分配给进程时，再令Finish[i]=1。

(2)在进程中查找符合以下条件的进程：
条件1：Finish[i]=0；
条件2：need[i][j]<=Work[j]
若找到，则执行步骤(3)否则，执行步骤(4)

(3)当进程获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：
Work[j]= Work[j]+ Allocation[i][j]；
Finish[i]=1；
goto step 2；

(4)如果所有的Finish[i]=1都满足，则表示系统处于安全状态，否则，处于不安全状态。

五、源程序结构分析及代码实现

1．程序结构

程序共有以下五个部分：

(1).初始化chushihua()：用于程序开始进行初始化输入数据：进程数量、资源种类、各种资源可利用数量、各进程的各种资源已分配数量、各进程对各类资源最大需求数等。
(2).当前安全性检查safe()：用于判断当前状态安全性，根据不同地方的调用提示处理不同。
(3).银行家算法bank()：进行银行家算法模拟实现的模块，调用其他各个模块进行银行家算法模拟过程。
(4).显示当前状态show()：显示当前资源分配详细情况，包括：各种资源的总数量(all)、系统目前各种资源可用的数量、各进程已经得到的资源数量、各进程还需要的资源量。
(5).主程序main()
逐个调用初始化、显示状态、安全性检查、银行家算法函数，使程序有序的进行。

2．数据结构
程序使用的全局变量：
const int x=10，y=10； //定义常量
int Available[x]; //各种资源可利用的数量
int Allocation[y][y]; //各进程当前已分配的资源数量
int Max[y][y]; //各进程对各类资源的最大需求数
int Need[y][y]; //还需求矩阵
int Request[x]; //申请各类资源的数量
int Work[x]; //工作向量，表系统可提供给进程运行所需各类资源数量
int Finish[y]; //表系统是否有足够的资源分配给进程，0为否，1为是
int p[y]; //存储安全序列
int i,j; //全局变量，主要用于循环语句中
int n,m; //n为进程的数量,m为资源种类数
int l=0,counter=0;

3．函数声明
void chushihua(); //系统初始化函数
void safe(); //安全性算法函数
void bank(); //银行家算法函数
void show (); //输出当前资源分配情况

4．主函数main()
int main()
{
cout<<…… //显示程序开始提示信息
chushihua(); //初始化函数调用
cout<<endl<<endl;
showdata(); //输出初始化后的状态
//===判断当前状态的安全性===
safe(); //安全性算法函数调用
if (l<n){
cout<<"\n当前状态不安全，无法申请,程序退出!!!!!"<<endl;
cout<<endl;
system("pause");
sign(); //调用签名函数
return 0; // break;
}
else{
int i; //局部变量
l=0;
cout<<"\n安全的状态!!!"<<endl;
cout<<"安全序列为: ";
cout<<endl<<"进程"<<"("<<p[0]<<")"; //输出安全序列，考虑显示格式，先输出第一个
for (i=1; i<n; i++){
cout<<"==>>"<<"进程"<<"("<<p[i]<<")";
}
for (i=0; i<n; i++) Finish[i]=0; //所有进程置为未分配状态
cout<<endl<<endl;
}
bank(); //银行家算法函数调用
return 0;
}

5. 操作系统银行家算法流程图：

2.源程序代码：
#include <iostream.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//定义全局变量
const int x=10,y=10; //常量，便于修改
int Available[x]; //各资源可利用的数量
int Allocation[y][y]; //各进程当前已分配的资源数量
int Max[y][y]; //各进程对各类资源的最大需求数
int Need[y][y]; //尚需多少资源
int Request[x]; //申请多少资源
int Work[x]; //工作向量，表示系统可提供给进程继续运行所需的各类资源数量
int Finish[y]; //表示系统是否有足够的资源分配给进程，1为是
int p[y]; //存储安全序列
int i,j; //i表示进程，j表示资源
int n,m; //n为进程i的数量,m为资源j种类数
int l=0; //l用来记录有几个进程是Finish[i]=1的，当l=n是说明系统状态是安全的
int counter=0;

//函数声明
void chushihua(); //初始化函数
void safe(); //安全性算法
void show(); //函数show,输出当前状态
void bank(); //银行家算法
void jieshu(); //结束函数

void chushihua()
{
cout<<"输入进程的数量: ";//从此开始输入有关数据
cin>>n;
cout<<"输入资源种类数: ";
cin>>m;
cout<<endl<<"输入各种资源当前可用的数量( "<<m<<" 种): "<<endl;
for (j=0; j<m; j++)
{
cout<<"输入资源 "<<j<<" 可利用的数量Available["<<j<<"]: ";
cin>>Available[j]; //输入数字的过程...
Work[j]=Available[j]; //初始化Work[j]，它的初始值就是当前可用的资源数
}

cout<<endl<<"输入各进程当前已分配的资源数量Allocation["<<n<<"]["<<m<<"]: "<<endl;
for (i=0; i<n; i++)
{
for (j=0; j<m; j++)
{
cout<<" 输入进程 "<<i<<" 当前已分配的资源 "<<j<<" 数量: ";
cin>>Allocation[i][j];
}
cout<<endl;
Finish[i]=0;//初始化Finish[i]
}

cout<<endl<<"输入各进程对各类资源的最大需求Max["<<n<<"]["<<m<<"]: "<<endl;
for (i=0; i<n; i++)
{
for (j=0; j<m; j++)
{
cout<<" 输入进程 "<<i<<" 对资源 "<<j<<" 的最大需求数: ";
cin>>Max[i][j];
if(Max[i][j]>=Allocation[i][j]) //若最大需求大于已分配，则计算需求量
Need[i][j] = Max[i][j]-Allocation[i][j];
else
Need[i][j]=0;//Max小于已分配的时候，此类资源已足够不需再申请
}
cout<<endl;
}
cout<<endl<<"初始化完成"<<endl;
}

//安全性算法函数
void safe()
{
l=0;
for (i=0; i<n;i++)
{ //i++
if (Finish[i]==0)
{ //逐个查找Finish[i]==0的进程 条件一
counter=0; //记数器

for (j=0; j<m; j++)
{
if (Work[j]>=Need[i][j]) counter=counter+1;//可用大于需求，记数
}

if(counter==m) //i进程的每类资源都符合Work[j]>=Need[i][j] 条件二
{
p[l]=i; //存储安全序列
Finish[i]=1; //i进程标志为可分配
for (j=0; j<m;j++)
Work[j]=Work[j]+Allocation[i][j]; //释放资源
l=l+1; //记数,现在有L个进程是安全的，当L=N时说明满足安全序列
i= -1; //从第一个进程开始继续寻找满足条件一二的进程
}
}
}
}

//显示当前状态函数
void show() //函数show,输出当前资源分配情况
{
int i,j; //局部变量
int All[y]; //各种资源的总数量
int L1; //局部变量L1

cout<<"当前的状态为："<<endl;
cout<<"各种资源的总数量:"<<endl;
for (j=0;j<m;j++)
{
cout<<" 资源"<<j<<": ";
All[j]=Available[j]; //总数量=可用的+已分配的
for (i=0;i<n;i++) All[j]+=Allocation[i][j];

cout<<All[j]<<" ";
}

cout<<endl<<"当前各种资源可用的量为(available):"<<endl;
for (j=0;j<m;j++)
cout<<" 资源"<<j<<": "<<Available[j]<<" ";

cout<<endl<<"各进程已经得到的资源量(allocation): "<<endl;
for(i=0;i<=m;i++)
{
for (j=i;j<m;j++) cout<<" 资源"<<j;
cout<<endl;
for(L1=0;L1<n;L1++)
{
cout<<"进程"<<L1<<":";
for (j=i;j<m;j++) cout<<Allocation[L1][j]<<" ";
cout<<endl;
}
}

cout<<endl<<"各进程还需要的资源量(need):"<<endl;
for(i=0;i<=m;i++)
{
for (j=i;j<m;j++) cout<<" 资源"<<j;
cout<<endl;
for(L1=0;L1<n;L1++)
{
cout<<"进程"<<L1<<":";
for (j=i;j<m;j++) cout<<Need[L1][j]<<" ";
cout<<endl;
}
}
}

//银行家算法函数
void bank()
{
cout<<endl<<"进程申请分配资源："<<endl;

int k=0; //用于输入进程编号
bool r=false; // 初值为假，输入Y继续申请则置为真
do{//输入请求
cout<<"输入申请资源的进程(0-"<<n-1<<"): ";
cin>>k;
cout<<endl;
while(k>n-1) //输入错误处理
{
cout<<endl<<"输入错误，重新输入："<<endl;
cout<<endl<<"输入申请资源的进程(0--"<<n-1<<"): ";
cin>>k;
cout<<endl;
}
cout<<endl<<"输入该进程申请各类资源的数量: "<<endl;
for (j=0; j<m; j++)
{
do{ //do……while 循环判断申请输入的情况
cout<<"进程 "<<k<<" 申请资源["<<j<<"]的数量:";
cin>>Request[j];
cout<<endl;
if(Request[j]>Need[k][j]){ //申请大于需求量时出错，提示重新输入（贷款数目不允许超过需求数目）
cout<<"申请大于需要量!"<<endl;
cout<<"申请的资源"<<j<<"的数量为"<<Request[j]<<",大于进程"<<k<<"对该资源需求量"<<Need[k][j]<<"。"<<endl;
cout<<"重新输入!"<<endl;
}
else //先判断是否申请大于需求量，再判断是否申请大于可利用量
if(Request[j]>Available[j]){ //申请大于可利用量， 应该阻塞等待？…… ？？？
cout<<"\n没有那么多资源，目前可利用资源"<<j<<"数量为"<<Available[j]<<",本次申请不成功，进程等待!"<<endl;
Finish[k]=0; //该进程等待
goto ppp; //goto语句 跳转，结束本次申请
}
}while(Request[j]>Need[k][j]); //Request[j]>Available[j]||
}

//改变Avilable、Allocation、Need的值
for (j=0; j<m; j++) {
Available[j] = Available[j]-Request[j];
Allocation[k][j] = Allocation[k][j]+Request[j];
Need[k][j] = Need[k][j]-Request[j];
Work[j] = Available[j];
}
//判断当前状态的安全性
safe(); //调用安全性算法函数
if (l<n)
{
l=0;
cout<<"\n试分配后，状态不安全,所以不予分配!恢复原状态"<<endl;
//恢复数据
for (j=0; j<m; j++)
{
Available[j] = Available[j]+Request[j];
Allocation[k][j] = Allocation[k][j]-Request[j];
Need[k][j] = Need[k][j]+Request[j];
Work[j] = Available[j];
}
for (i=0; i<n; i++)
Finish[i]=0; //进程置为未分配状态
}
else
{
l=0;
cout<<"\n申请资源成功!!!"<<endl;

for(j=0;j<m;j++)
{
if(Need[k][j]==0);
else { //有一种资源还没全部申请到，则该进程不可执行，不能释放拥有的资源
l=1; //置l为1，作为判断标志
break;
}
}
if(l!=1){ //进程可以执行，则释放该进程的所有资源
for (j=0;j<m;j++){
Available[j]=Available[j]+Allocation[k][j];
Allocation[k][j]=0;
}
cout<<"该进程已得到所有需求资源，执行后将释放其所有拥有资源！"<<endl;
}
l=0; //归零

cout<<"\n安全的状态!"<<endl;
cout<<"安全序列为: ";
cout<<endl<<"进程"<<"("<<p[0]<<")"; //输出安全序列，考虑显示格式，先输出第一个
Finish[0]=0;
for (i=1; i<n; i++){
cout<<"==>>"<<"进程"<<"("<<p[i]<<")";
Finish[i]=0; //所有进程置为未分配状态
}
cout<<endl<<endl;
}
show(); //显示当前状态
ppp: //申请大于可利用量， 应该阻塞等待,结束本次资源申请，GOTO 语句跳转至此
cout<<endl<<"是否继续申请资源(y/n) ?";
char* b=new char; //输入y/n，判断是否继续申请 <<endl
cin>>b;
cout<<endl;
cout<<"-------------------------------------------"<<endl<<endl;
cout<<endl;
if(*b=='y'||*b=='Y')
r=true;
else{
r=false; //输入非 Y 则令 R =false
jieshu(); //调用结束函数
}
} while (r==true);
}

//结束函数
void jieshu()
{
cout<<endl<<endl;
cout<<"\t\t 演示计算完毕"<<endl;
cout<<endl<<endl;
}

//主函数
int main()
{
cout<<endl<<endl<<"\t\t\t\t模拟银行家算法"<<endl<<endl;
chushihua(); //初始化函数调用
cout<<endl;
show(); //输出当前状态
safe(); //判断当前状态的安全性
if (l<n) //l在safe中是用来记录安全的进程的个数的
{
cout<<"\n当前状态不安全，拒绝申请！"<<endl;
cout<<endl;
return 0;
}
else
{
int i; //局部变量
l=0;
cout<<endl<<"\n当前的状态是安全的!安全序列为:"<<endl;
cout<<"进程"<<"("<<p[0]<<")"; //输出安全序列
for (i=1; i<n; i++) cout<<"->>"<<"进程"<<"("<<p[i]<<")";
for (i=0; i<n; i++) Finish[i]=0; //所有进程置为未分配状态
cout<<endl;
}

bank(); //调用银行家算法函数
cout<<"\t\t 演示计算完毕"<<endl;
return 0;
}

运行结果：
1.初始化结果
2.检测系统资源分配是否安全结果：

六、课程设计的总结
操作系统的基本特征是并发与共享。系统允许多个进程并发执行，并且共享系统的软、硬件资源。为了最大限度的利用计算机系统的资源，操作系统应采用动态分配的策略，但是这样就容易因资源不足，分配不当而引起“死锁”。而我本次课程设计就是得用银行家算法来避免“死锁”。银行家算法就是一个分配资源的过程，使分配的序列不会产生死锁。此算法的中心思想是：按该法分配资源时，每次分配后总存在着一个进程，如果让它单独运行下去，必然可以获得它所需要的全部资源，也就是说，它能结束，而它结束后可以归还这类资源以满足其他申请者的需要。
本次程序就是按照上面的思路展开的。但是因为时间上的仓促，本课程设计的存在着以下不足：一、不能实现并发操作，即当总资源同时满足几个进程所需要的资源数时，这些进程不能同时进行，只能一一按进程顺序执行。二、扫描进程顺序单一，只能按进程到来的顺序（即编号）来扫描，从而产生的安全顺序只能是在这个顺序的基础上产生的，而其实安全顺序是有多个的。三、对进程数和资源数进行的数量进行了限制，都只能最多有十个。四、运行程序后，界面较差，进程数，所需要资源数，已分配资源数，能用资源数，不能一目了然。
这次课程设计时间上虽说仓促点，但是我依然学到了很多的实用性知识。除了更深的了解这个算法，而且对C语言进行了复习，而且其过程中有很多的知识点都不记得了，所以在此感谢在此过程中帮助过我的老师和同学。
最后的感悟就是：只要你亲自动手，你就能学到知识。
再次感谢帮助过我的老师和同学！

⑻ 考虑下表所示的系统状态，利用银行家算法回答下列问题：

1.可利用资源向量Available
2.最大需求矩阵Max
3.分配矩阵Allocation
4.需求矩阵Need
**功能介绍:
模拟实现Dijkstra的银行家算法以避免死锁的出现.分两部分组成:
第一部分:银行家算法(扫描)
1．如果Request<=Need,则转向2;否则,出错
2．如果Request<=Available,则转向3,否则等待
3．系统试探分配请求的资源给进程
4．系统旅毁执行安全性算法
第二部分:安全性算法
1.设置两个向量
(1).工作向量:Work=Available(表示系统可提供桥扰给进程继续运行所需要的各类资源数目)
(2).Finish:表示系统是否有足够资源分配给进程(True:有;False:没有敏镇旦).初始化为False
2.若Finish[i]=False&&Need<=Work,则执行3;否则执行4(I为资源类别)
3.进程P获得第i类资源,则顺利执行直至完成!并释放资源:
Work=Work+Allocation;
Finish[i]=true;
转2
4. 若所有进程的Finish[i]=true,则表示系统安全;否则,不安全!

⑼ 用银行家算法判断下述每个状态是否安全

状态A是安全的，状态B是不安全的。
首先，从状态A来说，目前可分配资源数是1，而用户3正好差一个资源，所以分配给用户3，用户3执行完毕，就可以释放6个资源，这样，其他三个用户也都可以完成了。
而状态B呢，可分配资源数只有2个，无论给哪个用户都不能满足用户的需求，这样就出现了循环等待，也就出现死锁了。除非有剥夺机制，才能不发生死锁。

⑽ 谁有操作系统复习题啊

操作系统作业
第一章 序言
1. 选择题
1.1 （ ）不是一个操作系统环境。 A．赛扬（celeron） B．Windows CE C．Linux D．Solaris。
1.2 批处理操作系统的缺点是（ ） A．系统吞吐量小 B．CPU利用率低 C．系统开销小 D．缺少交互能力
1.3 批处理操作系统的目的是（ ）
A．提高系统与用户的交互性 B．提高系统资源利用率 C．提高系统吞吐率 D．降低用户作业的周转时间
1.4 实时操作系统必须在（ ）时间内响应一个新任务。A．一个机器周期 B．被控对象规定 C．任意周期 D．时间片
1.5 下列系统中，（ ）是实时系统。 A．火炮的自动化控制系统B．办公自动化系统C．管理信息系统D．计算机集成制造系统
1.6 如果分时操作系统的时间片一定，那么( ) ，则响应时间越长。A. 用户数越少B. 用户数越多C. 内存越少 D. 内存越多
1.7 分时系统通常采用( )策略为用户服务。 A. 可靠性和灵活性 B. 时间片轮转 C. 时间片加权分配 D. 短作业优先
1.8 多道批处理系统中引入了多道程序设计技术。为了充分提高各种资源的利用率，作业的类型最好是( )
A. 短作业型 B. 计算型，即其CPU计算的工作量重于I/O的工作量
C. I/O型，即其I/O的工作量重于CPU计算的工作量 D. 计算与I/O均衡型
2．填空题
2.1 在分时系统中，影响响应时间的主要因素有___ __、__ _。
2.2 设计实时系统时应特别强调系统的_ _和_ _。
2.3 操作系统的特征主要有：__ ___、_ _、_ _及 。
2.4 多道程序设计的特点是多道、 和 。
2.5 现代操作系统的两个最基本的特性是程序的 与系统资源的 。
3. 判断题
3.1 操作系统的主要作用是管理系统资源和提供用户界面。( )
4．简答题
4.1 并发与并行有何区别？
4.2 多道程序设计的主要优点是什么？
4.3 多用户分时系统如何保证系统的交互性？
第二章 操作系统结构
1. 选择题
1.1 用户使用操作系统通常有四种接口：终端命令、图形界面、系统调用和（ ）。
A．高级指令 B. 宏命令 C. 汇编语言 D. 作业控制语言
1.2 操作系统在执行系统调用时会产生一种中断，这种中断称为（ ）。A．系统中断 B. I/O中断 C. 程序性中断 D. 软中断
1.3 在下列操作中，不必将控制进入操作系统的操作是（ ）。A．中断 B. 键盘命令 C. 系统调用 D. 程序调用
1.4 （ ）中断是正在运行的进程所期待的自愿中断事件。A．程序 B. I/O C. 时钟 D. 访管
1.5 当用户程序执行访管指令时，系统（ ）。A. 维持在目态 B. 维持在管态 C. 从管态到目态 D. 从目态到管态
2．填空题
2.1 根据中断信号的来源，可分把中断为 和 二大类，属于第一类的中断有 ，属于第二类的中断有 。
2.2 根据中断信号的含义和功能，可把中断分为以下五类：机器故障中断、I/O中断、外中断、 和 。
2.3 用户程序是通过使用_ __产生中断进入系统内核的。 2.4 系统调用与一般过程的主要区别是_ _。
2.5 特权指令可以在中央处理器处于 时予以执行。
3. 判断题
3.3 特权指令仅允许在管态下执行。( ) 3.4 断点与恢复点是一致的。( )
3.5 就执行效率而言，解释程序要比编译程序好一些。( ) 3.6 解释程序是用来逐句分析执行源程序的系统软件。( )
3.8 命令处理程序执行完上一条命令后才接着处理下一条命令。( ) 3.9 中断向量是指中断处理程序入口地址。( )
3.10 用户程序有时也可以在核心态下运行. ( )
4．简答题
4.1 什么是中断与中断系统？ 4.2 什么是管态与目态？
4.3 什么是(外)中断？什么是异常？ 4.4系统调用与一般用户函数调用的区别？
5．问答题
5.1 根据中断信号的含义与功能，中断可以分为哪几类？

第三章 进程与处理机管理
1. 选择题
1.1 从作业提交到作业完成的时间间隔是( )。A. 响应时间 B. 周转时间 C. 运行时间 D. 等待时间
1.2 既考虑作业等待时间，又考虑作业执行时间的调度算法是（ ）。
A. 优先数调度 B. 先来先服务 C. 短作业优先 D. 最高响应比优先
1.3 一个进程被唤醒意味着（ ）。A. 进程重新占有CPU B. 进程变为执行状态C. PCB移到等待队列首 D. 进程变为就绪状态
1.4 在下列事件中不立即进入进程调度程序进行调度的是（ ）。A. 等待I/O B. 时间片到 C. 进程执行完 D. 输入新作业
1.5 UNIX系统的进程调度策略是基于（ ）。A. 时间片调度 B. 先来先调度 C. 短进程优先调度 D. 动态优先调度
1.6 如下所述的工作中，（ ）不是创建进程所必须做的。
A. 为进程分配CPU B. 为进程分配内存C. 建立一个PCB D. 将PCB链入就绪队列
1.7 进程管理中，在（ ）情况下，进程的状态由等待变为就绪。
A. 进程被调度 B. 等待某一事件 C. 时间片用完 D. 等待的事件发生
1.8 当作业调度程序将某作业调入内存并建立一个相应进程时，该进程的状态处于（ ）。
A. 等待状态 B. 后备状态 C. 就绪状态 D. 执行状态
1.9 系统处理某一紧急任务时，应选择（ ）。A. 最高响应比优先 B. 优先数调度 C. 短作业优先 D. 先来先服务
1.10 在下列状态中不是属于进程状态的是（ ）。A. 等待状态 B. 后备状态 C. 就绪状态 D. 执行状态
1.11 在单处理机上执行多道程序，是在（ ）进行的。A. 同一时刻 B. 某一时刻 C. 同一时间间隔内 D. 某一时间间隔内
1.12 如下的进程状态变化，不可能发生的是（ ）。A. 运行->就绪 B. 运行->等待 C. 等待->就绪 D. 等待->运行
1.13 当作业处于（ ）状态时，已处于进程管理之下。A. 等待 B. 后备 C. 执行 D. 完成
1.14 当某进程被调度建立一个相应的进程并分配到必要的资源，该进程的状态是（ ）。
A. 等待状态 B. 后备状态 C. 就绪状态 D. 执行状态
2．填空题
2.1 一个用作业说明书组织的批处理作业，其作业体一般由_ _ 、_ _和_ _组成。
2.2 按作业到达时间的先后进行调度称为__ 调度算法，按作业执行时间的长短进行调度称为__ __调度算法，既考虑到等待时间又考虑到执行时间的调度算法称为__ __调度算法。
2.3 操作系统内核的主要功能是__ __。
2.4 系统中用以表征进程的数据结构是_ _，表征“作业”的数据结构是_ 。
2.5 进程的基本状态有 。 2.6 进程的基本属性有__ __。
2.7 并行性是指两个或多个事件在_ __发生；并发性是指两个或多个事件在 _ 发生。
2.8 处于执行状态的进程被高优先级进程剥夺时，其状态变为__ __。
2.9 进程映象由_ __、_ __和_ __组成。
2.10 当系统建立一个进程时，系统就为其建立一个_ __，当进程被撤销时就将其收回。
2.11 在时间片调度算法中，如果时间片过大，则该调度算法就会退化为__ _。
3. 判断题
3.1 程序的并发与系统资源的共享是现代操作系统的两个基本特性。( )
3.2 当后备状态的作业被高级调度程序选中进入内存后，其相应的进程处于执行状态。( )
3.3 一个作业的处理由一个相应的进程来完成。( )
3.4 进程的就绪队列也是一个在一个时刻只允许一个进程访问的临界资源。( )
3.5 进程与程序是一 一对应的。( )
3.6 进程由执行状态变为等待状态是因为等待I/O操作完成、等待其他进程发来消息，等待
获取某个资源的使用等。( ) 3.7 进程由程序、数据和进程控制块组成。( )
3.8 实时系统中进程调度应采用非剥夺式调度方式。( ) 3.9 一个进程只能执行一个程序代码。( )
3.10 操作系统中，第一个进程是在系统初启时由初始化程序生成的。( )
3.11 作业调度程序也可以作为一个进程运行。( ) 3.12 进程控制块中的所有信息必须常驻内存. ( )
4．问答题
4.1 进程控制块PCB的作用是什么？它主要包含哪些内容？ 4.2 简述创建进程的大致过程。
4.3 进程和线程的主要区别是什么？ 4.4 试从动态性、并发性、独立性三个方面比较程序与进程。
4.5 试说明进程在三个基本状态之间转换的典型原因。 4.6 挂起状态具有那些性质？
4.7 引起进程阻塞或被唤醒的主要事件是什么？
5. 计算题
5.1 假设在单处理机上中有五个进程P1,P2,P3,P4,P5几乎同时创建，其运行时间(单位：ms)分别为10，1，2，1，5，其优先数分别为3，5，1，2，4（1为最低优先级）。系统时间片为1ms。试计算分别采用下列调度算法时进程的平均周转时间。（1）HPF（高优先级调度算法） （2）RR（时间片轮转调度算法），轮转顺序为P1,P2,P3,P4,P5。
5.2设单道批处理系统中有作业J1,J2,J3，J4,其提交时间分别为8.5，8.0，9.0，9.1；其运行时间分别为0.5, 1.0，0.2，0.1。试计算分别采用FCFS、SJF和HRF调度算法时的平均周转时间。
第四章 进程同步与通信、进程死锁
1. 选择题
1.1 在同步控制中，所谓的临界区是指（ ）。A.一个缓冲区 B. 一段共享数据区 C. 一段程序 D. 一个互斥的硬件资源
1.2 对于两个并发进程，设互斥信号量为mutex，若mutex=0，则表示（ ）。
A. 没有进程进入临界区 B. 一个进程进入临界区 C. 一个进入另一个等待 D. 二个进程进入临界区
1.3 在生产者－消费者问题中，设置信号量empty以确保生产者进程能向缓冲区存入信息，设置信号量full以确保消费者进程能从缓冲区中取出信息，当生产者进程向缓冲区存入信息后应执行以下的那一种PV操作（ B ）。
A. P(empty) B. V(full) C. P(full) D. V(empty)
1.4 若信号量s的初值为3，且有4个进程共享某临界资源，则s的取值范围是（ ）。A. [-3,3] B. [-1,3] C. [0,3] D. [-4,3]
1.5 为了防止死锁某系统采用一次性分配全部资源的方法，这种方法是破坏了产生死锁的那一个必要条件（ ）。
A. 互斥资源 B. 占有等待 C. 循环等待 D. 非剥夺式分配
1.6 在解决死锁的方法中属于死锁防止的策略是（ ）。A. 死锁检测法 B. 资源分配图化简C. 银行家算法 D. 资源有序分配法
1.7 Dijkstra提出的银行家算法是具有代表性的（ ）算法。A. 预防死锁 B. 避免死锁 C. 检测死锁 D. 解除死锁
1.8 系统中有3个并发进程都需要同类资源4个，则系统不会发生死锁的最少资源数是（ ）A. 8 B. 9 C. 10 D. 11
1.9 某系统中有同类互斥资源m个，可并发执行且共享该类资源的进程有n个，每个进程申请该类资源的最大量为x(n≤x≤m)，当不等式( )成立时，系统一定不发生死锁。A. nx+1≤m B. nx≤m C. m(x-1)+1≤n D. m-nx+(n-1)≥0
2．填空题
2.1 一次仅允许一个进程使用的资源叫 ,访问这种资源的那段程序称为 。
2.2 信号量的物理意义是：信号量大于零表示_ _，信号量小于零其绝对值表示__ _。
2.3 有n个进程共享同一临界资源，若使用信号量机制实现对临界资源的互斥访问，则信号量的变化范围是_ _。
2.4 如果信号量的当前值为－4，则表示系统中在该信号量上有 个等待进程。
2.5 进程间的制约关系可分为两类：_ __和_ _，其中_ _指合作进程之间具有一定的逻辑关系；_ __指进程间在使用共享资源方面的约束关系。
2.6 原语在执行过程中必须___ _。
2.7 从资源分配的角度看，P操作意味着向系统_ _资源，V操作意味着向系统__ _资源。
2.8 死锁的必要条件是：__ __、__ _、_ __、_ __。 2.9 死锁的充要条件是： 。
2.10 一次性分配进程所需的全部资源，这种预防死锁的方法破坏了产生死锁四个必要条件中的__ __条件。
2.11 采用 资源循序分配法，可以破坏产生死锁四个必要条件中的__ __条件。
2.12 产生死锁的主要原因是___ __、___ __和资源分配不当。
3. 判断题
3.1 进程的同步与互斥是进程的二种状态。( ) 3.2 所有进程都挂起时, 系统陷入死锁. ( )
3.3 如果信号量S的当前值为-5, 则表示系统中共有5个等待进程. ( )
3.4 系统出现死锁与资源的分配策略有关，与进程执行的相对速度无关。( )
3.5 一旦出现死锁, 所有进程都不能运行。( ) 3.6 参与死锁的进程至少有两个已经占有资源. ( )
3.7 有m个进程的操作系统出现死锁时, 死锁进程的个数为1<k≤m. ( ) 3.8 系统处于不安全状态不一定是死锁状态. ( )
4．简答题
4.1无忙等待的P、V操作是怎样定义的？
4.2多个进程对信号量S进行了5次 P操作，2次V操作后，现在信号量的值是 -3，与信号量S相关的处于阻塞状态的进程有几个？信号量的初值是多少？
5．综合题
5.1 假设三个并发进程P,Q,R。P和Q共享缓冲区A（有m个单元），Q和R共享缓冲区B（有n个单元），进程P负责从输入设备上读入信息并写入缓冲区A，进程Q从缓冲区A读出信息，加工后写入缓冲区B，进程R负责从缓冲区B读出信息并打印，写出模拟P,Q,R三进程的并发程序。
5.2 设某系统中有4个并发进程P1、P2、P3、P4合作完成某一任务，P1执行完后才能执行P2和P3，P2和P3执行完后才能执行P4，试画出优先图描述这4个进程间的关系，然后用PV操作实现。
5.3 某高校招生大厅只能容纳150人，当少于150人时，学生可以进入大厅办理入学手续；否则，需在外等候。若将每一个学生作为一个进程，请用P、V操作编程。
5.4两双胞胎兄弟共同使用一个银行帐号，约定每次限存或限取100元。设存钱与取钱两个进程是并发的，存钱进程与取钱进程的程序如下所示。假如最初帐户上有200元，哥哥第一次存钱时，弟弟取钱。请问最后帐号money可能出现的值是多少？如何用PV操作实现两并发进程的正确执行？

int money=200;
// Parbegin和Parend之间的程序并发执行
Parbegin
void Save( ) //存钱
{ int m1；
m1=money;
m1=m1+100;
money=m1;
}
void Take( ) //取钱
{ int m2;
m2=money;
if(m2>=100){
m2=m2-100;
money=m2;
}
}
Parend;

5.5 化简下列资源分配图，说明有无进程处于死锁状态？
5.6 一个计算机系统中拥有8个USB口，现有P个进程竞争使用，每个进程要求两台，试问，P的值如何选取时系统中绝对不会出现死锁？
5.7 某系统有165个存储单元。设四个进程p1、p2、p3、p4对存储单元的最大需求数分别为70、35、25、100，在T0时刻，四个进程已分配的存储单元数分别为25、15、15、25。试用银行家算法说明系统在T0时刻是否存在安全序列。
第五章 存储管理
1. 选择题
1.1 MS-Dos操作系统的命令处理程序分为常驻、暂驻二部分，其暂驻部分存放在主存中的高地址区域，以便用户区可向该区域扩展，这种存储管理技术称为（ ）。A. 虚存管理 B. 交换 C. 覆盖 D. 重定位
1.2 在虚拟存储管理中，为了避免不必要的信息写入，在页表中须设置（ ）。A. 主存块号 B. 辅存地址 C. 访问位 D. 修改位
1.3 在页面淘汰算法中，淘汰驻留集中下次访问离当前访问的页面最远的页面，这种页面淘汰算法称为（ ）。
A. OPT算法 B. FIFO算法 C. LRU算法 D. WS算法
1.4 一个目标程序所限定的存储范围称为该程序的（ D ）。A. 名空间 B. 地址空间 C. 物理空间 D. 符号空间
1.5 分段管理中，（ ）。
A．段与段之间必定连续 B. 以段为单位分配，段内连续 C. 段与段之间必定不连续 D. 以段为单位分配，每段等长
1.6 在下列存储管理方式中，不要求连续空间且不要求作业全部装入的管理方式是（ ）。
A. 单道连续 B. 请求式分页管理 C. 分页管理 D. 可变式分区管理
1.7 能够实际增加存储单元的存储扩充方式是（ ）。A. 覆盖技术 B. 交换技术 C. 物理扩充 D. 虚存技术
1.8 LRU页面淘汰算法选择（ ）页面作为淘汰页面。A. 最先进入 B 访问次数最少 C. 此前最长时间未访问 D 此后最长时间未访问
1.9 在存储管理中，所谓的虚拟存储技术是指（ ）的技术。A. 扩充逻辑空间B. 扩充内存空间C. 扩充外存空间D. 扩充存储空间
1.10 采用（ ），目标程序可以不经任何改动而装入内存。A. 静态重定位 B. 动态重定位 C.交换技术 D. 覆盖技术
1.11 在下列概念中，与虚存有关的概念是（ ）。A. 最佳适应 B. 覆盖技术 C. 动态可变 D. 抖动
1.12 要求存储分配时地址连续的管理方式是（ ）。A. 分区管理 B. 段式管理 C. 分页管理 D. 段页式管理
1.13 将暂不执行的进程映象移到外存，让出内存空间另作它用的技术是（ ）。A. 覆盖技术B. 交换技术C. 物理扩充 D. 虚存技术
1.14 在下列存储管理方法中，属于连续分区管理方法的是（ ）。A. 页式 B. 段式 C. 虚拟方法 D. 可变分区
1.15 为了使大作业可在小的主存空间中运行，可采用的技术是 A. 页式管理B. 段式管理C. 请求式分页管理 D. 可变式分区管理
1.16 程序的（ ）原理是虚拟存储管理系统的基础。A. 动态性 B. 虚拟性 C. 局部性 D. 全局性
2．填空题
2.1 可变分区法管理中， 法采用按起始地址的递增顺序排列空区。 __ _法采用按空块长度的递增顺序排列空区。
2.2 为了提高内存的使用效率，将暂不执行的进程映象移到外存，当具备执行条件时再将它调入内存，这种存储管理技术称为 。
2.3 在程序开始装入时先装入部分模块，当程序运行过程中调用另一模块时再从外存调入到同一内存区域，这种存储管理技术称为_ __。
2.4 在页式管理系统中，用户程序中使用的地址称为__ __，由系统将它转化为___ _。
2.5. 用户编程时使用 地址，处理机执行程序时使用 地址。
2.6 分页管理是把内存分为大小相等的区，每个区称为__ _，而把程序的逻辑空间分为若干__ _，页的大小与页帧的大小相等。
2.7 在分页存储管理中，为了加快地址变换速度，页面大小的值应取_ __。
2.8 在请求式分页系统中，被调出的页面又立刻被调入，这种频繁的调页现象称为_ _。
2.9 采用可变式分区法管理主存，存储空间存在_ ，可用 方法消除。
2.10 分段管理中，若逻辑地址中的段内地址大于段表中该段的段长，则发生_ 。
2.11 段页式存储管理中，每道程序都有一个 表和若干个 表。
2.12 页式管理系统的地址结构由__ __和_ __组成。
2.13 分段管理中的地址映射过程是：首先找到该作业段表的__ ___，然后根据逻辑地址中的_ 去查找段表得到该段的内存开始地址，再与逻辑地址中的__ __相加得到物理地址。
2.14 存储管理的任务是_ _、_ __、_ _和_ __。
2.15 _ _也称为__ _不是把一个进程映象的所有页面一次性全部装入内存，而只装入一部分，其余部分在执行中动态调入。
2.16 在段页式管理中，逻辑地址由__ __、_ _、__ 三部分组成。
3. 判断题
3.1 可共享的程序代码被称为可重入代码或纯代码，运行过程中不能被改变。( )
3.2 高速小容量联想存储器用于减少地址变换中访问主存的次数。( )
3.3 在可变式分区存储管理中，要求用户的一道作业必须放在一片连续的存储空间中。( )
3.4 缺页时，淘汰驻留内存时间最长的页面是比较合理的。( )
3.5 动态重定位可使目标程序不经任何改动就可装入内存，且可任意浮动。( )
3.6 虚拟存储器空间实际上就是辅存空间。( ) 3.7 请求式分页系统中，不要求进程映象一次全部装入内存。( )
3.8 简单分页管理控制简单，但易产生系统抖动。( ) 3.9 在分区存储管理中，一道作业必须存放在连续区域中。( )
3.10 请求式分页系统用时间换取空间，这是请求式分页管理方式的缺点。( )
3.11 页面替换算法都满足：‘存储块数越多，缺页中断就越少’的规律。( )
3.12 段式管理中，若逻辑地址中的段内地址小于段表中该段的段长，则发生越界中断。( )
3.13 页式存储管理方式比段式存储管理方式更易于实现保护和共享。( )
3.14 段式管理以段为单位分配内存，段内连续，但段间不一定连续。( )
3.15 虚存空间定义越大，则相应的效率就越高。( ) 3.16 虚拟存储系统可以在每一台计算机上实现. ( )
4．简答题
4.1 交换技术与虚存中使用的调入调出技术有何相同和不同之处？ 4.2 什么是抖动现象？
4.3 段页式存储系统中，若不考虑联想存储器，为了获得一条指令或数据，需访问几次内存？
4.4何谓虚拟存储器，并举一例说明操作系统如何实现虚拟内存的？
5．综合题
5.1 某虚拟存储器，用户编程空间32个页面，每页1KB，主存为8KB，假定某时刻用户的第2，3，5，7页分配的物理块号分别为6，7，4，2，问：虚地址0F80(十六进制)所对应的物理地址为多少？逻辑地址的有效位是多少？物理地址需要多少位？
5.2 在某个采用页式存储管理的系统中，现有J1、J2和J3共3个作业同驻主存。其中J2有4个页面，被分别装入到主存的第3、4、6、8页帧中。假定页面大小为1024字节，
主存容量为10kB字节。(1) 设每个页表项只由页号和页帧号组成，试写出J2的页表。 (2) 当J2在CPU上运行时，执行到其地址空间第500号处遇到一条传送指令： MOV 2100， 3100
请计算MOV指令中两个操作数（十进制数）的物理地址？
5.3 某采用页式虚拟存储管理的系统，接收了一个共7页的作业，作业执行时依次访问的页号为1、2、3、4、2、1、5、6、2、1、2、3、7、4、3、2、6。设驻留集大小为4，若分别采用FIFO和LRU页面替换策略，求作业访问上述页号产生多少次页故障？写出依次产生页故障后应淘汰的页。
5.4 在一虚存系统中，采用LRU淘汰算法，每个进程可有3个页帧内存空间，每页可存放200个整数。其中第一页存放程序，且假定程序已经在内存。下列程序A和程序B用二维整型数组A[100,100]存储数据，分别就程序A和程序B的执行过程计算缺页数。
程序A: for(int i=1; i<=100; i++) for(int j=1; j<=100;j++) A[i,j]=0;
程序B: for(int j=1; j<=100; j++) for(int i=1; i<=100;i++) A[i,j]=0;
5.5 现有一个分页式管理系统，其页表设置在内存中，若对内存的一次存取需要1.5us，则访问一次逻辑地址的存取的等效访问时间时间是多少？现有一联想存储器，其平均命中率为80%，当页表项在联想存储器中时其查找时间忽视不计，试问采用联想存储器时的存取的等效访问时间为多少？若命中率为90%，则等效访问时间又为多少？