第一篇：死鎖_銀行家算法實驗報告

實驗?zāi)康?/p>

銀行家算法是避免死鎖的一種重要方法。通過編寫一個模擬動態(tài)資源分配的銀行家算法程序，進一步深入理解死鎖、產(chǎn)生死鎖的必要條件、安全狀態(tài)等重要概念，并掌握避免死鎖的具體實施方法

二、實驗要求

根據(jù)銀行家算法的基本思想，編寫和調(diào)試一個實現(xiàn)動態(tài)資源分配的模擬程序，并能夠有效地防止和避免死鎖的發(fā)生。

（1）設(shè)計思想說明

設(shè)計銀行家算法是為了避免死鎖

三、實驗方法內(nèi)容 1.算法設(shè)計思路

銀行家算法又稱“資源分配拒絕”法，其基本思想是，系統(tǒng)中的所有進程放入進程集合，在安全狀態(tài)下系統(tǒng)受到進程的請求后試探性的把資源分配給他，現(xiàn)在系統(tǒng)將剩下的資源和進程集合中其他進程還需要的資源數(shù)做比較，找出剩余資源能滿足最大需求量的進程，從而保證進程運行完成后還回全部資源。這時系統(tǒng)將該進程從進程集合中將其清除。此時系統(tǒng)中的資源就更多了。反復(fù)執(zhí)行上面的步驟，最后檢查進程的集合為空時就表明本次申請可行，系統(tǒng)處于安全狀態(tài)，可以實施本次分配，否則，只要進程集合非空，系統(tǒng)便處于不安全狀態(tài)，本次不能分配給他。請進程等待 2.算法流程圖

3.算法中用到的數(shù)據(jù)結(jié)構(gòu)

數(shù)據(jù)結(jié)構(gòu)的說明

1.可利用資源向量AVAILABLE。這是一個含有M個元素的數(shù)組，其中的每一個元素代表一類可利用的資源數(shù)目，其3初始值是系統(tǒng)中所配置的該類全部可哦那個資源的數(shù)目，其數(shù)值隨該類資源的分配和回收而動態(tài)的改變。

2.最大需求矩陣MAX。這是一個M*N的矩陣，它定義了系統(tǒng)中N個進程中的每一個進程對M類資源的最大需求。

3.分配矩陣ALLOCATION。這也是一個M*N的矩陣，它定義了系統(tǒng)中每一類資源當前已分配給每一進程的資源數(shù)。

4.需求矩陣NEED。這也是一個M*N的矩陣，用以表示每一個進程尚需的各類資源數(shù)。5.NEED[R,W]=MAX[R,W]-ALLOCATION[R,W]

4.主要的常量變量 #define W 10 //最大進程數(shù)W=10 #define R 20 //最大資源總數(shù)R=20 int AVAILABLE[R];//可利用資源向量 int MAX[W][R];//最大需求矩陣 int ALLOCATION[W][R];//分配矩陣 int NEED[W][R];//需求矩陣 int Request[R];//進程請求向量

void changdata(int k);//進程請求資源數(shù)據(jù)改變 int chksec(int s);//系統(tǒng)安全性的檢測

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 //最大進程數(shù)W=10 #define R 20 //最大資源總數(shù)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();//數(shù)據(jù)輸入 void showdata();//數(shù)據(jù)顯示

void changdata(int k);//進程請求資源數(shù)據(jù)改變 void restoredata(int k);//數(shù)據(jù)恢復(fù) int chksec(int s);//系統(tǒng)安全性的檢測 int chkmax(int s);//檢測最大需求

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

if(j==0)break;} if(i>=M)cout<<“錯誤提示：經(jīng)安全性檢查發(fā)現(xiàn)，系統(tǒng)的初始狀態(tài)不安全??！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<<“各種資源的總數(shù)量，即向量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<<“該分配會導(dǎo)致系統(tǒng)不安全！!本次資源申請不成功，不予分配！!”<

cout<

restoredata(i);

}

else

{ cout<

cout<<“經(jīng)安全性檢查，系統(tǒng)安全，本次分配成功，且資源分配狀況如下所示：”<

cout<

showdata();

if(chkmax(i))

{cout<<“在資源分配成功之后，由于該進程所需的某些資源的最大需求量已經(jīng)滿足，”<

cout<<“因此在進程結(jié)束后系統(tǒng)將回收這些資源！”<

showdata();

}

}

} cout<>flag;} }

五、實驗結(jié)果 1.執(zhí)行結(jié)果

2.結(jié)果分析 銀行家算法就是當接收到一個系統(tǒng)資源的分配后找到一個安全序列，使得進程間不會發(fā)生死鎖，若發(fā)生死鎖則讓進程等待。

六、實驗總結(jié)

通過本次銀行家算法實驗，加深了我對銀行家算法的了解，掌握了如何利用銀行家算法避免死鎖。實驗中遇到點問題，通過查閱資料、詢問老師順利解決。通過這次的實踐，使我的理論知識更加的牢固。

第二篇：操作系統(tǒng)銀行家算法(避免死鎖)實驗報告

操作系統(tǒng)實驗：銀行家算法

姓名：李天瑋

班級：軟工1101 實驗內(nèi)容：

在windows系統(tǒng)中實現(xiàn)銀行家算法程序。

學(xué)號：201126630117 實現(xiàn)銀行家算法所用的數(shù)據(jù)結(jié)構(gòu)：

假設(shè)有5個進程3類資源，則有如下數(shù)據(jù)結(jié)構(gòu)： 1.MAX[5，3] 5個進程對3類資源的最大需求量。2.AVAILABLE[3]系統(tǒng)可用資源數(shù)。

3.ALLOCATION[5,3]5個進程已經(jīng)得到3類資源的資源量。4.NEED[5,3]5個進程還需要3類資源的資源量。

銀行家算法：

設(shè)進程1提出請求Request[N]，則銀行家算法按如下規(guī)則進行判斷。(1)如果Request[N]<=NEED[1,N],則轉(zhuǎn)（2）；否則，出錯。(2)如果Request[N]<=AVALIABLE，則轉(zhuǎn)（3）；否則，出錯。(3)系統(tǒng)試探非配資源，修改相關(guān)數(shù)據(jù)。

AVALIABLE=AVALIABLE-REQUEST ALLOCATION=ALLOCATION+REQUEST NEED=NEED-REQUEST(4)系統(tǒng)執(zhí)行安全性檢查，如安全，則分配成立；否則試探險性分配作廢，系統(tǒng)恢復(fù)原狀，進程等待。

安全性檢查：

（1）設(shè)置兩個工作向量WORK=AVAILABLE；FINISH[M]=FALSE.（2）從晉城集合中找到一個滿足下述條件的進程，F(xiàn)INISH[i]=FALSE NEED<=WORK 如找到，執(zhí)行（3）；否則，執(zhí)行（4）。

（3）設(shè)進程獲得資源，可順利執(zhí)行，直至完成，從而釋放資源。

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

（4）如所有進程FINISH[M]=TRUE，則表示安全；否則系統(tǒng)不安全。

1.用init（）函數(shù)對于數(shù)據(jù)的初始化

關(guān)鍵代碼：

#define M 5 #define N 3

void init(){

cout<<“請輸入5個進程對3類資源最大資源需求量:”<

} cout<<“請輸入系統(tǒng)可用的資哩源數(shù):”<

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

cout<<“請輸入5個進程已經(jīng)-的到的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.顯示數(shù)據(jù)詳細信息

進行測試 輸入一號進程號，并給需要申請資源設(shè)定為{1,0,2}

檢驗錯誤輸入時候的報錯信息

檢驗當再次申請0號資源并申請資源數(shù)目為{0,2,0}時，系統(tǒng)提示系統(tǒng)不安全申請不成功。

每當驗證申請成功后會進行的修改操作：

if(flag=='Y'||flag=='y')//進?行D數(shù)簓據(jù)Y修T改?

{ changdata(i);

}

} if(chkerr(0)){

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

第三篇：操作系統(tǒng)實驗報告-利用銀行家算法避免死鎖

計算機操作系統(tǒng)實驗報告

題 目 利用銀行家算法避免死鎖

一、實驗?zāi)康模?/p>

1、加深了解有關(guān)資源申請、避免死鎖等概念，并體會和了解死鎖和避免死鎖的具體實施方法。

2、要求編寫和調(diào)試一個系統(tǒng)動態(tài)分配資源的簡單模擬程序，觀察死鎖產(chǎn)生的條件，并采用銀行家算法，有效的防止和避免死鎖的發(fā)生。

二、實驗內(nèi)容：

用銀行家算法實現(xiàn)資源分配：

設(shè)計五個進程{p0,p1,p2,p3,p4}共享三類資源{A,B,C}的系統(tǒng)，例如，{A,B,C}的資源數(shù)量分別為10，5，7。進程可動態(tài)地申請資源和釋放資源，系統(tǒng)按進程的申請動態(tài)地分配資源，要求程序具有顯示和打印各進程的某一個時刻的資源分配表和安全序列；顯示和打印各進程依次要求申請的資源號以及為某進程分配資源后的有關(guān)資源數(shù)據(jù)。

三、問題分析與設(shè)計：

1、算法思路：

先對用戶提出的請求進行合法性檢查，即檢查請求是否大于需要的，是否大于可利用的。若請求合法，則進行預(yù)分配，對分配后的狀態(tài)調(diào)用安全性算法進行檢查。若安全，則分配；若不安全，則拒絕申請，恢復(fù)到原來的狀態(tài)，拒絕申請。

2、銀行家算法步驟：

（1）如果Requesti＜or =Need,則轉(zhuǎn)向步驟(2)；否則，認為出錯，因為它所需要的資源數(shù)已超過它所宣布的最大值。

（2）如果Request＜or=Available,則轉(zhuǎn)向步驟（3）；否則，表示系統(tǒng)中尚無足夠的資源，進程必須等待。

（3）系統(tǒng)試探把要求的資源分配給進程Pi,并修改下面數(shù)據(jù)結(jié)構(gòu)中的數(shù)值：

Available=Available-Request[i];

Allocation=Allocation+Request;Need=Need-Request;(4)系統(tǒng)執(zhí)行安全性算法，檢查此次資源分配后，系統(tǒng)是否處于安全狀態(tài)。

3、安全性算法步驟：（1）設(shè)置兩個向量

①工作向量Work。它表示系統(tǒng)可提供進程繼續(xù)運行所需要的各類資源數(shù)目，執(zhí)行安全算法開始時，Work=Allocation;②布爾向量Finish。它表示系統(tǒng)是否有足夠的資源分配給進程，使之運行完成，開始時先做Finish[i]=false，當有足夠資源分配給進程時，令Finish[i]=true。

（2）從進程集合中找到一個能滿足下述條件的進程：

①Finish[i]=false ②Need

（3）當進程P獲得資源后，可順利執(zhí)行，直至完成，并釋放出分配給它的資源，故應(yīng)執(zhí)行： Work=Work+Allocation;Finish[i]=true;轉(zhuǎn)向步驟（2）。

（4）如果所有進程的Finish[i]=true,則表示系統(tǒng)處于安全狀態(tài)；否則，系統(tǒng)處于不安全狀態(tài)。

4、流程圖： 系統(tǒng)主要過程流程圖

銀行家算法流程圖

安全性算法流程圖

5、主要數(shù)據(jù)結(jié)構(gòu)

假設(shè)有M個進程N類資源，則有如下數(shù)據(jù)結(jié)構(gòu)：

int max[M*N] M個進程對N類資源的最大需求量 int available[N] 系統(tǒng)可用資源數(shù)

int allocated[M*N] M個進程已經(jīng)得到N類資源的資源量 int need[M*N] M個進程還需要N類資源的資源量

int worked[] 系統(tǒng)提供給進程繼續(xù)運行所需的各類資源數(shù)目

四、源代碼

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

public class OsBanker extends JFrame { // 界面設(shè)計

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, “按鈕區(qū)”);

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(”請先輸入資源個數(shù)和進程個數(shù)（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(”資源個數(shù):“);b1.setForeground(Color.blue);JLabel b2 = new JLabel(”進程個數(shù):“);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(”安全序列數(shù)量：“ + count);if(flag){

labelInfo1.setText(”當前系統(tǒng)狀態(tài)：安全“);

f2.setVisible(true);

buttonRequest.setEnabled(true);

textProcessName.setEnabled(true);

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

textRequest[i].setEditable(true);

} } else {

labelInfo1.setText(”當前系統(tǒng)狀態(tài)：不安全“);} 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(”請先輸入資源個數(shù)和進程個數(shù)，后單擊確定“);} });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(”分配后導(dǎo)致系統(tǒng)處于不安全狀態(tài)!,不可立即分配");

Add(available, request);

Sub(allocated[processname], request);

Add(need[processname], request);

}

}

// } } }

五、實驗結(jié)果：

初始界面：

初始化：

檢測安全性：

請求資源：

（1）進程2（1，0，2）

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

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

六、遇到的問題及不足之處：

1、程序編寫的時候規(guī)定最大資源數(shù)和最大進程數(shù)均<=6。

2、程序直接初始化了6個進程框，既浪費了內(nèi)存空間，又對可視化界面的美觀造成影響。

3、未對輸入異常進行處理：比如在請求資源的第一個方框中只能填入進程的數(shù)字編號，當填入的為非整數(shù)時，程序會拋出異常。

4、未解決進程名中對字符串的處理，直接固定進程名為數(shù)字，用戶不能直接輸入原有的進程名，造成不好的用戶體驗。

第四篇：銀行家算法實驗報告

計算機操作系統(tǒng)實驗報告

何美西109253030212

一、實驗名稱：銀行家算法

二、實驗?zāi)康模恒y行家算法是避免死鎖的一種重要方法，通過編寫一個簡單的銀行家算法程序，加深了解有關(guān)資源申請、避免死鎖等概念，并體會和了解死鎖和避免死鎖的具體實施方法。

三、問題分析與設(shè)計：

1、算法思路：先對用戶提出的請求進行合法性檢查，即檢查請求是否大于需要的，是否大于可利用的。若請求合法，則進行預(yù)分配，對分配后的狀態(tài)調(diào)用安全性算法進行檢查。若安全，則分配；若不安全，則拒絕申請，恢復(fù)到原來的狀態(tài)，拒絕申請。

2、銀行家算法步驟：（1）如果Requesti＜or =Need,則轉(zhuǎn)向步驟(2)；否則，認為出錯，因為它所需要的資源數(shù)已超過它所宣布的最大值。

（2）如果Request＜or=Available,則轉(zhuǎn)向步驟（3）；否則，表示系統(tǒng)中尚無足夠的資源，進程必須等待。

（3）系統(tǒng)試探把要求的資源分配給進程Pi,并修改下面數(shù)據(jù)結(jié)構(gòu)中的數(shù)值：

Available=Available-Request[i];Allocation=Allocation+Request;Need=Need-Request;(4)系統(tǒng)執(zhí)行安全性算法，檢查此次資源分配后，系統(tǒng)是否處于安全狀態(tài)。

3、安全性算法步驟：

（1）設(shè)置兩個向量

①工作向量Work。它表示系統(tǒng)可提供進程繼續(xù)運行所需要的各類資源數(shù)目，執(zhí)行安全算法開始時，Work=Allocation;②布爾向量Finish。它表示系統(tǒng)是否有足夠的資源分配給進程，使之運行完成，開始時先做Finish[i]=false，當有足夠資源分配給進程時，令Finish[i]=true。

（2）從進程集合中找到一個能滿足下述條件的進程：

①Finish[i]=false ②Need

（3）當進程P獲得資源后，可順利執(zhí)行，直至完成，并釋放出分配給它的資源，故應(yīng)執(zhí)行：

Work=Work+Allocation;Finish[i]=true;轉(zhuǎn)向步驟（2）。（4）如果所有進程的Finish[i]=true,則表示系統(tǒng)處于安全狀態(tài)；否則，系統(tǒng)處于不安全狀態(tài)。

4、流程圖： 系統(tǒng)主要過程流程圖

銀行家算法流程圖

安全性算法流程圖

四、實驗代碼：

#include #include #include #define False 0 #define True 1 int Max[100][100]={0};//各進程所需各類資源的最大需求 int Avaliable[100]={0};//系統(tǒng)可用資源 char name[100]={0};//資源的名稱

int Allocation[100][100]={0};//系統(tǒng)已分配資源 int Need[100][100]={0};//還需要資源 int Request[100]={0};//請求資源向量 int temp[100]={0};//存放安全序列 int Work[100]={0};//存放系統(tǒng)可提供資源 int p[100]={0};int q[100][100]={0};int z[100][100]={0};int M=100;//作業(yè)的最大數(shù)為100 int N=100;//資源的最大數(shù)為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<

}//變分配數(shù) 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()//主函數(shù) {

int t=1,i,j,number,choice,m,n,flag;char ming;cout<<“*****************銀行家算法的設(shè)計與實現(xiàn)*****************”<>n;N=n;for(i=0;i>ming;name[i]=ming;cout<<“資源的數(shù)量:”;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();//用銀行家算法判定系統(tǒng)是否安全

while(1){

if(t==1){ cout<

t=0;} else break;cout<

}

return 1;}

五、程序執(zhí)行結(jié)果： cin>>t;cout<

六、實驗總結(jié)

多個進程同時運行時，系統(tǒng)根據(jù)各類系統(tǒng)資源的最大需求和各類系統(tǒng)的剩余資源為進程安排安全序列，使得系統(tǒng)能快速且安全地運行進程，不至發(fā)生死鎖。銀行家算法是避免死鎖的主要方法，其思路在很多方面都非常值得我們來學(xué)習(xí)借鑒。

09信管（2）班

何美西 109253030212

第五篇：銀行家算法實驗報告

計算機操作系統(tǒng)實驗報告

一、實驗名稱：銀行家算法

二、實驗?zāi)康模恒y行家算法是避免死鎖的一種重要方法，通過編寫一個簡單的銀行家算法程序，加深了解有關(guān)資源申請、避免死鎖等概念，并體會和了解死鎖和避免死鎖的具體實施方法。

三、問題分析與設(shè)計：

1、算法思路：先對用戶提出的請求進行合法性檢查，即檢查請求是否大于需要的，是否大于可利用的。若請求合法，則進行預(yù)分配，對分配后的狀態(tài)調(diào)用安全性算法進行檢查。若安全，則分配；若不安全，則拒絕申請，恢復(fù)到原來的狀態(tài)，拒絕申請。

2、銀行家算法步驟：（1）如果Requesti＜or =Need,則轉(zhuǎn)向步驟(2)；否則，認為出錯，因為它所需要的資源數(shù)已超過它所宣布的最大值。

（2）如果Request＜or=Available,則轉(zhuǎn)向步驟（3）；否則，表示系統(tǒng)中尚無足夠的資源，進程必須等待。

（3）系統(tǒng)試探把要求的資源分配給進程Pi,并修改下面數(shù)據(jù)結(jié)構(gòu)中的數(shù)值：

Available=Available-Request[i];Allocation=Allocation+Request;Need=Need-Request;(4)系統(tǒng)執(zhí)行安全性算法，檢查此次資源分配后，系統(tǒng)是否處于安全狀態(tài)。

3、安全性算法步驟：

（1）設(shè)置兩個向量

①工作向量Work。它表示系統(tǒng)可提供進程繼續(xù)運行所需要的各類資源數(shù)目，執(zhí)行安全算法開始時，Work=Allocation;②布爾向量Finish。它表示系統(tǒng)是否有足夠的資源分配給進程，使之運行完成，開始時先做Finish[i]=false，當有足夠資源分配給進程時，令Finish[i]=true。

（2）從進程集合中找到一個能滿足下述條件的進程：

①Finish[i]=false ②Need

（3）當進程P獲得資源后，可順利執(zhí)行，直至完成，并釋放出分配給它的資源，故應(yīng)執(zhí)行：

Work=Work+Allocation;Finish[i]=true;轉(zhuǎn)向步驟（2）。

（4）如果所有進程的Finish[i]=true,則表示系統(tǒng)處于安全狀態(tài)；否則，系統(tǒng)處于不安全狀態(tài)。

4、流程圖： 系統(tǒng)主要過程流程圖

銀行家算法流程圖

安全性算法流程圖

四、實驗代碼：

//#define M 5 //#define N 3 #include //本實驗中使用到的庫函數(shù) #include #include int max[5][1];//開始定義銀行家算法中需要用到的數(shù)據(jù) 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()//表示銀行家算法結(jié)束 { line();printf(” 銀行家算法結(jié)束，謝謝使用n“);line();} void input()//輸入銀行家算法起始各項數(shù)據(jù) {

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

{

printf(”請輸入進程P%d的相關(guān)信息：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(“請輸入系統(tǒng)可利用資源數(shù)Available:”);for(m=0;m<1;m++)

} void output()//輸出系統(tǒng)現(xiàn)有資源情況 { 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]時，系統(tǒng)把資源分配給進程P[i]，Available[j]和Need[i,j]發(fā)生改變

{ 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(“開始執(zhí)行安全性算法……n”);for(m=0;m<1;m++)//數(shù)組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;//以數(shù)組safe[k]記下各個進程得到

分配的資源的順序

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

放出分配給它的資源

work[0]+=allocation[n][0];//進程執(zhí)行后釋

finish[n]=“ture”;//finish[n]變?yōu)?以示該進

程完成本次分

}

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

0

素都為ture } else

if(m==4)//此處m=4表示所有數(shù)組finish的所有元if(strcmp(finish[m],“false”)==0){

printf(“找不到安全序列，系統(tǒng)處于不安全狀態(tài)。n”);return 0;//找不到安全序列，結(jié)束check函數(shù)，返回 {

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

} return 1;} void main()//主程序開始 { start();for(;j==0;)//確認輸入數(shù)據(jù)的正確性，若輸入錯誤，重新輸入

{

入：“);

} printf(”數(shù)據(jù)確認無誤，算法繼續(xù)。n“);if(check()==0)//若check函數(shù)返回值為0，表示輸入的初始數(shù)據(jù)找不到安全序列，無法進行下一步，程序結(jié)束

{

} for(;j==1;)//當有多個進程請求資源時，循環(huán)開始

{

printf(”請輸入請求資源的進程i(0、1、2、3、4)：“);//輸入發(fā)出請求向量的進程及請求向量 end();exit(0);input();printf(”以下為進程資源情況，請確認其是否正確：n“);output();printf(”數(shù)據(jù)是否無誤：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(“數(shù)據(jù)輸入有誤，請重試！n請輸入進程P%d的請求向量Request%d：”,i,i);

提供分配

n“,i);

} if(request[i][0]<=available[0])//判斷系統(tǒng)是否有足夠資源

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

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

} else

printf(”系統(tǒng)沒有足夠的資源，進程P%d需要等待。printf(“系統(tǒng)正在為進程P%d分配資源……n”,i);change();//分配資源 j=0;if(j==0)//j=0表示系統(tǒng)有足夠資源分配的情況 {

printf(“當前系統(tǒng)資源情況如下：n”);//輸出分配資源后的系統(tǒng)資源分配情況

分配無效

output();

if(check()==0)//若找不到安全系列，則之前的資源 {

printf(“本次資源分配作廢，恢復(fù)原來的資源分配

狀態(tài)。n”);

資源狀態(tài)

輸入：“);

for(m=0;m<1;m++)//恢復(fù)分配資源前的系統(tǒng)

}

}

{

}

output();//輸出系統(tǒng)資源狀態(tài)

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循環(huán)條件滿足

} end();}

五、程序執(zhí)行結(jié)果：

六、實驗總結(jié)

多個進程同時運行時，系統(tǒng)根據(jù)各類系統(tǒng)資源的最大需求和各類系統(tǒng)的剩余資源為進程安排安全序列，使得系統(tǒng)能快速且安全地運行進程，不至發(fā)生死鎖。銀行家算法是避免死鎖的主要方法，其思路在很多方面都非常值得我們來學(xué)習(xí)借鑒。