银行家算法允许的最大并发性

‘壹’ 谁有操作系统复习题啊

操作系统作业
第一章 序言
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%，则等效访问时间又为多少？

‘贰’ 避免死锁的方法有哪些

1、避免给一个锁嵌套上锁，在持有一个锁的时候，不要再给这个锁上锁。如果使用多个锁，使用std::lock。

2、在持有锁时，不要调用别人提供的函数，因为你不清楚别人的代码怎么实现的，不知道它是不是在使用锁。

3、给多个锁上锁时，固定顺序。如果在给多个所上锁，并且无法使用std::lock，最好的做法就是在每一个线程中，都按照同样的顺序。

4、分层次来使用锁，把程序分成几个层次。区分每个层次中使用的锁，当一个线程已经持有更低层次的锁时，不允许使用高层次的锁。可以在程序运行时给不同的锁加上层次号，记录每个线程持有的锁。

(2)银行家算法允许的最大并发性扩展阅读：

解决方法

在系统中已经出现死锁后，应该及时检测到死锁的发生，并采取适当的措施来解除死锁。

死锁预防。

这是一种较简单和直观的事先预防的方法。方法是通过设置某些限制条件，去破坏产生死锁的四个必要条件中的一个或者几个，来预防发生死锁。预防死锁是一种较易实现的方法，已被广泛使用。但是由于所施加的限制条件往往太严格，可能会导致系统资源利用率和系统吞吐量降低。

死锁避免。

系统对进程发出的每一个系统能够满足的资源申请进行动态检查，并根据检查结果决定是否分配资源；如果分配后系统可能发生死锁，则不予分配，否则予以分配。这是一种保证系统不进入死锁状态的动态策略。

死锁检测和解除。

先检测：这种方法并不须事先采取任何限制性措施，也不必检查系统是否已经进入不安全区，此方法允许系统在运行过程中发生死锁。但可通过系统所设置的检测机构，及时地检测出死锁的发生，并精确地确定与死锁有关的进程和资源。检测方法包括定时检测、效率低时检测、进程等待时检测等。

然后解除死锁：采取适当措施，从系统中将已发生的死锁清除掉。

这是与检测死锁相配套的一种措施。当检测到系统中已发生死锁时，须将进程从死锁状态中解脱出来。常用的实施方法是撤销或挂起一些进程，以便回收一些资源，再将这些资源分配给已处于阻塞状态的进程，使之转为就绪状态，以继续运行。死锁的检测和解除措施，有可能使系统获得较好的资源利用率和吞吐量，但在实现上难度也最大。

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

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语言进行了复习，而且其过程中有很多的知识点都不记得了，所以在此感谢在此过程中帮助过我的老师和同学。
最后的感悟就是：只要你亲自动手，你就能学到知识。
再次感谢帮助过我的老师和同学！

‘肆’ 操作系统银行家算法

银行家算法是根据一个进程序列的请求试探性地分配资源给，即在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。

这里系统一步一步的试探性分配资源给每个进程，
对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量没有超过系统当前剩余资源量与所有进程Pj (j<i )当前占有资源量之和。

所以他是安全序列。

‘伍’ 关于银行家算法一个简单的问题

按照你的做法，如果这时候系统给进程1一个资源，给进程2一个资源，
那样系统就会死锁。而你们老师说的就是正确的，因为无论系统把那一个
资源给任意一个进程，任意一个进程都会完成并释放资源。

‘陆’ 银行家算法 操作系统课程设计

这个刚做过，直接贴给你好了，给分吧
#include<iostream.h>
#include<string.h>
#include<stdio.h>
#define False 0
#define True 1
int Max[100][100]={0};//各进程所需各类资源的最大需求
int Avaliable[100]={0};//系统可用资源
char name[100]={0};//资源的名称
int Allocation[100][100]={0};//系统已分配资源
int Need[100][100]={0};//还需要资源
int Request[100]={0};//请求资源向量
int temp[100]={0};//存放安全序列
int Work[100]={0};//存放系统可提供资源
int M=100;//作业的最大数为100
int N=100;//资源的最大数为100
void showdata()//显示资源矩阵
{
int i,j;
cout<<"系统目前可用的资源[Avaliable]:"<<endl;
for(i=0;i<N;i++)
cout<<name[i]<<" ";
cout<<endl;
for (j=0;j<N;j++)
cout<<Avaliable[j]<<" ";//输出分配资源
cout<<endl;
cout<<" Max Allocation Need"<<endl;
cout<<"进程名 ";
for(j=0;j<3;j++){
for(i=0;i<N;i++)
cout<<name[i]<<" ";
cout<<" ";
}
cout<<endl;
for(i=0;i<M;i++){
cout<<" "<<i<<" ";
for(j=0;j<N;j++)
cout<<Max[i][j]<<" ";
cout<<" ";
for(j=0;j<N;j++)
cout<<Allocation[i][j]<<" ";
cout<<" ";
for(j=0;j<N;j++)
cout<<Need[i][j]<<" ";
cout<<endl;
}
}

int changdata(int i)//进行资源分配
{
int j;
for (j=0;j<M;j++) {
Avaliable[j]=Avaliable[j]-Request[j];
Allocation[i][j]=Allocation[i][j]+Request[j];
Need[i][j]=Need[i][j]-Request[j];
}
return 1;
}
int safe()//安全性算法
{
int i,k=0,m,apply,Finish[100]={0};
int j;
int flag=0;
Work[0]=Avaliable[0];
Work[1]=Avaliable[1];
Work[2]=Avaliable[2];
for(i=0;i<M;i++){
apply=0;
for(j=0;j<N;j++){
if (Finish[i]==False&&Need[i][j]<=Work[j]){
apply++;
if(apply==N){
for(m=0;m<N;m++)
Work[m]=Work[m]+Allocation[i][m];//变分配数
Finish[i]=True;
temp[k]=i;
i=-1;
k++;
flag++;
}
}
}
}
for(i=0;i<M;i++){
if(Finish[i]==False){
cout<<"系统不安全"<<endl;//不成功系统不安全
return -1;
}
}
cout<<"系统是安全的!"<<endl;//如果安全，输出成功
cout<<"分配的序列:";
for(i=0;i<M;i++){//输出运行进程数组
cout<<temp[i];
if(i<M-1) cout<<"->";
}
cout<<endl;
return 0;
}
void share()//利用银行家算法对申请资源对进行判定
{
char ch;
int i=0,j=0;
ch='y';
cout<<"请输入要求分配的资源进程号(0-"<<M-1<<"):";
cin>>i;//输入须申请的资源号
cout<<"请输入进程 "<<i<<" 申请的资源:"<<endl;
for(j=0;j<N;j++)
{
cout<<name[j]<<":";
cin>>Request[j];//输入需要申请的资源
}
for (j=0;j<N;j++){
if(Request[j]>Need[i][j])//判断申请是否大于需求，若大于则出错
{
cout<<"进程 "<<i<<"申请的资源大于它需要的资源";
cout<<" 分配不合理，不予分配！"<<endl;
ch='n';
break;
}
else {
if(Request[j]>Avaliable[j])//判断申请是否大于当前资源，若大于则
{ //出错
cout<<"进程"<<i<<"申请的资源大于系统现在可利用的资源";
cout<<" 分配出错，不予分配!"<<endl;
ch='n';
break;
}
}
}
if(ch=='y') {
changdata(i);//根据进程需求量变换资源
showdata();//根据进程需求量显示变换后的资源
safe();//根据进程需求量进行银行家算法判断
}
}
void addresources(){//添加资源
int n,flag;
cout<<"请输入需要添加资源种类的数量:";
cin>>n;
flag=N;
N=N+n;
for(int i=0;i<n;i++){
cout<<"名称:";
cin>>name[flag];
cout<<"数量:";
cin>>Avaliable[flag++];
}
showdata();
safe();
}
void delresources(){//删除资源
char ming;
int i,flag=1;
cout<<"请输入需要删除的资源名称：";
do{
cin>>ming;
for(i=0;i<N;i++)
if(ming==name[i]){
flag=0;
break;
}
if(i==N)
cout<<"该资源名称不存在，请重新输入：";
}
while(flag);
for(int j=i;j<N-1;j++)
{
name[j]=name[j+1];
Avaliable[j]=Avaliable[j+1];

}
N=N-1;
showdata();
safe();
}
void changeresources(){//修改资源函数
cout<<"系统目前可用的资源[Avaliable]:"<<endl;
for(int i=0;i<N;i++)
cout<<name[i]<<":"<<Avaliable[i]<<endl;
cout<<"输入系统可用资源[Avaliable]:"<<endl;
cin>>Avaliable[0]>>Avaliable[1]>>Avaliable[2];
cout<<"经修改后的系统可用资源为"<<endl;
for (int k=0;k<N;k++)
cout<<name[k]<<":"<<Avaliable[k]<<endl;
showdata();
safe();
}
void addprocess(){//添加作业
int flag=M;
M=M+1;
cout<<"请输入该作业的最打需求量[Max]"<<endl;
for(int i=0;i<N;i++){
cout<<name[i]<<":";
cin>>Max[flag][i];
Need[flag][i]=Max[flag][i]-Allocation[flag][i];
}
showdata();
safe();
}
int main()//主函数
{

int i,j,number,choice,m,n,flag;
char ming;
cout<<"*****************资源管理系统的设计与实现*****************"<<endl;
cout<<"请首先输入系统可供资源种类的数量:";
cin>>n;
N=n;
for(i=0;i<n;i++)
{
cout<<"资源"<<i+1<<"的名称:";
cin>>ming;
name[i]=ming;
cout<<"资源的数量:";
cin>>number;
Avaliable[i]=number;
}
cout<<endl;
cout<<"请输入作业的数量:";
cin>>m;
M=m;
cout<<"请输入各进程的最大需求量("<<m<<"*"<<n<<"矩阵)[Max]:"<<endl;
for(i=0;i<m;i++)
for(j=0;j<n;j++)
cin>>Max[i][j];
do{
flag=0;
cout<<"请输入各进程已经申请的资源量("<<m<<"*"<<n<<"矩阵)[Allocation]:"<<endl;
for(i=0;i<m;i++)
for(j=0;j<n;j++){
cin>>Allocation[i][j];
if(Allocation[i][j]>Max[i][j])
flag=1;
Need[i][j]=Max[i][j]-Allocation[i][j];
}
if(flag)
cout<<"申请的资源大于最大需求量，请重新输入!\n";
}
while(flag);

showdata();//显示各种资源
safe();//用银行家算法判定系统是否安全
while(choice)
{
cout<<"**************银行家算法演示***************"<<endl;
cout<<" 1:增加资源 "<<endl;
cout<<" 2:删除资源 "<<endl;
cout<<" 3:修改资源 "<<endl;
cout<<" 4:分配资源 "<<endl;
cout<<" 5:增加作业 "<<endl;
cout<<" 0:离开 "<<endl;
cout<<"*******************************************"<<endl;
cout<<"请选择功能号：";
cin>>choice;
switch(choice)
{
case 1: addresources();break;
case 2: delresources();break;
case 3: changeresources();break;
case 4: share();break;
case 5: addprocess();break;
case 0: choice=0;break;
default: cout<<"请正确选择功能号(0-5)!"<<endl;break;
}
}
return 1;
}

‘柒’ 银行家算法

什么是银行家算法：
银行家算法是一种最有代表性的避免死锁的算法。在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。为实现银行家算法，系统必须设置若干数据结构。

要解释银行家算法，必须先解释操作系统安全状态和不安全状态。
安全序列是指一个进程序列{P1，…，Pn}是安全的，如果对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。
安全状态
如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。安全状态一定是没有死锁发生。
不安全状态
不存在一个安全序列。不安全状态不一定导致死锁。
原理：
我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。
为保证资金的安全,银行家规定:
(1) 当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客;
(2) 顾客可以分歧贷款,但贷款的总数不能超过最大需求量;
(3) 当银行家现有的资金不能满足顾客尚需的贷款数额时,对顾客的贷款可推迟支付,但总能使顾客在有限的时间里得到贷款;
(4) 当顾客得到所需的全部资金后,一定能在有限的时间里归还所有的资金.
操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。若超过则拒绝分配资源，若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配。
程序举例：
已知进程{P0,P1,P2,P3,P4}，有三类系统资源A、B、C的数量分别为10、5、7，在T0时刻的资源
（1）若进程P1请求资源，发出请求向量Request1（1，0，2），编写程序用银行家算法判断系统能否将资源分配给它；
（2）若进程P2提出请求Request(0，1，0)，用银行家算法程序验证系统能否将资源分配给它。
程序代码：
P1进程提出的请求，可以分配。
P2进程不能分配，因为请求的B类资源超过了它的最大值。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAXSIZE 50
void main()
{
unsigned int Available[MAXSIZE]; //可利用资源向量
unsigned int Max[MAXSIZE][MAXSIZE]; //最大需求矩阵
unsigned int Allocation[MAXSIZE][MAXSIZE]; //已分配矩阵
unsigned int Need[MAXSIZE][MAXSIZE]; //需求矩阵
unsigned int Request[MAXSIZE]; //请求向量
unsigned int Work[MAXSIZE]; //工作向量
bool Finish[MAXSIZE]; //是否有足够资源分配给进程,使之运行完成
unsigned int SafeSequence[MAXSIZE]; //安全序列

int i,j;
int p; //请求资源的进程的下标
int temp = 0; //安全序列下标
int total = 0;
int N;
int M;

printf("请输入进程数N=");
scanf("%d",&N);
printf("请输入资源种类数M=");
scanf("%d",&M);

//用户输入数据,初始化Available数组
printf("初始化可用资源数组:\n");
for(i=0; i<M; i++)
{
printf("\t%c类资源:",65+i);
scanf("%d",&Available[i]);
}

//用户输入数据,初始化Max数组
printf("初始化最大需求数组:\n");
for(i=0; i<N; i++)
{
printf("\tP%d进程最大需要\n",i);
for(j=0; j<M; j++)
{
printf("\t\t%c类资源:",65+j);
scanf("%d",&Max[i][j]);
}
}

//用户输入数据,初始化Allocation数组
printf("初始化已分配资源数组:\n");
for(i=0; i<N; i++)
{
printf("\tP%d进程已分配\n",i);
for(j=0; j<M; j++)
{
printf("\t\t%c类资源:",65+j);
scanf("%d",&Allocation[i][j]);
}
}

//初始化Need数组
for(i=0; i<N; i++)
for(j=0; j<M; j++)
{
Need[i][j] = Max[i][j] - Allocation[i][j];
}

//进程发出资源请求后检查
do
{
printf("资源请求:\n");
printf("\t输入请求资源的进程下标:");
scanf("%d",&p);
printf("\t进程P%d请求\n",p);
//初始化请求向量
for(i=0; i<M; i++)
{
printf("\t\t%c类资源:",65+i);
scanf("%d",&Request[i]);
}
for(i=0; i<M; i++) //检查Request <= Need ?
if(Request[i] > Need[p][i])
{
printf("\t请求的%c类资源数超过它所宣布的最大值!\n",65+i);
break;
}
if(i == M) //通过上层检查,继续检查Request <= Available ?
{
for(i=0; i<M; i++)
if(Request[i] > Available[i])
{
printf("\t尚无足够%c类资源,P%d须等待!\n",65+i,p);
break;
}
}
if(i == M) //尝试分配
{
for(i=0; i<M; i++)
{
Available[i] -= Request[i];
Allocation[p][i] += Request[i];
Need[p][i] -= Request[i];
}

}
}while(i<M);

//初始化Work,Finish向量
for(i=0; i<M; i++)
{
Work[i] = Available[i];
}
for(i=0; i<N; i++)
{
Finish[i] = false;
}

//安全性算法
do
{
total = temp;
for(i=0; i<N; i++)
{
if(Finish[i] == false)
{
for(j=0; j<M; j++)
if(Need[i][j] > Work[j])
{
break;
}
if(j == M) //各类资源都满足Need <= Work
{
for(j=0; j<M; j++)
{
Work[j] += Allocation[i][j]; //释放资源
}
Finish[i] = true;
SafeSequence[temp++] = i; //加入安全序列
}
}
}
}while(total != temp); //所有进程检查一遍之后，如果安全序列有变化，则进行下一轮
//否则说明所有的Finish都为true,或者因没有安全序列退出循环

if(temp == N)
{
printf("安全序列:");
for(temp=0; temp<N; temp++)
{
printf("P%d ",SafeSequence[temp]);
}
}
else
{
printf("系统处于不安全状态!不能分配!\n");
}
getchar();
getchar();
}
这个程序还行，输入有点麻烦，我自己编写的是用文件输入系统描述信息的，但是缺少说明，怕你搞不明白。希望对你有所帮助！

‘捌’ 进程同步及银行家算法的模拟实现 有会的大侠们帮帮忙吧 这个要求实在是太多 不太懂 答的好的追100

银行家算法=-- -

1. 安全状态: 在某时刻系统中所有进程可以排列一个安全序列:,刚称此时,系统是安全的.
所谓安全序列是指对于P2,都有它所需要剩余资源数量不大于系统掌握的剩余的空间资源与所有Pi(j<i)所占的资源之和.
2.不安全状态可能产生死锁.
目前状态 最大需求 尚需
P1 3 9 6
P2 5 10 5
P3 2 4 2

在每一次进程中申请的资源,判定一下,若实际分配的话,之后系统是否安全.
3.银行家算法的思路:
1),进程一开始向系统提出最大需求量.
2),进程每次提出新的需求(分期贷款)都统计是否超出它事先提出的最大需求量.
3),若正常,则判断该进程所需剩余剩余量(包括本次申请)是否超出系统所掌握的
剩余资源量,若不超出,则分配,否则等待.
4.银行家算法的数据结构.
1),系统剩余资源量A[n],其中A[n]表示第I类资源剩余量.
2),各进程最大需求量,B[m][n],其中B[j][i]表示进程j对i
类资源最大需求.
3),已分配资源量C[m][n],其中C[j][i]表示系统j程已得到的第i资源的数量.
4),剩余需求量.D[m][n],其中D[j][i]对第i资源尚需的数目.
5.银行家算法流程:当某时刻,某进程时,提出新的资源申请,系统作以下操作:
1),判定E[n]是否大于D[j][n],若大于,表示出错.
2),判定E[n]是否大于系统剩余量A[n],若大于,则该进程等待.
3),若以上两步没有问题,尝试分配,即各变量作调整.
4),按照安全性推测算法,判断,分配过后,系统是否安全,若安全,则实际分配,否则,撤消分配,让进程等待.
6."安全性检测"算法
1),先定义两个变量,用来表示推算过程的数据.
F[n]=A[n],表示推算过程中,系统中剩余资源量的变化.
J[n]=False表示推算过程中各进程是否假设"已完成"
2),流程:
在"剩余"的进程中(在推算)过程中,一些进程假设已完成,查找D[j][n]<=F[n]的进程,找到后令J[j]=True
(假设该进程完成),F[n]+D[j][n](该进程所占资源释放),如此循环执行.
若最后,所有的F[n]=True(在推算过程中,所有进程均可以完成),则表示(分配过后)系统是安全的,否则系统是不安全的.

#include "malloc.h"
#include "stdio.h"
#define alloclen sizeof(struct allocation)
#define maxlen sizeof(struct max)
#define avalen sizeof(struct available)
#define needlen sizeof(struct need)
#define finilen sizeof(struct finish)
#define pathlen sizeof(struct path)
struct allocation
{
int value;
struct allocation *next;
};
struct max
{
int value;
struct max *next;
};
struct available
{
int value;
struct available *next;
};
struct need
{
int value;
struct need *next;
};
struct path
{
int value;
struct path *next;
};
struct finish
{
int stat;
struct finish *next;
};
int main()
{
int row,colum,status=0,i,j,t,temp,processtest;
struct allocation *allochead,*alloc1,*alloc2,*alloctemp;
struct max *maxhead,*maxium1,*maxium2,*maxtemp;
struct available *avahead,*available1,*available2,*availabletemp,*workhead,*work1,*work2,*worktemp,*worktemp1;
struct need *needhead,*need1,*need2,*needtemp;
struct finish *finihead,*finish1,*finish2,*finishtemp;
struct path *pathhead,*path1,*path2,*pathtemp;
char c;
printf("\nPlease enter the type of sources the system has:\n");
scanf("%d",&colum);
printf("Please enter the number of processes now in the memory:\n");
scanf("%d",&row);
printf("Please enter the allocation array:\n");
for(i=0;i<row;i++)
{
printf("The allocation for process p%d:\n",i);
for (j=0;j<colum;j++)
{
printf("The type %c system resource allocated:\n",'A'+j);
if(status==0)
{
allochead=alloc1=alloc2=(struct allocation*)malloc(alloclen);
alloc1->next=alloc2->next=NULL;
scanf("%d",&allochead->value);
status++;
}
else
{
alloc2=(struct allocation *)malloc(alloclen);
scanf("%d,%d",&alloc2->value);
if(status==1)
{
allochead->next=alloc2;
status++;
}
alloc1->next=alloc2;
alloc1=alloc2;
}
}
}
alloc2->next=NULL;
status=0;
printf("Please enter the max array:\n");
for(i=0;i<row;i++)
{
printf("The max needed from process p%d:\n",i);
for (j=0;j<colum;j++)
{
printf("The type %c maxium system resource may needed:\n",'A'+j);
if(status==0)
{
maxhead=maxium1=maxium2=(struct max*)malloc(maxlen);
maxium1->next=maxium2->next=NULL;
scanf("%d",&maxium1->value);
status++;
}
else
{
maxium2=(struct max *)malloc(maxlen);
scanf("%d,%d",&maxium2->value);
if(status==1)
{
maxhead->next=maxium2;
status++;
}
maxium1->next=maxium2;
maxium1=maxium2;
}
}
}
maxium2->next=NULL;
status=0;
printf("Please enter the available array now exists in the system:\n");
for (j=0;j<colum;j++)
{
printf("The type %c available system resource number:\n",'A'+j);
if(status==0)
{
avahead=available1=available2=(struct available*)malloc(avalen);
workhead=work1=work2=(struct available*)malloc(avalen);
available1->next=available2->next=NULL;
work1->next=work2->next=NULL;
scanf("%d",&available1->value);
work1->value=available1->value;
status++;
}
else
{
available2=(struct available*)malloc(avalen);
work2=(struct available*)malloc(avalen);
scanf("%d,%d",&available2->value);
work2->value=available2->value;
if(status==1)
{
avahead->next=available2;
workhead->next=work2;
status++;
}
available1->next=available2;
available1=available2;
work1->next=work2;
work1=work2;
}
}
available2->next=NULL;
work2->next=NULL;
status=0;
alloctemp=allochead;
maxtemp=maxhead;
for(i=0;i<row;i++)
for (j=0;j<colum;j++)
{
if(status==0)
{
needhead=need1=need2=(struct need*)malloc(needlen);
need1->next=need2->next=NULL;
need1->value=maxtemp->value-alloctemp->value;
status++;
}
else
{
need2=(struct need *)malloc(needlen);
need2->value=(maxtemp->value)-(alloctemp->value);
if(status==1)
{
needhead->next=need2;
status++;
}
need1->next=need2;
need1=need2;
}
maxtemp=maxtemp->next;
alloctemp=alloctemp->next;
}
need2->next=NULL;
status=0;
for(i=0;i<row;i++)
{
if(status==0)
{
finihead=finish1=finish2=(struct finish*)malloc(finilen);
finish1->next=finish2->next=NULL;
finish1->stat=0;
status++;
}
else
{
finish2=(struct finish*)malloc(finilen);
finish2->stat=0;
if(status==1)
{
finihead->next=finish2;
status++;
}
finish1->next=finish2;
finish1=finish2;
}
}
finish2->next=NULL; /*Initialization compleated*/
status=0;
processtest=0;
for(temp=0;temp<row;temp++)
{
alloctemp=allochead;
needtemp=needhead;
finishtemp=finihead;
worktemp=workhead;
for(i=0;i<row;i++)
{
worktemp1=worktemp;
if(finishtemp->stat==0)
{
for(j=0;j<colum;j++,needtemp=needtemp->next,worktemp=worktemp->next)
if(needtemp->value<=worktemp->value)
processtest++;
if(processtest==colum)
{
for(j=0;j<colum;j++)
{
worktemp1->value+=alloctemp->value;
worktemp1=worktemp1->next;
alloctemp=alloctemp->next;
}
if(status==0)
{
pathhead=path1=path2=(struct path*)malloc(pathlen);
path1->next=path2->next=NULL;
path1->value=i;
status++;
}
else
{
path2=(struct path*)malloc(pathlen);
path2->value=i;
if(status==1)
{
pathhead->next=path2;
status++;
}
path1->next=path2;
path1=path2;
}
finishtemp->stat=1;
}
else
{
for(t=0;t<colum;t++)
alloctemp=alloctemp->next;
finishtemp->stat=0;
}
}
else
for(t=0;t<colum;t++)
{
needtemp=needtemp->next;
alloctemp=alloctemp->next;
}
processtest=0;
worktemp=workhead;
finishtemp=finishtemp->next;
}
}
path2->next=NULL;
finishtemp=finihead;
for(temp=0;temp<row;temp++)
{
if(finishtemp->value==0)
{
printf("\nWARNING,the system is in nonsafe status!\n");
exit(0);
}
finishtemp=finishtemp->next;
}
printf("\nThe system is in safe status!\n");
printf("\nThe safe sequence is: \n");
do
{
printf("p%d ",pathhead->value);
}
while(pathhead=pathhead->next);
}

‘玖’ 什么是银行家算法

银行家算法是一种最有代表性的避免死锁的算法。在避免死锁方法中允许进程动态地申请资源，但系 银行家算法统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。为实现银行家算法，系统必须设置若干

‘拾’ 银行家算法的背景简介

在银行中，客户申请贷款的数量是有限的，每个客户在第一次申请贷款时要声明完成该项目所需的最大资金量，在满足所有贷款要求时，客户应及时归还。银行家在客户申请的贷款数量不超过自己拥有的最大值时，都应尽量满足客户的需要。在这样的描述中，银行家就好比操作系统，资金就是资源，客户就相当于要申请资源的进程。
银行家算法是一种最有代表性的避免死锁的算法。在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。为实现银行家算法，系统必须设置若干数据结构。
要解释银行家算法，必须先解释操作系统安全状态和不安全状态。
安全序列是指一个进程序列{P1，…，Pn}是安全的，即对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。