㈠ c語言銀行家演算法安全性判別
把1作為參數傳給yanzheng（） yanzheng（int m)
然後驗證函數里修改：
work=Avaliable;
i=m;
while(i<m)
{
if(Finish[i]==false&&Need[i]<=work)
{
work=work+Allocation[i];
Finish[i]=true;
anquan[k]=i;
k++;
i=0;
}
else
i++;
}
㈡ 操作系統題目,好的追加高分,感謝大蝦
http://tieba..com/f?kz=588380474
http://blog.163.com/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語言進行了復習，而且其過程中有很多的知識點都不記得了，所以在此感謝在此過程中幫助過我的老師和同學。
最後的感悟就是：只要你親自動手，你就能學到知識。
再次感謝幫助過我的老師和同學！
㈢ 求n個數的全排列，n不定。用c語言。用於銀行家演算法中求安全序列
好久沒用c了，所以代碼可能要用到偽代碼
先定義a[maxn]
用子函數遞歸
void p(int x)
{
if (n == x+1)
{
//foreach a print
//輸出數組a
}
for (int i=1 to n)
{
a[x] = i;
p(x+1);
a[x] = 0;
}
}
主函數main調用p(n)
㈣ 銀行家演算法
什麼是銀行家演算法：
銀行家演算法是一種最有代表性的避免死鎖的演算法。在避免死鎖方法中允許進程動態地申請資源，但系統在進行資源分配之前，應先計算此次分配資源的安全性，若分配不會導致系統進入不安全狀態，則分配，否則等待。為實現銀行家演算法，系統必須設置若干數據結構。
要解釋銀行家演算法，必須先解釋操作系統安全狀態和不安全狀態。
安全序列是指一個進程序列{P1，…，Pn}是安全的，如果對於每一個進程Pi(1≤i≤n），它以後尚需要的資源量不超過系統當前剩餘資源量與所有進程Pj (j < i )當前佔有資源量之和。
安全狀態
如果存在一個由系統中所有進程構成的安全序列P1，…，Pn，則系統處於安全狀態。安全狀態一定是沒有死鎖發生。
不安全狀態
不存在一個安全序列。不安全狀態不一定導致死鎖。
原理：
我們可以把操作系統看作是銀行家，操作系統管理的資源相當於銀行家管理的資金，進程向操作系統請求分配資源相當於用戶向銀行家貸款。
為保證資金的安全,銀行家規定:
(1) 當一個顧客對資金的最大需求量不超過銀行家現有的資金時就可接納該顧客;
(2) 顧客可以分歧貸款,但貸款的總數不能超過最大需求量;
(3) 當銀行家現有的資金不能滿足顧客尚需的貸款數額時,對顧客的貸款可推遲支付,但總能使顧客在有限的時間里得到貸款;
(4) 當顧客得到所需的全部資金後,一定能在有限的時間里歸還所有的資金.
操作系統按照銀行家制定的規則為進程分配資源，當進程首次申請資源時，要測試該進程對資源的最大需求量，如果系統現存的資源可以滿足它的最大需求量則按當前的申請量分配資源，否則就推遲分配。當進程在執行中繼續申請資源時，先測試該進程已佔用的資源數與本次申請的資源數之和是否超過了該進程對資源的最大需求量。若超過則拒絕分配資源，若沒有超過則再測試系統現存的資源能否滿足該進程尚需的最大資源量，若能滿足則按當前的申請量分配資源，否則也要推遲分配。
程序舉例：
已知進程{P0,P1,P2,P3,P4}，有三類系統資源A、B、C的數量分別為10、5、7，在T0時刻的資源
（1）若進程P1請求資源，發出請求向量Request1（1，0，2），編寫程序用銀行家演算法判斷系統能否將資源分配給它；
（2）若進程P2提出請求Request(0，1，0)，用銀行家演算法程序驗證系統能否將資源分配給它。
程序代碼：
P1進程提出的請求，可以分配。
P2進程不能分配，因為請求的B類資源超過了它的最大值。
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAXSIZE 50
void main()
{
unsigned int Available[MAXSIZE]; //可利用資源向量
unsigned int Max[MAXSIZE][MAXSIZE]; //最大需求矩陣
unsigned int Allocation[MAXSIZE][MAXSIZE]; //已分配矩陣
unsigned int Need[MAXSIZE][MAXSIZE]; //需求矩陣
unsigned int Request[MAXSIZE]; //請求向量
unsigned int Work[MAXSIZE]; //工作向量
bool Finish[MAXSIZE]; //是否有足夠資源分配給進程,使之運行完成
unsigned int SafeSequence[MAXSIZE]; //安全序列
int i,j;
int p; //請求資源的進程的下標
int temp = 0; //安全序列下標
int total = 0;
int N;
int M;
printf("請輸入進程數N=");
scanf("%d",&N);
printf("請輸入資源種類數M=");
scanf("%d",&M);
//用戶輸入數據,初始化Available數組
printf("初始化可用資源數組:\n");
for(i=0; i<M; i++)
{
printf("\t%c類資源:",65+i);
scanf("%d",&Available[i]);
}
//用戶輸入數據,初始化Max數組
printf("初始化最大需求數組:\n");
for(i=0; i<N; i++)
{
printf("\tP%d進程最大需要\n",i);
for(j=0; j<M; j++)
{
printf("\t\t%c類資源:",65+j);
scanf("%d",&Max[i][j]);
}
}
//用戶輸入數據,初始化Allocation數組
printf("初始化已分配資源數組:\n");
for(i=0; i<N; i++)
{
printf("\tP%d進程已分配\n",i);
for(j=0; j<M; j++)
{
printf("\t\t%c類資源:",65+j);
scanf("%d",&Allocation[i][j]);
}
}
//初始化Need數組
for(i=0; i<N; i++)
for(j=0; j<M; j++)
{
Need[i][j] = Max[i][j] - Allocation[i][j];
}
//進程發出資源請求後檢查
do
{
printf("資源請求:\n");
printf("\t輸入請求資源的進程下標:");
scanf("%d",&p);
printf("\t進程P%d請求\n",p);
//初始化請求向量
for(i=0; i<M; i++)
{
printf("\t\t%c類資源:",65+i);
scanf("%d",&Request[i]);
}
for(i=0; i<M; i++) //檢查Request <= Need ?
if(Request[i] > Need[p][i])
{
printf("\t請求的%c類資源數超過它所宣布的最大值!\n",65+i);
break;
}
if(i == M) //通過上層檢查,繼續檢查Request <= Available ?
{
for(i=0; i<M; i++)
if(Request[i] > Available[i])
{
printf("\t尚無足夠%c類資源,P%d須等待!\n",65+i,p);
break;
}
}
if(i == M) //嘗試分配
{
for(i=0; i<M; i++)
{
Available[i] -= Request[i];
Allocation[p][i] += Request[i];
Need[p][i] -= Request[i];
}
}
}while(i<M);
//初始化Work,Finish向量
for(i=0; i<M; i++)
{
Work[i] = Available[i];
}
for(i=0; i<N; i++)
{
Finish[i] = false;
}
//安全性演算法
do
{
total = temp;
for(i=0; i<N; i++)
{
if(Finish[i] == false)
{
for(j=0; j<M; j++)
if(Need[i][j] > Work[j])
{
break;
}
if(j == M) //各類資源都滿足Need <= Work
{
for(j=0; j<M; j++)
{
Work[j] += Allocation[i][j]; //釋放資源
}
Finish[i] = true;
SafeSequence[temp++] = i; //加入安全序列
}
}
}
}while(total != temp); //所有進程檢查一遍之後，如果安全序列有變化，則進行下一輪
//否則說明所有的Finish都為true,或者因沒有安全序列退出循環
if(temp == N)
{
printf("安全序列:");
for(temp=0; temp<N; temp++)
{
printf("P%d ",SafeSequence[temp]);
}
}
else
{
printf("系統處於不安全狀態!不能分配!\n");
}
getchar();
getchar();
}
這個程序還行，輸入有點麻煩，我自己編寫的是用文件輸入系統描述信息的，但是缺少說明，怕你搞不明白。希望對你有所幫助！