第一篇：操作系統(tǒng)課程設計----模擬銀行家算法避免死鎖
模擬通過銀行家算法避免死鎖
一、銀行家算法產(chǎn)生的背景及目的 1：在多道程序系統(tǒng)中，雖然借助于多個進程的并發(fā)執(zhí)行來改善系統(tǒng)的利用率，提高系統(tǒng)的吞吐量，但可能發(fā)生一種危險—死鎖。死鎖就是多個進程在運行過程中因爭奪資源而造成的一種僵局，當進程處于這種僵局狀態(tài)時，如無外力作用，他們將無法再向前進行，如再把信號量作為同步工具時，多個Wait和Signal操作順序不當，會產(chǎn)生進程死鎖。
然而產(chǎn)生死鎖的必要條件有互斥條件，請求和保持條件，不剝奪條件和環(huán)路等待條件。在預防死鎖的幾種方法中，都施加了較強的限制條件，在避免死鎖的方法中，所施加的條件較弱，有可能獲得令人滿意的系統(tǒng)性能。在該方法中把系統(tǒng)的狀態(tài)分為安全狀態(tài)和不安全狀態(tài)，只要能使系統(tǒng)都處于安全狀態(tài)，便可避免死鎖。2：實驗目的：讓學生獨立的使用編程語言編寫和調試一個系統(tǒng)分配資源的簡單模擬程序，了解死鎖產(chǎn)生的原因及條件。采用銀行家算法及時避免死鎖的產(chǎn)生，進一步理解課堂上老師講的相關知識點。銀行家算法是從當前狀態(tài)出發(fā)，逐個按安全序列檢查各客戶中誰能完成其工作，然后假定其完成工作且歸還全部貸款，再進而檢查下一個能完成工作的客戶。如果所有客戶都能完成工作，則找到一個安全序列，銀行家才是安全的。
二：銀行家算法中的數(shù)據(jù)結構
1：可利用資源向量Available。這是一個含有m個元素的數(shù)組，其中的每個元素代表一類可利用的資源數(shù)目，其初始值是系統(tǒng)中所配置的該類全部可用資源的數(shù)目，其數(shù)值隨該類資源的分配和回收而動態(tài)的改變。如果Available[j]=k，z 則表示系統(tǒng)中現(xiàn)有Rj類資源K 個。
2：最大需求矩陣Max。這是一個n*m的矩陣，它定義了系統(tǒng)中n個進程中的每一個進程對m類資源的最大需求。如果Max[i,j]=k，表示第i個進程需要第Rj類資源的最大數(shù)目k個.3: 分配矩陣Allocation,也是n*m的矩陣，若Allocation[i,j]=k,表示第i 個進程已分配Rj類資源的數(shù)目為k個。
4：需求矩陣Need。也是一個n*m的矩陣，Need[i,j]=k,表示第i個進程還需Rj類資源k個。
三、銀行家算法及安全性算法
1：銀行家算法
設Request[i]是進程Pi的請求向量，若Request[i][j]=k;表示進程需要j類資源k個。當Pi發(fā)出資源請求時，系統(tǒng)按下屬步驟進行檢查；(1)如果Request[i][j]<=Need[i][j];便轉向步驟（2），否則認為出錯，因為它所需要的資源數(shù)已超過他所宣布的最大值。
(2)如果Request[i][j]<=Available[i][j],便轉向步驟（3），否則認為尚無足夠資源，進程需等待。(3)系統(tǒng)試探著把資源分配給進程，并修改下面數(shù)據(jù)結構的數(shù)據(jù) 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)系統(tǒng)執(zhí)行安全性算法，檢查此次資源分配后系統(tǒng)是否處于安全狀態(tài)。若安全，才正式將資源分配給進程Pi，已完成此次分配。否則，將本次的試探分配作廢，回復原來的資源分配狀態(tài)，將進程Pi等待。2：安全性算法
（1）設置兩個向量；
1：工作向量Work，表示系統(tǒng)可提供給進程運行所需的各類資源數(shù)目，它含有m個元素，初始時Work=Available 2：Finish ,表示系統(tǒng)是否有足夠的資源分配給進程，使之運行完成。開始時先做Finish[i]=true（2）從進程中找到一個能滿需下屬條件的進程
1；Finish[i]=false；
2：Need[i][j]<=Work[j];若找到執(zhí)行步驟（3），否則執(zhí)行步驟（4）
（3）當進程Pi順利獲得資源后，直至完成，并釋放分配給它的資源，執(zhí)行： Work[j]=Work[j]+Allocation[i][j];Finish[i]=true;Go to step(2);(5)如果所有的進程Finish[i]都滿足，則表示系統(tǒng)處于安全狀態(tài)，否則，處于不安全狀態(tài)。
四、模塊設計與分析及整體功能概述
模塊設計與分析：
整個銀行家算法分為初始化函數(shù)Init（），安全性算法函數(shù) safe（），銀行家算法函數(shù)bank（）三部分。初始化函數(shù)生成開始時刻系統(tǒng)中的進程和資源情況，安全性算法判斷當某進程申請資源時，系統(tǒng)能否處于安全狀態(tài)。在本實驗中，若系統(tǒng)處于安全狀態(tài)，便生成一個安全進程序列（安全序列可能有多個）。銀行家算法函數(shù)bank（）負責整體的檢查與異常判斷。整體功能概述：
死鎖會引起系統(tǒng)陷入僵局，操作系統(tǒng)必須防止此現(xiàn)象的發(fā)生。本實驗通過一個動態(tài)分配資源的模擬程序，更清楚的理解死鎖產(chǎn)生的原因和條件。Dijkstra的銀行家算法是最有代表性的避免死鎖的方法。運行程序時用戶設定系統(tǒng)中進程和可利用資源的種類數(shù)目。輸入各進程的可利用資源Available，最大需求MAX，已分配資源Allocation，需求資源Need，之后各系統(tǒng)發(fā)出資源請求Request，利用實驗中的安全性算法判斷能否產(chǎn)生一個安全性隊列，若能，則給該進程分配成功，否則，不予分配。
五、流程圖設計
六、源代碼及調試分析
#include
// 定義最大進程數(shù) #define MAXn 100
//定義最大資源數(shù)
int MAX[MAXm][MAXn];
//最大需求矩陣 int Allocation[MAXm][MAXn];
//已分配矩陣 int Available[MAXn];
//可用資源數(shù)組 int Need[MAXm][MAXn];
//需求矩陣 int Request[MAXm][MAXn];
//請求矩陣
int Finish[MAXm];
//存儲完成資源分配的進程 int Sequence[MAXm];
//模擬的資源分配序列
int Work[MAXn];
//系統(tǒng)是否有足夠的資源分配給進程 int m,n;
//m個進程,n個資源
#define False 0 #define True 1 void input();//數(shù)據(jù)輸入函數(shù) int safealg();//安全性算法函數(shù) void banker();//銀行家算法函數(shù) void main(){input();safealg();banker();}
//*************初始化算法*************** void input(){ int i,j;
//************自定義進程數(shù)目與資源種類******************* cout<<“***********************************n”;cout<<“*利用銀行家算法避免死鎖*n”;
cout<<“*
*n”;cout<<“************************************n”;cout<<“請輸入進程的數(shù)目:”;cin>>m;cout<<“請輸入資源的種類:”;cin>>n;//*****輸入每個進程對每種資源的最大需求、已經(jīng)獲得的數(shù)量、每種類型資源的數(shù)目
cout<<“各進程資源最大需求(Max),按照”< cout<<“P”< for(j=0;j { cin>>MAX[i][j]; if(j==n) cout<<“資源種類數(shù)匹配出現(xiàn)錯誤！”;//當資源配置的種類數(shù)大于預先輸入的數(shù)值時，出錯 } } cout<<“各進程當前獲得資源(Allocation),按照”< cout<<“P”< for(j=0;j { cin>>Allocation[i][j]; if(j==n) cout<<“資源種類數(shù)匹配出現(xiàn)錯誤！”;//當資源配置的種類數(shù)大于預先輸入的數(shù)值時，出錯 Need[i][j]=MAX[i][j]-Allocation[i][j];//需求數(shù)等于最大需求減去已經(jīng)分配數(shù) } } cout<<“系統(tǒng)可用資源(Available):”< cin>>Available[j];//輸入各種資源的可利用數(shù) } 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<<“申請的資源大于它需要的資源數(shù),請重新輸入!n”;//資源申請不合理 continue; } if(Request[i][j]>Available[j]) { //資源申請數(shù)目大于可利用數(shù)，無法分配，得等待 cout<<“當前系統(tǒng)可用資源不夠，請等待!”< 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 //把資源恢復成分配之前的狀態(tài) { 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]; //工作分配初始化為系統(tǒng)可用資源 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<<“系統(tǒng)安全!”< cout<<“安全序列：”; for(i=0;i //輸出安全序列 cout<<“進程P”< cout< return 0;} }// cout<<“系統(tǒng)進入不安全狀態(tài)！”< 分析：輸入各進程的可利用資源Available，最大需求MAX，已分配資源Allocation，需求資源Need，之后各系統(tǒng)發(fā)出資源請求Request，利用實驗中的安全性算法判斷能否產(chǎn)生一個安全性隊列，若能，則給該進程分配成功，否則，不予分配。在確定安全序列的過程中，要檢測所有進程的Finish[i]的值，每次循環(huán)檢測完后要重復從第一個進程開始。 七、運行結果 假設輸入進程個數(shù)為5，資源種類數(shù)為3，并以此輸入各進程初始時刻的各種資源數(shù)量，如下 若再繼續(xù)申請資源，假設為P4，申請資源（1 2 2） 假設P1 申請資源（2 2 4）有 八、心得體會 經(jīng)過這次操作系統(tǒng)課程設計，讓我受益匪淺，收獲頗多。主要體會如下： 1.利用Vc++編譯程序編寫銀行家算法，進一步理解到通過銀行家算法避免死鎖的思想,同時也理解了系統(tǒng)死鎖產(chǎn)生的原因及條件。 2.在實驗過程中所有的設計步驟遵循老師教授的程序功能化的思想，分別定義了三個函數(shù)，init()初始化函數(shù),safealg()安全性算法函數(shù)，bank（）銀行家算法函數(shù)，體現(xiàn)了函數(shù)的模塊化思想。這樣的話，不僅提高了程序的可讀性和可操作性，而且還提高了CPU的利用率和內存的利用率，因為程序的運行是局部性的，這種思想對于段頁式存儲管理系統(tǒng)尤為重要。 3.實驗過程中遇到的種種疑難問題通過自己上網(wǎng)查找答案，鍛煉了自己糾錯能力和搜索有價值信息的能力及自學的能力，并且進一步鞏固了自己以前學過的專業(yè)知識。 操作系統(tǒng)實驗：銀行家算法 姓名：李天瑋 班級：軟工1101 實驗內容： 在windows系統(tǒng)中實現(xiàn)銀行家算法程序。 學號：201126630117 實現(xiàn)銀行家算法所用的數(shù)據(jù)結構： 假設有5個進程3類資源，則有如下數(shù)據(jù)結構： 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類資源的資源量。 銀行家算法： 設進程1提出請求Request[N]，則銀行家算法按如下規(guī)則進行判斷。(1)如果Request[N]<=NEED[1,N],則轉（2）；否則，出錯。(2)如果Request[N]<=AVALIABLE，則轉（3）；否則，出錯。(3)系統(tǒng)試探非配資源，修改相關數(shù)據(jù)。 AVALIABLE=AVALIABLE-REQUEST ALLOCATION=ALLOCATION+REQUEST NEED=NEED-REQUEST(4)系統(tǒng)執(zhí)行安全性檢查，如安全，則分配成立；否則試探險性分配作廢，系統(tǒng)恢復原狀，進程等待。 安全性檢查： （1）設置兩個工作向量WORK=AVAILABLE；FINISH[M]=FALSE.（2）從晉城集合中找到一個滿足下述條件的進程，F(xiàn)INISH[i]=FALSE NEED<=WORK 如找到，執(zhí)行（3）；否則，執(zhí)行（4）。 （3）設進程獲得資源，可順利執(zhí)行，直至完成，從而釋放資源。 WORK=WORK+ALLOCATION FINISH[i]=TRUE GOTO（2） （4）如所有進程FINISH[M]=TRUE，則表示安全；否則系統(tǒng)不安全。 1.用init（）函數(shù)對于數(shù)據(jù)的初始化 關鍵代碼： #define M 5 #define N 3 void init(){ cout<<“請輸入5個進程對3類資源最大資源需求量:”< } cout<<“請輸入系統(tǒng)可用的資哩源數(shù):”< { } cin>>AVAILABLE[j];for(int j=0;j cout<<“請輸入5個進程已經(jīng)-的到的3類資源的資源量:”< for(int i=0;i } cout<<“請?輸?入?5個?進?程ì還1需è要癮3類え?資哩?源′的?資哩?源′量?:”< } for(int j=0;j }// Stack around the variable 'AVAILABLE' was corrupted.顯示數(shù)據(jù)詳細信息 進行測試 輸入一號進程號，并給需要申請資源設定為{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< 計算機操作系統(tǒng)實驗報告 題 目 利用銀行家算法避免死鎖 一、實驗目的： 1、加深了解有關資源申請、避免死鎖等概念，并體會和了解死鎖和避免死鎖的具體實施方法。 2、要求編寫和調試一個系統(tǒng)動態(tài)分配資源的簡單模擬程序，觀察死鎖產(chǎn)生的條件，并采用銀行家算法，有效的防止和避免死鎖的發(fā)生。 二、實驗內容： 用銀行家算法實現(xiàn)資源分配： 設計五個進程{p0,p1,p2,p3,p4}共享三類資源{A,B,C}的系統(tǒng)，例如，{A,B,C}的資源數(shù)量分別為10，5，7。進程可動態(tài)地申請資源和釋放資源，系統(tǒng)按進程的申請動態(tài)地分配資源，要求程序具有顯示和打印各進程的某一個時刻的資源分配表和安全序列；顯示和打印各進程依次要求申請的資源號以及為某進程分配資源后的有關資源數(shù)據(jù)。 三、問題分析與設計： 1、算法思路： 先對用戶提出的請求進行合法性檢查，即檢查請求是否大于需要的，是否大于可利用的。若請求合法，則進行預分配，對分配后的狀態(tài)調用安全性算法進行檢查。若安全，則分配；若不安全，則拒絕申請，恢復到原來的狀態(tài)，拒絕申請。 2、銀行家算法步驟： （1）如果Requesti＜or =Need,則轉向步驟(2)；否則，認為出錯，因為它所需要的資源數(shù)已超過它所宣布的最大值。 （2）如果Request＜or=Available,則轉向步驟（3）；否則，表示系統(tǒng)中尚無足夠的資源，進程必須等待。 （3）系統(tǒng)試探把要求的資源分配給進程Pi,并修改下面數(shù)據(jù)結構中的數(shù)值： Available=Available-Request[i]; Allocation=Allocation+Request;Need=Need-Request;(4)系統(tǒng)執(zhí)行安全性算法，檢查此次資源分配后，系統(tǒng)是否處于安全狀態(tài)。 3、安全性算法步驟：（1）設置兩個向量 ①工作向量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í)行，直至完成，并釋放出分配給它的資源，故應執(zhí)行： Work=Work+Allocation;Finish[i]=true;轉向步驟（2）。 （4）如果所有進程的Finish[i]=true,則表示系統(tǒng)處于安全狀態(tài)；否則，系統(tǒng)處于不安全狀態(tài)。 4、流程圖： 系統(tǒng)主要過程流程圖 銀行家算法流程圖 安全性算法流程圖 5、主要數(shù)據(jù)結構 假設有M個進程N類資源，則有如下數(shù)據(jù)結構： 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 { // 界面設計 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(”分配后導致系統(tǒng)處于不安全狀態(tài)!,不可立即分配"); 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、程序編寫的時候規(guī)定最大資源數(shù)和最大進程數(shù)均<=6。 2、程序直接初始化了6個進程框，既浪費了內存空間，又對可視化界面的美觀造成影響。 3、未對輸入異常進行處理：比如在請求資源的第一個方框中只能填入進程的數(shù)字編號，當填入的為非整數(shù)時，程序會拋出異常。 4、未解決進程名中對字符串的處理，直接固定進程名為數(shù)字，用戶不能直接輸入原有的進程名，造成不好的用戶體驗。 操作系統(tǒng)課程設計 （銀行家算法的模擬實現(xiàn)） 一、設計目的 1、進一步了解進程的并發(fā)執(zhí)行。 2、加強對進程死鎖的理解。 3、用銀行家算法完成死鎖檢測。 二、設計內容 給出進程需求矩陣C、資源向量R以及一個進程的申請序列。使用進程啟動拒絕和資源分配拒絕（銀行家算法）模擬該進程組的執(zhí)行情況。 三、設計要求 1、初始狀態(tài)沒有進程啟動。 2、計算每次進程申請是否分配，如：計算出預分配后的狀態(tài)情況（安全狀態(tài)、不安全狀態(tài)），如果是安全狀態(tài)，輸出安全序列。 3、每次進程申請被允許后，輸出資源分配矩陣A和可用資源向量V。 4、每次申請情況應可單步查看，如：輸入一個空格，繼續(xù)下個申請。 四、算法原理 1、銀行家算法中的數(shù)據(jù)結構(1)、可利用資源向量Available，這是一個含有m個元素的數(shù)組，其中的每個元素代表一類可利用資源的數(shù)目，其初始值是系統(tǒng)中所配置的該類全部資源的數(shù)目，其數(shù)值隨該類資源的分配和回收而動態(tài)改變。如果Available[j]=K，則表示系統(tǒng)中現(xiàn)有Rj類資源K個。 （2）、最大需求矩陣Max，這是一個n*m的矩陣，它定義了系統(tǒng)中n個進程中的每一個進程對m類資源的最大需求。如果Max[i,j]=K，則表示進程i需要Rj類資源的最大數(shù)目為K。 （3）、分配矩陣Allocation。這也是一個n*m的矩陣，它定義了系統(tǒng)中每一類資源當前已分配給每一進程的資源數(shù)。如果Allocation[i,j]=K，則表示進程i當前已經(jīng)分得Rj類資源的數(shù)目為K。 （4）、需求矩陣Need。這也是一個n*m的矩陣，用以表示每個進程尚需要的各類資源數(shù)。如果Need[i,j]=K，則表示進程i還需要Rj類資源K個，方能完成其任務。上述三個矩陣間存在以下關系： Need[i,j]=Max[i,j]-Allocation[i,j] 2、銀行家算法應用 模擬實現(xiàn)Dijkstra的銀行家算法以避免死鎖的出現(xiàn)，分兩部分組成：一是銀行家算法（掃描）；二是安全性算法。 （1）銀行家算法（掃描） 設Requesti是進程Pi的請求向量，如果Requesti[j]=K，表示進程Pi需要K個Ri類型的資源。當Pi發(fā)出資源請求后，系統(tǒng)按下述步驟進行檢查： ①如果Requesti[j]<=Need[i,j]，便轉向步驟②；否則認為出錯，因為它所需的資源數(shù)已經(jīng)超過了它所宣布的最大值。 ②如果Requesti[j]<=Allocation[i,j]，便轉向步驟③；否則表示尚無足夠資源，Pi需等待。 ③系統(tǒng)試探著把資源分配給進程Pi，并修改下面數(shù)據(jù)結構中的數(shù)值。 Available[j]=Available-Requesti[j]； Allocation[i,j]=Allocation[i,j]+Requesti[j]； Need[i,j]=Need[i,j]-Requesti[j]； ④系統(tǒng)執(zhí)行安全性算法，檢查此次資源分配后，系統(tǒng)是否處于安全狀態(tài)。若安全，才正式將資源分配給進程Pi，已完成本次分配；否則，將本次的試探分配作廢，恢復原來資源的分配狀態(tài)，讓進程Pi等待。 （2）安全性算法 系統(tǒng)所執(zhí)行的安全性算法可描述如下： ①設置兩個向量：一個是工作向量Work；它表示系統(tǒng)可提供給進程繼續(xù)運行所需要的各類資源的數(shù)目，它含有m個元素，在執(zhí)行安全性算法開始時，work=Available；另一個是Finish；它表示系統(tǒng)是否有足夠的資源分配給進程，使之運行完成。開始時先做Finish[i]=false；當有足夠資源分配給進程時，再令Finish[i]=true； ②從進程集合中找到能滿足下述條件的進程： 一是Finish[i]==false；二是Need[i,j]<=Work[j]；若找到，執(zhí)行步驟③，否則，執(zhí)行步驟④； ③當進程Pi獲得資源后，可順利執(zhí)行，直至完成，并釋放出分配給它的資源，故應執(zhí)行： Work[j]=Work[j]+Allocation[i,j]； Finish[i]=true； go to step②； ④如果所有進程的 Finish[i]==true都滿足，則表示系統(tǒng)處于安全狀態(tài)，否則系統(tǒng)處于不安全狀態(tài)。 五、設計思路 1、進程一開始向系統(tǒng)提出最大需求量； 2、進程每次提出新的需求（分期貸款）都統(tǒng)計是否超出它事先提出的最大需求量； 3、若正常，則判斷該進程所需剩余量（包括本次申請）是否超出系統(tǒng)所掌握的剩余資源量，若不超出，則分配，否則等待。 六、程序運行調試結果 1、程序初始化 2、檢測系統(tǒng)資源分配是否安全結果 七、小結 “銀行家算法的模擬實現(xiàn)”是本學期操作系統(tǒng)課程的課程設計。在設計此程序的過程中我們遇到過許多問題也學到了很多東西。通過這周的課程設計，我加深了對銀行家算法的理解，掌握了銀行家算法避免死鎖的過程和方法，理解了死鎖產(chǎn)生的原因和條件以及避免死鎖的方法。所編寫程序基本實現(xiàn)了銀行家算法的功能，并在其基礎上考慮了輸出顯示格式的美觀性，使界面盡可能友好。并且在編程時將主要的操作都封裝在函數(shù)中，這樣使程序可讀性增強，使程序更加清晰明了。在算法的數(shù)據(jù)結構設計上考慮了很長時間。在程序設計中先后參考了很多網(wǎng)絡資料也參考了一些別人寫的的程序綜合這些算法思想和自己的思路對程序做了很好的設計方式對一些算法的優(yōu)越性等也作了一些考慮。當然，在編寫和調試過程中我遇到了許多的問題，通過網(wǎng)上查詢資料、翻閱課本、向同學請教、多次調試等方法逐漸解決了大部分問題。讓我收獲很多，相信在今后的生活中也有一定幫助。 附：程序源代碼： #include int no1;//進程數(shù) int no2;//資源數(shù) 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(“* 銀行家算法的設計與實現(xiàn) *n”);printf(“**********************************************n”);printf(“請輸入進程總數(shù):n”);scanf(“%d”,&no1);printf(“請輸入資源種類數(shù):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]);//輸入已知的進程已分配的資源數(shù) for(i=0;i for(j=0;j need[i][j]=max[i][j]-allocation[i][j];//根據(jù)輸入的兩個數(shù)組計算出need矩陣的值 printf(“請輸入Available矩陣n”);for(i=0;i scanf(“%d”,&available[i]);//輸入已知的可用資源數(shù) print();//輸出已知條件 check();//檢測T0時刻已知條件的安全狀態(tài) if(r==1)//如果安全則執(zhí)行以下代碼 { 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請輸入該進程所請求的資源數(shù)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]; //保存原已分配的資源數(shù)，仍需要的資源數(shù)和可用的資源數(shù) available[j]=available[j]-request[j]; allocation[i][j]+=request[j]; need[i][j]=need[i][j]-request[j];//系統(tǒng)嘗試把資源分配給請求的進程 } print(); check();//檢測分配后的安全性 if(r==0)//如果分配后系統(tǒng)不安全 { for(j=0;j { available[j]=available1[j]; allocation[i][j]=allocation1[i][j]; need[i][j]=need1[i][j];//還原已分配的資源數(shù)，仍需要的資源數(shù)和可用的資源數(shù) } printf(“返回分配前資源數(shù)n”); print(); } } }printf(“n你還要繼續(xù)分配嗎？Y or N ?n”); //判斷是否繼續(xù)進行資源分配 for(j=0;j if(p) printf(“請求資源超過該進程資源需求量，請求失??！n”);else { for(j=0;j if(request[j]>available[j])q=1;//判斷請求是否超過可用資源數(shù) if(q) printf(“沒有做夠的資源分配，請求失敗！n”); c=getche(); }while(c=='y'||c=='Y');} } void check()//安全算法函數(shù) { int k,f,v=0,i,j;int work[m],a[m];bool finish[m];r=1;for(i=0;i finish[i]=false;// 初始化進程均沒得到足夠資源數(shù)并完成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)//找到還沒有完成且需求數(shù)小于可提供進程繼續(xù)運行的資源數(shù)的進程 { finish[i]=true; a[v++]=i;//記錄安全序列號 for(j=0;j work[j]+=allocation[i][j];//釋放該進程已分配的資源 } } } k--;//每完成一個進程分配，未完成的進程數(shù)就減1 }while(k>0);f=1;for(i=0;i if(finish[i]==false) { f=0; break; } } if(f==0)//若有進程沒完成，則為不安全狀態(tài) { printf(“系統(tǒng)處在不安全狀態(tài)！”); r=0;} else { printf(“n系統(tǒng)當前為安全狀態(tài)，安全序列為：n”); for(i=0;i printf(“p%d ”,a[i]);//輸出安全序列 } } void print()//輸出函數(shù) { 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(“各類資源可利用的資源數(shù)為:”); for(j = 0;j < no2;j++) {printf(“ %d”,available[j]);} } printf(“n”); （程序結束） 課程設計報告書 課程名稱： 操作系統(tǒng)原理 題 目： 編程序模擬銀行家算法 系 名： 信息工程系 專業(yè)班級： 軟件 姓 名： 學 號： 指導教師: 2013年 X 月 X 日 學院信息工程系 課 程 設 計 任 務 書 課程名稱： 操作系統(tǒng)原理課程設計 指導教師： 班級名稱： 軟件 開課系、教研室： 軟件與信息安全 一、課程設計目的與任務 操作系統(tǒng)課程設計是《操作系統(tǒng)原理》課程的后續(xù)實踐課程，旨在通過一周的實踐訓練，加深學生對理論課程中操作系統(tǒng)概念，原理和方法的理解，加強學生綜合運用操作系統(tǒng)原理、Linux系統(tǒng)、C語言程序設計技術進行實際問題處理的能力，進一步提高學生進行分析問題和解決問題的能力，包含系統(tǒng)分析、系統(tǒng)設計、系統(tǒng)實現(xiàn)和系統(tǒng)測試的能力。 學生將在指導老師的指導下，完成從需求分析，系統(tǒng)設計，編碼到測試的全過程。 二、課程設計的內容與基本要求 1、課程設計題目 編程序模擬銀行家算法 2、課程設計內容 本課程設計要求在Linux操作系統(tǒng)，GCC編譯環(huán)境下開發(fā)。 銀行家算法是避免死鎖的一種重要方法，本實驗要求用用c/c++語言在Linux操作系統(tǒng)環(huán)境下編寫和調試一個簡單的銀行家算法程序。加深了解有關資源申請、避免死鎖等概念，并體會和了解死鎖和避免死鎖的具體實施方法。 思想：將一定數(shù)量的資金供多個用戶周轉使用，當用戶對資金的最大申請量不超過現(xiàn)存資金時可接納一個新客戶，客戶可以分期借款，但借款總數(shù)不能超過最大的申請量。銀行家對客戶的借款可以推遲支付，但是能夠使客戶在有限的時間內得到借款，客戶得到所有的借款后能在有限的時間內歸還。用銀行家算法分配資源時，測試進程對資源的最大需求量，若現(xiàn)存資源能滿足最大需求就滿足當前進程的申請，否則推遲分配，這樣能夠保證至少有一個進程可以得到所需的全部資源而執(zhí)行到結束，然后歸還資源，若OS能保證所有進程在有限的時間內得到所需資源則稱系統(tǒng)處于安全狀態(tài)。 3、設計報告撰寫格式要求： 1設計題目與要求 設計思想 3系統(tǒng)結構 數(shù)據(jù)結構的說明和模塊的算法流程圖 使用說明書（即用戶手冊）：內容包含如何登錄、退出、讀、寫等操作說明 運行結果和結果分析（其中包括實驗的檢查結果、程序的運行情況） 自我評價與總結 附錄：程序清單，注意加注釋（包括關鍵字、方法、變量等），在每個模塊前加注釋； 三、課程設計步驟及時間進度和場地安排 本課程設計將安排在第15周,教育技術中心。具體安排如下： 第一天 下發(fā)任務書，學生查閱資料 第二天 系統(tǒng)設計和原型開發(fā) 第三，四天 系統(tǒng)功能實現(xiàn) 第五天 系統(tǒng)調試 測試 打包和驗收 四、課程設計考核及評分標準 課程設計考核將綜合考慮學生考勤和參與度，系統(tǒng)設計方案正確性，系統(tǒng)設計和開發(fā)效果以及課程設計報告書的質量。具體評分標準如下： 設置六個評分點 （1）設計方案正確，具有可行性、創(chuàng)新性； 25分 （2）系統(tǒng)開發(fā)效果較好； 25分 （3）態(tài)度認真、刻苦鉆研、遵守紀律； 10分 （4）設計報告規(guī)范、課程設計報告質量高、參考文獻充分 20分 （5）課程設計答辯概念清晰，內容正確 10分 （6）課程設計期間的課堂考勤、答疑與統(tǒng)籌考慮。 10分 按上述六項分別記分后求和，總分按五級記分法記載最后成績。 優(yōu)秀（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 操作系統(tǒng)環(huán)境下編寫和調試一個簡單的銀行家算法程序。加深了解有關資源申請、避免死鎖等概念，并體會和了解死鎖和避免死鎖的具體實施方法。 1.4 實驗內容 ： 1.4.1編寫安全性算法； 1.4.2編寫銀行家算法，并編制銀行家算法通用程序，將調試結果顯示在計算機屏幕上，再檢測和筆算的一致性。 設計思想 將一定數(shù)量的資金供多個用戶周轉使用，當用戶對資金的最大申請量不超過現(xiàn)存資金時可接納一個新客戶，客戶可以分期借款，但借款總數(shù)不能超過最大的申請量。銀行家對客戶的借款可以推遲支付，但是能夠使客戶在有限的時間內得到借款，客戶得到所有的借款后能在有限的時間內歸還。 用銀行家算法分配資源時，測試進程對資源的最大需求量，若現(xiàn)存資源能滿足最大需求就滿足當前進程的申請，否則推遲分配，這樣能夠保證至少有一個進程可以得到所需的全部資源而執(zhí)行到結束，然后歸還資源，若OS能保證所有進程在有限的時間內得到所需資源則稱系統(tǒng)處于安全狀態(tài)。 3.需求分析 3.1問題描述：利用銀行家算法模擬計算機系統(tǒng)分配資源的過程。 3.2要求： 3.2.11、以課本例題中數(shù)據(jù)為例，模擬資源分配過程。 3.2.2、系統(tǒng)中資源種類，各類資源數(shù)目，進程申請資源數(shù)目可任意輸入，模擬資源分配過程。 4.系統(tǒng)結構 初始化函數(shù)init（）開始 輸入進程的數(shù)目m 輸入資源種類n 輸入每個進程最多所需的各種資源數(shù) 輸入每個進程分配的資源數(shù) 輸入各個資源現(xiàn)有數(shù)目 初始化函數(shù)init（）結束 輸入提示： 輸入有誤重新輸入 圖 5.數(shù)據(jù)結構的說明和模塊的算法流程圖 5.1 數(shù)據(jù)結構： ①可利用資源向量 Available 是個含有 m 個元素的數(shù)組，其中的每一個元素代表一類可利用的資源數(shù)目。如果 AvailablejK，則表示系統(tǒng)中現(xiàn)有 Rj 類資源 K 個。 ②最大需求矩陣 Max 這是一個 n×m的矩陣，它定義了系統(tǒng)中 n 個進程中的每一個進程對 m 類資源的最大需求。如果 MaxijK，則表示進程 i 需要 Rj 類資源的最大數(shù)目為 K。 ③分配矩陣 Allocation 這也是一個 n×m的矩陣，它定義了系統(tǒng)中每一類資源當前已分配給每一進程的資源數(shù)。如果 AllocationijK，則表示進程 i 當前已分得 Rj 類資源的數(shù)目為 K。 ④需求矩陣 Need。 這也是一個 n×m的矩陣，用以表示每一個進程尚需的各類資源數(shù)。如果NeedijK，則表示進程 i 還需要 Rj 類資源 K 個，才可以完成其任務。 5．2 程序流程圖： ①、系統(tǒng)主要過程流程 預分配 安全？ 實際分配打印輸出 退出系統(tǒng) Request[i]>Available[i]? Request[i]>need[i]? 提出申請 打印輸出此時刻資源分配情況 進入系統(tǒng) 輸入： 1.繼續(xù)分配 2.退出 進入初始化 ②、安全性算法流程圖 調用safty()函數(shù) Work[]=Available[],Finish[]=False Need[]<=work[]且Finsh[]=Falsse? Work[]=work[]+Alloccation[],Finish[]=Ture 所有進程的Finsh[]=Ture? 實際分配輸出安全序列并打印出 輸出提示系統(tǒng)不安全 調用結束 用戶手冊 6.1 首先在終端中使用 vi 編輯器建立 c的源文件 6.2 然后使用 gcc 編輯器編譯生成可執(zhí)行文件 6.3 使用命令./當前名字，來執(zhí)行 7.運行結果和結果分析 7．1 運行結果： 申請成功如圖 2，申請失敗如圖 3： 圖 申請金額在需求范圍之內同意 圖 申請金額在需求范圍之外拒絕 7.2 結果分析 首先是自己定義 個用戶所需的金額數(shù)，銀行可以給用戶貸款的總金額數(shù)是100，用戶 Id 號的范圍是在0 到 4，超過 之后的id 請求貸款，會顯示拒絕提示信息，每個客戶的貸款數(shù)量必須是在之前定義的范圍之內，如果超出，也會出現(xiàn)錯誤提示，只有在規(guī)定的用戶 id 和在客戶所要求金額的范圍之內請求，才會給予貸款，并且輸出安全序列號。 8.自我評價與總結 一周的課程設計結束了。在這一周里，我收獲很多，以前都是在自己的教室由我們自己的老師進行講課，這次學校沒有這樣做，而是請的校外的老師給我們做課程設計，讓我們體會一下真正的公司是怎樣做業(yè)務的。在這一周里我做一個模擬銀行家算法。我覺得在著手設計前設計的思路是很重要的。只有思路清晰才能進行下一階段的設計。這樣才能完成整個程序的設計，完成整個文報告的書寫。 課程設計這幾天學到的東西還真不少。以前不清楚的現(xiàn)在都暴露出來了。以前認為學了沒用的東西現(xiàn)在也用到了。這次的課程設計使我進一步了解了調度與死鎖的問題。以及有關資源申請的問題、避免死鎖的具體實施方法。深入了解了銀行家算法的資源申請和資源分配的過程及原則。保證系統(tǒng)處于安全狀態(tài)。 經(jīng)過本周的課程設計，我對操作系統(tǒng)的掌握又進了一步，收獲了很多知識。，終于我了由于對 c 語言不夠熟練，在試驗過程中，進行了反復的修改和調試，解銀行家算法的基本原理，并且在此次的課程設計中我又復習了一下 c 語言，加深了對它的了解，而且在課程設計的過程中我們同樣學會了如何簡單的操作與使用 Linux 操作系統(tǒng)，學習到了許多 Linux 操作系統(tǒng)中常用的一些密令。 這次的設計數(shù)據(jù)是通過一道實際的題目來體現(xiàn)銀行家算法避免死鎖的問題，先用銀行家算法給其中一個進程分配資源，看它所請求的資源是否大于它的需求量，才和系統(tǒng)所能給的資源相比較.讓進程形成一個安全隊列看系統(tǒng)是否安全.再利用安全性算法檢查此時系統(tǒng)是否安全。 操作系統(tǒng)的基本特征是并發(fā)與共享。系統(tǒng)允許多個進程并發(fā)執(zhí)行，并且共享系統(tǒng)的軟、硬件資源。為了最大限度的利用計算機系統(tǒng)的資源，操作系統(tǒng)應采用動態(tài)分配的策略，但是這樣就容易因資源不足，分配不當而引起“死鎖”。而我本次課程設計就是得用銀行家算法來避免“死鎖”。銀行家算法就是一個分配資源的過程，使分配的序列不會產(chǎn)生死鎖。此算法的中心思想是：按該法分配資源時，每次分配后總存在著一個進程，如果讓它單獨運行下去，必然可以獲得它所需要的全部資源，也就是說，它能結束，而它結束后可以歸還這類資源以滿足其他申請者的需要。 通過這次實驗，我體會到銀行家算法的重要性，銀行家算法是避免死鎖的主要方法，其思路在很多方面都非常值得我來學習借鑒。 附錄： 主要源程序 參考文獻 [1] 張堯學主編．計算機操作系統(tǒng)教程（第三版）．北京:清華大學出版社，2006 [2] 張堯學編．計算機操作系統(tǒng)教程（第三版）習題解答與實驗指導．北京:清華大學出版社，2006 [3] 湯子瀛主編．計算機操作系統(tǒng)（第三版）．西安:西安電子科技大學出版社，2001 [4] 張坤等編．操作系統(tǒng)實驗教程．北京:清華大學出版社，2008 [5] 張麗芬等編．操作系統(tǒng)實驗教程．北京:清華大學出版社，2006 [6] 屠祁等編.操作系統(tǒng)基礎（第三版）．北京:清華大學出版社，2000 [7] 馮耀霖等編.操作系統(tǒng).西安:西安電子科技大學出版社，2001 [8] 左萬歷．計算機操作系統(tǒng)教程（第二版）．北京：高等教育出版社，2004 [9]譚浩強.《C語言程序設計》.北京：清華大學出版社2003 [8] 龐麗華.《操作系統(tǒng)原理》（第四版）.北京.華中科技大學出版社 2002 設計過程中質疑（或答辯）記載： 1.銀行家算法的主要思想是什么？ 答：一個進程進入系統(tǒng)時分配資源之前,判斷系統(tǒng)是否是安全的，即看它所請求的資源是否大于它的最大需求量，若正常,則判斷該進程所需剩余剩余量(包括本次申請)是否超出系統(tǒng)所掌握的剩余資源量,若不超出,則分配,否則等待。 2.銀行家算法的主要問題是什么？ 答：要求每個進程必須事先知道資源的最大需求量，而且，在系統(tǒng)運行過程中，考查每個進程對各類資源的申請需花費較多的時間。 3.在銀行家算法中各個資源存在什么關系？ 答：該進程所需要的資源數(shù)NEED[m][n]=MAX[m][n](該進程所需要的最多的資源數(shù))-----ALLOCATION[m][n](該進程所占有的資源數(shù)) 指導教師評語： 簽名： ****年**月**日第二篇：操作系統(tǒng)銀行家算法(避免死鎖)實驗報告
第三篇：操作系統(tǒng)實驗報告-利用銀行家算法避免死鎖
第四篇：操作系統(tǒng)課程設計(銀行家算法的模擬實現(xiàn))
第五篇：操作系統(tǒng)課程設計編程序模擬銀行家算法
點擊咨詢 