銀行息演算法
A. 銀行家演算法具有以下多種功能：
銀行家演算法程序代碼
#include <string.h>
#include <stdio.h>
#include <iostream.h>
#define FALSE 0
#define TRUE 1
#define W 10
#define R 10
int M ; // 總進程數
int N ; // 資源種類
int ALL_RESOURCE[W];// 各種資源的數目總和
int MAX[W][R]; // M個進程對N類資源最大資源需求量
int AVAILABLE[R]; // 系統可用資源數
int ALLOCATION[W][R]; // M個進程已經得到N類資源的資源量
int NEED[W][R]; // M個進程還需要N類資源的資源量
int Request[R]; // 請求資源個數
void output()
{
int i,j;
cout<<endl<<"━━━━━━━━━━━━━━━━━━"<<endl;
cout<<"各種資源的總數量:"<<endl;
for (j=0;j<N;j++)
cout<<" 資源"<<j<<": "<<ALL_RESOURCE[j];
cout<<endl;
cout<<"━━━━━━━━━━━━━━━━━━"<<endl;
cout<<"目前各種資源可利用的數量為:"<<endl;
for (j=0;j<N;j++)
cout<<" 資源"<<j<<": "<<AVAILABLE[j];
cout<<endl;
cout<<"━━━━━━━━━━━━━━━━━━"<<endl;
cout<<"各進程還需要的資源數量:"<<endl<<endl;
for(i=0;i<N;i++)
cout<<" 資源"<<i;
cout<<endl;
for (i=0;i<M;i++)
{
cout<<"進程"<<i<<": ";
for (j=0;j<N;j++)
cout<<NEED[i][j]<<" ";
cout<<endl;
}
cout<<endl;
cout<<"━━━━━━━━━━━━━━━━━━"<<endl;
cout<<"各進程已經得到的資源量: "<<endl<<endl;
for(i=0;i<N;i++)
cout<<" 資源"<<i;
cout<<endl;
for (i=0;i<M;i++)
{
cout<<"進程"<<i<<": ";
for (j=0;j<N;j++)
cout<<ALLOCATION[i][j]<<" ";
cout<<endl;
}
cout<<endl;
}
void distribute(int k)
{
int j;
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];
}
}
void restore(int k)
{
int j;
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];
}
}
int check()
{
int WORK[R],FINISH[W];
int i,j;
for(j=0;j<N;j++) WORK[j]=AVAILABLE[j];
for(i=0;i<M;i++) FINISH[i]=FALSE;
for(i=0;i<M;i++)
{
for(j=0;j<N;j++)
{
if(FINISH[i]==FALSE&&NEED[i][j]<=WORK[j])
{
WORK[j]=WORK[i]+ALLOCATION[i][j];
}
}
FINISH[i]=TRUE;
}
for(i=0;i<M;i++)
{
if(FINISH[i]==FALSE)
{
cout<<endl;
cout<<" 系統不安全!!! 本次資源申請不成功!!!"<<endl;
cout<<endl;
return 1;
}
else
{
cout<<endl;
cout<<" 經安全性檢查，系統安全，本次分配成功。"<<endl;
cout<<endl;
return 0;
}
}
}
void bank() // 銀行家演算法
{
int i=0,j=0;
char flag='Y';
while(flag=='Y'||flag=='y')
{
i=-1;
while(i<0||i>=M)
{
cout<<"━━━━━━━━━━━━━━━━━━"<<endl;
cout<<endl<<" 請輸入需申請資源的進程號:";
cin>>i;
if(i<0||i>=M) cout<<" 輸入的進程號不存在，重新輸入!"<<endl;
}
cout<<" 請輸入進程"<<i<<"申請各類資源的數量:"<<endl;
for (j=0;j<N;j++)
{
cout<<" 資源"<<j<<": ";
cin>>Request[j];
if(Request[j]>NEED[i][j]) // 若請求的資源數大於進程還需要i類資源的資源量j
{
cout<<endl<<" 進程"<<i<<"申請的資源數大於進程"<<i<<"還需要"<<j<<"類資源的數量!";
cout<<" 若繼續執行系統將處於不安全狀態!"<<endl;
flag='N';
break;
}
else
{
if(Request[j]>AVAILABLE[j]) // 若請求的資源數大於可用資源數
{
cout<<endl<<" 進程"<<i<<"申請的資源數大於系統可用"<<j<<"類資源的數量!";
cout<<" 若繼續執行系統將處於不安全狀態!"<<endl;
flag='N';
break;
}
}
}
if(flag=='Y'||flag=='y')
{
distribute(i); // 調用change(i)函數，改變資源數
if(check()) // 若系統安全
{
restore(i); // 調用restore(i)函數，恢復資源數
output(); // 輸出資源分配情況
}
else // 若系統不安全
output(); // 輸出資源分配情況
}
else // 若flag=N||flag=n
cout<<endl;
cout<<" 是否繼續銀行家演算法演示,按'Y'或'y'鍵繼續,按'N'或'n'鍵退出演示: ";
cin>>flag;
}
}
void version()
{
cout<<endl;
cout<<"\t 銀 行 家 算 法 "<<endl;
}
void main() // 主函數
{
int i=0,j=0,p;
version();
getchar();
cout<<endl<<"請輸入總進程數:";
cin>>M;
cout<<endl<<"━━━━━━━━━━━━━━━━━━"<<endl;
cout<<"請輸入總資源種類:";
cin>>N;
cout<<endl<<"━━━━━━━━━━━━━━━━━━"<<endl;
cout<<"請輸入各類資源總數:(需要輸入數為"<<N<<"個)";
for(i=0;i<N;i++)
cin>>ALL_RESOURCE[i];
cout<<endl<<"━━━━━━━━━━━━━━━━━━"<<endl;
cout<<"輸入各進程所需要的各類資源的最大數量:(需要輸入數為"<<M*N<<"個)";
for (i=0;i<M;i++)
{
for (j=0;j<N;j++)
{
do
{
cin>>MAX[i][j];
if (MAX[i][j]>ALL_RESOURCE[j])
cout<<endl<<"佔有資源超過了聲明的該資源總數,請重新輸入"<<endl;
}
while (MAX[i][j]>ALL_RESOURCE[j]);
}
}
cout<<endl<<"━━━━━━━━━━━━━━━━━━"<<endl;
cout<<"輸入各進程已經占據的各類資源的數量:(需要輸入數為"<<M
*N<<"個)";
for (i=0;i<M;i++)
{
for (j=0;j<N;j++)
{
do
{
cin>>ALLOCATION[i][j];
if (ALLOCATION[i][j]>MAX[i][j])
cout<<endl<<"佔有資源超過了聲明的最大資源,請重新輸入"<<endl;
}
while (ALLOCATION[i][j]>MAX[i][j]);
}
}
for (j=0;j<N;j++) // 初始化資源數量
{
p=ALL_RESOURCE[j];
for (i=0;i<M;i++)
{
p=p-ALLOCATION[i][j];// 減去已經被占據的資源
AVAILABLE[j]=p;
if(AVAILABLE[j]<0)
AVAILABLE[j]=0;
}
}
for (i=0;i<M;i++)
for(j=0;j<N;j++)
NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];
output();
bank();
}
實驗結果分析
1.根據下面給出的系統中資源分配情況，以及各個進程的資源申請情況，通過銀行家演算法來判斷各進程的資源請求能否滿足（要求記錄程序的運行過程）。
已分配的資源 最大需求量
A B C A B C
P1 0 1 0 7 5 3
P2 2 0 0 3 2 2
P3 3 0 2 9 0 2
P4 2 1 1 2 2 2
P5 0 0 2 4 3 3
剩餘資源 A B C
3 3 2
B. 銀行家演算法
#include<stdio.h>
#include "stdlib.h"
#define M 5
#define N 3
int max[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};
int need[M][N]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};
int allocation[M][N]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};
int request[N]={0};
int finish[M]={0};
int available[N]={3,3,2};
int work[N]={3,3,2};
int safe[M]={0};
int n=1,m=1;
void showdata()
{
int i,j;
printf("系統可用的資源數為:\n");
for (j=0;j<N;j++)
printf("資源%c: %d \n",j+65, work[j]);
printf("\n");
printf("進程還需要的資源量: \n");
printf(" A B C\n" );
for(i=0;i<M;i++)
{
printf("進程p%d:",i);
for(j=0;j<N;j++)
printf(" %d ", need[i][j]);
printf("\n");
}
printf("進程已經得到的資源量:\n");
printf(" A B C\n" );
for(i=0;i<M;i++)
{
printf("進程%d:",i);
for(j=0;j<N;j++)
printf(" %d ",allocation[i][j]);
printf("\n"坦源);
}
}
void fp(int i){
for(int j=0;j<N;j++){
work[j]=work[j]+allocation[i][j];
finish[i]=1;
}
}
void secure(){
showdata();
int y=0,flag=6,h,i,j;
while(flag){
for(i=0;i<M;i++){
for(j=0;j<N;j++){
if((finish[i]==0)&&(need[i][j]<=work[j]))
continue;
else
j=15;
}
if(j==N){
fp(i);
safe[y++]=i;
i=15;
}
else
continue;
}
flag--;
}
for( h=0;h<M;h++){
if(finish[h]==1)
continue;
else
h=M+1;
}
if(h==M){
printf("該狀態安全！安全序列鏈碧是:\n");
for(int l=0;l<M;l++){
if(l==M-1)
printf("p%d",safe[l]);
else
printf("p%d-->",safe[l]);
}
n=1;
}
else
{
n=0;
printf("該狀態不安全！！");
}
}
void sfp(int k){
for(int i=0;i<N;i++){
work[i]=work[i]-request[i];
allocation[k][i]+=request[i];
need[k][i]-=request[i];
}
secure();
if(n==1){
printf("給與分配！\n");
}
else if(n==0){
printf("不給與分配！\n");
}
}
int choice(int k){
int e=1;
printf("輸入選擇的量:\n"讓喚態);
while(e){
for(int i=0;i<N;i++){
printf("資源%c:",65+i);
scanf("%d",&request[i]);
}
for(int j=0;j<N;j++){
if((request[j]<=need[k][j])&&(request[j]<=work[j]))
continue;
else{
printf("資源%c申請超量！不與分配!",65+j);
return 0;
e=0;
}
}
if(j==N){
printf("可以試申請！\n");
return 1;
e=0;
}
}
}
void recover(int k){
for(int i=0;i<N;i++){
work[i]=available[i];
need[k][i]+=request[i];
allocation[k][i]-=request[i];
}
}
void main(){
int p=1,k=1,i=0,c,f;
while(k){
printf("請選擇：1:顯示進程情況；2:判斷此時狀態是否安全；3:選擇進程進行申請資源；4：結束程序！");
scanf("%d",&c);
switch(c){
case 1:showdata();break;
case 2:secure();work[0]=3;for(i=0;i<N;i++) work[i]=available[i];
break;
case 3: for(i=0;i<M;i++)
finish[i]=0;
printf("請選擇進程（0--4）:\n");
scanf("%d",&f);
if(choice(f)){
sfp(f);
recover(f);
}
else{
printf("不與分配");
}
break;
case 4:k=0;
break;
default:k=0;break;
}
printf("\n");
}
}
C. 「銀行家演算法」是怎樣的一個演算法
銀行家演算法=-- -
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
D. 銀行家演算法
銀行家演算法是一種預防死鎖的演算法。具體演算法步驟可以參考網路： 銀行家演算法
例子 ：某系統有A、B、C、D , 4類資源共5個進程（P0、P1、P2、P3、P4）共享，各進程對資源的需求和分配情況如下表所示。
輸入進程的數目:5
輸入資源的種類:4
輸入每個進程最多所需的各類資源數:
P0 : 0 0 1 2
P1 : 1 7 5 0
P2 : 2 3 5 6
P3 : 0 6 5 2
P4 : 0 6 5 6
輸入每個進程已經分配的各類資源數:
P0 : 0 0 1 2
P1 : 1 0 0 0
P2 : 1 3 5 4
P3 : 0 6 3 2
P4 : 0 0 1 4
請輸入各個資源現有的數目:
1 5 2 0
當前系統安全!
系統安全序列是:
P0->P2->P1->P3->P4
輸入要申請資源的進程號(0-4)：1
輸入進程所請求的各資源的數量:0 4 2 0
系統安全!
系統安全序列是:
P0->P2->P1->P3->P4
同意分配請求!
系統可用的資源數為 : 1 1 0 0
各進程還需要的資源量:
進程 P0 : 0 0 0 0
進程 P1 : 0 3 3 0
進程 P2 : 1 0 0 2
進程 P3 : 0 0 2 0
進程 P4 : 0 6 4 2
各進程已經得到的資源量:
進程 P0 : 0 0 1 2
進程 P1 : 1 4 2 0
進程 P2 : 1 3 5 4
進程 P3 : 0 6 3 2
進程 P4 : 0 0 1 4
是否再次請求分配？是請按Y/y，否請按N/n:
N
E. 銀行家演算法得出的安全序列有順序嗎如{ p3，p0，p4 ，p2， p1}和{ p3，p0，p4 ，p1， p2}是一樣的嗎
不一樣
銀行家演算法假定前提如下：
p0 ~ p 4 各掌握有銀行家的若干資源，但要求完成他們的目標，分別還需要請求若干資源。
現在，銀行家已經付出很多資源，手裡資源不多。而pX 們另外需求的資源也是大小不一的。
而一旦銀行家所有資源支出後，pX中仍然沒有誰完成任務，這就死鎖了（每個進程都把握一部分資源，並還在要資源，而資源已經木有了）
==========================
現在，演算法得出這樣一條順序，先優先供應p3,等p3完成他的線程後，p3會釋放所佔有的資源。銀行家（系統）利用p3所有的資源和自己手裡剩餘的資源按順序供應p0，p4 等等。
現在假定 供應完 p4後，銀行家手中握有資源 10單位
p1 總共需要20單位才能完成他的進程，而p1手中現有5單元
p2 總共需要10單位才能完成他的進程，而p2手中已經有了8單元了
請問，系統應該先供應哪個線程？
答案必然是先p2再p1
因為使用2資源供應完p2（10單位才能完成，已有8單位，還要2單位）,p2完成任務後，釋放所有資源，系統累計資源才有 10 - 2 + 10 = 18 單位的資源 ，才能滿足p1 的 15( = 20 -5 ）單位資源的請求。
而若反之， 所有資源投入p1 , p1 完成進度 15 / 20 p2 完成進度 8 / 10 這就徹底死了
所以 xxxxx p2 p1 能活， xxxxx p1 p2 會死
特別說明的是，銀行家演算法可以得到不止一條安全順序。能被銀行家證明可行的演算法都是死不了的演算法
F. 銀行家演算法
什麼是銀行家演算法：
銀行家演算法是一種最有代表性的避免死鎖的演算法。在避免死鎖方法中允許進程動態地申請資源，但系統在進行資源分配之前，應先計算此次分配資源的安全性，若分配不會導致系統進入不安全狀態，則分配，否則等待。為實現銀行家演算法，系統必須設置若干數據結構。
要解釋銀行家演算法，必須先解釋操作系統安全狀態和不安全狀態。
安全序列是指一個進程序列{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();
}
這個程序還行，輸入有點麻煩，我自己編寫的是用文件輸入系統描述信息的，但是缺少說明，怕你搞不明白。希望對你有所幫助！
G. 銀行家演算法是什麼
銀行家演算法=-- -
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
H. 銀行家演算法
Dijkstra（1965）提出了一種能夠避免死鎖的調度演算法，稱為銀行家演算法（banker's algorithm），這是6.4.1節中給出的死鎖檢測演算法的擴展。該模型基於一個小城鎮的銀行家，他向一群客戶分別承諾了一定的貸款額度。演算法要做的是判斷對請求的滿足是否會導致進入不安全狀態。如果是，就拒絕請求；如果滿足請求後系統仍然是安全的，就予以分配。在圖6-11a中我們看到4個客戶A、B、C、D，每個客戶都被授予一定數量的貸款單位（比如1單位是1千美元），銀行家知道不可能所有客戶同時都需要最大貸款額，所以他只保留10個單位而不是22個單位的資金來為客戶服務。這里將客戶比作進程，貸款單位比作資源，銀行家比作操作系統。