銀行家演算法安全序列
❶ 銀行家演算法的安全序列怎麼尋找
1）安全。
安全序列 P1 P3 P4 P0 P2
（從第一個進程開始，找所需資源數小於系統可用資源數的進程(P1 Need(1 2 2) < Availabe(3 3 2)),該進程需求滿足後把其所有資源還給系統(Available(5 3 2)，依此。）
2)不能.
如果滿足P1的請求Request（1，0，2）後，P1的需求沒有完全滿足，也就是說P1獲得該資源後不會結束，依然在等待系統分配資源。
而系統剩餘資源為(2,3,0)不能再滿足任何進程的需求,處在不安全狀態，可能產生死鎖。
❷ 銀行家演算法的多個安全序列的輸出
銀行家演算法=-- -
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(在推算過程中,所有進程均可以完成),則表示(分配過後)系統是安全的,否則系統是不安全的.
❸ 銀行家演算法中的安全狀態是一個什麼樣的狀態
安全序列是指一個進程序列{P1，…，Pn}是安全的，即對於每一個進程Pi(1≤i≤n），它以後尚需要的資源量不超過系統當前剩餘資源量與所有進程Pj
(j < i )當前佔有資源量之和。
如果存在一個由系統中所有進程構成的安全序列P1，…，Pn，則系統處於安全狀態。安全狀態一定是沒有死鎖發生。
❹ 銀行家演算法(操作系統）
1、這是安全狀態：
P1的需求小於可用資源數，先滿足P1的請求，然後回收P1資源：可用資源變為 （3,3,2）＋（2,0,0）＝（5,3,2）；
這時P3可分配，P3結束後回收資源，可用資源為（5,3,2）＋（2,1,1）＝（7,4,3）
這時P0可分配，P0結束後回收資源，可用資源為（7,4,3）＋（0,1,0）＋（7,5,3）
接下來是P2，結束後可用資源為（7,5,3）＋（3,0,2）＝（10,5,5）
最後分配P4，結束後可用資源為（10,5,5）＋（0,0,2）＝（10,5,7）
這樣得到一個安全序列：P1－P3－P0－P2－P4，所以T0狀態是安全的。
2、T0時刻P1請求（1,1,2）<可用資源數（3,3,2），可以直接滿足。
❺ 銀行家演算法安全序列怎麼判斷
先說一下銀行家的演算法：
設進程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)系統執行安全性檢查，如安全，則分配成立；否則試探險性分配作廢，系統恢復原狀，進程等待。
=================================================
題目中的計算過程：
先算出每個進程還需要多少進程才能滿足，即Request的值 = Need - Allocation
進程名 Allocation Need Request Available
ABC ABC ABC ABC
P1 4 0 5 4 0 11 0 0 6 2 3 3
P2 4 0 2 5 3 6 1 2 4
P3 2 1 4 4 2 5 2 1 1
P4 2 1 2 5 5 9 3 4 7
P5 3 1 3 4 2 4 1 1 1
第一題A項p3 p1 p4 p2 p5
先分配給P3，其Request(2,1,1) < available(2,2,3) 滿足，分配資源等待P3完成，P3進程完成之後，Available = (2,1,4) + (2,3,3) = (4,4,7)
然後分配給p1,其Request(0,0,6) < available(4,4,7)，可以滿足資源，分配資源給P1,P1完成任務釋放資源Available = (4,0,5) +(4,4,7) = (8,4,12)
接著P4，request(3 4 7) < available(8,4,12),可以滿足資源，分配資源給P4,P4完成任務釋放資源Available = (2,1,2) +(8,4,12) = (10,5,14)
接著p2，request(1 2 4) < available(10,5,14)可以滿足資源，分配資源給P4,P4完成任務釋放資源Available = (4,0,2)+ (10,5,14) = (14,5,16)
最後P5,request(1 1 1) < available(14,5,16)可以滿足資源，分配資源給P4,P4完成任務,資源全部釋放，變為(3 1 3 )+ (14,5,16) = (17,6,19)
所以A是安全序列。
同理分析B p1 p3 p5 p2 p4，先分配給P1的話Request(0,0,6) > available(2,3,3)，C資源不滿足，所以該序列不安全。
分析C項p4 p2 p3 p5 p1,先分配給p4, Request(3,4,7) > available(2,3,3)，ABC資源都不滿足，該序列不安全。
分析D項p2 p3 p1 p4 p5，先分配給P2，Request(1,2,4) > available(2,3,3)，C資源不滿足，所以該序列不安全。
第二題，分析方法跟上面的一樣，只是比較費時。如果單選的話，看一下答案，D項，先分配給P4，顯然完成P4還需( 3 4 7) ,其大於 available，所D項不安全。
❻ 有沒有人懂操作系統的銀行家演算法，最好有一道例題可以講
銀行家演算法是一種最有代表性的避免死鎖的演算法。在避免死鎖方法中允許進程動態地申請資源，但系 銀行家演算法統在進行資源分配之前，應先計算此次分配資源的安全性，若分配不會導致系統進入不安全狀態，則分配，否則等待。為實現銀行家演算法，系統必須設置若干數據結構。
要解釋銀行家演算法，必須先解釋操作系統安全狀態和不安全狀態。
安全序列是指一個進程序列{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;
}
❼ 銀行家演算法得出的安全序列有順序嗎如{ 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 會死
特別說明的是，銀行家演算法可以得到不止一條安全順序。能被銀行家證明可行的演算法都是死不了的演算法
❽ 「銀行家演算法」是怎樣的一個演算法
銀行家演算法=-- -
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，則系統處於安全狀態。安全狀態一定是沒有死鎖發生。
❿ 關於銀行家演算法安全分配序列問題
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(在推算過程中,所有進程均可以完成),則表示(分配過後)系統是安全的,否則系統是不安全的.
拿此題來說，可用資源為1020 要先從這些個進程裡面看 誰的need 小於等於它，這里只能選擇p3（0020），p3完成後釋放他的allocation(1101),此時 可用資源變成2121，然後再從其餘的裡面找need小於等於2121的，這里我選的是p0，同樣的p0執行完以後，釋放出他的已有資源後，可用資源變成4132，同理依次可選擇p4 p2 p1。由此可知 此時系統是安全的，因為可以找到一個安全序列 p3，p0，p4 p2 p1（注意 安全序列不是唯一的）