【操做系統】銀行家算法

　　對於計算機中的死鎖，咱們有四種處理的方法，分別爲預防死鎖、避免死鎖、檢測死鎖和解除死鎖，而今天要說的Dijkstra的銀行家算法就是最具備表明性的避免死鎖的算法。

　　銀行家算法的名字來源於該算法本來是爲銀行系統設計的，以確保銀行在發放現金貸款時，不會發生不能知足全部客戶須要的狀況，在OS中能夠用它來避免死鎖。

　　爲實現銀行家算法，每個新進程在進入系統時，必須申明在運行過程當中可能須要每種資源類型的最大單元數目，其數目不該超過系統所擁有的資源總量。當進程請求一組資源時，系統必須首先肯定是否有足夠的資源分配給該進程。如有，再進一步計算在將這些資源分配給進程後，是否會使系統處於不安全狀態。若是不會，纔將資源分配給它，不然讓進程等待。

　　首先爲實現銀行家算法，在系統中必須設置這樣四個數據結構：

　　（1）可利用資源向量Avaliable。這是一個含有m個元素的數組，其中每個元素表明一類可利用的資源數目，其初始值是系統所配置的該類所有可用資源的數目，其中的每個元素表明一類可利用的資源數目，其初始值是系統中所配置的該類所有可用資源的數目，其數值隨該類資源的分配和回收而動態的改變。若是Available[j]=K，則表示系統中現有R_j類資源的最大數目爲K_。

　　（2）最大需求矩陣Max。是一個n×m的矩陣，定義了系統中n個進程中的每個進程對m類資源的最大需求。若是Max[i, j]=K，則表示進程i須要R_j類資源的最大數目爲K。

　　（3）分配矩陣Allocation。是一個n×m的矩陣，定義了系統中每一類資源當前已分配給每一進程的資源數。若是Allocation[i, j]=K，則表示進程i當前已分得R_j類資源的數目爲K。

　　（4）需求矩陣Need。是一個n×m的矩陣，用以表示每個進程尚需的各種資源數。若是Need[i, j]=K，則表示進程i還須要R_j類資源K個方能完成其任務。

　　它們之間的關係爲:　　Need[i, j]=Max[i, j]-Allocation[i, j]

　

　　先來看看安全性算法，描述以下：

　　（1）設置兩個向量：

　　　　① 工做向量Work，表示系統可提供給進程繼續運行所需的各種資源數目，含有m個元素，在執行安全算法開始時，Work=Available；

　　　　② Finish，表示系統是否有足夠的資源分配給進程，使之運行完成。先令Finish[i]=false；當有足夠資源分配給進程時，令Finish[i]=true。

　　（2）從進程集合中找到一個能知足下述條件的進程：

　　　　① Finish[i]=false；

　　　　② Need[i, j]≤Work[j]；

　　　　若找到，執行步驟（3），不然，執行步驟（4）。

　　（3）當進程P_i得到資源後，可順利執行，直至完成，並釋放出分配給它的資源，故執行：

　　　　Work[j]=Work[j]+Allocation[i, j]；

　　　　Finish[i]=true；

　　　　返回步驟（2）。

　　（4）若是全部進程的Finish[i]=true都知足，則表示系統處於安全狀態，不然，系統處於不安全狀態。

 

　　下面對安全性算法舉個實例：

　　假定系統中有5個進程｛P0，P1，P2，P3｝和5類資源，各類資源的數量分別爲[5，6，8，6，4]，在某個時刻資源分配狀況以下：

進程號	Allocation					Need
P0	0	2	1	1	1	1	0	2	1	1
P1	2	0	1	1	1	0	3	2	1	0
P2	0	1	0	1	1	0	3	3	2	2
P3	0	3	1	2	0	1	0	1	2	1

 

 

 

 

 

　　

　　咱們首先先將表格補充完整，已知各類資源的數量，那隻需用[5，6，8，6，4]減去全部對應進程號的Allocation的和[2，6，3，5，3]就能夠獲得Available的值爲[3，0，5，1，1]。

　　題目中至少會有Max、Need、Allocation中的兩個數據結構，根據公式Need[i, j]=Max[i, j]-Allocation[i, j]便可推出其他的數據結構。

　　好比這道題完整的表格以下：

進程號	Max					Allocation					Need					Available
P0	1	2	3	2	2	0	2	1	1	1	1	0	2	1	1	3	0	5	1	1
P1	2	3	3	2	1	2	0	1	1	1	0	3	2	1	0
P2	0	4	3	3	3	0	1	0	1	1	0	3	3	2	2
P3	1	3	2	4	1	0	3	1	2	0	1	0	1	2	1

 

 

 

 

　　

　　分析過程（最終結果只需一張表格便可）：進行安全性檢測，首先根據上述安全性算法得出Work，從P0開始逐行檢測，P0時Work=Available，判斷髮現Need≤Work，則P0知足條件，Finish=true，運算Work+Allocation，並將這個值做爲新的Work值進行檢測，P1是不知足Need≤Work，則跳過判斷P2，一樣不知足Need≤Work，跳過判斷P3，發現知足Need≤Work，則P3知足條件，Finish=true，運算Work+Allocation，並將這個值做爲新的Work值繼續進行檢測，回到P1，發現P1知足條件，Finish=true，繼續進行上述操做，發現P2也知足條件，Finish=true，全部Finish值都爲true，故存在這麼一條安全序列｛P0，P3，P1，P2｝，故系統是安全的，表格以下：

進程號	Work					Need					Allocation					Work+Allocation					Finish
P0	3	0	5	1	1	1	0	2	1	1	0	2	1	1	1	3	2	6	2	2	true
P3	3	2	6	2	2	1	0	1	2	1	0	3	1	2	0	3	5	7	4	2	true
P1	3	5	7	4	2	0	3	2	1	0	2	0	1	1	1	5	5	8	5	3	true
P2	5	5	8	5	3	0	3	3	2	2	0	1	0	1	1	5	6	8	6	4	true

 

 

 

 

　　

　　反之，若是沒法得到一條安全的序列，則系統是不安全的。

 

　　以上就是安全性算法，如今再來看銀行家算法的過程。

　　設Request_i是進程Pi的請求向量，若是Request_i[j]=K，表示進程P_i須要K個R_j類型的資源。當P_i發出資源請求後，系統按下述步驟進行檢查：

　　（1）若是Request_i[j]≤Need[i, j]，轉向步驟（2）；不然所需資源數已超過它所宣佈的最大值。

　　（2）若是Request_i[j]≤Available[i, j]，轉向步驟（3）；不然無足夠資源，P_i需等待。

　　（3）系統試探着把資源分配給進程P_i，並修改下面數據結構中的數值：

　　　　Available[j]=Available[j]-Request_i[j]；

　　　　Allocation[i, j]=Allocation[i, j]+Request_i[j]；

　　　　Need[i, j]=Need[i, j]-Request_i[j]；

　　（4）系統執行安全性算法，檢查這次資源分配後系統是否處於安全狀態。若安全，才正式將資源分配給進程P_i，以完成本次分配；不然，將本次的試探分配做廢，恢復原來的資源分配狀態，讓進程P_i等待。

　　

　　仍是上述表格，若P0請求資源[1，0，0，0，1]，用銀行家算法進行檢查（由於是P0請求資源因此從P0開始檢測）：

　　① Request₀(1，0，0，0，1)≤Need₀(1，0，2，1，1)；

　　② Request₀(1，0，0，0，1)≤Available₀(3，0，5，1，1)；

　　③ 系統先假定可爲P0分配資源，並修改Available，Allocation₀，Need₀向量，根據公式可得Available=[2，0，5，1，0]，Need₀=[0，0，2，1，0]，Allocation₀=[1，2，1，1，2]，修改P0的這三個值；

　　④ 利用安全性算法檢查此時系統是否安全，以下：

進程號	Work					Need					Allocation					Work+Allocation					Finish
P0	2	0	5	1	0	0	0	2	1	0	1	2	1	1	2	3	2	6	2	2	true
P3	3	2	6	2	2	1	0	1	2	1	0	3	1	2	0	3	5	7	4	2	true
P1	3	5	7	4	2	0	3	2	1	0	2	0	1	1	1	5	5	8	5	3	true
P2	5	5	8	5	3	0	3	3	2	2	0	1	0	1	1	5	6	8	6	4	true

 

 

 

 

　　

　　能夠找到一個安全序列｛P0，P3，P1，P2｝。所以，系統是安全的，能夠當即將P0所申請的資源分配給它。

　　反之，若是沒法得到一條安全的序列，則系統是不安全的，不能將資源分配給它。