銀行家演算法操作系統
#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;
}
Ⅱ 銀行家演算法假定系統資源總量
按照3-6-1-2-4-5的順序分配。則Q已經運行完，P佔6個資源，R佔3個資源，剩餘2個資源。
如果資源數量為10個，系統會死鎖。因為按照如上的順序分配，P還需要2個資源，R還需要3個資源，但是剩餘資源為1個，系統將死鎖。
Ⅲ 哪個操作系統採用銀行家演算法windows xp linux freebsd unix none of the above
銀行的操作系統有Windows98或者Linux的等，當然都經過改的
Ⅳ 「銀行家演算法」是怎樣的一個演算法
銀行家演算法=-- -
1. 安全狀態: 在某時刻系統中所有進程可以排列一個安全序列:{P1,P2,`````Pn},剛稱此時,系統是安全的.
所謂安全序列{P1,P2,`````Pn}是指對於P2,都有它所需要剩餘資源數量不大於系統掌握的剩餘的空間資源與所有Pi(j<i)所佔的資源之和.
2.不安全狀態可能產生死鎖.
目前狀態 最大需求 尚需
P1 3 9 6
P2 5 10 5
P3 2 4 2
在每一次進程中申請的資源,判定一下,若實際分配的話,之後系統是否安全.
3.銀行家演算法的思路:
1),進程一開始向系統提出最大需求量.
2),進程每次提出新的需求(分期貸款)都統計是否超出它事先提出的最大需求量.
3),若正常,則判斷該進程所需剩餘剩餘量(包括本次申請)是否超出系統所掌握的
剩餘資源量,若不超出,則分配,否則等待.
4.銀行家演算法的數據結構.
1),系統剩餘資源量A[n],其中A[n]表示第I類資源剩餘量.
2),各進程最大需求量,B[m][n],其中B[j][i]表示進程j對i
類資源最大需求.
3),已分配資源量C[m][n],其中C[j][i]表示系統j程已得到的第i資源的數量.
4),剩餘需求量.D[m][n],其中D[j][i]對第i資源尚需的數目.
5.銀行家演算法流程:當某時刻,某進程時,提出新的資源申請,系統作以下操作:
1),判定E[n]是否大於D[j][n],若大於,表示出錯.
2),判定E[n]是否大於系統剩餘量A[n],若大於,則該進程等待.
3),若以上兩步沒有問題,嘗試分配,即各變數作調整.
4),按照安全性推測演算法,判斷,分配過後,系統是否安全,若安全,則實際分配,否則,撤消分配,讓進程等待.
6."安全性檢測"演算法
1),先定義兩個變數,用來表示推算過程的數據.
F[n]=A[n],表示推算過程中,系統中剩餘資源量的變化.
J[n]=False表示推算過程中各進程是否假設"已完成"
2),流程:
在"剩餘"的進程中(在推算)過程中,一些進程假設已完成,查找D[j][n]<=F[n]的進程,找到後令J[j]=True
(假設該進程完成),F[n]+D[j][n](該進程所佔資源釋放),如此循環執行.
若最後,所有的F[n]=True(在推算過程中,所有進程均可以完成),則表示(分配過後)系統是安全的,否則系統是不安全的.
參考資料：http://huangqiyu.blogchina.com/419807.html
Ⅳ 有沒有人懂操作系統的銀行家演算法，最好有一道例題可以講
銀行家演算法是一種最有代表性的避免死鎖的演算法。在避免死鎖方法中允許進程動態地申請資源，但系 銀行家演算法統在進行資源分配之前，應先計算此次分配資源的安全性，若分配不會導致系統進入不安全狀態，則分配，否則等待。為實現銀行家演算法，系統必須設置若干數據結構。
要解釋銀行家演算法，必須先解釋操作系統安全狀態和不安全狀態。
安全序列是指一個進程序列{P1，…，Pn}是安全的，即對於每一個進程Pi(1≤i≤n），它以後尚需要的資源量不超過系統當前剩餘資源量與所有進程Pj (j < i )當前佔有資源量之和。
我們可以把操作系統看作是銀行家，操作系統管理的資源相當於銀行家管理的資金，進程向操作系統請求分配資源相當於用戶向銀行家貸款。
為保證資金的安全，銀行家規定：
(1) 當一個顧客對資金的最大需求量不超過銀行家現有的資金時就可接納該顧客；
(2) 顧客可以分期貸款，但貸款的總數不能超過最大需求量；
(3) 當銀行家現有的資金不能滿足顧客尚需的貸款數額時，對顧客的貸款可推遲支付，但總能使顧客在有限的時間里得到貸款；
(4) 當顧客得到所需的全部資金後，一定能在有限的時間里歸還所有的資金.
操作系統按照銀行家制定的規則為進程分配資源，當進程首次申請資源時，要測試該進程對資源的最大需求量，如果系統現存的資源可以滿足它的最大需求量則按當前的申請量分配資源，否則就推遲分配。當進程在執行中繼續申請資源時，先測試該進程本次申請的資源數是否超過了該資源所剩餘的總量。若超過則拒絕分配資源，若能滿足則按當前的申請量分配資源，否則也要推遲分配。
銀行家演算法
在避免死鎖的方法中，所施加的限制條件較弱，有可能獲得令人滿意的系統性能。在該方法中把系統的狀態分為安全狀態和不安全狀態，只要能使系統始終都處於安全狀態，便可以避免發生死鎖。
銀行家演算法的基本思想是分配資源之前，判斷系統是否是安全的；若是，才分配。它是最具有代表性的避免死鎖的演算法。
設進程cusneed提出請求REQUEST [i]，則銀行家演算法按如下規則進行判斷。
(1)如果REQUEST [cusneed] [i]<= NEED[cusneed][i]，則轉（2)；否則，出錯。
(2)如果REQUEST [cusneed] [i]<= AVAILABLE[i]，則轉（3)；否則，等待。
(3)系統試探分配資源，修改相關數據：
AVAILABLE[i]-=REQUEST[cusneed][i];
ALLOCATION[cusneed][i]+=REQUEST[cusneed][i];
NEED[cusneed][i]-=REQUEST[cusneed][i];
(4)系統執行安全性檢查，如安全，則分配成立；否則試探險性分配作廢，系統恢復原狀，進程等待。
安全性檢查演算法
（1)設置兩個工作向量Work=AVAILABLE;FINISH
(2)從進程集合中找到一個滿足下述條件的進程，
FINISH==false;
NEED<=Work;
如找到，執行（3)；否則，執行（4)
(3)設進程獲得資源，可順利執行，直至完成，從而釋放資源。
Work=Work+ALLOCATION;
Finish=true;
GOTO 2
(4)如所有的進程Finish= true，則表示安全；否則系統不安全。
銀行家演算法流程圖
演算法（C語言實現）
#include<STRING.H>
#include<stdio.h>
#include<stdlib.h>
#include<CONIO.H>/*用到了getch()*/
#defineM5/*進程數*/
#defineN3/*資源數*/
#defineFALSE0
#defineTRUE1
/*M個進程對N類資源最大資源需求量*/
intMAX[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};
/*系統可用資源數*/
intAVAILABLE[N]={10,5,7};
/*M個進程已分配到的N類數量*/
intALLOCATION[M][N]={{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0}};
/*M個進程已經得到N類資源的資源量*/
intNEED[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};
/*M個進程還需要N類資源的資源量*/
intRequest[N]={0,0,0};
voidmain()
{
inti=0,j=0;
charflag;
voidshowdata();
voidchangdata(int);
voidrstordata(int);
intchkerr();
showdata();
enter:
{
printf("請輸入需申請資源的進程號（從0到");
printf("%d",M-1);
printf("）:");
scanf("%d",&i);
}
if(i<0||i>=M)
{
printf("輸入的進程號不存在，重新輸入!\n");
gotoenter;
}
err:
{
printf("請輸入進程");
printf("%d",i);
printf("申請的資源數\n");
printf("類別:ABC\n");
printf("");
for(j=0;j<N;j++)
{
scanf("%d",&Request[j]);
if(Request[j]>NEED[i][j])
{
printf("%d",i);
printf("號進程");
printf("申請的資源數>進程");
printf("%d",i);
printf("還需要");
printf("%d",j);
printf("類資源的資源量!申請不合理，出錯!請重新選擇!\n");
gotoerr;
}
else
{
if(Request[j]>AVAILABLE[j])
{
printf("進程");
printf("%d",i);
printf("申請的資源數大於系統可用");
printf("%d",j);
printf("類資源的資源量!申請不合理，出錯!請重新選擇!\n");
gotoerr;
}
}
}
}
changdata(i);
if(chkerr())
{
rstordata(i);
showdata();
}
else
showdata();
printf("\n");
printf("按'y'或'Y'鍵繼續,否則退出\n");
flag=getch();
if(flag=='y'||flag=='Y')
{
gotoenter;
}
else
{
exit(0);
}
}
/*顯示數組*/
voidshowdata()
{
inti,j;
printf("系統可用資源向量:\n");
printf("***Available***\n");
printf("資源類別:ABC\n");
printf("資源數目:");
for(j=0;j<N;j++)
{
printf("%d",AVAILABLE[j]);
}
printf("\n");
printf("\n");
printf("各進程還需要的資源量:\n");
printf("******Need******\n");
printf("資源類別:ABC\n");
for(i=0;i<M;i++)
{
printf("");
printf("%d",i);
printf("號進程:");
for(j=0;j<N;j++)
{
printf("%d",NEED[i][j]);
}
printf("\n");
}
printf("\n");
printf("各進程已經得到的資源量:\n");
printf("***Allocation***\n");
printf("資源類別:ABC\n");
for(i=0;i<M;i++)
{
printf("");
printf("%d",i);
printf("號進程:");
/*printf(":\n");*/
for(j=0;j<N;j++)
{
printf("%d",ALLOCATION[i][j]);
}
printf("\n");
}
printf("\n");
}
/*系統對進程請求響應，資源向量改變*/
voidchangdata(intk)
{
intj;
for(j=0;j<N;j++)
{
AVAILABLE[j]=AVAILABLE[j]-Request[j];
ALLOCATION[k][j]=ALLOCATION[k][j]+Request[j];
NEED[k][j]=NEED[k][j]-Request[j];
}
}
/*資源向量改變*/
voidrstordata(intk)
{
intj;
for(j=0;j<N;j++)
{
AVAILABLE[j]=AVAILABLE[j]+Request[j];
ALLOCATION[k][j]=ALLOCATION[k][j]-Request[j];
NEED[k][j]=NEED[k][j]+Request[j];
}
}
/*安全性檢查函數*/
intchkerr()//在假定分配資源的情況下檢查系統的安全性
{
intWORK[N],FINISH[M],temp[M];//temp[]用來記錄進程安全執行的順序
inti,j,m,k=0,count;
for(i=0;i<M;i++)
FINISH[i]=FALSE;
for(j=0;j<N;j++)
WORK[j]=AVAILABLE[j];//把可利用資源數賦給WORK[]
for(i=0;i<M;i++)
{
count=0;
for(j=0;j<N;j++)
if(FINISH[i]==FALSE&&NEED[i][j]<=WORK[j])
count++;
if(count==N)//當進程各類資源都滿足NEED<=WORK時
{
for(m=0;m<N;m++)
WORK[m]=WORK[m]+ALLOCATION[i][m];
FINISH[i]=TRUE;
temp[k]=i;//記錄下滿足條件的進程
k++;
i=-1;
}
}
for(i=0;i<M;i++)
if(FINISH[i]==FALSE)
{
printf("系統不安全!!!本次資源申請不成功!!!\n");
return1;
}
printf("\n");
printf("經安全性檢查，系統安全，本次分配成功。\n");
printf("\n");
printf("本次安全序列：");
for(i=0;i<M;i++)//列印安全系統的進程調用順序
{
printf("進程");
printf("%d",temp[i]);
if(i<M-1)
printf("->");
}
printf("\n");
return0;
}
Ⅵ 操作系統題目 ：在銀行家演算法中，若出現下述資源分配情：
1、這是安全狀態
P3所需的資源數Need（0 0 1 2）小於可分配資源數Available（1 5 1 2），滿足P3需求後，完成P3
回收資源，Avaliable 變為（1 5 1 2）+ （0 1 3 2）= （1 6 4 4）
這時P0可分配資源，即Need（0 6 4 2） < Avaliable（1 6 4 4），分配資源給P0，完成P0回收資源變為（1 6 4 4） + （0 3 3 2） = （1 9 7 6）
這時P1可分配，回收資源後可用資源為（1 9 7 6） + （1 0 0 1）= （2 9 7 7）
這時P2可分配，回收資源後可用資源為（2 9 7 7） + （1 3 5 4）= （3 12 12 11）
這時P4可分配，回收資源後可用資源為（3 12 12 11） + （0 0 1 4）= （3 12 12 15）
2、P2提出 Request（1 2 0 0） < Avaliable( 1 5 1 2)，可以將資源分配給它。
補充：分配後可用資源變為 （1 5 1 2）- （1 2 0 0） = （0 3 1 2），按照上題的分析方法步驟，狀態就不安全了。
(6)銀行家演算法操作系統擴展閱讀：
我國國有商業銀行由專業銀行演變而來，這種轉化是基於整個社會經濟運行體制由計劃經濟向市場經濟轉變的宏觀背景下產生的，相應的資源配置方法由計劃配置逐漸向以市場配置為主、計劃調控為輔的模式轉變。
(一)資產結構不合理，資產負債比例過高在國有商業銀行的資產中，無效資產和不良資產的佔比較高，致使創利水平不高，而資產負債比例過高又增大了經營的風險。
(二)組織結構不合理網點布局追求鋪攤子，不結合實際情況，勢必使信貸資源、資本資源、人力資源、固定資產等各方面資源的配置分散，導致營運成本增加，人均創利水平不高。
(三)地區發展不平鎢東部地區與西部地區之間、城市行與縣行資源配置比例失調。總體而言，東部地區的資源配置效率較高，西部地區的資源配置效率較低，如某西部地區2002年到2006年四年時間，工、農、中、建、交五行存款增長了1200億元，貸款僅增長了69億元。
新增存款是新增貸款的17倍，存貸比由73.4%降到46%，存貸差與貸款余額之比由2002年的37%上升到2006年的l 1 5%。這意味著，每100元存款中沒有作為貸款發放出去的已從37元上升到全部無法投放，金融市場環境不佳，難以支持業務的快速發展。
Ⅶ 操作系統銀行家演算法
不會分配，看一下銀行家演算法的流程。
可以看到 在step(1)若Request<=Need, goto step(2);否則錯誤返回.
原因如下，每個進程開始之前，都必須聲明自己需要的各類資源的最大值Max。
Need 需求資源 = Max 最大需求 - Allocation 已分配資源
進程運行過程中，不能再要比Need還多的資源。
參考書 操作系統概念(OS concepts Six Edition)
演算法:
n:系統中進程的總數
m:資源類總數
符號說明:
Available 可用剩餘資源
Max 最大需求
Allocation 已分配資源
Need 需求資源
Request 請求資源
當進程pi提出資源申請時, 系統執行下列
步驟:("="為賦值符號, "=="為等號)
step(1)若Request<=Need, goto step(2);否則錯誤返回
step(2)若Request<=Available, goto step(3);否則進程等待
step(3)假設系統分配了資源, 則有:
Available=Available-Request;
Allocation=Allocation+Request;
Need=Need-Request
若系統新狀態是安全的, 則分配完成
若系統新狀態是不安全的, 則恢復原狀態, 進程等待
為進行安全性檢查, 定義數據結構:
Work:ARRAY[1...m] of integer;
Finish:ARRAY[1...n] of Boolean;
安全性檢查的步驟:
step (1):
Work=Available;
Finish=false;
step (2) 尋找滿足條件的i:
a. Finish==false;
b. Need<=Work;
如果不存在, goto step(4)
step(3)
Work=Work+Allocation;
Finish=true;
goto step(2)
step (4) 若對所有i, Finish=true, 則系統處於安全狀態, 否則處於不安全狀態
Ⅷ 銀行家演算法的主要功能是用來檢測某種狀態下系統中是否發生了死鎖
1.銀行家演算法是系統用來分配資源的演算法 2.不可搶占條件 3.後備狀態 4.都不是 5.在一台處理器上執行操作系統，其他處理器執行應用進程 6.伺服器 7.Wait操作
Signal操作一個整型變數 8.信號量機制 中斷屏蔽方式 9.任意型變數 10.並行性
Ⅸ 操作系統關於銀行家演算法的一道題 哪位大神能幫小弟我解答一下啊 跪謝！！
【解答】
①系統資源總數向量為（9, 3, 6）
各進程對資源需求矩陣為：
2 2 2
2 0 2
1 0 3
4 2 0
②採用銀行家演算法進行計算分析可知：
系統可以滿足P2進程對資源的請求，將資源分配給P2之後，至少可以找到一個安全的執行序列，如（P2, P1, P3, P4）使各進程正常運行終結。
系統不可以將資源分配給進程P1，雖然可利用資源還可以滿足進程P1現在的需求，但是一旦分配給進程P1後，就找不到一個安全執行的序列保證各進程能夠正常運行終結。所以進程P1應該進入阻塞狀態。
③系統滿足進程P1和P2的請求後，並沒有立即進入死鎖狀態，因為這時所有進程沒有提出新的資源申請，全部進程均沒有因資源沒得到滿足而進入阻塞狀態。只有當進程提出資源申請且全部進程都進入阻塞狀態時，系統才處於死鎖狀態。
Ⅹ 淺析銀行家演算法
作為避免死鎖的一種演算法，銀行家演算法可以說是最為出名的了。這個名字的來源是因為該演算法起初是為銀行系統設計的，以確保銀行在發放現金貸款時，不會發生不能滿足所有客戶需要的情況。在操作系統中也可以用它來實現避免死鎖。
首先我們要了解銀行家演算法的本質也即避免死鎖的原理。避免死鎖作為一種事先預防死鎖的策略，原理是在為各個進程分配資源的過程中不允許系統進去不安全狀態，以此來避免死鎖的發生。所謂安全狀態，是指系統能按某種進程推進順序為每個進程分配其所需資源，直至滿足每個進程對資源的最大需求，使每個進程都可以順利地完成。此時稱該進程推進序列為安全序列，如果無法找到這樣一個安全序列，則稱系統處於不安全狀態。
銀行家演算法中的數據結構。為了實現銀行家演算法，在系統中必須設置這樣四個數據結構，分別用來描述系統中可利用的資源，所有進程對資源的最大需求，系統中的資源分配以及所有進程還需要多少資源的情況。
(1)可利用資源向量Available。這是一個含有m個元表的數組,其中的每一個元素代表一類可利用的資源數目。其數值隨該類資源的分配和回收而動態地改變。如果 Available=K,則表示系統中現有Rj類資源K個。
(2)最大需求矩陣Max。這是一個nxm的矩陣,它定義了系統中n個進程中的每個進程對m類資源的最大需求。如果Max[i,j]=K,則表示進程i需要Rj類資源的最大數目為K。
(3)分配矩陣 Allocation。這也是一個nxm的矩陣,它定義了系統中每一類資源當前已分配給每一進程的資源數。如果Allocation[i,j]=K,表示進程i當前已分得Rj類資源的數目為K。
(4)需求矩陣Need。這也是一個nxm的矩陣,用以表示每一個進程尚需的各類資源數。如果Need[i,j]=K，則表示進程i還需要Rj類資源K個才能完成。
當一個進程發出請求資源的請求後，如果它所請求的資源大於目前系統可利用資源則不予分配。如果小於可利用資源，則系統試探著把資源分配給該進程，並修改分配之後的資源數值。接著系統執行安全演算法，檢查此次資源分配後系統是否處於安全狀態。若安全，才正式將資源分配給該進程，以完成本次分配。否則，將本次的試探分配作廢，恢復原來的資源分配狀態，讓該進程等待。