银行家算法，我这里有个程序，每次运行完就输出同样的结果，安全序列也一样，请帮忙看看那里错了！

我给你个程序，你复制粘贴为五个文件，然后编译运行就行了。

这是我改编自己以前的一个程序而得，能力有限。

功能：支持任意个进程和资源

具有功能界面和错误处理

//-------------------------maincpp

#include <cstdlib>

#include "Bankerh"

//----#include "Bankercpp" 若用dev c++等老牌编译器，就要去掉注释。若用vc++就保留注释

int main()

{

Banker OneBanker;

if (!OneBankerInitBanker())

return false;

if (!OneBankerInitProgram())

return false;

while(1)

OneBankerMenu();

system("pause");

return 0;

}

//----------------processcpp

#include <iostream>

#include <cassert>

#include "processh"

bool Process::AllocMemory(int rNum)

{

State = 0;

Request = new int [rNum];

Max = new int [rNum];

Alloc = new int [rNum];

Need = new int [rNum];

return true;

}

//------------------processh

#ifndef _PROCESS_H

#define _PROCESS_H

class Process

{

public:

bool AllocMemory(int);

//bool IsSafe();

int Max,//------------最大需求

Alloc,//-------------目前已分配

Request,

Need;//--------------目前需求

int State;

//int Id;

};

#endif

//---------------------bankerh

#ifndef _BANKER_H

#define _BANKER_H

#include "processh"

#define M 20;

class Banker

{

public:

int Menu();

bool Check();

bool IsSafe();

bool InitBanker();

bool InitProgram();

bool AllocMemory(int,int);

bool IsAlloc(int);

//------------为方便、效率等因素，以下设置为共有

int pNum; //-------进程数

int rNum; //-------资源数

int m_iSafe; //---------------保存可行序列

int Avail,//--------------系统可用资源

Work;//-----------系统可用资源

Process m_pProcess;//---------------保存系统中个资源对象的地址的数组。

};

#endif

//--------------bankercpp

#include <iostream>

#include <cstdlib>

#include "processh"

#include "Bankerh"

//------#include "processcpp" //-------dev c++等编译器需要，vc++不需要。

#define M 20;

using namespace std;

bool Banker::IsAlloc(int Id)

{

int i;

for (i=0; i<rNum; i++)

{

if(m_pProcess[Id]Request[i]>m_pProcess[Id]Need[i])

{

cout << "请求失败，"<<Id<<"号进程的Request["<<i<<"] > Need["<<i<<"]!"<<endl;

return false;

}

if(m_pProcess[Id]Request[i] > Work[i])

{

cout << "请求失败，系统资源不够！"<<endl;

return false;

}

}

for (i=0; i<rNum; i++)

{

//---------------------暂时响应请求，并分配资源

Work[i] -= m_pProcess[Id]Request[i];

Avail[i] = Work[i]; //-----------------使Avail与Work同步。

m_pProcess[Id]Need[i] -= m_pProcess[Id]Request[i];

m_pProcess[Id]Alloc[i] +=m_pProcess[Id]Request[i];

}

for(i=0; i<pNum; i++)

{

m_pProcess[i]State = 0;

}

if (!IsSafe())

{

//---------------------还原资源；

for (i=0; i<rNum; i++)

{

Work[i] +=m_pProcess[Id]Request[i];

Avail[i] = Work[i]; //-----------------使Avail与Work同步。

m_pProcess[Id]Need[i] += m_pProcess[Id]Request[i];

m_pProcess[Id]Alloc[i] -=m_pProcess[Id]Request[i];

}

cout <<"为了系统的安全运行，不能响应请求。";

return false;

}

else

{

return true;

}

}

bool Banker::InitBanker()

{

cout << "请输入进程总数:\n"; /输入进程总数/

cin >> pNum;

if(!cin)

{

cout<<"输入错误，请输入整型数！";

cinclear();//---------清楚cin的错误状态。

cinsync(); //------------刷新缓冲区

}

cout << "请输入资源种类总数:\n"; /输入资源种类总数/

cin >> rNum;

if(!cin)

{

cout<<"输入错误，请输入整型数！";

cinclear();//---------清楚cin的错误状态。

cinsync(); //------------刷新缓冲区

}

if (!AllocMemory(pNum,rNum))

{

cout << "overflow!"<<endl;

return false;

}

return true;

}

bool Banker::AllocMemory(int pNum, int rNum)

{

m_iSafe = new int[pNum]; //------------------状态栈，进程如果被分配资源则把相应序号入栈。

Avail = new int [rNum];

Work = new int [rNum];

m_pProcess = new Process[pNum];

for (int i=0; i<pNum; i++)

{

if (!m_pProcess[i]AllocMemory(rNum))

{

cout << "进程"<<i<<"分配资源失败"<<endl;

return false;

}

//m_pProcess[i]Id = i;

}

return true;

}

bool Banker::InitProgram()

{

int i,j;

cout << "请输入最大需求矩阵:\n";

for(i=0;i<pNum;i++)

for(j=0;j<rNum;j++)

cin >> m_pProcess[i]Max[j];

cout << "\n请输入已分配矩阵:\n";

for(i=0;i<pNum;i++)

for(j=0;j<rNum;j++)

{

cin>> m_pProcess[i]Alloc[j];

while(m_pProcess[i]Alloc[j]>m_pProcess[i]Max[j])

{

cout << "Alloc["<<i<<"]["<<j

<<"]分配矩阵给值不合理！\n请重新输入:\n";

cinclear();

cinsync();

cin>>m_pProcess[i]Alloc[j];

}

}

cout << "\n则,需求矩阵为:\n";

for(i=0;i<pNum;i++)

{

cout<<"p"<<i<<": ";

for(j=0;j<rNum;j++)

{

m_pProcess[i]Need[j] = m_pProcess[i]Max[j] - m_pProcess[i]Alloc[j];

cout<<m_pProcess[i]Need[j]<<" ";

}

cout<<endl;

}

cout <<"\n请输入可利用资源矩阵:\n";

for(j=0;j<rNum;j++)

if(!(cin>>Avail[j]))

return false;

for (i=0;i<rNum; i++)//---------------初始化Work和State数组

Work[i] = Avail[i];

return true;

}

int Banker::Menu()

{

int choose=0;

system("cls");

cout <<"系统初始化成功,\n";

cout <<"-------------1,查看当前拥有进程数--------------------\n";

cout <<"-------------2,查看最大需求(Max)矩阵-----------------\n";

cout <<"-------------3,查看当前已分配(Alloc)矩阵-------------\n";

cout <<"-------------4,查看当前需求(Need)矩阵----------------\n";

cout <<"-------------5,查看当前可用(Work)矩阵----------------\n";

cout <<"-------------6,查看当前系统是否存在安全序列？-------\n";

cout <<"-------------7,是否请求分配(Request)资源------------\n";

cout <<"-------------8,清屏------------------------------------------\n";

cout <<"-------------9,退出系统-------------------------------------\n";

cout << "请选择:";

cin>>choose;

while(!cin||choose<1||choose>8)

{

cout << "输入错误，请重新输入:";

cinclear();//-------------清除错误状态

cinsync();//------------刷新缓冲区

cin >> choose;

}

switch(choose)

{

int i,j;

case 1:

cout <<"当前进程数：" <<pNum <<endl;

break;

case 2:

cout <<"最大需求矩阵(Max)为：\n";

for (i=0;i<pNum;i++)

{

for (j=0;j<rNum;j++)

{

cout << m_pProcess[i]Max[j]<<" ";

}

cout<<endl;

}

break;

case 3:

cout << "当前已分配矩阵(Alloc)为:\n";

for (i=0;i<pNum;i++)

{

for (j=0;j<rNum;j++)

{

cout << m_pProcess[i]Alloc[j]<<" ";

}

cout<<endl;

}

break;

case 4:

cout << "当前需求矩阵(Need)为:\n";

for (i=0;i<pNum;i++)

{

for (j=0;j<rNum;j++)

{

cout << m_pProcess[i]Need[j]<<" ";

}

cout<<endl;

}

break;

case 5:

cout << "当前可用矩阵(Work)为:\n";

for(i=0;i<rNum;i++)

cout << Work[i]<<" ";

cout << endl;

break;

case 6:

if (!IsSafe())

{

cout << "此刻系统不安全！"<<endl;

}

else

{

cout << "此刻系统是安全的！"<<endl;

cout << "可行序列为：";

for(int k=0;k< pNum;k++)

{

cout<<"p"<<m_iSafe[k]<<"->";

}

cout<<"end"<<endl;

}

break;

case 7:

int Id;

cout << "请输入请求资源的进程号：";

cin >> Id;

cout << "请输入请求分配矩阵："<<endl;

for(i=0; i<rNum; i++)

{

cin >> m_pProcess[Id]Request[i];

}

if (!IsAlloc(Id))

{

cout << "请求资源失败！\n";

}

else

{

cout << "可请求资源！"<<endl;

cout << "可行序列为：";

for(int k=0;k< pNum;k++)

{

cout<<"p"<<m_iSafe[k]<<"->";

}

cout<<"end"<<endl;

cout <<"分配完成！\n";

}

break;

case 8:

system("cls");//---------------系统清屏

case 9:

exit(0);

default:

break;

}

system("pause");

return 0;

}

bool Banker::IsSafe()

{

static int Num = 0; //------------设置为静态

int i =0;

while (i<pNum)

{

if(m_pProcess[i]State ==1)

{

i++;

continue;

}

int j;

for(j=0; j<rNum; j++)

{

if(Work[j] < m_pProcess[i]Need[j])

break;

}

if(j!=rNum)

{

if(i==pNum-1)

{

return false;

}

i++;

continue;

}

else if(Num==pNum-1&&i==pNum-1)

{

m_pProcess[i]State = 1; //---------暂时分配资源

m_iSafe[Num++] = i;

Num = 0;

//cout << Num <<endl;

return true;

}

//-----------------------------暂时分配资源

for(int k=0; k<rNum; k++)

{

//------------该进程完成后释放资源。

Work[k] += m_pProcess[i]Alloc[k];

Avail[k] = Work[k];//-----------使Avail与Work同步

}

m_pProcess[i]State = 1; //---------暂时分配资源

m_iSafe[Num++] = i; //--------入顺序栈（数组实现）

if(!IsSafe()) //------------利用递归，判断分配资源后系统是否安全。

{

Num--;

m_iSafe[Num]=0; //------------d出顺序栈

m_pProcess[i]State = 0;

//----------------------------返还资源。

for(int k=0; k<rNum; k++)

{

Work[k] -= m_pProcess[i]Alloc[k];

Avail[k] = Work[k];//-----------使Avail与Work同步

}

i++;

}

else

{

for(int k=0; k<rNum; k++)

{

Work[k] -= m_pProcess[i]Alloc[k];

Avail[k] = Work[k];//-----------使Avail与Work同步

}

return true;

}

}

for(i=0; i<pNum; i++)

{

if(m_pProcess[i]State !=1 )

break;

}

if (i==pNum)

{

return true;

}

else

{

return false;

}

}

1．当时引入多道程序的目的在于（ c ）。

A有利于代码共享，减少主、辅存信息交换量 B．充分利用存储器

C充分利用CPU，减少CPU等待时间 D．提高实时响应速度

2 在单处理机计算机系统中，（ B ）是并行 *** 作的。

A程序与程序B处理机的 *** 作与通道的 *** 作C主程序与子程序D用户程序与 *** 作系统程序

3下面哪一个不是程序在并发系统内执行的特点（ A ）。

A产生死锁的必然性 B资源分配的动态性C程序执行的间断性 D相互通信的可能性

4．进程和程序的一个本质区别是( D )。

A 进程分时使用CPU，程序独占CPU B．进程存储在内存，程序存储在外存

C 进程在一个文件中，程序在多个文件中 D．进程为动态的，程序为静态的

5．在下列情况( B )，系统需要进行进程调度。

A 某一进程正访问一临界资源 B．某一进程运行时因缺乏资源进入阻塞状态

C．某一进程处于运行状态，而另一进程处于自由状态

D．某一进程正在访问打印机，而另一进程处于就绪状态

6．与设备控制器关系最密切的软件是（ B ）。

A编译程序 B设备驱动程序 C存储管理程序 D处理机管理

7 若进程P一旦被唤醒就能够投入运行，系统可能（ A ）。

A在抢占调度方式中，P的优先级高于当前运行的进程 B进程P的优先级最高

C就绪队列为空队列 D在抢占调度方式中，P的优先级高于就绪队列中所有的进程

8 在下列选项中，属于预防死锁的方法是（ A ）。

A剥夺资源法 B资源分配图法 C资源随意分配 D银行家算法

9 如果要使装入内存的程序，在内存中移动后仍能正常运行，必须要有( B )的支持。

A 静态重定位 B动态重定位 C 动态链接D静态链接

10 段页式管理中，地址转换表是( )。

A 每个进程一张段表，一张页表 B．每个进程的每个段一张段表，一张页表

C．每个进程一张段表，每个段一张页表 D．每个进程一张页表，每个段一张段表

11下列( C )存储管理方式能使内存碎片尽可能少，避免内存的整理。

A固定分区 B可变分区 C分页管理 D段式管理

12．为了提高系统的交互性，人们设计了( B )。

A批处理系统 B．分时系统 C．实时系统 D分布式系统

13 在下面的I/O控制方式中，需要CPU干预最少的方式是（ D ）。

A程序I/O方式 B中断驱动I/O控制方式

CDMA控制方式 DI/O通道控制方式

14 引入缓冲可以（ C ）。

A．改善用户编程环境 B．提高CPU的处理速度

C．提高CPU与设备之间的并行程度 D．降低计算机的硬件成本

15 *** 作系统实现按名存取的关键在于解决( B )。

A文件逻辑地址到文件具体的存储地址的转换

B文件的符号名与文件具体的存储地址的转换和映射

C文件逻辑结构到文件名称转换

D文件名称到文件逻辑地址的转换

16一般用户需要知道（ A ），才能使用文件中的信息。

A．文件的符号名 B．文件的逻辑结构 C．文件的物理结构 D．文件的存取方法

17 如果有三个进程共享同一互斥段，而且每次最多允许两个进程进入该互斥段，则信号量的初值应设置为（ C ）

A．0 B．1 C．2 D．3

18．当系统中进程发生死锁时，解除死锁所付出代价较小的措施是（ A ）。

A 撤消发生死锁的进程 B阻塞没有发生死锁的进程

C创立新进程 D挂起一些没有发生死锁的进程

19（ A ）措施可以提高系统的可靠性

A．访问控制 B．双磁盘镜像 C．钥匙盘 D．增加口令

20 ( B )进程调度算法适合多用户分时系统。

A先来先服务 B轮转 C可抢占优先级 D优先级

21． 当线程处于阻塞状态时，线程( B )。

A 正在占用处理机 B没有占用处理机 C 将进入执行状态 D将进入结束状态

22．当多道程序系统中发生死锁时，（ C ）。

A 计算机系统不能处理任何事情 B某个进程不能够执行

C一组进程相互等待，并进入阻塞状态 D不能进行输入和输出

23 在文件系统中，采用位图主要是实现（ B ）。

A 磁盘的驱动调度 B 磁盘空间的分配和回收 C 文件目录的查找 D 页面置换

24．进程调度的基本功能是选择( A )

A就绪的进程 B后备的作业 C空闲内存 D空闲设备

25．对于普通用户而言，OS的（ B ）是最重要。

A开放性 B方便性 C有效性 D可扩充性

26．计算机的普通用户通常通过（ D ）使用OS所提供的服务。

A中断键盘 B控制接口 C特权指令 D系统调用

27．（ B ）进程调度算法适合分时系统

A先来先服务 B轮转 C短作业优先 D最高优先级

28．进程的控制信息和描述信息存放在（ B ）。

AJCB BPCB CAFT DSFT

30．( D )进程调度算法适合紧急事件的处理。

A先来先服务 B轮转 C可抢占优先级 D优先级

31．进程依靠什么从阻塞状态过渡到就绪状态（ D ）。

A *** 作人员的命令 B系统服务 C等待下一个时间片到来 D由"合作"进程唤醒

32．在下面的I/O控制方式中，需要CPU干预最少的方式是（ B ）。

A 程序I/O方式 B 中断驱动I/O控制方式

C 直接存储器访问DMA控制方式 D I/O通道控制方式

33．新创立的进程首先进入( A )状态。

A就绪 B执行 C阻塞 D挂起

34．在OS中，文件的存取控制可以使（ A ）。

A 用户间不能相互删除文件 B 内存中的多道程序间不相互破坏

C 内存中的程序不破坏OS D 防止黑客攻击

35．页的逻辑地址形式是:页号24位，页内地址10位,内存128M,辅存10G，那么虚拟存储器最大实际容量可能是( D ) 。

A1024K B16G C10G D10G+128M

36．分页存储管理的存储保护是通过( A )完成的。

A页表 B快表 C存储键 D索引

37．用户使用（ D ）形式的文件。

A链接 B连续 C物理 D逻辑

38．能够装入内存任何位置并能执行的程序代码必须是可( B )。

A动态链接 B重定位 C可重入的 D静态链接

39 采用（A ）不会产生内部碎片。

A分页式存储管理 B分段式存储管理

C固定分区式存储管理 D段页式存储管理

40 假脱机技术中，对打印机的 *** 作实际上是用对磁盘存储实现的，用以替代打印机的部分是指（ C ）。

（A）共享设备 （B）独占设备 （C）虚拟设备 （D）物理设备

模块2：

1． *** 作系统中采用多道程序设计技术提高CPU和外部设备的（A） 。

A 利用率 B．可靠性 C 稳定性 D 兼容性

2．设计实时 *** 作系统时，首先应该考虑系统的（B）。

A 可靠性和灵活性 B．实时性和可靠性

C 分配性和可靠性 D．灵活性和实时性

3．如果把 *** 作系统看作计算机系统资源的管理者，下列的不属于 *** 作系统所管理的资源（D） 。

A程序 B内存 CCPU D中断

4． 对记录式文件， *** 作系统为用户存取文件的最小单位是（C） 。

A 字符 B 数据项C 记录 D 文件

5．要保证一个程序在主存中被改变了存放位置后仍能正确执行，则对主存空间应采用（B ）技术。

A．静态重定位 B．动态重定位C．动态分配D．静态分配

6． 若系统中有五台绘图仪，有多个进程均需要使用两台，规定每个进程一次仅允许申请一台，则至多允许（D）个进程参于竞争，而不会发生死锁。

A5 B．2 C．3 D．4

7．（B ）结构的文件最适合于随机存取的应用场合。

A．流式B．索引C．链接D．顺序

8． 对磁盘进行移臂调度的目的是为了缩短 （A）时间。

A 寻找 B． 延迟 C． 传送 D． 启动

9．为防止用户使用共享文件时可能造成文件被破坏，通常可采用（ C）方法来保护文件。

A．建立多个副本 B．定时转储文件C．规定使用权限D．设置口令

10． 下面的存储管理方案中，（A） 方式可以采用静态重定位。

A． 固定分区 B． 可变分区 C． 页式 D． 段式

11． 用 V *** 作唤醒一个等待进程时，被唤醒进程的状态变为（C）。

A． 运行 B． 等待 C． 就绪 D． 完成

12．如果有多个中断同时发生，系统将根据中断优先级响应优先级最高的中断请求。若要调整中断事件的响应次序，（D）可以利用。

A 中断禁止 B中断嵌套 C 中断响应 D中断屏蔽

13． 若在磁盘格式化时把每个盘面划分成大小相等的 10个扇区，磁盘的转速为20毫秒／圈，则传送一块所需的时间为 A毫秒。

A．2 B．1 C．20 D．10

14． 进程间采用信箱通信方式时， send原语把发送者的信件存放到A 中。

A．信箱 B．消息缓冲区 C．接收者的PCB D．指定的工作区

15．采用段式存储管理时，一个程序如何分段是在（B ）决定的。

A．分配主存时 B．用户编程时 C．装作业时 D．程序执行时

16． 用来实现进程同步与互斥的 PV *** 作实际上是由 D过程组成的。

A．一个可被中断的 B．一个不可被中断的 C．两个可被中断的 D 两个不可被中断的

17． 磁盘是可共享的设备，因此每一时刻D 作业启动它。

A． 可以有任意多个 B． 能限定几个 C． 至少能有一个 D． 至多能有一个

18．并发进程执行的相对速度是（ C）。

A．由进程的程序结构决定的 B．由进程自己来控制的

C．与进程调度策略有关的 D．在进程被创建时确定的

19．按照 *** 作系统提供的服务进行分类，______是基本的 *** 作系统。（B ）

A．批处理 *** 作系统、分时 *** 作系统、网络 *** 作系统

B．批处理 *** 作系统、分时 *** 作系统、实时 *** 作系统

C．批处理 *** 作系统、分时 *** 作系统、分布式 *** 作系统

D．分时 *** 作系统、网络 *** 作系统、分布式 *** 作系统

20．在______ *** 作系统的控制下，计算机能及时处理过程控制装置反馈的信息，并作出响应。

（ C ）

A．网络 B．分时 C．实时 D．批处理

22．对计算机系统起着控制和管理作用的是（ B ）

A．硬件 B． *** 作系统 C．编译系统 D．应用程序

23．进程在执行中状态会发生变化，不可能出现的状态变化情况是（D ）

A．运行变为就绪 B．运行变为等待 C．等待变为就绪 D．等待变为运行

24．若在一个单处理器的计算机系统中同时存在5个并发进程，则任何时刻允许占用处理器的进程数为（ B ）

A．至少1个 B．最多1个 C．至少5个 D．最多5个

25．实存的存储分配算法用来决定输入的程序和数据放到主存中的位置，采用“总是把程序装入主存中最大的空闲区域”的算法称为（ B ）

A．最优适应算法 B．最坏适应算法 C．最先适应算法 D．循环最先适应算法

26．虚拟存储系统中，完成地址转换工作的是（ D ）

A．硬件 B．地址转换程序 C．装入程序和地址转换程序 D．装入程序

27．通过______表示磁盘上每一磁盘块的唯一地址。（ B）

A．柱面号、扇区号 B．磁头号、扇区号 C．柱面号、磁头号 D．柱面号、磁头号、扇区号

28．UNIX中对可分配磁盘存储空间采用______方法管理。（ B ）

A．位示图 B．空闲块成组链 C．空闲块单向链 D．空闲块表

29．属共享型设备的是（ C ）

A．打印机 B．磁带机 C．磁盘机 D．输入机

30．等待当前磁道上的某指定扇区旋转到磁头下所需的时间称为（ C ）

A．寻找时间 B．启动时间 C．延迟时间 D．传送时间

31．作业调度选中一个作业并把它装入主存，就为该作业创建一个进程，这个进程的初始状态为（ B ）

A．收容状态 B．就绪状态 C．执行状态 D．等待状态

32．能使平均周转时间最小的作业调度算法是（ A ）

A．计算时间短的作业优先算法 B．响应比最高者优先算法 C．优先数调度算法 D．均衡调度算法

33．引起一个进程从运行状态变为等待状态的原因可能是由于（ C ）

A有更高优先级的进程就绪 B某外围设备完成了指定的 *** 作 C进程调用了P *** 作 D进程调用了V *** 作

34．在实现进程通信时会导致调用Send原语的进程被设置成“等信箱”状态的原因是 D

A．指定的信箱不存在 B．调用时没有设置参数 C．指定的信箱中无信件 D．指定的信箱中存满了信件

35．对资源采用按序分配的策略可以使产生死锁的______条件不成立。（ D ）

A．互斥使用资源 B．占有并等待资源 C．不可抢夺资源 D．循环等待资源

36．在下列解决死锁的方法中，属于死锁预防策略的是（ B ）

A．银行家算法 B．资源有序分配法 C．定时运行死锁检测程序法 D．资源分配图化简法

37．要求进程一次性申请所需的全部资源，是破坏了死锁必要条件中的（ B ）

A．互斥 B．请求与保持 C．不剥夺 D．循环等待

38．使用一个信号量协调6个进程对2个同类临界资源的访问，下列哪个信号量值不应该出现（ A ）

A．3 B．0 C．–1 D．–3

39．可执行程序存在于（ D ）

A．名空间 B．逻辑地址空间 C．储存空间 D．物理地址空间

40．从下列关于虚拟存储器的论述中，选出一条正确的论述。B

A．要求作业运行前，必须全部装入内存，且在运行中必须常驻内存；

B．要求作业运行前，不必全部装入内存，且在运行中不必常驻内存；

C．要求作业运行前，不必全部装入内存，但在运行中必须常驻内存；

D．要求作业运行前，不必全部装入内存，但在运行中必须常驻内存；

41．可解决文件重名问题的最简单的目录结构是（C ）

A．单级目录 B．树型结构目录 C．二级目录 D．便于共享的目录

42．系统利用 SPOOLING技术实现（ B）

A对换手段 B虚拟设备 C系统调用 D虚拟存储

存储管理

 1。一个32位地址的计算机系统使用二级页表，虚地址被分为9位顶级页表，11位二级页表和偏移。试问：页面长度是多少？虚地址空间共有多少个页面？解答：

 因为32-9-11=12，所以，页面大小为4KB

 页面个数为2的20次访个

 2。在一分页存储管理系统中，逻辑地址长度为16位，页面大小为4096字节，现有一逻辑地址为2F6AH,且第0、1、2页依次存在物理块10、12、14号中，问相应的物理地址为多少？

 解答：因逻辑地址长度为16位，页面大小4096字节，

 所以，前面的4位表示页号。

 2F6AH的二进制表示：0010 1111 0110 1010

 可知页号为2。故放在14号物理块中。

 十六进制表示为：EF6AH

 3。设一页式管理系统，向用户提供的逻辑地址空间最大为16页，每页2048字节，内存中共有8个存储块。试问逻辑地址至少应为多少位？内存空间有多大？解答：

 逻辑地址： 211╳24，为15位

 内存大小为： 23╳211=214 B=16KB

 4``一个有快表的请页式虚存系统，设内存访问周期为1微秒，内外存传送一个页面的平均时间为5毫秒，如果快表命中率为75%，缺页中断率为10%。忽略快表访问时间，试求内存的有效存取时间。解答：

 内存命中率15%

 内存的有效存取时间：

 1╳75%+2╳15%+(5000+2)╳10%=50125微

5．某虚拟存储器的用户编程空间共32个页面，每页为1KB，内存16KB。假定某时刻一用户页表中已调入内存的页面的页号和物理块号的对照表如下：

页号 物理块号

0 3

1 7

2 11

3 8

则逻辑地址0A5C(H)所对应的物理地址是什么？

解答：

0A5C(H)： 0000 1010 0101 1100

2

查表得： 11

0010 11

拼接得： 0010 1110 0101 1100

2E5C(H)

在存储器管理中，页面是信息的 物理 单位，分段是信息的 逻辑 单位。页面大小由 系统 确定，分段大小由＿用户程序确定。

4银行家算法中，若出现下述的资源分配情况：

已分配 尚需资源 未分配

P0 0 0 1 0 2 0 1 0 2 4 3 1

P1 1 0 0 0 0 7 5 1

P2 1 3 5 4 1 0 0 4

P3 0 1 3 1 0 0 4 1

P4 0 0 1 4 0 5 4 2

⑴该状态是安全的吗？

⑵如果P1再提出资源请求Request（0 3 2 1），系统能否将资源分配给它？

解：系统的已分配资源数数为(2 4 10 9),可用资源数为(2 4 3 1)

⑴ P0(2 4 4 1)-> P3(2 5 7 2)->P4(2 5 8 6)->P2(3 8 13 10)

->P1(4 8 13 10)为其中一个安全序列，所以该状态安全。

⑵ 不能。因为一旦分配，P1还需P1(0 4 3 0),系统的可用资源数为(2 1 1 1)，在所有进程中只有P0(2 0 1 0)，为其分配，作上完成标志，可用资源为(2 1 2 1)；而P1/P2/P3/P4均不能作上完成标志

5一个请求页式存储系统中，一个程序的页面走向为2，3，1，2，4，3，5，7，2，3，4，3，6，2，1，3，4，1假设分配给程序的存储块数为3块，请给出OPT、FIFO、LRU每种页面置换算法的页面走向，并计算缺页率。

解：

1 OPT最佳置换算法：淘汰最远将来才使用的页。

2 FIFO先进先出置换算法：淘汰最先进来的页。

3 LRU最近最久未使用置换算法：最近最久未使用的页。

FOPT=10/18=56% FIFO=14/18=78% LRU=15/18=83%

1 6 *** 作系统如果采用段页式存储分配方案，要求：（8分）有5个批处理的作业A，B，C，D，E几乎同时到达一个计算中心，估计的运行时间分另为2，4，6，8，10min，它们的优先权分别为1，2，3，4，5（5为最高优先级）。请用下面的调度算法，分别计算作业的平均周转时间（忽略作业的切换开销）：

（1）时间片轮转（时间片为2min）

（2）最短作业优先

解：（1）时间片轮转，各作业的执行结束时间分别为2，12，20，26，30，平均周转时间为：

T＝（2＋12＋20＋26＋30）/5＝18min

（2）最短作业优先，各作业的执行结束时间分别为2，6，12，20，30，平均周转时间为：

T＝（2＋6＋12＋20＋30）/5＝14min

⑴给出段页式存储分配方案的基本思想及产生什么零头？

⑵如果一页为2K，请通过以下给出的表计算出逻辑地址2/3673的物理地址

解：⑴段页式存储的基本思想：把程序按本身的逻辑结构分成若干段，每段都有自己的地址，内存等分成若干大小相等位置固定的块，分配是以块为单位进行分配，装入时把每段分成与块相等的页，页装入到块中，一个程序不用所有的段，一段不用所有的页都装入就可运行。零头：最后一页可能在存储时出现空间闲置。

⑵如果一页为2K，请通过以下给出的表计算出逻辑地址2/3673的物理地址。

解⑵从题意和表中看出属2段，页号1对应的块号33

物理地址=块的大小×块号+页内位移=2K×33+1625=69209

9有一多道程序设计系统，主存空间为100K，采用可变分区管理及最先适应算法，作业和进程调度均采用FCFS算法，作业序列如下

作业 提交时间 运行时间 主存要求 装入时间

1 101 03小时 15K

2 103 05小时 60K

3 105 04小时 50K

4 106 04小时 10K

5 107 02小时 20K

• (1)作业装入主存的时间及次序；J1→J2→J4→J5→J3

(2)计算周转时间，及平均周转时间

作业 提交时间 运行时间 开始时间 完成时间 周转时间

1 101 03小时 101 104 03

2 103 05小时 104 109 06

3 105 04小时 115 119 14

4 106 04小时 109 113 07

5 107 02小时 113 115 08

12 段表如下：

段号 基址 长度 ……

0 1300 390 ……

1 400 780 ……

2 2900 1000 ……

3 230 30 ……

逻辑地址[1, 282]的物理地址是 (1) 682 ；

逻辑地址[2, 1003]的物理地址是 (2)溢出 ；

逻辑地址[3, 28]的物理地址是 (3)258 。

39某个采用多道程序设计的计算机系统配有输入机和打印机各一台，现有程序A和程序B并行执行，且程序A先开始50ms。假定程序A的执行过程为：计算50ms，打印100ms，再计算50ms，打印100ms，结束；程序B的执行过程为：计算50ms，输入数据60ms，再计算50ms，打印100ms，结束。当忽略调度和启动外设等所花费的时间时，回答下列问题：(8分)

(1)把程序A和程序B并行执行时各自使用CPU与外设的时间用实线画在下图中

时间

CPU

输入机

打印机

(2)在程序开始执行直到两道程序都执行结束时，处理器的利用率是

________。

(3)程序B从开始执行直到结束实际花费的时间是________。

40假设有一磁盘含有64000块，每块长度为1024字节，块号记为1～64000，现用2000个32位(Bit)的字作该盘的位示图，试问第59999块对应于位示图中第几字的第几位(字位均从0开始)；而第1599字的第17位(同上，从0开始)对应于第几块(10分)

41在单道批处理系统中，有下列四个作业，采用计算时间短的作业优先的调度算法，当第一个作业进入系统后就可以开始调度，忽略调度及I/O所化的时间。(8分)

(1)按上述要求填充表中空白处

作业号 进入系统时间 需计算时间 开始时间 完成时间 周转时间

1 10:00 24分钟

2 10:06 1小时

3 10:12 36分钟

4 10:18 12分钟

(2)四个作业的平均周转时间为________。

以上就是关于银行家算法，我这里有个程序，每次运行完就输出同样的结果，安全序列也一样，请帮忙看看那里错了！全部的内容，包括:银行家算法，我这里有个程序，每次运行完就输出同样的结果，安全序列也一样，请帮忙看看那里错了！、计算机 *** 作系统为什么要引用对换、等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！