/mqt_signature/blog/static/1049595722009429104343122/
或者看看這個，可是妳需要的
《操作系統--銀行家算法》
課程設計報告
1 課程設計目的 …………………………………………………… 1
2 課程設計的要求 ………………………………………………… 1
3 課程設計題目描述 ……………………………………………… 2
4 課程設計之銀行家算法原理 …………………………………… 2
5 源程序結構分析及代碼實現 …………………………………… 4
6 課程設計總結 …………………………………………………… 25
壹、課程設計的目的
操作系統是計算機系統的核心系統軟件，它負責控制和管理整個系統的資源並組織用戶協調使用這些資源，使計算機高效的工作。《操作系統課程設計》是《操作系統》理論課的必要補充，是復習和檢驗所學課程的重要手段，本課程設計的目的是綜合應用學生所學知識，通過實驗環節，加深學生對操作系統基本原理和工作過程的理解，提高學生獨立分析問題、解決問題的能力，增強學生的動手能力。
二、課程設計的要求
1．分析設計內容，給出解決方案（要說明設計實現的原理，采用的數據結構）。
2．畫出程序的基本結構框圖和流程圖。
3．對程序的每壹部分要有詳細的設計分析說明。
4．源代碼格式要規範。
5．設計合適的測試用例，對得到的運行結果要有分析。
6．設計中遇到的問題，設計的心得體會。
7．按期提交完整的程序代碼、可執行程序和課程設計報告。
三、課程設計題目描述
銀行家算法是壹種最有代表性的避免死鎖的算法。
要解釋銀行家算法，必須先解釋操作系統安全狀態和不安全狀態。
安全狀態：如果存在壹個由系統中所有進程構成的安全序列P1，…，Pn，則系統處於安全狀態。安全狀態壹定是沒有死鎖發生。
不安全狀態:不存在壹個安全序列。不安全狀態不壹定導致死鎖。
那麽什麽是安全序列呢？
安全序列：壹個進程序列{P1，…，Pn}是安全的，如果對於每壹個進程Pi(1≤i≤n），它以後尚需要的資源量不超過系統當前剩余資源量與所有進程Pj (j < i )當前占有資源量之和。
銀行家算法：
我們可以把操作系統看作是銀行家，操作系統管理的資源相當於銀行家管理的資金，進程向操作系統請求分配資源相當於用戶向銀行家貸款。操作系統按照銀行家制定的規則為進程分配資源，當進程首次申請資源時，要測試該進程對資源的最大需求量，如果系統現存的資源可以滿足它的最大需求量則按當前的申請量分配資源，否則就推遲分配。當進程在執行中繼續申請資源時，先測試該進程已占用的資源數與本次申請的資源數之和是否超過了該進程對資源的最大需求量。若超過則拒絕分配資源，若沒有超過則再測試系統現存的資源能否滿足該進程尚需的最大資源量，若能滿足則按當前的申請量分配資源，否則也要推遲分配。
四、課程設計之銀行家算法原理
1．銀行家算法的思路
先對用戶提出的請求進行合法性檢查，即檢查請求的是不大於需要的，是否不大於可利用的。若請求合法，則進行試分配。最後對試分配後的狀態調用安全性檢查算法進行安全性檢查。若安全，則分配，否則，不分配，恢復原來狀態，拒絕申請。
2．銀行家算法中用到的主要數據結構
可利用資源向量 int Available[j] j為資源的種類。
最大需求矩陣 int Max[i][j] i為進程的數量。
分配矩陣 int Allocation[i][j]
需求矩陣 int need[i][j]= Max[i][j]- Allocation[i][j]
申請各類資源數量 int Request i[j] i進程申請j資源的數量
工作向量 int Work[x] int Finish[y]
3．銀行家算法bank()
進程i發出請求申請k個j資源，Request i[j]=k
(1)檢查申請量是否不大於需求量：Request i[j]<=need[i,j],若條件不符重新輸入，不允許申請大於需求量。
(2)檢查申請量是否小於系統中的可利用資源數量：Request i[j]<=available[i,j]，若條件不符就申請失敗，阻塞該進程，用goto語句跳轉到重新申請資源。
(3)若以上兩個條件都滿足，則系統試探著將資源分配給申請的進程，並修改下面數據結構中的數值：
Available[i,j]= Available[i,j]- Request i[j]；
Allocation[i][j]= Allocation[i][j]+ Request i[j]；
need[i][j]= need[i][j]- Request i[j]；
(4)試分配後，執行安全性檢查，調用safe()函數檢查此次資源分配後系統是否處於安全狀態。若安全，才正式將資源分配給進程；否則本次試探分配作廢，恢復原來的資源分配狀態，讓該進程等待。
(5)用do{…}while 循環語句實現輸入字符y/n判斷是否繼續進行資源申請。
4．安全性檢查算法（safe()函數）
(1)設置兩個向量：
工作向量Work，它表示系統可提供給進程繼續運行所需的各類資源數目，在執行安全性算法開始時，Work= Available。
Finish，它表示系統是否有足夠的資源分配給進程，使之運行完成。開始時先做Finish[i]=0；當有足夠的資源分配給進程時，再令Finish[i]=1。
(2)在進程中查找符合以下條件的進程：
條件1：Finish[i]=0；
條件2：need[i][j]<=Work[j]
若找到，則執行步驟(3)否則，執行步驟(4)
(3)當進程獲得資源後，可順利執行，直至完成，並釋放出分配給它的資源，故應執行：
Work[j]= Work[j]+ Allocation[i][j]；
Finish[i]=1；
goto step 2；
(4)如果所有的Finish[i]=1都滿足，則表示系統處於安全狀態，否則，處於不安全狀態。
五、源程序結構分析及代碼實現
1．程序結構
程序***有以下五個部分：
(1).初始化chushihua()：用於程序開始進行初始化輸入數據：進程數量、資源種類、各種資源可利用數量、各進程的各種資源已分配數量、各進程對各類資源最大需求數等。
(2).當前安全性檢查safe()：用於判斷當前狀態安全性，根據不同地方的調用提示處理不同。
(3).銀行家算法bank()：進行銀行家算法模擬實現的模塊，調用其他各個模塊進行銀行家算法模擬過程。
(4).顯示當前狀態show()：顯示當前資源分配詳細情況，包括：各種資源的總數量(all)、系統目前各種資源可用的數量、各進程已經得到的資源數量、各進程還需要的資源量。
(5).主程序main()
逐個調用初始化、顯示狀態、安全性檢查、銀行家算法函數，使程序有序的進行。
2．數據結構
程序使用的全局變量：
const int x=10，y=10； //定義常量
int Available[x]; //各種資源可利用的數量
int Allocation[y][y]; //各進程當前已分配的資源數量
int Max[y][y]; //各進程對各類資源的最大需求數
int Need[y][y]; //還需求矩陣
int Request[x]; //申請各類資源的數量
int Work[x]; //工作向量，表系統可提供給進程運行所需各類資源數量
int Finish[y]; //表系統是否有足夠的資源分配給進程，0為否，1為是
int p[y]; //存儲安全序列
int i,j; //全局變量，主要用於循環語句中
int n,m; //n為進程的數量,m為資源種類數
int l=0,counter=0;
3．函數聲明
void chushihua(); //系統初始化函數
void safe(); //安全性算法函數
void bank(); //銀行家算法函數
void show (); //輸出當前資源分配情況
4．主函數main()
int main()
{
cout<<…… //顯示程序開始提示信息
chushihua(); //初始化函數調用
cout<<endl<<endl;
showdata(); //輸出初始化後的狀態
//===判斷當前狀態的安全性===
safe(); //安全性算法函數調用
if (l<n){
cout<<"\n當前狀態不安全，無法申請,程序退出!!!!!"<<endl;
cout<<endl;
system("pause");
sign(); //調用簽名函數
return 0; // break;
}
else{
int i; //局部變量
l=0;
cout<<"\n安全的狀態!!!"<<endl;
cout<<"安全序列為: ";
cout<<endl<<"進程"<<"("<<p[0]<<")"; //輸出安全序列，考慮顯示格式，先輸出第壹個
for (i=1; i<n; i++){
cout<<"==>>"<<"進程"<<"("<<p[i]<<")";
}
for (i=0; i<n; i++) Finish[i]=0; //所有進程置為未分配狀態
cout<<endl<<endl;
}
bank(); //銀行家算法函數調用
return 0;
}
5. 操作系統銀行家算法流程圖：
2.源程序代碼：
#include <iostream.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//定義全局變量
const int x=10,y=10; //常量，便於修改
int Available[x]; //各資源可利用的數量
int Allocation[y][y]; //各進程當前已分配的資源數量
int Max[y][y]; //各進程對各類資源的最大需求數
int Need[y][y]; //尚需多少資源
int Request[x]; //申請多少資源
int Work[x]; //工作向量，表示系統可提供給進程繼續運行所需的各類資源數量
int Finish[y]; //表示系統是否有足夠的資源分配給進程，1為是
int p[y]; //存儲安全序列
int i,j; //i表示進程，j表示資源
int n,m; //n為進程i的數量,m為資源j種類數
int l=0; //l用來記錄有幾個進程是Finish[i]=1的，當l=n是說明系統狀態是安全的
int counter=0;
//函數聲明
void chushihua(); //初始化函數
void safe(); //安全性算法
void show(); //函數show,輸出當前狀態
void bank(); //銀行家算法
void jieshu(); //結束函數
void chushihua()
{
cout<<"輸入進程的數量: ";//從此開始輸入有關數據
cin>>n;
cout<<"輸入資源種類數: ";
cin>>m;
cout<<endl<<"輸入各種資源當前可用的數量( "<<m<<" 種): "<<endl;
for (j=0; j<m; j++)
{
cout<<"輸入資源 "<<j<<" 可利用的數量Available["<<j<<"]: ";
cin>>Available[j]; //輸入數字的過程...
Work[j]=Available[j]; //初始化Work[j]，它的初始值就是當前可用的資源數
}
cout<<endl<<"輸入各進程當前已分配的資源數量Allocation["<<n<<"]["<<m<<"]: "<<endl;
for (i=0; i<n; i++)
{
for (j=0; j<m; j++)
{
cout<<" 輸入進程 "<<i<<" 當前已分配的資源 "<<j<<" 數量: ";
cin>>Allocation[i][j];
}
cout<<endl;
Finish[i]=0;//初始化Finish[i]
}
cout<<endl<<"輸入各進程對各類資源的最大需求Max["<<n<<"]["<<m<<"]: "<<endl;
for (i=0; i<n; i++)
{
for (j=0; j<m; j++)
{
cout<<" 輸入進程 "<<i<<" 對資源 "<<j<<" 的最大需求數: ";
cin>>Max[i][j];
if(Max[i][j]>=Allocation[i][j]) //若最大需求大於已分配，則計算需求量
Need[i][j] = Max[i][j]-Allocation[i][j];
else
Need[i][j]=0;//Max小於已分配的時候，此類資源已足夠不需再申請
}
cout<<endl;
}
cout<<endl<<"初始化完成"<<endl;
}
//安全性算法函數
void safe()
{
l=0;
for (i=0; i<n;i++)
{ //i++
if (Finish[i]==0)
{ //逐個查找Finish[i]==0的進程 條件壹
counter=0; //記數器
for (j=0; j<m; j++)
{
if (Work[j]>=Need[i][j]) counter=counter+1;//可用大於需求，記數
}
if(counter==m) //i進程的每類資源都符合Work[j]>=Need[i][j] 條件二
{
p[l]=i; //存儲安全序列
Finish[i]=1; //i進程標誌為可分配
for (j=0; j<m;j++)
Work[j]=Work[j]+Allocation[i][j]; //釋放資源
l=l+1; //記數,現在有L個進程是安全的，當L=N時說明滿足安全序列
i= -1; //從第壹個進程開始繼續尋找滿足條件壹二的進程
}
}
}
}
//顯示當前狀態函數
void show() //函數show,輸出當前資源分配情況
{
int i,j; //局部變量
int All[y]; //各種資源的總數量
int L1; //局部變量L1
cout<<"當前的狀態為："<<endl;
cout<<"各種資源的總數量:"<<endl;
for (j=0;j<m;j++)
{
cout<<" 資源"<<j<<": ";
All[j]=Available[j]; //總數量=可用的+已分配的
for (i=0;i<n;i++) All[j]+=Allocation[i][j];
cout<<All[j]<<" ";
}
cout<<endl<<"當前各種資源可用的量為(available):"<<endl;
for (j=0;j<m;j++)
cout<<" 資源"<<j<<": "<<Available[j]<<" ";
cout<<endl<<"各進程已經得到的資源量(allocation): "<<endl;
for(i=0;i<=m;i++)
{
for (j=i;j<m;j++) cout<<" 資源"<<j;
cout<<endl;
for(L1=0;L1<n;L1++)
{
cout<<"進程"<<L1<<":";
for (j=i;j<m;j++) cout<<Allocation[L1][j]<<" ";
cout<<endl;
}
}
cout<<endl<<"各進程還需要的資源量(need):"<<endl;
for(i=0;i<=m;i++)
{
for (j=i;j<m;j++) cout<<" 資源"<<j;
cout<<endl;
for(L1=0;L1<n;L1++)
{
cout<<"進程"<<L1<<":";
for (j=i;j<m;j++) cout<<Need[L1][j]<<" ";
cout<<endl;
}
}
}
//銀行家算法函數
void bank()
{
cout<<endl<<"進程申請分配資源："<<endl;
int k=0; //用於輸入進程編號
bool r=false; // 初值為假，輸入Y繼續申請則置為真
do{//輸入請求
cout<<"輸入申請資源的進程(0-"<<n-1<<"): ";
cin>>k;
cout<<endl;
while(k>n-1) //輸入錯誤處理
{
cout<<endl<<"輸入錯誤，重新輸入："<<endl;
cout<<endl<<"輸入申請資源的進程(0--"<<n-1<<"): ";
cin>>k;
cout<<endl;
}
cout<<endl<<"輸入該進程申請各類資源的數量: "<<endl;
for (j=0; j<m; j++)
{
do{ //do……while 循環判斷申請輸入的情況
cout<<"進程 "<<k<<" 申請資源["<<j<<"]的數量:";
cin>>Request[j];
cout<<endl;
if(Request[j]>Need[k][j]){ //申請大於需求量時出錯，提示重新輸入（貸款數目不允許超過需求數目）
cout<<"申請大於需要量!"<<endl;
cout<<"申請的資源"<<j<<"的數量為"<<Request[j]<<",大於進程"<<k<<"對該資源需求量"<<Need[k][j]<<"。"<<endl;
cout<<"重新輸入!"<<endl;
}
else //先判斷是否申請大於需求量，再判斷是否申請大於可利用量
if(Request[j]>Available[j]){ //申請大於可利用量， 應該阻塞等待？…… ？
cout<<"\n沒有那麽多資源，目前可利用資源"<<j<<"數量為"<<Available[j]<<",本次申請不成功，進程等待!"<<endl;
Finish[k]=0; //該進程等待
goto ppp; //goto語句 跳轉，結束本次申請
}
}while(Request[j]>Need[k][j]); //Request[j]>Available[j]||
}
//改變Avilable、Allocation、Need的值
for (j=0; j<m; j++) {
Available[j] = Available[j]-Request[j];
Allocation[k][j] = Allocation[k][j]+Request[j];
Need[k][j] = Need[k][j]-Request[j];
Work[j] = Available[j];
}
//判斷當前狀態的安全性
safe(); //調用安全性算法函數
if (l<n)
{
l=0;
cout<<"\n試分配後，狀態不安全,所以不予分配!恢復原狀態"<<endl;
//恢復數據
for (j=0; j<m; j++)
{
Available[j] = Available[j]+Request[j];
Allocation[k][j] = Allocation[k][j]-Request[j];
Need[k][j] = Need[k][j]+Request[j];
Work[j] = Available[j];
}
for (i=0; i<n; i++)
Finish[i]=0; //進程置為未分配狀態
}
else
{
l=0;
cout<<"\n申請資源成功!!!"<<endl;
for(j=0;j<m;j++)
{
if(Need[k][j]==0);
else { //有壹種資源還沒全部申請到，則該進程不可執行，不能釋放擁有的資源
l=1; //置l為1，作為判斷標誌
break;
}
}
if(l!=1){ //進程可以執行，則釋放該進程的所有資源
for (j=0;j<m;j++){
Available[j]=Available[j]+Allocation[k][j];
Allocation[k][j]=0;
}
cout<<"該進程已得到所有需求資源，執行後將釋放其所有擁有資源！"<<endl;
}
l=0; //歸零
cout<<"\n安全的狀態!"<<endl;
cout<<"安全序列為: ";
cout<<endl<<"進程"<<"("<<p[0]<<")"; //輸出安全序列，考慮顯示格式，先輸出第壹個
Finish[0]=0;
for (i=1; i<n; i++){
cout<<"==>>"<<"進程"<<"("<<p[i]<<")";
Finish[i]=0; //所有進程置為未分配狀態
}
cout<<endl<<endl;
}
show(); //顯示當前狀態
ppp: //申請大於可利用量， 應該阻塞等待,結束本次資源申請，GOTO 語句跳轉至此
cout<<endl<<"是否繼續申請資源(y/n) ?";
char* b=new char; //輸入y/n，判斷是否繼續申請 <<endl
cin>>b;
cout<<endl;
cout<<"-------------------------------------------"<<endl<<endl;
cout<<endl;
if(*b=='y'||*b=='Y')
r=true;
else{
r=false; //輸入非 Y 則令 R =false
jieshu(); //調用結束函數
}
} while (r==true);
}
//結束函數
void jieshu()
{
cout<<endl<<endl;
cout<<"\t\t 演示計算完畢"<<endl;
cout<<endl<<endl;
}
//主函數
int main()
{
cout<<endl<<endl<<"\t\t\t\t模擬銀行家算法"<<endl<<endl;
chushihua(); //初始化函數調用
cout<<endl;
show(); //輸出當前狀態
safe(); //判斷當前狀態的安全性
if (l<n) //l在safe中是用來記錄安全的進程的個數的
{
cout<<"\n當前狀態不安全，拒絕申請！"<<endl;
cout<<endl;
return 0;
}
else
{
int i; //局部變量
l=0;
cout<<endl<<"\n當前的狀態是安全的!安全序列為:"<<endl;
cout<<"進程"<<"("<<p[0]<<")"; //輸出安全序列
for (i=1; i<n; i++) cout<<"->>"<<"進程"<<"("<<p[i]<<")";
for (i=0; i<n; i++) Finish[i]=0; //所有進程置為未分配狀態
cout<<endl;
}
bank(); //調用銀行家算法函數
cout<<"\t\t 演示計算完畢"<<endl;
return 0;
}
運行結果：
1.初始化結果
2.檢測系統資源分配是否安全結果：
六、課程設計的總結
操作系統的基本特征是並發與***享。系統允許多個進程並發執行，並且***享系統的軟、硬件資源。為了最大限度的利用計算機系統的資源，操作系統應采用動態分配的策略，但是這樣就容易因資源不足，分配不當而引起“死鎖”。而我本次課程設計就是得用銀行家算法來避免“死鎖”。銀行家算法就是壹個分配資源的過程，使分配的序列不會產生死鎖。此算法的中心思想是：按該法分配資源時，每次分配後總存在著壹個進程，如果讓它單獨運行下去，必然可以獲得它所需要的全部資源，也就是說，它能結束，而它結束後可以歸還這類資源以滿足其他申請者的需要。
本次程序就是按照上面的思路展開的。但是因為時間上的倉促，本課程設計的存在著以下不足：壹、不能實現並發操作，即當總資源同時滿足幾個進程所需要的資源數時，這些進程不能同時進行，只能壹壹按進程順序執行。二、掃描進程順序單壹，只能按進程到來的順序（即編號）來掃描，從而產生的安全順序只能是在這個順序的基礎上產生的，而其實安全順序是有多個的。三、對進程數和資源數進行的數量進行了限制，都只能最多有十個。四、運行程序後，界面較差，進程數，所需要資源數，已分配資源數，能用資源數，不能壹目了然。
這次課程設計時間上雖說倉促點，但是我依然學到了很多的實用性知識。除了更深的了解這個算法，而且對C語言進行了復習，而且其過程中有很多的知識點都不記得了，所以在此感謝在此過程中幫助過我的老師和同學。
最後的感悟就是：只要妳親自動手，妳就能學到知識。
再次感謝幫助過我的老師和同學！