操作系统课程设计----模拟银行家算法避免死锁（优秀范文五篇）

第一篇：操作系统课程设计----模拟银行家算法避免死锁

模拟通过银行家算法避免死锁

一、银行家算法产生的背景及目的 1：在多道程序系统中，虽然借助于多个进程的并发执行来改善系统的利用率，提高系统的吞吐量，但可能发生一种危险—死锁。死锁就是多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵局状态时，如无外力作用，他们将无法再向前进行，如再把信号量作为同步工具时，多个Wait和Signal操作顺序不当，会产生进程死锁。

然而产生死锁的必要条件有互斥条件，请求和保持条件，不剥夺条件和环路等待条件。在预防死锁的几种方法中，都施加了较强的限制条件，在避免死锁的方法中，所施加的条件较弱，有可能获得令人满意的系统性能。在该方法中把系统的状态分为安全状态和不安全状态，只要能使系统都处于安全状态，便可避免死锁。2：实验目的：让学生独立的使用编程语言编写和调试一个系统分配资源的简单模拟程序，了解死锁产生的原因及条件。采用银行家算法及时避免死锁的产生，进一步理解课堂上老师讲的相关知识点。银行家算法是从当前状态出发，逐个按安全序列检查各客户中谁能完成其工作，然后假定其完成工作且归还全部贷款，再进而检查下一个能完成工作的客户。如果所有客户都能完成工作，则找到一个安全序列，银行家才是安全的。

二：银行家算法中的数据结构

1：可利用资源向量Available。这是一个含有m个元素的数组，其中的每个元素代表一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源的数目，其数值随该类资源的分配和回收而动态的改变。如果Available[j]=k，z 则表示系统中现有Rj类资源K 个。

2：最大需求矩阵Max。这是一个n*m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。如果Max[i,j]=k，表示第i个进程需要第Rj类资源的最大数目k个.3: 分配矩阵Allocation,也是n*m的矩阵，若Allocation[i,j]=k,表示第i 个进程已分配Rj类资源的数目为k个。

4：需求矩阵Need。也是一个n*m的矩阵，Need[i,j]=k,表示第i个进程还需Rj类资源k个。

三、银行家算法及安全性算法

1：银行家算法

设Request[i]是进程Pi的请求向量，若Request[i][j]=k;表示进程需要j类资源k个。当Pi发出资源请求时，系统按下属步骤进行检查；(1)如果Request[i][j]<=Need[i][j];便转向步骤（2），否则认为出错，因为它所需要的资源数已超过他所宣布的最大值。

(2)如果Request[i][j]<=Available[i][j],便转向步骤（3），否则认为尚无足够资源，进程需等待。(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)系统执行安全性算法，检查此次资源分配后系统是否处于安全状态。若安全，才正式将资源分配给进程Pi，已完成此次分配。否则，将本次的试探分配作废，回复原来的资源分配状态，将进程Pi等待。2：安全性算法

（1）设置两个向量；

1：工作向量Work，表示系统可提供给进程运行所需的各类资源数目，它含有m个元素，初始时Work=Available 2：Finish ,表示系统是否有足够的资源分配给进程，使之运行完成。开始时先做Finish[i]=true（2）从进程中找到一个能满需下属条件的进程

1；Finish[i]=false；

2：Need[i][j]<=Work[j];若找到执行步骤（3），否则执行步骤（4）

（3）当进程Pi顺利获得资源后，直至完成，并释放分配给它的资源，执行： Work[j]=Work[j]+Allocation[i][j];Finish[i]=true;Go to step(2);(5)如果所有的进程Finish[i]都满足，则表示系统处于安全状态，否则，处于不安全状态。

四、模块设计与分析及整体功能概述

模块设计与分析：

整个银行家算法分为初始化函数Init（），安全性算法函数 safe（），银行家算法函数bank（）三部分。初始化函数生成开始时刻系统中的进程和资源情况，安全性算法判断当某进程申请资源时，系统能否处于安全状态。在本实验中，若系统处于安全状态，便生成一个安全进程序列（安全序列可能有多个）。银行家算法函数bank（）负责整体的检查与异常判断。整体功能概述：

死锁会引起系统陷入僵局，操作系统必须防止此现象的发生。本实验通过一个动态分配资源的模拟程序，更清楚的理解死锁产生的原因和条件。Dijkstra的银行家算法是最有代表性的避免死锁的方法。运行程序时用户设定系统中进程和可利用资源的种类数目。输入各进程的可利用资源Available，最大需求MAX，已分配资源Allocation，需求资源Need，之后各系统发出资源请求Request，利用实验中的安全性算法判断能否产生一个安全性队列，若能，则给该进程分配成功，否则，不予分配。

五、流程图设计

六、源代码及调试分析

#include #define MAXm 50

// 定义最大进程数 #define MAXn 100

//定义最大资源数

int MAX[MAXm][MAXn];

//最大需求矩阵 int Allocation[MAXm][MAXn];

//已分配矩阵 int Available[MAXn];

//可用资源数组 int Need[MAXm][MAXn];

//需求矩阵 int Request[MAXm][MAXn];

//请求矩阵

int Finish[MAXm];

//存储完成资源分配的进程 int Sequence[MAXm];

//模拟的资源分配序列

int Work[MAXn];

//系统是否有足够的资源分配给进程 int m,n;

//m个进程,n个资源

#define False 0 #define True 1 void input();//数据输入函数 int safealg();//安全性算法函数 void banker();//银行家算法函数 void main(){input();safealg();banker();}

//*************初始化算法*************** void input(){ int i,j;

//************自定义进程数目与资源种类******************* cout<<“***********************************n”;cout<<“*利用银行家算法避免死锁*n”;

cout<<“*

*n”;cout<<“************************************n”;cout<<“请输入进程的数目:”;cin>>m;cout<<“请输入资源的种类:”;cin>>n;//*****输入每个进程对每种资源的最大需求、已经获得的数量、每种类型资源的数目

cout<<“各进程资源最大需求(Max),按照”<

cout<<“P”<

for(j=0;j

{

cin>>MAX[i][j];

if(j==n)

cout<<“资源种类数匹配出现错误！”;//当资源配置的种类数大于预先输入的数值时，出错

} } cout<<“各进程当前获得资源(Allocation),按照”<

cout<<“P”<

for(j=0;j

{

cin>>Allocation[i][j];

if(j==n)

cout<<“资源种类数匹配出现错误！”;//当资源配置的种类数大于预先输入的数值时，出错

Need[i][j]=MAX[i][j]-Allocation[i][j];//需求数等于最大需求减去已经分配数

} } cout<<“系统可用资源(Available):”<

cin>>Available[j];//输入各种资源的可利用数

} cout<<“当前时刻的进程分配情况如图：n”;cout<<“进程号-”<<“MAX----”<<“Allocation---”<<“Need--”<<“Available---n”;//显示各进程的资源情况

for(i=0;i

cout<<“P”<

for(j=0;j

cout<<“ ”<

for(j=0;j

cout<<“ ”<

cout<<“ ”;

for(j=0;j

cout<<“ ”<

for(j=0;j

cout<<“ ”<

cout<

} } //*****************银行家算法，为进程分配资源***********// void banker(){ int i,j;

int choice;

while(1)

{

cout<

cout<<“输入要进行的操作(1:分配资源

2:离开):”;

//用户选择

cin>>choice;

if(choice==1)

//分配资源

{

cout<<“从P0到P”<

cin>>i;

if(i>=m)

{

cout<<“无此进程号!请重新输入:n”;

cin>>i;//重新输入进程号

}

cout<<“请输入进程申请的资源(Request):”<

for(j=0;j

cin>>Request[i][j];

//**********银行家算法进行检查*************//

for(j=0;j

{

if(Request[i][j]>Need[i][j])

{

cout<<“申请的资源大于它需要的资源数,请重新输入!n”;//资源申请不合理

continue;

}

if(Request[i][j]>Available[j])

{

//资源申请数目大于可利用数，无法分配，得等待

cout<<“当前系统可用资源不够，请等待!”<

continue;

}

}

for(j=0;j

{

Available[j]=Available[j]-Request[i][j];

//可用资源减少

Allocation[i][j]=Allocation[i][j]+Request[i][j];//所得资源增加

Need[i][j]=Need[i][j]-Request[i][j];

//仍需资源减少

}

if(safealg()<0)//安全性算法的返回值

{

cout<<“分配不成功，请等待！”;

for(j=0;j

//把资源恢复成分配之前的状态

{

Available[j]=Available[j]+Request[i][j];

Allocation[i][j]=Allocation[i][j]-Request[i][j];

Need[i][j]=Need[i][j]+Request[i][j];

}

for(i=0;i

{

Finish[i]=False;//没有足够的资源分配给该进程

}

}//if(safealg()<0)

else

{

cout<<“同意分配请求!”<

for(j=0;j

Work[j]=Available[j];

cout<<“进程号-”<<“--Work----”<<“Need---”<<“Allocation---”<<“Work+Allocation--”

<<“Finish--”<

for(i=0;i

{

cout<<“进程P”<

for(j=0;j

cout<

cout<<“ ”;

for(j=0;j

cout<

cout<<“ ”;

for(j=0;j

cout<

cout<<“

”;

for(j=0;j

cout<

cout<<“

”;

cout<

for(j=0;j

Work[j]=Allocation[Sequence[i]][j]+Work[j];//回收该进程所分配的资源

cout<

}

}//if(safealg()>=0)

}//if(choice=1)

else if(choice==2)

//离开————

break;

else cout<<“请输入1或2!”;//只认可1或2 }//while(1)} //*********安全性算法 ************// int safealg(){

int i,j,k,l=0;

//int Work[MAXn];

//工作组

//记录序列

for(i=0;i

Work[i]=Available[i];

//工作分配初始化为系统可用资源

for(i=0;i

//扫描所有进程，预设所有进程不能运行

{

Finish[i]=False;

}

for(i=0;i

{ //

if(Finish[i]==True)

{

continue;

}

else //对于未运行的进程，进行如下处理

{///

for(j=0;j

{

if(Need[i][j]>Work[j])//由于部分资源得不到满足，进程i无法运行

{ 的资源

用资源

}

break;

} }

if(j==n)//进程各类资源全部得到满足

{

Finish[i]=True;

for(k=0;k

{ Work[k]+=Allocation[i][k];//工作分配加上可

}

Sequence[l++]=i;

//模拟资源分配序列生成 i=-1;

//重新扫描所有进程从i=0开始

}

else

{ //某一资源得不到满足

continue;//试探下一个进程

} }// if(l==m)//都试探完毕

{

cout<<“系统安全!”<

cout<<“安全序列：”;

for(i=0;i

//输出安全序列

cout<<“进程P”< ”;

cout<

return 0;} }// cout<<“系统进入不安全状态！”<

分析：输入各进程的可利用资源Available，最大需求MAX，已分配资源Allocation，需求资源Need，之后各系统发出资源请求Request，利用实验中的安全性算法判断能否产生一个安全性队列，若能，则给该进程分配成功，否则，不予分配。在确定安全序列的过程中，要检测所有进程的Finish[i]的值，每次循环检测完后要重复从第一个进程开始。

七、运行结果 假设输入进程个数为5，资源种类数为3，并以此输入各进程初始时刻的各种资源数量，如下

若再继续申请资源，假设为P4，申请资源（1 2 2）

假设P1 申请资源（2 2 4）有

八、心得体会

经过这次操作系统课程设计，让我受益匪浅，收获颇多。主要体会如下： 1.利用Vc++编译程序编写银行家算法，进一步理解到通过银行家算法避免死锁的思想,同时也理解了系统死锁产生的原因及条件。

2.在实验过程中所有的设计步骤遵循老师教授的程序功能化的思想，分别定义了三个函数，init()初始化函数,safealg()安全性算法函数，bank（）银行家算法函数，体现了函数的模块化思想。这样的话，不仅提高了程序的可读性和可操作性，而且还提高了CPU的利用率和内存的利用率，因为程序的运行是局部性的，这种思想对于段页式存储管理系统尤为重要。

3.实验过程中遇到的种种疑难问题通过自己上网查找答案，锻炼了自己纠错能力和搜索有价值信息的能力及自学的能力，并且进一步巩固了自己以前学过的专业知识。

第二篇：操作系统银行家算法(避免死锁)实验报告

操作系统实验：银行家算法

姓名：李天玮

班级：软工1101 实验内容：

在windows系统中实现银行家算法程序。

学号：201126630117 实现银行家算法所用的数据结构：

假设有5个进程3类资源，则有如下数据结构： 1.MAX[5，3] 5个进程对3类资源的最大需求量。2.AVAILABLE[3]系统可用资源数。

3.ALLOCATION[5,3]5个进程已经得到3类资源的资源量。4.NEED[5,3]5个进程还需要3类资源的资源量。

银行家算法：

设进程1提出请求Request[N]，则银行家算法按如下规则进行判断。(1)如果Request[N]<=NEED[1,N],则转（2）；否则，出错。(2)如果Request[N]<=AVALIABLE，则转（3）；否则，出错。(3)系统试探非配资源，修改相关数据。

AVALIABLE=AVALIABLE-REQUEST ALLOCATION=ALLOCATION+REQUEST NEED=NEED-REQUEST(4)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。

安全性检查：

（1）设置两个工作向量WORK=AVAILABLE；FINISH[M]=FALSE.（2）从晋城集合中找到一个满足下述条件的进程，FINISH[i]=FALSE NEED<=WORK 如找到，执行（3）；否则，执行（4）。

（3）设进程获得资源，可顺利执行，直至完成，从而释放资源。

WORK=WORK+ALLOCATION FINISH[i]=TRUE GOTO（2）

（4）如所有进程FINISH[M]=TRUE，则表示安全；否则系统不安全。

1.用init（）函数对于数据的初始化

关键代码：

#define M 5 #define N 3

void init(){

cout<<“请输入5个进程对3类资源最大资源需求量:”<

} cout<<“请输入系统可用的资哩源数:”<

{ } cin>>AVAILABLE[j];for(int j=0;j>MAX[i][j];} //cout<

cout<<“请输入5个进程已经-的到的3类资源的资源量:”<

for(int i=0;i

} cout<<“请?输?入?5个?进?程ì还1需è要癮3类え?资哩?源′的?资哩?源′量?:”<

} for(int j=0;j>NEED[i][j];} //cout<>ALLOCATION[i][j];} //cout<

}// Stack around the variable 'AVAILABLE' was corrupted.显示数据详细信息

进行测试 输入一号进程号，并给需要申请资源设定为{1,0,2}

检验错误输入时候的报错信息

检验当再次申请0号资源并申请资源数目为{0,2,0}时，系统提示系统不安全申请不成功。

每当验证申请成功后会进行的修改操作：

if(flag=='Y'||flag=='y')//进?行D数簓据Y修T改?

{ changdata(i);

}

} if(chkerr(0)){

} else showdata();rstordata(i);showdata();else showdata();cout<>flag;退?出?演Y示?”;

第三篇：操作系统实验报告-利用银行家算法避免死锁

计算机操作系统实验报告

题 目 利用银行家算法避免死锁

一、实验目的：

1、加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。

2、要求编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用银行家算法，有效的防止和避免死锁的发生。

二、实验内容：

用银行家算法实现资源分配：

设计五个进程{p0,p1,p2,p3,p4}共享三类资源{A,B,C}的系统，例如，{A,B,C}的资源数量分别为10，5，7。进程可动态地申请资源和释放资源，系统按进程的申请动态地分配资源，要求程序具有显示和打印各进程的某一个时刻的资源分配表和安全序列；显示和打印各进程依次要求申请的资源号以及为某进程分配资源后的有关资源数据。

三、问题分析与设计：

1、算法思路：

先对用户提出的请求进行合法性检查，即检查请求是否大于需要的，是否大于可利用的。若请求合法，则进行预分配，对分配后的状态调用安全性算法进行检查。若安全，则分配；若不安全，则拒绝申请，恢复到原来的状态，拒绝申请。

2、银行家算法步骤：

（1）如果Requesti＜or =Need,则转向步骤(2)；否则，认为出错，因为它所需要的资源数已超过它所宣布的最大值。

（2）如果Request＜or=Available,则转向步骤（3）；否则，表示系统中尚无足够的资源，进程必须等待。

（3）系统试探把要求的资源分配给进程Pi,并修改下面数据结构中的数值：

Available=Available-Request[i];

Allocation=Allocation+Request;Need=Need-Request;(4)系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。

3、安全性算法步骤：（1）设置两个向量

①工作向量Work。它表示系统可提供进程继续运行所需要的各类资源数目，执行安全算法开始时，Work=Allocation;②布尔向量Finish。它表示系统是否有足够的资源分配给进程，使之运行完成，开始时先做Finish[i]=false，当有足够资源分配给进程时，令Finish[i]=true。

（2）从进程集合中找到一个能满足下述条件的进程：

①Finish[i]=false ②Need

（3）当进程P获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行： Work=Work+Allocation;Finish[i]=true;转向步骤（2）。

（4）如果所有进程的Finish[i]=true,则表示系统处于安全状态；否则，系统处于不安全状态。

4、流程图： 系统主要过程流程图

银行家算法流程图

安全性算法流程图

5、主要数据结构

假设有M个进程N类资源，则有如下数据结构：

int max[M*N] M个进程对N类资源的最大需求量 int available[N] 系统可用资源数

int allocated[M*N] M个进程已经得到N类资源的资源量 int need[M*N] M个进程还需要N类资源的资源量

int worked[] 系统提供给进程继续运行所需的各类资源数目

四、源代码

import java.awt.*;import javax.swing.*;import java.util.*;import java.awt.event.*;import javax.swing.border.*;

public class OsBanker extends JFrame { // 界面设计

JLabel labelInfo;JLabel labelInfo1;int resourceNum, processNum;int count = 0;JButton buttonRequest, buttonSetInit, button, button1, buttonsearch,button2;JTextField tf1, tf2;JTextField[] textAvailable;JTextField[][] textAllocation;JTextField[][] textNeed;JTextField textProcessName;JTextField[] textRequest;int available[];int max[][];int need[][];int allocated[][];int SafeSequence[];int request[];boolean Finish[];int worked[];boolean flag = false;JFrame f1;JFrame f2;JFrame f3;JTextArea jt;

void display(){

Border border = BorderFactory.createLoweredBevelBorder();

Border borderTitled = BorderFactory.createTitledBorder(border, “按钮区”);

textAvailable = new JTextField[5];

textAllocation = new JTextField[6][5];

textNeed = new JTextField[6][5];

textProcessName = new JTextField(“");

textProcessName.setEnabled(false);

textRequest = new JTextField[5];

tf1 = new JTextField(20);

tf2 = new JTextField(20);labelInfo = new JLabel(”请先输入资源个数和进程个数（1~6），后单击确定“);JPanel contentPane;contentPane =(JPanel)this.getContentPane();contentPane.setLayout(null);contentPane.setBackground(Color.pink);labelInfo.setBounds(50, 10, 300, 40);labelInfo.setOpaque(true);labelInfo.setForeground(Color.red);labelInfo.setBackground(Color.pink);contentPane.add(labelInfo, null);JLabel b1 = new JLabel(”资源个数:“);b1.setForeground(Color.blue);JLabel b2 = new JLabel(”进程个数:“);b2.setForeground(Color.blue);b1.setBounds(50, 80, 80, 30);contentPane.add(b1, null);tf1.setBounds(180, 80, 170, 30);contentPane.add(tf1, null);b2.setBounds(50, 150, 80, 30);contentPane.add(b2, null);tf2.setBounds(180, 150, 170, 30);contentPane.add(tf2, null);button1 = new JButton(”确定“);button = new JButton(”重置“);button1.setBounds(80, 200, 80, 30);contentPane.add(button1, null);button.setBounds(220, 200, 80, 30);contentPane.add(button, null);this.setSize(400, 300);this.setResizable(false);this.setTitle(”银行家算法(SXJ)“);this.setLocationRelativeTo(null);this.setDefaultCloseOperation(EXIT_ON_CLOSE);this.setVisible(true);f1 = new JFrame();labelInfo1 = new JLabel(”请先输入最大需求和分配矩阵，然后单击初始化“);JPanel contentPane1;contentPane1 =(JPanel)f1.getContentPane();contentPane1.setLayout(null);contentPane1.setBackground(Color.pink);labelInfo1.setOpaque(true);labelInfo1.setBounds(75, 10, 400, 40);

labelInfo1.setBackground(Color.pink);

labelInfo1.setForeground(Color.blue);

contentPane1.add(labelInfo1, null);

JLabel labelAvailableLabel = new JLabel(”AllResource:“);

JLabel labelNeedLabel = new JLabel(”MaxNeed:“);

JLabel labelAllocationLabel = new JLabel(”allocated:“);

JLabel labelRequestLabel = new JLabel(”request process:“);

labelNeedLabel.setBounds(75, 90, 100, 20);

// x,y,width,height

contentPane1.add(labelNeedLabel, null);

labelAllocationLabel.setBounds(75, 240, 100, 20);

contentPane1.add(labelAllocationLabel, null);

labelAvailableLabel.setBounds(75, 70, 100, 20);

contentPane1.add(labelAvailableLabel, null);

labelRequestLabel.setBounds(75, 400, 100, 20);

contentPane1.add(labelRequestLabel, null);

JLabel[] labelProcessLabel1 = { new JLabel(”进程1“), new JLabel(”进程2“)，new JLabel(”进程3“), new JLabel(”进程4“), new JLabel(”进程5“)，new JLabel(”进程6“)};

JLabel[] labelProcessLabel2 = { new JLabel(”进程1“), new JLabel(”进程2“)，new JLabel(”进程3“), new JLabel(”进程4“), new JLabel(”进程5“)，new JLabel(”进程6“)};

JPanel pPanel1 = new JPanel(), pPanel2 = new JPanel(), pPanel3 = new JPanel(), pPanel4 = new JPanel();

pPanel1.setLayout(null);

pPanel2.setLayout(null);

/*

* pPanel4.setLayout(null);pPanel4.setBounds(440,120,90,270);

* pPanel4.setBorder(borderTitled);

*/

buttonSetInit = new JButton(”初始化“);

buttonsearch = new JButton(”检测安全性“);

button2 = new JButton(”重置“);

buttonRequest = new JButton(”请求资源“);

buttonSetInit.setBounds(420, 140, 100, 30);

contentPane1.add(buttonSetInit, null);

buttonsearch.setBounds(420, 240, 100, 30);

contentPane1.add(buttonsearch, null);

button2.setBounds(420, 340, 100, 30);

contentPane1.add(button2, null);

buttonRequest.setBounds(420, 425, 100, 30);

contentPane1.add(buttonRequest, null);

for(int pi = 0;pi < 6;pi++){

labelProcessLabel1[pi].setBounds(0, 0 + pi * 20, 60, 20);labelProcessLabel2[pi].setBounds(0, 0 + pi * 20, 60, 20);} pPanel1.setBounds(75, 120, 60, 120);pPanel2.setBounds(75, 270, 60, 120);for(int pi = 0;pi < 6;pi++){ pPanel1.add(labelProcessLabel1[pi], null);pPanel2.add(labelProcessLabel2[pi], null);} contentPane1.add(pPanel1);contentPane1.add(pPanel2);contentPane1.add(pPanel4);for(int si = 0;si < 5;si++)for(int pi = 0;pi < 6;pi++){

textNeed[pi][si] = new JTextField();

textNeed[pi][si]

.setBounds(150 + si * 50, 120 + pi * 20, 50, 20);

textNeed[pi][si].setEditable(false);

textAllocation[pi][si] = new JTextField();

textAllocation[pi][si].setBounds(150 + si * 50, 270 + pi * 20，50, 20);

textAllocation[pi][si].setEditable(false);} for(int si = 0;si < 5;si++){ textAvailable[si] = new JTextField();textAvailable[si].setEditable(false);textAvailable[si].setBounds(150 + si * 50, 70, 50, 20);textRequest[si] = new JTextField();textRequest[si].setEditable(false);textRequest[si].setBounds(150 + si * 50, 430, 50, 20);contentPane1.add(textAvailable[si], null);contentPane1.add(textRequest[si], null);} for(int pi = 0;pi < 6;pi++)for(int si = 0;si < 5;si++){

contentPane1.add(textNeed[pi][si], null);

contentPane1.add(textAllocation[pi][si], null);} textProcessName.setBounds(80, 430, 50, 20);contentPane1.add(textProcessName, null);f1.setSize(550, 500);

f1.setResizable(false);

f1.setTitle(”银行家算法(SXJ)“);

f1.setLocationRelativeTo(null);

f1.setDefaultCloseOperation(EXIT_ON_CLOSE);

// f1.setVisible(true);

f1.setVisible(false);

f2 = new JFrame(”安全序列显示框“);

jt = new JTextArea(75, 40);

jt.setBackground(Color.pink);

jt.setForeground(Color.blue);

JScrollPane scrollPane = new JScrollPane(jt);// 加滚动条

scrollPane.setBorder(BorderFactory.createLoweredBevelBorder());// 边界

(f2.getContentPane()).add(scrollPane);

f2.setSize(450, 400);

f2.setResizable(false);

f2.setDefaultCloseOperation(EXIT_ON_CLOSE);

f2.setVisible(false);

buttonSetInit.setEnabled(false);

buttonRequest.setEnabled(false);

buttonsearch.setEnabled(false);

button1.addActionListener(new ActionListener(){

public void actionPerformed(ActionEvent e){

// labelInfo.setText(”请先初始化allocated和Maxneed，后单击初始化按钮“);

f1.setVisible(true);

buttonSetInit.setEnabled(true);

resourceNum = Integer.parseInt(tf1.getText());

processNum = Integer.parseInt(tf2.getText());

for(int i = 0;i < processNum;i++){

for(int j = 0;j < resourceNum;j++){

textNeed[i][j].setEditable(true);

textAllocation[i][j].setEditable(true);

textAvailable[j].setEditable(true);

}

}

}

});

buttonSetInit.addActionListener(new ActionListener(){

public void actionPerformed(ActionEvent e){

Init();

buttonsearch.setEnabled(true);

}

});

buttonsearch.addActionListener(new ActionListener(){

public void actionPerformed(ActionEvent e){ count = 0;SafeSequence = new int[processNum];worked = new int[resourceNum];Finish = new boolean[processNum];copyVector(worked, available);Safety(0);jt.append(”安全序列数量：“ + count);if(flag){

labelInfo1.setText(”当前系统状态：安全“);

f2.setVisible(true);

buttonRequest.setEnabled(true);

textProcessName.setEnabled(true);

for(int i = 0;i < resourceNum;i++){

textRequest[i].setEditable(true);

} } else {

labelInfo1.setText(”当前系统状态：不安全“);} buttonSetInit.setEnabled(false);} });buttonRequest.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e){

count = 0;

for(int i = 0;i < processNum;i++){

Finish[i] = false;

}

jt.setText(”“);

flag = false;RequestResource();} });button2.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e){

/*

* tf1.setText(”“);tf2.setText(”“);

*/

f2.setVisible(false);

jt.setText(”“);

for(int i = 0;i < processNum;i++){

}

for(int j = 0;j < resourceNum;j++){

textNeed[i][j].setText(”“);

textAllocation[i][j].setText(”“);

textAvailable[j].setText(”“);

textRequest[j].setText(”“);

// textNeed[i][j].setEditable(false);

// textAllocation[i][j].setEditable(false);

// textAvailable[j].setEditable(false);

textRequest[j].setEditable(false);

textProcessName.setText(”“);

Finish[i] = false;

}

}

flag = false;

buttonsearch.setEnabled(false);

// labelInfo.setText(”请先输入资源个数和进程个数，后单击确定“);} });button.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e){

tf1.setText(”“);

tf2.setText(”“);

f2.setVisible(false);

jt.setText(”“);flag = false;} });void copyVector(int[] v1, int[] v2){ for(int i = 0;i < v1.length;i++)

v1[i] = v2[i];} void Add(int[] v1, int[] v2){ for(int i = 0;i < v1.length;i++)

v1[i] += v2[i];} void Sub(int[] v1, int[] v2){ for(int i = 0;i < v1.length;i++)

} v1[i]-= v2[i];boolean Smaller(int[] v1, int[] v2){ boolean value = true;for(int i = 0;i < v1.length;i++)

if(v1[i] > v2[i]){

value = false;

break;

} return value;} public static void main(String[] args){ OsBanker ob = new OsBanker();ob.display();// System.out.println(” “+count);} void Init()// 初始化操作矩阵 { available = new int[resourceNum];for(int i = 0;i < resourceNum;i++){

available[i] = Integer.parseInt(textAvailable[i].getText());} max = new int[processNum][resourceNum];allocated = new int[processNum][resourceNum];need = new int[processNum][resourceNum];for(int i = 0;i < processNum;i++){

for(int j = 0;j < resourceNum;j++){

max[i][j] = Integer.parseInt(textNeed[i][j].getText());

allocated[i][j] = Integer.parseInt(textAllocation[i][j]

.getText());

} } for(int i = 0;i < resourceNum;i++)

for(int j = 0;j < processNum;j++)

need[j][i] = max[j][i]1);

request = new int[resourceNum];

for(int i = 0;i < resourceNum;i++){

request[i] = Integer.parseInt(textRequest[i].getText());

}

if(!Smaller(request, need[processname])){

labelInfo.setText(”资源请求不符该进程的需求量.“);

} else if(!Smaller(request, available)){

labelInfo1.setText(”可用资源不足以满足请求,进程需要等待.“);

} else {

Sub(available, request);

Add(allocated[processname], request);

Sub(need[processname], request);

copyVector(worked, available);

Safety(0);

if(flag){

labelInfo1.setText(”可立即分配给该进程!“);

} else {

labelInfo1.setText(”分配后导致系统处于不安全状态!,不可立即分配");

Add(available, request);

Sub(allocated[processname], request);

Add(need[processname], request);

}

}

// } } }

五、实验结果：

初始界面：

初始化：

检测安全性：

请求资源：

（1）进程2（1，0，2）

（2）进程5（3，3，0）

（3）进程1（0，2，0）

六、遇到的问题及不足之处：

1、程序编写的时候规定最大资源数和最大进程数均<=6。

2、程序直接初始化了6个进程框，既浪费了内存空间，又对可视化界面的美观造成影响。

3、未对输入异常进行处理：比如在请求资源的第一个方框中只能填入进程的数字编号，当填入的为非整数时，程序会抛出异常。

4、未解决进程名中对字符串的处理，直接固定进程名为数字，用户不能直接输入原有的进程名，造成不好的用户体验。

第四篇：操作系统课程设计(银行家算法的模拟实现)

操作系统课程设计

（银行家算法的模拟实现）

一、设计目的

1、进一步了解进程的并发执行。

2、加强对进程死锁的理解。

3、用银行家算法完成死锁检测。

二、设计内容

给出进程需求矩阵C、资源向量R以及一个进程的申请序列。使用进程启动拒绝和资源分配拒绝（银行家算法）模拟该进程组的执行情况。

三、设计要求

1、初始状态没有进程启动。

2、计算每次进程申请是否分配，如：计算出预分配后的状态情况（安全状态、不安全状态），如果是安全状态，输出安全序列。

3、每次进程申请被允许后，输出资源分配矩阵A和可用资源向量V。

4、每次申请情况应可单步查看，如：输入一个空格，继续下个申请。

四、算法原理

1、银行家算法中的数据结构(1)、可利用资源向量Available，这是一个含有m个元素的数组，其中的每个元素代表一类可利用资源的数目，其初始值是系统中所配置的该类全部资源的数目，其数值随该类资源的分配和回收而动态改变。如果Available[j]=K，则表示系统中现有Rj类资源K个。

（2）、最大需求矩阵Max，这是一个n*m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。如果Max[i,j]=K，则表示进程i需要Rj类资源的最大数目为K。

（3）、分配矩阵Allocation。这也是一个n*m的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。如果Allocation[i,j]=K，则表示进程i当前已经分得Rj类资源的数目为K。

（4）、需求矩阵Need。这也是一个n*m的矩阵，用以表示每个进程尚需要的各类资源数。如果Need[i,j]=K，则表示进程i还需要Rj类资源K个，方能完成其任务。上述三个矩阵间存在以下关系：

Need[i,j]=Max[i,j]-Allocation[i,j]

2、银行家算法应用

模拟实现Dijkstra的银行家算法以避免死锁的出现，分两部分组成：一是银行家算法（扫描）；二是安全性算法。

（1）银行家算法（扫描）

设Requesti是进程Pi的请求向量，如果Requesti[j]=K，表示进程Pi需要K个Ri类型的资源。当Pi发出资源请求后，系统按下述步骤进行检查：

①如果Requesti[j]<=Need[i,j]，便转向步骤②；否则认为出错，因为它所需的资源数已经超过了它所宣布的最大值。

②如果Requesti[j]<=Allocation[i,j]，便转向步骤③；否则表示尚无足够资源，Pi需等待。

③系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值。

Available[j]=Available-Requesti[j]；

Allocation[i,j]=Allocation[i,j]+Requesti[j]；

Need[i,j]=Need[i,j]-Requesti[j]；

④系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。若安全，才正式将资源分配给进程Pi，已完成本次分配；否则，将本次的试探分配作废，恢复原来资源的分配状态，让进程Pi等待。

（2）安全性算法

系统所执行的安全性算法可描述如下：

①设置两个向量：一个是工作向量Work；它表示系统可提供给进程继续运行所需要的各类资源的数目，它含有m个元素，在执行安全性算法开始时，work=Available；另一个是Finish；它表示系统是否有足够的资源分配给进程，使之运行完成。开始时先做Finish[i]=false；当有足够资源分配给进程时，再令Finish[i]=true；

②从进程集合中找到能满足下述条件的进程：

一是Finish[i]==false；二是Need[i,j]<=Work[j]；若找到，执行步骤③，否则，执行步骤④；

③当进程Pi获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：

Work[j]=Work[j]+Allocation[i,j]；

Finish[i]=true；

go to step②；

④如果所有进程的 Finish[i]==true都满足，则表示系统处于安全状态，否则系统处于不安全状态。

五、设计思路

1、进程一开始向系统提出最大需求量；

2、进程每次提出新的需求（分期贷款）都统计是否超出它事先提出的最大需求量；

3、若正常，则判断该进程所需剩余量（包括本次申请）是否超出系统所掌握的剩余资源量，若不超出，则分配，否则等待。

六、程序运行调试结果

1、程序初始化

2、检测系统资源分配是否安全结果

七、小结

“银行家算法的模拟实现”是本学期操作系统课程的课程设计。在设计此程序的过程中我们遇到过许多问题也学到了很多东西。通过这周的课程设计，我加深了对银行家算法的理解，掌握了银行家算法避免死锁的过程和方法，理解了死锁产生的原因和条件以及避免死锁的方法。所编写程序基本实现了银行家算法的功能，并在其基础上考虑了输出显示格式的美观性，使界面尽可能友好。并且在编程时将主要的操作都封装在函数中，这样使程序可读性增强，使程序更加清晰明了。在算法的数据结构设计上考虑了很长时间。在程序设计中先后参考了很多网络资料也参考了一些别人写的的程序综合这些算法思想和自己的思路对程序做了很好的设计方式对一些算法的优越性等也作了一些考虑。当然，在编写和调试过程中我遇到了许多的问题，通过网上查询资料、翻阅课本、向同学请教、多次调试等方法逐渐解决了大部分问题。让我收获很多，相信在今后的生活中也有一定帮助。

附：程序源代码：

#include #include #include # define m 50

int no1;//进程数 int no2;//资源数 int r;int allocation[m][m],need[m][m],available[m],max[m][m];char name1[m],name2[m];//定义全局变量 void main(){ void check();void print();int i,j,p=0,q=0;char c;int request[m],allocation1[m][m],need1[m][m],available1[m];printf(“**********************************************n”);printf(“* 银行家算法的设计与实现 *n”);printf(“**********************************************n”);printf(“请输入进程总数:n”);scanf(“%d”,&no1);printf(“请输入资源种类数:n”);scanf(“%d”,&no2);printf(“请输入Max矩阵:n”);for(i=0;i

for(j=0;j

scanf(“%d”,&max[i][j]);//输入已知进程最大资源需求量

printf(“请输入Allocation矩阵:n”);for(i=0;i

for(j=0;j

scanf(“%d”,&allocation[i][j]);//输入已知的进程已分配的资源数

for(i=0;i

for(j=0;j

need[i][j]=max[i][j]-allocation[i][j];//根据输入的两个数组计算出need矩阵的值

printf(“请输入Available矩阵n”);for(i=0;i

scanf(“%d”,&available[i]);//输入已知的可用资源数

print();//输出已知条件

check();//检测T0时刻已知条件的安全状态

if(r==1)//如果安全则执行以下代码

{

do{ q=0;p=0;printf(“n请输入请求资源的进程号(0~4)：n”);

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

{

scanf(“%d”,&i);

if(i>=no1)

{

printf(“输入错误，请重新输入：n”);

continue;

}

else break;

}

printf(“n请输入该进程所请求的资源数request[j]:n”);

for(j=0;j

scanf(“%d”,&request[j]);

else //请求满足条件

{

for(j=0;j

{

available1[j]=available[j];

allocation1[i][j]=allocation[i][j];

need1[i][j]=need[i][j];

//保存原已分配的资源数，仍需要的资源数和可用的资源数

available[j]=available[j]-request[j];

allocation[i][j]+=request[j];

need[i][j]=need[i][j]-request[j];//系统尝试把资源分配给请求的进程

}

print();

check();//检测分配后的安全性

if(r==0)//如果分配后系统不安全

{

for(j=0;j

{

available[j]=available1[j];

allocation[i][j]=allocation1[i][j];

need[i][j]=need1[i][j];//还原已分配的资源数，仍需要的资源数和可用的资源数

}

printf(“返回分配前资源数n”);

print();

}

}

}printf(“n你还要继续分配吗？Y or N ?n”);

//判断是否继续进行资源分配 for(j=0;jneed[i][j])p=1;//判断请求是否超过该进程所需要的资源数

if(p)

printf(“请求资源超过该进程资源需求量，请求失败！n”);else {

for(j=0;j

if(request[j]>available[j])q=1;//判断请求是否超过可用资源数

if(q)

printf(“没有做够的资源分配，请求失败！n”);

c=getche();

}while(c=='y'||c=='Y');} }

void check()//安全算法函数 { int k,f,v=0,i,j;int work[m],a[m];bool finish[m];r=1;for(i=0;i

finish[i]=false;// 初始化进程均没得到足够资源数并完成for(i=0;i

k=no1;do{

for(i=0;i

{

if(finish[i]==false)

{

f=1;

for(j=0;j

if(need[i][j]>work[j])

f=0;

if(f==1)//找到还没有完成且需求数小于可提供进程继续运行的资源数的进程

{

finish[i]=true;

a[v++]=i;//记录安全序列号

for(j=0;j

work[j]+=allocation[i][j];//释放该进程已分配的资源

}

}

}

k--;//每完成一个进程分配，未完成的进程数就减1 }while(k>0);f=1;for(i=0;i

if(finish[i]==false)

{

f=0;

break;

} } if(f==0)//若有进程没完成，则为不安全状态

{

printf(“系统处在不安全状态！”);

r=0;} else {

printf(“n系统当前为安全状态，安全序列为：n”);

for(i=0;i

printf(“p%d ”,a[i]);//输出安全序列

} }

void print()//输出函数 { int i,j;printf(“n”);printf(“*************此时刻资源分配情况*********************n”);printf(“进程名/号 | Max | Allocation | Need |n”);for(i = 0;i < no1;i++)

{

printf(“ p%d/%d ”,i,i);

for(j = 0;j < no2;j++){printf(“%d ”,max[i][j]);}

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

{printf(“ %d ”,allocation[i][j]);}

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

{printf(“ %d ”,need[i][j]);}

printf(“n”);

} printf(“n”);

printf(“各类资源可利用的资源数为:”);

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

{printf(“ %d”,available[j]);}

} printf(“n”);

（程序结束）

第五篇：操作系统课程设计编程序模拟银行家算法

课程设计报告书

课程名称：

操作系统原理

题

目：

编程序模拟银行家算法

系

名：

信息工程系

专业班级：

软件

姓

名：

学

号：

指导教师:

2013年

X

月

X

日

学院信息工程系

课

程

设

计

任

务

书

课程名称：

操作系统原理课程设计

指导教师：

班级名称：

软件

开课系、教研室：

软件与信息安全

一、课程设计目的与任务

操作系统课程设计是《操作系统原理》课程的后续实践课程，旨在通过一周的实践训练，加深学生对理论课程中操作系统概念，原理和方法的理解，加强学生综合运用操作系统原理、Linux系统、C语言程序设计技术进行实际问题处理的能力，进一步提高学生进行分析问题和解决问题的能力，包含系统分析、系统设计、系统实现和系统测试的能力。

学生将在指导老师的指导下，完成从需求分析，系统设计，编码到测试的全过程。

二、课程设计的内容与基本要求

1、课程设计题目

编程序模拟银行家算法

2、课程设计内容

本课程设计要求在Linux操作系统，GCC编译环境下开发。

银行家算法是避免死锁的一种重要方法，本实验要求用用c/c++语言在Linux操作系统环境下编写和调试一个简单的银行家算法程序。加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。

思想：将一定数量的资金供多个用户周转使用，当用户对资金的最大申请量不超过现存资金时可接纳一个新客户，客户可以分期借款，但借款总数不能超过最大的申请量。银行家对客户的借款可以推迟支付，但是能够使客户在有限的时间内得到借款，客户得到所有的借款后能在有限的时间内归还。用银行家算法分配资源时，测试进程对资源的最大需求量，若现存资源能满足最大需求就满足当前进程的申请，否则推迟分配，这样能够保证至少有一个进程可以得到所需的全部资源而执行到结束，然后归还资源，若OS能保证所有进程在有限的时间内得到所需资源则称系统处于安全状态。

3、设计报告撰写格式要求：

1设计题目与要求

设计思想

3系统结构

数据结构的说明和模块的算法流程图

使用说明书（即用户手册）：内容包含如何登录、退出、读、写等操作说明

运行结果和结果分析（其中包括实验的检查结果、程序的运行情况）

自我评价与总结

附录：程序清单，注意加注释（包括关键字、方法、变量等），在每个模块前加注释；

三、课程设计步骤及时间进度和场地安排

本课程设计将安排在第15周,教育技术中心。具体安排如下：

第一天

下发任务书，学生查阅资料

第二天

系统设计和原型开发

第三，四天

系统功能实现

第五天

系统调试

测试

打包和验收

四、课程设计考核及评分标准

课程设计考核将综合考虑学生考勤和参与度，系统设计方案正确性，系统设计和开发效果以及课程设计报告书的质量。具体评分标准如下：

设置六个评分点

（1）设计方案正确，具有可行性、创新性；

25分

（2）系统开发效果较好；

25分

（3）态度认真、刻苦钻研、遵守纪律；

10分

（4）设计报告规范、课程设计报告质量高、参考文献充分

20分

（5）课程设计答辩概念清晰，内容正确

10分

（6）课程设计期间的课堂考勤、答疑与统筹考虑。

10分

按上述六项分别记分后求和，总分按五级记分法记载最后成绩。

优秀（100～90分），良好（80～89分），中等（70～79分），及格（60～69分），不及格（0～59分）

1.题目要求与实验目的1.1

实验目的：

1.1.1进一步理解利用银行家算法避免死锁的问题；

1.1.2在了解和掌握银行家算法。

1.1.3理解和掌握安全序列、安全性算法

1.2

设计题目:

编程序模拟银行家算法

1.3

要求

：

本实验要求用用

c/c语言在Linux

操作系统环境下编写和调试一个简单的银行家算法程序。加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。

1.4

实验内容

：

1.4.1编写安全性算法；

1.4.2编写银行家算法，并编制银行家算法通用程序，将调试结果显示在计算机屏幕上，再检测和笔算的一致性。

设计思想

将一定数量的资金供多个用户周转使用，当用户对资金的最大申请量不超过现存资金时可接纳一个新客户，客户可以分期借款，但借款总数不能超过最大的申请量。银行家对客户的借款可以推迟支付，但是能够使客户在有限的时间内得到借款，客户得到所有的借款后能在有限的时间内归还。

用银行家算法分配资源时，测试进程对资源的最大需求量，若现存资源能满足最大需求就满足当前进程的申请，否则推迟分配，这样能够保证至少有一个进程可以得到所需的全部资源而执行到结束，然后归还资源，若OS能保证所有进程在有限的时间内得到所需资源则称系统处于安全状态。

3.需求分析

3.1问题描述：利用银行家算法模拟计算机系统分配资源的过程。

3.2要求：

3.2.11、以课本例题中数据为例，模拟资源分配过程。

3.2.2、系统中资源种类，各类资源数目，进程申请资源数目可任意输入，模拟资源分配过程。

4.系统结构

初始化函数init（）开始

输入进程的数目m

输入资源种类n

输入每个进程最多所需的各种资源数

输入每个进程分配的资源数

输入各个资源现有数目

初始化函数init（）结束

输入提示：

输入有误重新输入

图

5.数据结构的说明和模块的算法流程图

5.1

数据结构：

①可利用资源向量

Available

是个含有

m

个元素的数组，其中的每一个元素代表一类可利用的资源数目。如果

AvailablejK，则表示系统中现有

Rj

类资源

K

个。

②最大需求矩阵

Max

这是一个

n×m的矩阵，它定义了系统中

n

个进程中的每一个进程对

m

类资源的最大需求。如果

MaxijK，则表示进程

i

需要

Rj

类资源的最大数目为

K。

③分配矩阵

Allocation

这也是一个

n×m的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。如果

AllocationijK，则表示进程

i

当前已分得

Rj

类资源的数目为

K。

④需求矩阵

Need。

这也是一个

n×m的矩阵，用以表示每一个进程尚需的各类资源数。如果NeedijK，则表示进程

i

还需要

Rj

类资源

K

个，才可以完成其任务。

5．2

程序流程图：

①、系统主要过程流程

预分配

安全？

实际分配打印输出

退出系统

Request[i]>Available[i]?

Request[i]>need[i]?

提出申请

打印输出此时刻资源分配情况

进入系统

输入：

1.继续分配

2.退出

进入初始化

②、安全性算法流程图

调用safty()函数

Work[]=Available[],Finish[]=False

Need[]<=work[]且Finsh[]=Falsse?

Work[]=work[]+Alloccation[],Finish[]=Ture

所有进程的Finsh[]=Ture?

实际分配输出安全序列并打印出

输出提示系统不安全

调用结束

用户手册

6.1

首先在终端中使用

vi

编辑器建立

c的源文件

6.2

然后使用

gcc

编辑器编译生成可执行文件

6.3

使用命令./当前名字，来执行

7.运行结果和结果分析

7．1

运行结果：

申请成功如图

2，申请失败如图

3：

图

申请金额在需求范围之内同意

图

申请金额在需求范围之外拒绝

7.2

结果分析

首先是自己定义

个用户所需的金额数，银行可以给用户贷款的总金额数是100，用户

Id

号的范围是在0

到

4，超过

之后的id

请求贷款，会显示拒绝提示信息，每个客户的贷款数量必须是在之前定义的范围之内，如果超出，也会出现错误提示，只有在规定的用户

id

和在客户所要求金额的范围之内请求，才会给予贷款，并且输出安全序列号。

8.自我评价与总结

一周的课程设计结束了。在这一周里，我收获很多，以前都是在自己的教室由我们自己的老师进行讲课，这次学校没有这样做，而是请的校外的老师给我们做课程设计，让我们体会一下真正的公司是怎样做业务的。在这一周里我做一个模拟银行家算法。我觉得在着手设计前设计的思路是很重要的。只有思路清晰才能进行下一阶段的设计。这样才能完成整个程序的设计，完成整个文报告的书写。

课程设计这几天学到的东西还真不少。以前不清楚的现在都暴露出来了。以前认为学了没用的东西现在也用到了。这次的课程设计使我进一步了解了调度与死锁的问题。以及有关资源申请的问题、避免死锁的具体实施方法。深入了解了银行家算法的资源申请和资源分配的过程及原则。保证系统处于安全状态。

经过本周的课程设计，我对操作系统的掌握又进了一步，收获了很多知识。，终于我了由于对

c

语言不够熟练，在试验过程中，进行了反复的修改和调试，解银行家算法的基本原理，并且在此次的课程设计中我又复习了一下

c

语言，加深了对它的了解，而且在课程设计的过程中我们同样学会了如何简单的操作与使用

Linux

操作系统，学习到了许多

Linux

操作系统中常用的一些密令。

这次的设计数据是通过一道实际的题目来体现银行家算法避免死锁的问题，先用银行家算法给其中一个进程分配资源，看它所请求的资源是否大于它的需求量，才和系统所能给的资源相比较.让进程形成一个安全队列看系统是否安全.再利用安全性算法检查此时系统是否安全。

操作系统的基本特征是并发与共享。系统允许多个进程并发执行，并且共享系统的软、硬件资源。为了最大限度的利用计算机系统的资源，操作系统应采用动态分配的策略，但是这样就容易因资源不足，分配不当而引起“死锁”。而我本次课程设计就是得用银行家算法来避免“死锁”。银行家算法就是一个分配资源的过程，使分配的序列不会产生死锁。此算法的中心思想是：按该法分配资源时，每次分配后总存在着一个进程，如果让它单独运行下去，必然可以获得它所需要的全部资源，也就是说，它能结束，而它结束后可以归还这类资源以满足其他申请者的需要。

通过这次实验，我体会到银行家算法的重要性，银行家算法是避免死锁的主要方法，其思路在很多方面都非常值得我来学习借鉴。

附录：

主要源程序

参考文献

[1]

张尧学主编．计算机操作系统教程（第三版）．北京:清华大学出版社，2006

[2]

张尧学编．计算机操作系统教程（第三版）习题解答与实验指导．北京:清华大学出版社，2006

[3]

汤子瀛主编．计算机操作系统（第三版）．西安:西安电子科技大学出版社，2001

[4]

张坤等编．操作系统实验教程．北京:清华大学出版社，2008

[5]

张丽芬等编．操作系统实验教程．北京:清华大学出版社，2006

[6]

屠祁等编.操作系统基础（第三版）．北京:清华大学出版社，2000

[7]

冯耀霖等编.操作系统.西安:西安电子科技大学出版社，2001

[8]

左万历．计算机操作系统教程（第二版）．北京：高等教育出版社，2004

[9]谭浩强.《C语言程序设计》.北京：清华大学出版社2003

[8]

庞丽华.《操作系统原理》（第四版）.北京.华中科技大学出版社

2002

设计过程中质疑（或答辩）记载：

1.银行家算法的主要思想是什么？

答：一个进程进入系统时分配资源之前,判断系统是否是安全的，即看它所请求的资源是否大于它的最大需求量，若正常,则判断该进程所需剩余剩余量(包括本次申请)是否超出系统所掌握的剩余资源量,若不超出,则分配,否则等待。

2.银行家算法的主要问题是什么？

答：要求每个进程必须事先知道资源的最大需求量，而且，在系统运行过程中，考查每个进程对各类资源的申请需花费较多的时间。

3.在银行家算法中各个资源存在什么关系？

答：该进程所需要的资源数NEED[m][n]=MAX[m][n](该进程所需要的最多的资源数)-----ALLOCATION[m][n](该进程所占有的资源数)

指导教师评语：

签名：

****年**月**日