銀行家演算法課程設計

① 銀行家演算法課程設計

利用銀行家演算法避免鎖 . 銀行家演算法 設Requesti是進程Pi的請求向量，如果Requesti［j］=K，表示進程Pi需要K個Rj類型的資源。當Pi發出資源請求後，系統按下述步驟進行檢查： (1) 如果Requesti［j］≤Need［i,j］，便轉向步驟2；否則認為出錯，因為它所需要的資源數已超過它所宣布的最大值。 (2) 如果Requesti［j］≤Available［j］，便轉向步驟(3)；否則， 表示尚無足夠資源，Pi須等待。 (3) 系統試探著把資源分配給進程Pi，並修改下面數據結構中的數值： Available［j］∶=Available［j］-Requesti［j］; Allocation［i,j］∶=Allocation［i,j］+Requesti［j］; Need［i,j］∶=Need［i,j］-Requesti［j］; (4) 系統執行安全性演算法，檢查此次資源分配後，系統是否處於安全狀態。若安全，才正式將資源分配給進程Pi，以完成本次分配；否則， 將本次的試探分配作廢，恢復原來的資源分配狀態，讓進程Pi等待。 (3) 系統試探著把資源分配給進程Pi，並修改下面數據結構中的數值： Available［j］∶=Available［j］-Requesti［j］; Allocation［i,j］∶=Allocation［i,j］+Requesti［j］; Need［i,j］∶=Need［i,j］-Requesti［j］; (4) 系統執行安全性演算法，檢查此次資源分配後，系統是否處於安全狀態。若安全，才正式將資源分配給進程Pi，以完成本次分配；否則， 將本次的試探分配作廢，恢復原來的資源分配狀態，讓進程Pi等待。 (3) 系統試探著把資源分配給進程Pi，並修改下面數據結構中的數值： Available［j］∶=Available［j］-Requesti［j］; Allocation［i,j］∶=Allocation［i,j］+Requesti［j］; Need［i,j］∶=Need［i,j］-Requesti［j］; (4) 系統執行安全性演算法，檢查此次資源分配後，系統是否處於安全狀態。若安全，才正式將資源分配給進程Pi，以完成本次分配；否則， 將本次的試探分配作廢，恢復原來的資源分配狀態，讓進程Pi等待。

② 銀行家演算法 操作系統課程設計

這個剛做過，直接貼給你好了，給分吧
#include<iostream.h>
#include<string.h>
#include<stdio.h>
#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 M=100;//作業的最大數為100
int N=100;//資源的最大數為100
void showdata()//顯示資源矩陣
{
int i,j;
cout<<"系統目前可用的資源[Avaliable]:"<<endl;
for(i=0;i<N;i++)
cout<<name[i]<<" ";
cout<<endl;
for (j=0;j<N;j++)
cout<<Avaliable[j]<<" ";//輸出分配資源
cout<<endl;
cout<<" Max Allocation Need"<<endl;
cout<<"進程名 ";
for(j=0;j<3;j++){
for(i=0;i<N;i++)
cout<<name[i]<<" ";
cout<<" ";
}
cout<<endl;
for(i=0;i<M;i++){
cout<<" "<<i<<" ";
for(j=0;j<N;j++)
cout<<Max[i][j]<<" ";
cout<<" ";
for(j=0;j<N;j++)
cout<<Allocation[i][j]<<" ";
cout<<" ";
for(j=0;j<N;j++)
cout<<Need[i][j]<<" ";
cout<<endl;
}
}

int changdata(int i)//進行資源分配
{
int j;
for (j=0;j<M;j++) {
Avaliable[j]=Avaliable[j]-Request[j];
Allocation[i][j]=Allocation[i][j]+Request[j];
Need[i][j]=Need[i][j]-Request[j];
}
return 1;
}
int safe()//安全性演算法
{
int i,k=0,m,apply,Finish[100]={0};
int j;
int flag=0;
Work[0]=Avaliable[0];
Work[1]=Avaliable[1];
Work[2]=Avaliable[2];
for(i=0;i<M;i++){
apply=0;
for(j=0;j<N;j++){
if (Finish[i]==False&&Need[i][j]<=Work[j]){
apply++;
if(apply==N){
for(m=0;m<N;m++)
Work[m]=Work[m]+Allocation[i][m];//變分配數
Finish[i]=True;
temp[k]=i;
i=-1;
k++;
flag++;
}
}
}
}
for(i=0;i<M;i++){
if(Finish[i]==False){
cout<<"系統不安全"<<endl;//不成功系統不安全
return -1;
}
}
cout<<"系統是安全的!"<<endl;//如果安全，輸出成功
cout<<"分配的序列:";
for(i=0;i<M;i++){//輸出運行進程數組
cout<<temp[i];
if(i<M-1) cout<<"->";
}
cout<<endl;
return 0;
}
void share()//利用銀行家演算法對申請資源對進行判定
{
char ch;
int i=0,j=0;
ch='y';
cout<<"請輸入要求分配的資源進程號(0-"<<M-1<<"):";
cin>>i;//輸入須申請的資源號
cout<<"請輸入進程 "<<i<<" 申請的資源:"<<endl;
for(j=0;j<N;j++)
{
cout<<name[j]<<":";
cin>>Request[j];//輸入需要申請的資源
}
for (j=0;j<N;j++){
if(Request[j]>Need[i][j])//判斷申請是否大於需求，若大於則出錯
{
cout<<"進程 "<<i<<"申請的資源大於它需要的資源";
cout<<" 分配不合理，不予分配！"<<endl;
ch='n';
break;
}
else {
if(Request[j]>Avaliable[j])//判斷申請是否大於當前資源，若大於則
{ //出錯
cout<<"進程"<<i<<"申請的資源大於系統現在可利用的資源";
cout<<" 分配出錯，不予分配!"<<endl;
ch='n';
break;
}
}
}
if(ch=='y') {
changdata(i);//根據進程需求量變換資源
showdata();//根據進程需求量顯示變換後的資源
safe();//根據進程需求量進行銀行家演算法判斷
}
}
void addresources(){//添加資源
int n,flag;
cout<<"請輸入需要添加資源種類的數量:";
cin>>n;
flag=N;
N=N+n;
for(int i=0;i<n;i++){
cout<<"名稱:";
cin>>name[flag];
cout<<"數量:";
cin>>Avaliable[flag++];
}
showdata();
safe();
}
void delresources(){//刪除資源
char ming;
int i,flag=1;
cout<<"請輸入需要刪除的資源名稱：";
do{
cin>>ming;
for(i=0;i<N;i++)
if(ming==name[i]){
flag=0;
break;
}
if(i==N)
cout<<"該資源名稱不存在，請重新輸入：";
}
while(flag);
for(int j=i;j<N-1;j++)
{
name[j]=name[j+1];
Avaliable[j]=Avaliable[j+1];

}
N=N-1;
showdata();
safe();
}
void changeresources(){//修改資源函數
cout<<"系統目前可用的資源[Avaliable]:"<<endl;
for(int i=0;i<N;i++)
cout<<name[i]<<":"<<Avaliable[i]<<endl;
cout<<"輸入系統可用資源[Avaliable]:"<<endl;
cin>>Avaliable[0]>>Avaliable[1]>>Avaliable[2];
cout<<"經修改後的系統可用資源為"<<endl;
for (int k=0;k<N;k++)
cout<<name[k]<<":"<<Avaliable[k]<<endl;
showdata();
safe();
}
void addprocess(){//添加作業
int flag=M;
M=M+1;
cout<<"請輸入該作業的最打需求量[Max]"<<endl;
for(int i=0;i<N;i++){
cout<<name[i]<<":";
cin>>Max[flag][i];
Need[flag][i]=Max[flag][i]-Allocation[flag][i];
}
showdata();
safe();
}
int main()//主函數
{

int i,j,number,choice,m,n,flag;
char ming;
cout<<"*****************資源管理系統的設計與實現*****************"<<endl;
cout<<"請首先輸入系統可供資源種類的數量:";
cin>>n;
N=n;
for(i=0;i<n;i++)
{
cout<<"資源"<<i+1<<"的名稱:";
cin>>ming;
name[i]=ming;
cout<<"資源的數量:";
cin>>number;
Avaliable[i]=number;
}
cout<<endl;
cout<<"請輸入作業的數量:";
cin>>m;
M=m;
cout<<"請輸入各進程的最大需求量("<<m<<"*"<<n<<"矩陣)[Max]:"<<endl;
for(i=0;i<m;i++)
for(j=0;j<n;j++)
cin>>Max[i][j];
do{
flag=0;
cout<<"請輸入各進程已經申請的資源量("<<m<<"*"<<n<<"矩陣)[Allocation]:"<<endl;
for(i=0;i<m;i++)
for(j=0;j<n;j++){
cin>>Allocation[i][j];
if(Allocation[i][j]>Max[i][j])
flag=1;
Need[i][j]=Max[i][j]-Allocation[i][j];
}
if(flag)
cout<<"申請的資源大於最大需求量，請重新輸入!\n";
}
while(flag);

showdata();//顯示各種資源
safe();//用銀行家演算法判定系統是否安全
while(choice)
{
cout<<"**************銀行家演算法演示***************"<<endl;
cout<<" 1:增加資源 "<<endl;
cout<<" 2:刪除資源 "<<endl;
cout<<" 3:修改資源 "<<endl;
cout<<" 4:分配資源 "<<endl;
cout<<" 5:增加作業 "<<endl;
cout<<" 0:離開 "<<endl;
cout<<"*******************************************"<<endl;
cout<<"請選擇功能號：";
cin>>choice;
switch(choice)
{
case 1: addresources();break;
case 2: delresources();break;
case 3: changeresources();break;
case 4: share();break;
case 5: addprocess();break;
case 0: choice=0;break;
default: cout<<"請正確選擇功能號(0-5)!"<<endl;break;
}
}
return 1;
}

③ 操作系統題目,好的追加高分,感謝大蝦

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語言進行了復習，而且其過程中有很多的知識點都不記得了，所以在此感謝在此過程中幫助過我的老師和同學。
最後的感悟就是：只要你親自動手，你就能學到知識。
再次感謝幫助過我的老師和同學！

④ 操作系統課程設計任務書:銀行家演算法設計

#include<stdio.h>
#include<stdlib.h>
struct type
{
int a;
int b;
int c;
};
struct allocation
{
struct type value;
struct allocation *next;
};
struct max
{
struct type value;
struct max *next;
};
struct available
{
struct type value;
struct available *next;
};
struct need
{
struct type value;
struct need *next;
};
struct path
{
int value;
struct path *next;
};
struct finish
{
int value;
struct finish *next;
};

void main()
{
int p,status=0,i,j,temp,flag=0;
struct allocation *allochead,*alloc1,*alloc2,*alloctemp;
struct max *maxhead,*max1,*max2,*maxtemp;
struct available *availablehead,*workhead,*worktemp;
struct need *needhead,*need1,*need2,*needtemp;
struct path *pathhead,*path1,*path2,*pathtemp;
struct finish *finishhead,*finish1,*finish2,*finishtemp;

printf("請輸入進程的數目\n");
scanf("%d",&p);
for(i=0;i<p;i++)
{
printf("\n輸入進程p%d已經分配的資源\n",i+1);
if(flag==0)
{
allochead=alloc1=alloc2=(struct allocation*)malloc(sizeof(struct allocation));
printf("\t當前資源類型是 %c\t",'a');
scanf("%d",&alloc1->value.a);
printf("\t當前資源類型是 %c\t",'b');
scanf("%d",&alloc1->value.b);
printf("\t當前資源類型是 %c\t",'c');
scanf("%d",&alloc1->value.c);
flag++;
allochead=alloc1;
}
else
{
alloc2=(struct allocation*)malloc(sizeof(struct allocation));
printf("\t當前資源類型是 %c\t",'a');
scanf("%d",&alloc2->value.a);
printf("\t當前資源類型是 %c\t",'b');
scanf("%d",&alloc2->value.b);
printf("\t當前資源類型是 %c\t",'c');
scanf("%d",&alloc2->value.c);

alloc1->next=alloc2;
alloc1=alloc2;
flag++;
}
}
alloc2->next=NULL;
flag=0;

for(i=0;i<p;i++)
{
printf("\n輸入進程p%d要求的最大數目\n",i+1);
if(flag==0)
{
maxhead=max1=max2=(struct max*)malloc(sizeof(struct max));
printf("\t當前資源類型是 %c\t",'a');
scanf("%d",&max1->value.a);
printf("\t當前資源類型是 %c\t",'b');
scanf("%d",&max1->value.b);
printf("\t當前資源類型是 %c\t",'c');
scanf("%d",&max1->value.c);
maxhead=max1;
flag++;
}
else
{
max2=(struct max*)malloc(sizeof(struct max));
printf("\t當前資源類型是 %c\t",'a');
scanf("%d",&max2->value.a);
printf("\t當前資源類型是 %c\t",'b');
scanf("%d",&max2->value.b);
printf("\t當前資源類型是 s %c\t",'c');
scanf("%d",&max2->value.c);
max1->next=max2;
max1=max2;
flag++;
}
}
max2->next=NULL;
flag=0;

printf("\n請輸入可以利用是資源數目\n");
availablehead=workhead=(struct available*)malloc(sizeof(struct available));
printf("\n");
printf("\t當前資源類型是 %c\t",'a');
scanf("%d",&availablehead->value.a);
printf("\t當前資源類型是 %c\t",'b');
scanf("%d",&availablehead->value.b);
printf("\t當前資源類型是 %c\t",'c');
scanf("%d",&availablehead->value.c);
workhead=availablehead;
workhead->value=availablehead->value;
flag=0;

alloctemp=allochead;
maxtemp=maxhead;
for(i=0;i<p;i++)
{
if(flag==0)
{
needhead=need1=need2=(struct need*)malloc(sizeof(struct need));
need1->next=need2->next=NULL;
need1->value.a=(maxtemp->value.a)-(alloctemp->value.a);
need1->value.b=(maxtemp->value.b)-(alloctemp->value.b);
need1->value.c=(maxtemp->value.c)-(alloctemp->value.c);
needhead=need1;
flag++;
}
else
{
need2=(struct need*)malloc(sizeof(struct need));
need2->value.a=(maxtemp->value.a)-(alloctemp->value.a);
need2->value.b=(maxtemp->value.b)-(alloctemp->value.b);
need2->value.c=(maxtemp->value.c)-(alloctemp->value.c);

need1->next=need2;
need1=need2;
flag++;
}
maxtemp=maxtemp->next;
alloctemp=alloctemp->next;
}
need2->next=NULL;
flag=0;

for(i=0;i<p;i++)
{
if(flag==0)
{
finishhead=finish1=finish2=(struct finish*)malloc(sizeof(struct finish));
finish1->next=finish2->next=NULL;
finish1->value=0;
finishhead=finish1;
flag++;
}
else
{
finish2=(struct finish*)malloc(sizeof(struct finish));
finish2->value=0;

finish1->next=finish2;
finish1=finish2;
flag++;
}
}
finish2->next=NULL;
flag=0;

for(temp=0;temp<p;temp++)
{
alloctemp=allochead;
needtemp=needhead;
finishtemp=finishhead;
worktemp=workhead;

for(j=0;j<p;j++)
{
if(finishtemp->value==0)
{
if((needtemp->value.a<=worktemp->value.a)&&(needtemp->value.b<=worktemp->value.b)&&(needtemp->value.c<=worktemp->value.c))
{
worktemp->value.a+=alloctemp->value.a;
worktemp->value.b+=alloctemp->value.b;
worktemp->value.c+=alloctemp->value.c;
finishtemp->value=1;
if(flag==0)
{
pathhead=path1=path2=(struct path*)malloc(sizeof(struct path));
path1->next=path2->next=NULL;
path1->value=j+1;
pathhead=path1;
flag++;
}
else
{
path2=(struct path*)malloc(sizeof(struct path));
path2->value=j+1;
path1->next=path2;
path1=path2;
flag++;
}
finishtemp=finishtemp->next;
alloctemp=alloctemp->next;
needtemp=needtemp->next;
}
else
{
finishtemp=finishtemp->next;
alloctemp=alloctemp->next;
needtemp=needtemp->next;
}
}
else
{
finishtemp=finishtemp->next;
alloctemp=alloctemp->next;
needtemp=needtemp->next;
}

}
}
path2->next=NULL;
finishtemp=finishhead;
pathtemp=pathhead;
for(temp=0;temp<p;temp++)
{
if(finishtemp->value==0)
{
printf("\n警告!當前系統是不安全的\n");
exit(0);
}
finishtemp=finishtemp->next;
}
printf("\n當前系統是安全的!\n");
printf("\n安全序列為: \n");
for(i=0;i<p;i++)
{
printf("p%d\t",pathhead->value);
pathhead=pathhead->next;
}
}

⑤ 操作系統課程設計

這里有許多操作系統的課程內容和課件,有的演示程序比較生動,希望對你的課有幫助:
http://www.ccec.e.cn/xxjs/jsjx/jpk/os/1.htm
http://oa.gt.e.cn/os/multimedia/learn.htm
http://jpkc.cuit.e.cn/kecheng/czxt/contentshow.asp?classid=51&class=1