死锁_银行家算法实验报告

时间:2019-05-14 09:40:45下载本文作者:会员上传
简介:写写帮文库小编为你整理了多篇相关的《死锁_银行家算法实验报告》,但愿对你工作学习有帮助,当然你在写写帮文库还可以找到更多《死锁_银行家算法实验报告》。

第一篇:死锁_银行家算法实验报告

实验目的

银行家算法是避免死锁的一种重要方法。通过编写一个模拟动态资源分配的银行家算法程序,进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念,并掌握避免死锁的具体实施方法

二、实验要求

根据银行家算法的基本思想,编写和调试一个实现动态资源分配的模拟程序,并能够有效地防止和避免死锁的发生。

(1)设计思想说明

设计银行家算法是为了避免死锁

三、实验方法内容 1.算法设计思路

银行家算法又称“资源分配拒绝”法,其基本思想是,系统中的所有进程放入进程集合,在安全状态下系统受到进程的请求后试探性的把资源分配给他,现在系统将剩下的资源和进程集合中其他进程还需要的资源数做比较,找出剩余资源能满足最大需求量的进程,从而保证进程运行完成后还回全部资源。这时系统将该进程从进程集合中将其清除。此时系统中的资源就更多了。反复执行上面的步骤,最后检查进程的集合为空时就表明本次申请可行,系统处于安全状态,可以实施本次分配,否则,只要进程集合非空,系统便处于不安全状态,本次不能分配给他。请进程等待 2.算法流程图

3.算法中用到的数据结构

数据结构的说明

1.可利用资源向量AVAILABLE。这是一个含有M个元素的数组,其中的每一个元素代表一类可利用的资源数目,其3初始值是系统中所配置的该类全部可哦那个资源的数目,其数值随该类资源的分配和回收而动态的改变。

2.最大需求矩阵MAX。这是一个M*N的矩阵,它定义了系统中N个进程中的每一个进程对M类资源的最大需求。

3.分配矩阵ALLOCATION。这也是一个M*N的矩阵,它定义了系统中每一类资源当前已分配给每一进程的资源数。

4.需求矩阵NEED。这也是一个M*N的矩阵,用以表示每一个进程尚需的各类资源数。5.NEED[R,W]=MAX[R,W]-ALLOCATION[R,W]

4.主要的常量变量 #define W 10 //最大进程数W=10 #define R 20 //最大资源总数R=20 int AVAILABLE[R];//可利用资源向量 int MAX[W][R];//最大需求矩阵 int ALLOCATION[W][R];//分配矩阵 int NEED[W][R];//需求矩阵 int Request[R];//进程请求向量

void changdata(int k);//进程请求资源数据改变 int chksec(int s);//系统安全性的检测

5.主要模块

void inputdata()void showdata()void changdata(int k)void restoredata(int k)int chksec(int s)int chkmax(int s)

四、实验代码

#include #include #define FALSE 0 #define TRUE 1 #define W 10 //最大进程数W=10 #define R 20 //最大资源总数R=20 int M;int N;int ALL_RESOURCE[W];int AVAILABLE[R];//可利用资源向量 int MAX[W][R];//最大需求矩阵 int ALLOCATION[W][R];//分配矩阵 int NEED[W][R];//需求矩阵 int Request[R];//进程请求向量 void inputdata();//数据输入 void showdata();//数据显示

void changdata(int k);//进程请求资源数据改变 void restoredata(int k);//数据恢复 int chksec(int s);//系统安全性的检测 int chkmax(int s);//检测最大需求

void bank();//检测分配的资源是否合理 void main(){ int i,j;inputdata();for(i=0;i

if(j==0)break;} if(i>=M)cout<<“错误提示:经安全性检查发现,系统的初始状态不安全!!n”<>M;

if(M>W)cout<W);cout<>N;

if(N>R)cout<R);cout<>ALL_RESOURCE[i];cout<>MAX[i][j];if(MAX[i][j]>ALL_RESOURCE[j])cout<ALL_RESOURCE[j]);} } cout<

for(j=0;j

do{ cin>>ALLOCATION[i][j];

if(ALLOCATION[i][j]>MAX[i][j])

cout<

}while(ALLOCATION[i][j]>MAX[i][j]);} } cout<

for(j=0;j

NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];for(j=0;j

for(i=0;i

AVAILABLE[j]=0;} } }

void showdata(){ int i,j;cout<<“各种资源的总数量,即向量all_resource为:”<

cout<

for(j=0;j

cout<

void changdata(int k){ int j;for(j=0;j

AVAILABLE[j]=AVAILABLE[j]-Request[j];

ALLOCATION[k][j]=ALLOCATION[k][j]+Request[j];

NEED[k][j]=NEED[k][j]-Request[j];} }

void restoredata(int k){ int j;for(j=0;j

ALLOCATION[k][j]=ALLOCATION[k][j]-Request[j];

NEED[k][j]=NEED[k][j]+Request[j];} }

int chksec(int s){ int WORK,FINISH[W];int i,j,k=0;for(i=0;i

FINISH[i]=FALSE;for(j=0;j

{ if(FINISH[i]==FALSE&&NEED[i][j]<=WORK)

{

WORK=WORK+ALLOCATION[i][j];

FINISH[i]=TRUE;

i=0;

}else

{ i++;

}

}while(i

if(FINISH[i]==FALSE)

{ return 1;

} } return 0;}

int chkmax(int s){ int j,flag=0;for(j=0;j

if(MAX[s][j]==ALLOCATION[s][j])

{ flag=1;

AVAILABLE[j]=AVAILABLE[j]+MAX[s][j];

MAX[s][j]=0;

} } return flag;}

c { int i=0,j=0;char flag='Y';while(flag=='Y'||flag=='y'){ i=-1;while(i<0||i>=M){ cout<<“请输入需申请资源的进程号(从P0到P”<

cin>>i;if(i<0||i>=M)

cout<<“输入的进程号不存在,重新输入!”<

for(j=0;j

cin>>Request[j];if(Request[j]>NEED[i][j])

{ cout<<“进程P”<

cout<<“申请不合理,出错!请重新选择!”<

flag='N';

break;

}

else

{ if(Request[j]>AVAILABLE[j])

{ cout<<“进程P”<

cout<<“申请不合理,出错!请重新选择!”<

flag='N';

break;

}

} }

if(flag=='Y'||flag=='y'){ changdata(i);

if(chksec(i))

{ cout<

cout<<“该分配会导致系统不安全!!本次资源申请不成功,不予分配!!”<

cout<

restoredata(i);

}

else

{ cout<

cout<<“经安全性检查,系统安全,本次分配成功,且资源分配状况如下所示:”<

cout<

showdata();

if(chkmax(i))

{cout<<“在资源分配成功之后,由于该进程所需的某些资源的最大需求量已经满足,”<

cout<<“因此在进程结束后系统将回收这些资源!”<

showdata();

}

}

} cout<>flag;} }

五、实验结果 1.执行结果

2.结果分析 银行家算法就是当接收到一个系统资源的分配后找到一个安全序列,使得进程间不会发生死锁,若发生死锁则让进程等待。

六、实验总结

通过本次银行家算法实验,加深了我对银行家算法的了解,掌握了如何利用银行家算法避免死锁。实验中遇到点问题,通过查阅资料、询问老师顺利解决。通过这次的实践,使我的理论知识更加的牢固。

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

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

姓名:李天玮

班级:软工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、未解决进程名中对字符串的处理,直接固定进程名为数字,用户不能直接输入原有的进程名,造成不好的用户体验。

第四篇:银行家算法实验报告

计算机操作系统实验报告

何美西109253030212

一、实验名称:银行家算法

二、实验目的:银行家算法是避免死锁的一种重要方法,通过编写一个简单的银行家算法程序,加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。

三、问题分析与设计:

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、流程图: 系统主要过程流程图

银行家算法流程图

安全性算法流程图

四、实验代码:

#include #include #include #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 p[100]={0};int q[100][100]={0};int z[100][100]={0};int M=100;//作业的最大数为100 int N=100;//资源的最大数为100 int gg=1;void showdata()//显示资源矩阵 { int i,j;cout<

int changdata(int i)//进行资源分配 { int j;for(j=0;j

for(i=0;i

cout<

}//变分配数 Finish[i]=True;temp[k]=i;cout<<“ ”;cout<<“true”<<“ ”;cout<

for(i=0;i

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

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

} cout<

return 0;} }

cout<

cout<<“安全序列为:”;for(i=0;i”;} cout<>i;//输入须申请的资源号

cout<>Request[j];//输入需要申请的资源 } for(j=0;jNeed[i][j])//判断申请是否大于需求,若大于则出错

{ cout<Avaliable[j])//判断申请是否大于当前资源,若大于则

{ //出错

cout<

int main()//主函数 {

int t=1,i,j,number,choice,m,n,flag;char ming;cout<<“*****************银行家算法的设计与实现*****************”<>n;N=n;for(i=0;i>ming;name[i]=ming;cout<<“资源的数量:”;cin>>number;Avaliable[i]=number;} cout<>m;M=m;cout<>Max[i][j];do{ flag=0;cout<>Allocation[i][j];if(Allocation[i][j]>Max[i][j])flag=1;Need[i][j]=Max[i][j]-Allocation[i][j];} if(flag)cout<

showdata();//显示各种资源

safe();//用银行家算法判定系统是否安全

while(1){

if(t==1){ cout<

t=0;} else break;cout<

}

return 1;}

五、程序执行结果: cin>>t;cout<

六、实验总结

多个进程同时运行时,系统根据各类系统资源的最大需求和各类系统的剩余资源为进程安排安全序列,使得系统能快速且安全地运行进程,不至发生死锁。银行家算法是避免死锁的主要方法,其思路在很多方面都非常值得我们来学习借鉴。

09信管(2)班

何美西 109253030212

第五篇:银行家算法实验报告

计算机操作系统实验报告

一、实验名称:银行家算法

二、实验目的:银行家算法是避免死锁的一种重要方法,通过编写一个简单的银行家算法程序,加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。

三、问题分析与设计:

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、流程图: 系统主要过程流程图

银行家算法流程图

安全性算法流程图

四、实验代码:

//#define M 5 //#define N 3 #include //本实验中使用到的库函数 #include #include int max[5][1];//开始定义银行家算法中需要用到的数据 int allocation[5][1];int need[5][1];int available[1];int request[5][1];char *finish[5];int safe[5];int n,i,m;int k=0;int j=0;int work[1];int works[5][1];

void line()//美化程序,使程序运行时更加明朗美观 { printf(“-----------------n”);} void start()//表示银行家算法开始 { line();printf(“ 银行家算法开始n”);printf(“--死锁避免方法 line();} void end()//表示银行家算法结束 { line();printf(” 银行家算法结束,谢谢使用n“);line();} void input()//输入银行家算法起始各项数据 {

for(n=0;n<5;n++)

{

printf(”请输入进程P%d的相关信息:n“,n);

printf(”Max:“);

for(m=0;m<1;m++)

scanf(”%d“,&max[n][m]);

printf(”Allocation:“);

for(m=0;m<1;m++)

scanf(”%d“,&allocation[n][m]);

n”);

}

for(m=0;m<1;m++)

need[n][m]=max[n][m]-allocation[n][m];printf(“请输入系统可利用资源数Available:”);for(m=0;m<1;m++)

} void output()//输出系统现有资源情况 { line();printf(“资源情况 Max Allocation Need Availablen”);printf(“进程 A A A A n”);line();for(n=0;n<5;n++){ printf(“P%d%3d%3d%3d”,n,max[n][0],allocation[n][0],need[n][0]);

} line();}

void change()//当Request[i,j]<=Available[j]时,系统把资源分配给进程P[i],Available[j]和Need[i,j]发生改变

{ for(m=0;m<1;m++){ if(n==0)else

printf(“n”);

printf(“%3d%3dn”,available[0]);scanf(“%d”,&available[m]);

} } available[m]-=request[i][m];allocation[i][m]+=request[i][m];need[i][m]-=request[i][m];void outputsafe()//输出安全序列的资源分配表 { printf(“该安全序列的资源分配图如下:n”);line();printf(“资源情况 Work Need Allocation Work+Allocation Finishn”);printf(“进程 A A A A n”);line();for(n=0;n<5;n++)

printf(“P%d%9d%3d%3d%5d%12sn”,safe[n],works[safe[n]][0],need[safe[n]][0],allocation[safe[n]][0],works[safe[n]][0]+allocation[safe[n]][0],finish[n]);line();} int check()//安全性算法 { printf(“开始执行安全性算法……n”);for(m=0;m<1;m++)//数组work和finish初始化

work[m]=available[m];for(n=0;n<5;n++){

} finish[n]=“false”;safe[n]=0;k=0;for(m=0;m<5;m++)for(n=0;n<5;n++)

if(strcmp(finish[n],“false”)==0 && need[n][0]<=work[0])//查找可以分配资源但尚未分配到资源的进程

{

safe[k]=n;//以数组safe[k]记下各个进程得到

分配的资源的顺序

works[safe[k]][0]=work[0];

放出分配给它的资源

work[0]+=allocation[n][0];//进程执行后释

finish[n]=“ture”;//finish[n]变为1以示该进

程完成本次分

}

k++;for(m=0;m<5;m++)//判断是否所有进程分配资源完成{

0

素都为ture } else

if(m==4)//此处m=4表示所有数组finish的所有元if(strcmp(finish[m],“false”)==0){

printf(“找不到安全序列,系统处于不安全状态。n”);return 0;//找不到安全序列,结束check函数,返回 {

printf(“找到安全序列P%d->P%d->P%d->P%d->P%d,系统是安全的n”,safe[0],safe[1],safe[2],safe[3],safe[4]);

} return 1;} void main()//主程序开始 { start();for(;j==0;)//确认输入数据的正确性,若输入错误,重新输入

{

入:“);

} printf(”数据确认无误,算法继续。n“);if(check()==0)//若check函数返回值为0,表示输入的初始数据找不到安全序列,无法进行下一步,程序结束

{

} for(;j==1;)//当有多个进程请求资源时,循环开始

{

printf(”请输入请求资源的进程i(0、1、2、3、4):“);//输入发出请求向量的进程及请求向量 end();exit(0);input();printf(”以下为进程资源情况,请确认其是否正确:n“);output();printf(”数据是否无误:n正确:输入1n错误:输入0n请输

}

j=1;

outputsafe();//输出安全序列的资源分配表

scanf(“%d”,&j);

scanf(“%d”,&i);printf(“请输入进程P%d的请求向量Request%d:”,i,i);for(n=0;n<1;n++)

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

for(;request[i][0]>need[i][0];)//若请求向量大于需求资源,则认为是输入错误,要求重新输入

{

printf(“数据输入有误,请重试!n请输入进程P%d的请求向量Request%d:”,i,i);

提供分配

n“,i);

} if(request[i][0]<=available[0])//判断系统是否有足够资源

for(n=0;n<1;n++)

scanf(”%d“,&request[i][n]);{

} else

printf(”系统没有足够的资源,进程P%d需要等待。printf(“系统正在为进程P%d分配资源……n”,i);change();//分配资源 j=0;if(j==0)//j=0表示系统有足够资源分配的情况 {

printf(“当前系统资源情况如下:n”);//输出分配资源后的系统资源分配情况

分配无效

output();

if(check()==0)//若找不到安全系列,则之前的资源 {

printf(“本次资源分配作废,恢复原来的资源分配

状态。n”);

资源状态

输入:“);

for(m=0;m<1;m++)//恢复分配资源前的系统

}

}

{

}

output();//输出系统资源状态

available[m]+=request[i][m];allocation[i][m]-=request[i][m];need[i][m]+=request[i][m];printf(”是否还有进程请求资源?n是:输入1n否:输入0n请

scanf(“%d”,&j);//若还有进程请求资源,j=1,之前的for循环条件满足

} end();}

五、程序执行结果:

六、实验总结

多个进程同时运行时,系统根据各类系统资源的最大需求和各类系统的剩余资源为进程安排安全序列,使得系统能快速且安全地运行进程,不至发生死锁。银行家算法是避免死锁的主要方法,其思路在很多方面都非常值得我们来学习借鉴。

下载死锁_银行家算法实验报告word格式文档
下载死锁_银行家算法实验报告.doc
将本文档下载到自己电脑,方便修改和收藏,请勿使用迅雷等下载。
点此处下载文档

文档为doc格式


声明:本文内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎发送邮件至:645879355@qq.com 进行举报,并提供相关证据,工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。

相关范文推荐

    银行家算法_实验报告

    课程设计报告 课程设计名称 共享资源分配与银行家算法 系(部)专业班级姓 名学 号指导教师 年 月 日 第 1 页 共 1 页 、 目 录 一、课程设计目的和意义 ........................

    操作系统银行家算法实验报告

    实验四死锁 一、 实验目的 当系统的总资源数m小于或等于所有进程对对资源的最大需求时,就可能产生 死锁。死锁会引起计算机系统的瘫痪。银行家算法是在实现资源分配时避免......

    银行家算法实验报告[推荐阅读]

    实验三 银行家算法 (1)死锁产生的原因和必要条件是什么? 原因: a) 系统资源不足; b) 进程运行推进的顺序不合适; c) 资源分配不当。 如果系统资源充足,进程的资源请求都能够得到满......

    东南大学操作系统实验报告--银行家算法

    操作系统实验三:银行家算法的实现 一、 基本信息: a) 实验题目:银行家算法的实现 b) 完成人姓名:韩璐璐 c) 学号:71114115 d) 报告日期:2016.5.27 二、 实验目的 通过实验,加深对......

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

    模拟通过银行家算法避免死锁 一、 银行家算法产生的背景及目的 1:在多道程序系统中,虽然借助于多个进程的并发执行来改善系统的利用率,提高系统的吞吐量,但可能发生一种危险—死......

    银行家算法的模拟【实验报告】(合集5篇)

    实验二银行家算法的模拟 专业:信息管理与信息系统 学号:2014****** 姓名:陈* 实验日期:2016年12月20日 一、 实验目的 银行家算法是一种最具有代表性的避免死锁的算法。 要解释......

    操作系统课程设计实验报告-用C++实现银行家算法

    操 作 系 统 实 验 报 告 (2) 学院:计算机科学与技术学院 班级:计091 学号:姓名: 时间:2011/12/30 目 录 1. 实验名称……………………………………………………3 2. 实验目的…......

    算法实验报告

    《算法设计与分析》 实验报告 班级姓名学号年 月日 目录 实验一二分查找程序实现…………………………………………………………………03页 实验二棋盘覆盖问题(分治法).…......