#include<stdio.h>
voidrukou(intjinchenggeshu,intziyuangeshu)
{
inti,j,k=0;
intzanyong[100][100];
intxuqiuzuida[100][100];
intxuyaoziyuangeshu[100][100];
intmeizhongziyuangeshu[100];
intmeizhongzuyuanshengyugeshu[100];
intjieguo[100];
intshifouanquan=0;
intkongshu;
intgaibianshuju;
intyongyouziyuanjishu;
for(i=0;i<jinchenggeshu;i++)
for(j=0;j<ziyuangeshu;j++)
{
printf(" 请输入第%d进程现在占用第%d种资源的个数：",i+1,j+1);
scanf("%d",&zanyong[i][j]);
}
for(i=0;i<jinchenggeshu;i++)
for(j=0;j<ziyuangeshu;j++)
{
printf(" 请输入第%d进程现在所需最大第%d种资源的个数：",i+1,j+1);
scanf("%d",&xuqiuzuida[i][j]);
}
for(i=0;i<ziyuangeshu;i++)
{
printf(" 请输入第%d种资源的个数：",i+1);
scanf("%d",&meizhongziyuangeshu[i]);
}
printf("如果有输入错误想改变 ");
gaibian:printf("想改变占用的数据请输入1 ");
printf("想改变最大资源需求量的数据请输入2 ");
printf("想改变资源中的数据请输入3 ");
printf("退出改变数据请输入4 ");
scanf("%d",&gaibianshuju);
if(gaibianshuju==1)
{
printf("请输入改变哪个进程中的数据：");
scanf("%d",&i);
printf("请输入改变哪种资源中的数据：");
scanf("%d",&j);
printf("请输入新数据：");
scanf("%d",&zanyong[i][j]);
gotogaibian;
}
elseif(gaibianshuju==2)
{
printf("请输入改变哪个进程中的数据：");
scanf("%d",&i);
printf("请输入改变哪种资源中的数据：");
scanf("%d",&j);
printf("请输入新数据：");
scanf("%d",&xuyaoziyuangeshu[i][j]);
gotogaibian;
}
elseif(gaibianshuju==3)
{
printf("请输入改变哪种资源中的数据：");
scanf("%d",&j);
printf("请输入新数据：");
scanf("%d",&meizhongziyuangeshu[j]);
gotogaibian;
}
elseif(gaibianshuju==4);
else{
printf("您选择的无效，请从新选择 ：");
gotogaibian;
}
for(i=0;i<jinchenggeshu;i++)
for(j=0;j<ziyuangeshu;j++)
xuyaoziyuangeshu[i][j]=xuqiuzuida[i][j]-zanyong[i][j];
for(j=0;j<ziyuangeshu;j++)
{
yongyouziyuanjishu=0;
for(i=0;i<jinchenggeshu;i++)
yongyouziyuanjishu+=zanyong[i][j];
meizhongzuyuanshengyugeshu[j]=meizhongziyuangeshu[j]-yongyouziyuanjishu;
}
while(1)
{
shifouanquan++;
for(i=0;i<jinchenggeshu;i++)
{
if(zanyong[i][0]!=-1)
{
kongshu=0;
for(j=0;j<ziyuangeshu;j++)
if(meizhongzuyuanshengyugeshu[j]>=xuyaoziyuangeshu[i][j])
kongshu+=1;
if(kongshu==ziyuangeshu)
{
for(j=0;j<ziyuangeshu;j++)
meizhongzuyuanshengyugeshu[j]+=zanyong[i][j];
zanyong[i][0]=-1;
jieguo[k]=i+1;
k++;
}
}
}
if(k==jinchenggeshu)
{
printf("T0时刻是安全状态，安全序列为：");
for(i=0;i<jinchenggeshu;i++)
printf("%d",jieguo[i]);
break;
}
if(shifouanquan>k)
{
printf("T0时刻是不安全状态!");
break;
}
}
}
intmain()
{
intjinchenggeshu,ziyuangeshu;
printf("请输入进程个数：");
scanf("%d",&jinchenggeshu);
printf("请输入资源种类数:");
scanf("%d",&ziyuangeshu);
rukou(jinchenggeshu,ziyuangeshu);
return0;
}
B. 高分 求计算机操作系统填空题答案~!
1. 操作系统的基本功能包括（ 存储）管理、（处理机 ）管理、（ 文件 ）管理、（ 设备）管理以及提供用户接口。
2. 系统调用与一般函数调用的执行方式有着明显的不同,系统调用运行在（ 系统 ）态,一般函数调用运行在( 用户)态。
3. 进程并发执行时有间断性、（制约性）和（无封闭性和可再现性）的特点。
4. 进程的基本特征有（ 9动态 ）、（ 10并发 ）、独立、异步及结构特征。
5. UNIX系统的文件目录项由两部分构成，即文件名和（ 11 ）；
6. 临界资源的概念是（12不允许多个进程交替、穿插、轮流进行访问的资源），而临界区是指（13访问临界资源的那段代码）。
7. 产生死锁的原因可以归结为两点：（14资源竞争）和（15不可抢占）。
8. 段页式存储管理中，是将作业分（ 段 ），（ 段 ）内分（ 18页 ），内存分配以（ 19页面 ）为单位。
9. 分页存储管理方式中，在不考虑使用快表的情况下，每条访问内存的指令需要（ 20两 ）次访问内存；
10. 在操作系统中，不可中断执行的操作称为（ 21 ）操作；
11. 进程访问临界资源的代码段称为（ 22临界区 ），为保证进程互斥，应在进程的临界区前设置（ 23P（mutex） ），在临界区后设置（ 24V（mutex） ）。
12.银行家算法中，当一个进程提出的资源请求将导致系统从（ 25安全状态 ）进入（ 26不安全状态 ）时，系统就拒绝它的资源请求。
13.页面调入策略要解决（27请求页）、（28提前页）两个问题。
14.最佳置换算法是选择（29永不使用）或（30最长时间不再使用）的页面做为被淘汰的页面。
15.UNIX系统中，用于创建进程的两个常用系统调用是( 31 )和( 32 )。
16.进程调度负责（ 33处理机 ）的分配工作。
17.操作系统内核通常包含（34 ）功能和（35 ）功能。
18. 快表用来存放（36正在运行进程的、当前最常用的部分页号及它的相应页面号 ）。
我就知道这么多了……
C. 银行家算法应用在哪些方面
只要是涉及多个独立个体对某种资源的动态申请和回收就可以应用此算法。在计算机科学中一般用此算法检测进程的推进顺序是否是安全队列，如果不是的话，会因为对资源的争夺而造成死锁。
D. 银行家算法
Dijkstra（1965）提出了一种能够避免死锁的调度算法，称为银行家算法（banker's algorithm），这是6.4.1节中给出的死锁检测算法的扩展。该模型基于一个小城镇的银行家，他向一群客户分别承诺了一定的贷款额度。算法要做的是判断对请求的满足是否会导致进入不安全状态。如果是，就拒绝请求；如果满足请求后系统仍然是安全的，就予以分配。在图6-11a中我们看到4个客户A、B、C、D，每个客户都被授予一定数量的贷款单位（比如1单位是1千美元），银行家知道不可能所有客户同时都需要最大贷款额，所以他只保留10个单位而不是22个单位的资金来为客户服务。这里将客户比作进程，贷款单位比作资源，银行家比作操作系统。
E. 为什么银行家算法避免死锁的发生
在T0时刻如果有某个进程提出资源请求，比如：进程1提出request（1,2,2）请求，即分别需要三类资源数为1,2,2。然后系统先检测该请求是否合法（是否超出它的尚需资源量，是否超出系统目前剩余量），在合法的前提下系统尝试将他所申请的资源分配给P1进程，然后系统调用安全性算法来检测经过这次尝试性分配后能不能再找到一个安全序列，使所有进程顺利结束，如果能找到则此次尝试分配是安全的，否则回收刚才进行的尝试分配的所有资源。
F. 一道关于银行家算法（计算机）的问题
你这段代码有输出，怎么没有包含 stdio.h 头文件，你打错单词了吧
'studio.h' studio是 套件、工作室 的意思吧
应该是包含<stdio.h>,std是‘标准 standard’的缩写，io是 in/out 输出输入。
G. 计算机操作系统安全序列
序列号共有5组，每组5个字符，总共有25个字符。这些字符包括字母和数字，一个正确的序列号会选用以下24个基本字符：B、C、D、F、G、H、J、K、M、P、Q、R、T、V、W、X、Y、2、3、4、6、7、8、9。如果你的序列号含有这24个字符之外的其他字符，那不用说一定是错误的。
下面言归正传，为大家介绍一下不同版本Windows序列号的查找方法。让Windows序列号原形毕露1．Windows98Windows98的安装序列号最容易找，因为它就藏在注册表里，我们一起把它给揪出来吧！首先打开注册表编辑器，依次展开HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion分支，在右侧窗口中找到“ProctKey”字符串值，对，它的键值就是序列号！晨风提示（1）WindowsMe基于Windows98内核，所以其序列号的查找方法与Windows98一样，就连在注册表中的藏身之处也丝毫不差。
（2）上面介绍的方法有个前提条件，就是必须能进入Windows图形界面，如果连Windows也进不了，我们还可以在DOS下查看Windows98的序列号：用启动盘启动电脑，然后输入C?＼Windows＼Command＼Find/l“ProctKey”C?＼Windows＼System．dat（假设C盘为系统盘），回车后就会显示出Windows98的序列号了。
2．Windows2000既然Windows98的安装序列号藏身在注册表里，那么Windows2000呢？你可不要指望能在注册表里找到它，因为出于安全考虑，微软根本就没有将Windows2000的序列号放到注册表里。别着急，我们不妨在Windows2000的系统文件夹里搜寻一番，说不定“踏破铁鞋无觅处，得来全不费工夫”。
在资源管理器中进入Windows2000的系统安装文件夹，打开\System32文件夹，找到$winnt$。inf文件，直接双击用记事本打开，[userdata]小节“Proctid=”后面引号中的字符串，就是Windows2000的序列号！3．WindowsXP
H. 浅析银行家算法
作为避免死锁的一种算法，银行家算法可以说是最为出名的了。这个名字的来源是因为该算法起初是为银行系统设计的，以确保银行在发放现金贷款时，不会发生不能满足所有客户需要的情况。在操作系统中也可以用它来实现避免死锁。
首先我们要了解银行家算法的本质也即避免死锁的原理。避免死锁作为一种事先预防死锁的策略，原理是在为各个进程分配资源的过程中不允许系统进去不安全状态，以此来避免死锁的发生。所谓安全状态，是指系统能按某种进程推进顺序为每个进程分配其所需资源，直至满足每个进程对资源的最大需求，使每个进程都可以顺利地完成。此时称该进程推进序列为安全序列，如果无法找到这样一个安全序列，则称系统处于不安全状态。
银行家算法中的数据结构。为了实现银行家算法，在系统中必须设置这样四个数据结构，分别用来描述系统中可利用的资源，所有进程对资源的最大需求，系统中的资源分配以及所有进程还需要多少资源的情况。
(1)可利用资源向量Available。这是一个含有m个元表的数组,其中的每一个元素代表一类可利用的资源数目。其数值随该类资源的分配和回收而动态地改变。如果 Available=K,则表示系统中现有Rj类资源K个。
(2)最大需求矩阵Max。这是一个nxm的矩阵,它定义了系统中n个进程中的每个进程对m类资源的最大需求。如果Max[i,j]=K,则表示进程i需要Rj类资源的最大数目为K。
(3)分配矩阵 Allocation。这也是一个nxm的矩阵,它定义了系统中每一类资源当前已分配给每一进程的资源数。如果Allocation[i,j]=K,表示进程i当前已分得Rj类资源的数目为K。
(4)需求矩阵Need。这也是一个nxm的矩阵,用以表示每一个进程尚需的各类资源数。如果Need[i,j]=K，则表示进程i还需要Rj类资源K个才能完成。
当一个进程发出请求资源的请求后，如果它所请求的资源大于目前系统可利用资源则不予分配。如果小于可利用资源，则系统试探着把资源分配给该进程，并修改分配之后的资源数值。接着系统执行安全算法，检查此次资源分配后系统是否处于安全状态。若安全，才正式将资源分配给该进程，以完成本次分配。否则，将本次的试探分配作废，恢复原来的资源分配状态，让该进程等待。
I. 操作系统题目,好的追加高分,感谢大虾
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语言进行了复习，而且其过程中有很多的知识点都不记得了，所以在此感谢在此过程中帮助过我的老师和同学。
最后的感悟就是：只要你亲自动手，你就能学到知识。
再次感谢帮助过我的老师和同学！