避免死锁之银行家算法

避免死锁之银行家算法
分类：Operating System2013-12-28 01:14 922人阅读评论(0) 收藏举报
目录(?)[+]上篇博客中进程管理之死锁我们讲到了进程管理中死锁的各种问题，其中留下了死锁避免算法中著名的银行家算法没讲，下面就为大家详细解读。

1.安全序列
讲银行家算法之前，我们首先引入安全序列的定义：所谓系统是安全的，是指系统中的所有进程能够按照某一种次序分配资源，并且依次地运行完毕，这种进程序列{P1，P2，...，Pn}就是安全序列。

如果存在这样一个安全序列，则系统是安全的；如果系统不存在这样一个安全序列，则系统是不安全的。

安全序列{P1，P2，...，Pn}是这样组成的：若对于每一个进程Pi，它需要的附加资源可以被系统中当前可用资源加上所有进程Pj当前占有资源之和所满足，则{P1，P2，...，Pn}为一个安全序列，这时系统处于安全状态，不会进入死锁状态。

虽然存在安全序列时一定不会有死锁发生，但是系统进入不安全状态（四个死锁的必要条件同时发生）也未必会产生死锁。

当然，产生死锁后，系统一定处于不安全状态。

2.银行家算法
(为了熟悉英语请原谅我借用wiki上的文字来描述)
For the Banker's algorithm to work, it needs to know three things:∙How much of each resource each process could possibly request[CLAIMS]
∙How much of each resource each process is currently holding[ALLOCATED]
∙How much of each resource the system currently has available[AVAILABLE]
Resources may be allocated to a process only if it satisfies the following conditions:
∙request ≤ max, else set error condition as process has crossed maximum claim made by it.
∙request ≤ available, else process waits until resources are available.
Basic data structures to be maintained to implement the Banker's Algorithm:
∙Available: A vector of length m indicates the number of available resources of each type. If Available[j] = k, there are k
instances of resource type Rj available.
∙Max: An n×m matrix defines the maximum demand of each process. If Max[i,j] = k, then Pi may request at most k instances of resource type Rj.
∙Allocation: An n×m matrix defines the number of resources of each type currently allocated to each process. If Allocation[i,j] = k, then process Pi is currently allocated k instance of resource
type Rj.
∙Need: An n×m matrix indicates the remaining resource need of each process. If Need[i,j] = k, then Pi may need k more
instances of resource type Rj to complete task.
Note: Need[i,j] = Max[i,j] - Allocation[i,j].
∙银行家算法:
设进程i提出请求Request[j]，则银行家算法按如下规则进行判断。

(1) 如果Request[j]≤Need[i,j]，则转向（2），否则认为出错。

(2) 如果Re quest[j]≤Available[j]，则转向（3）；否则表示尚无足够资源，Pi需等待。

(3) 假设进程i的申请已获批准，于是修改系统状态：
Available[j]=Available[j]-Request[i]
Allocation[i,j]=Allocation[i,j]+Request[j]
Need[i,j]=Need[i,j]-Request[j]
(4)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。

安全性检查
(1) 设置两个工作向量Work=Available；Finish[i]=False
(2) 从进程集合中找到一个满足下述条件的进程，
Finish [i]=False;
Need[i,j]≤Work[j];
如找到，执行(3)；否则，执行(4)
(3) 设进程获得资源，可顺利执行，直至完成，从而释放资源。

Work[j]=Work[i]+Allocation[i,j];
Finish[i]=True;
go to step 2;
(4) 如所有的进程Finish[i]=true，则表示安全；否则系统不安全。

由于时间不早了就借用下wiki上的c语言实现代码，改天用java实现一遍。

[cpp]view plaincopyprint?
1./*PROGRAM TO IMPLEMENT BANKER'S ALGORITHM
2. * --------------------------------------------*/
3.#include <stdio.h>
4.int curr[5][5], maxclaim[5][5], avl[5];
5.int alloc[5] = {0,0,0,0,0};
6.int maxres[5], running[5], safe=0;
7.int count = 0, i, j, exec, r, p,k=1;
8.
9.int main()
10.{
11. printf("\nEnter the number of processes: ");
12. scanf("%d",&p);
13.
14.for(i=0;i<p;i++)
15. {
16. running[i]=1;
17. count++;
19.
20. printf("\nEnter the number of resources: ");
21. scanf("%d",&r);
22.
23.for(i=0;i<r;i++)
24. {
25. printf("\nEnter the resource for instance %d: ",k++);
26. scanf("%d",&maxres[i]);
27. }
28.
29. printf("\nEnter maximum resource table:\n");
30.for(i=0;i<p;i++)
31. {
32.for(j=0;j<r;j++)
33. {
34. scanf("%d",&maxclaim[i][j]);
35. }
36. }
37.
38. printf("\nEnter allocated resource table:\n");
39.for(i=0;i<p;i++)
40. {
41.for(j=0;j<r;j++)
42. {
43. scanf("%d",&curr[i][j]);
44. }
45. }
46.
47. printf("\nThe resource of instances: ");
48.for(i=0;i<r;i++)
49. {
50. printf("\t%d",maxres[i]);
51. }
52.
53. printf("\nThe allocated resource table:\n");
54.for(i=0;i<p;i++)
55. {
56.for(j=0;j<r;j++)
57. {
58. printf("\t%d",curr[i][j]);
59. }
60.
61. printf("\n");
63.
64. printf("\nThe maximum resource table:\n");
65.for(i=0;i<p;i++)
66. {
67.for(j=0;j<r;j++)
68. {
69. printf("\t%d",maxclaim[i][j]);
70. }
71.
72. printf("\n");
73. }
74.
75.for(i=0;i<p;i++)
76. {
77.for(j=0;j<r;j++)
78. {
79. alloc[j]+=curr[i][j];
80. }
81. }
82.
83. printf("\nAllocated resources:");
84.for(i=0;i<r;i++)
85. {
86. printf("\t%d",alloc[i]);
87. }
88.
89.for(i=0;i<r;i++)
90. {
91. avl[i]=maxres[i]-alloc[i];
92. }
93.
94. printf("\nAvailable resources:");
95.for(i=0;i<r;i++)
96. {
97. printf("\t%d",avl[i]);
98. }
99. printf("\n");
100.
101.//Main procedure goes below to check for unsafe state. 102.while(count!=0)
103. {
104. safe=0;
105.for(i=0;i<p;i++)
106. {
107.if(running[i])
108. {
109. exec=1;
110.for(j=0;j<r;j++)
111. {
112.if(maxclaim[i][j] - curr[i][j] > avl[j]){ 113. exec=0;
114.break;
115. }
116. }
117.if(exec)
118. {
119. printf("\nProcess%d is executing\n",i+1); 120. running[i]=0;
121. count--;
122. safe=1;
123.
124.for(j=0;j<r;j++) {
125. avl[j]+=curr[i][j];
126. }
127.
128.break;
129. }
130. }
131. }
132.if(!safe)
133. {
134. printf("\nThe processes are in unsafe state.\n"); 135.break;
136. }
137.else
138. {
139. printf("\nThe process is in safe state");
140. printf("\nSafe sequence is:");
141.
142.for(i=0;i<r;i++)
143. {
144. printf("\t%d",avl[i]);
145. }
146.
147. printf("\n");
148. }
149. }
151.
152.
153./*SAMPLE OUTPUT
154.-----------------
155.Enter the number of resources:4 156.
157.Enter the number of processes:5 158.
159.Enter Claim Vector:8 5 9 7
160.
161.Enter Allocated Resource Table: 162.2 0 1 1
163.0 1 2 1
164.4 0 0 3
165.0 2 1 0
166.1 0 3 0
167.
168.Enter Maximum Claim table:
169.3 2 1 4
170.0 2 5 2
171.5 1 0 5
172.1 5 3 0
173.3 0 3 3
174.
175.The Claim Vector is: 8 5 9 7 176.The Allocated Resource Table:
177. 2 0 1 1
178. 0 1 2 1
179. 4 0 0 3
180. 0 2 1 0
181. 1 0 3 0
182.
183.The Maximum Claim Table:
184. 3 2 1 4
185. 0 2 5 2
186. 5 1 0 5
187. 1 5 3 0
188. 3 0 3 3
189.
190. Allocated resources: 7 3 7 5 191. Available resources: 1 2 2 2 192.
193.Process3 is executing
195. The process is in safe state
196. Available vector: 5 2 2 5
197.Process1 is executing
198.
199. The process is in safe state
200. Available vector: 7 2 3 6
201.Process2 is executing
202.
203. The process is in safe state
204. Available vector: 7 3 5 7
205.Process4 is executing
206.
207. The process is in safe state
208. Available vector: 7 5 6 7
209.Process5 is executing
210.
211. The process is in safe state
212. Available vector: 8 5 9 7
213.
214. ---------------------------------------------------------*/
下面是java代码实现
[java]view plaincopyprint?
1.import java.util.Scanner;
2.
3.public class Bankers{
4.private int need[][],allocate[][],max[][],avail[][],np,nr;
5.
6.private void input(){
7. Scanner sc=new Scanner(System.in);
8. System.out.print("Enter no. of processes and resources : ");
9. np=sc.nextInt(); //no. of process
10. nr=sc.nextInt(); //no. of resources
11. need=new int[np][nr]; //initializing arrays
12. max=new int[np][nr];
13. allocate=new int[np][nr];
14. avail=new int[1][nr];
15.
16. System.out.println("Enter allocation matrix -->");
17.for(int i=0;i<np;i++)
18.for(int j=0;j<nr;j++)
19. allocate[i][j]=sc.nextInt(); //allocation matrix
20.
21. System.out.println("Enter max matrix -->");
22.for(int i=0;i<np;i++)
23.for(int j=0;j<nr;j++)
24. max[i][j]=sc.nextInt(); //max matrix
25.
26. System.out.println("Enter available matrix -->");
27.for(int j=0;j<nr;j++)
28. avail[0][j]=sc.nextInt(); //available matrix
29.
30. sc.close();
31. }
32.
33.private int[][] calc_need(){
34.for(int i=0;i<np;i++)
35.for(int j=0;j<nr;j++) //calculating need matrix
36. need[i][j]=max[i][j]-allocate[i][j];
37.
38.return need;
39. }
40.
41.private boolean check(int i){
42.//checking if all resources for ith process can be allocated
43.for(int j=0;j<nr;j++)
44.if(avail[0][j]<need[i][j])
45.return false;
46.
47.return true;
48. }
49.
50.public void isSafe(){
51. input();
52. calc_need();
53.boolean done[]=new boolean[np];
54.int j=0;
55.
56.while(j<np){ //until all process allocated
57.boolean allocated=false;
58.for(int i=0;i<np;i++)
59.if(!done[i] && check(i)){ //trying to allocate
60.for(int k=0;k<nr;k++)
61. avail[0][k]=avail[0][k]-need[i][k]+max[i][k];
62. System.out.println("Allocated process : "+i);
63. allocated=done[i]=true;
64. j++;
65. }
66.if(!allocated) break; //if no allocation
67. }
68.if(j==np) //if all processes are allocated
69. System.out.println("\nSafely allocated");
70.else
71. System.out.println("All proceess cant be allocated safely");
72. }
73.
74.public static void main(String[] args) {
75.new Bankers().isSafe();
76. }
77.}
78.----------------------------------------------------------------------------
----------------------------------------------
79.Output
80.----------------------------------------------------------------------------
----------------------------------------------
81.Enter no. of processes and resources : 34
82.Enter allocation matrix -->
83.1221
84.1033
85.1210
86.Enter max matrix -->
87.3322
88.1134
89.1350
90.Enter available matrix -->
91.3112
92.Allocated process : 0
93.Allocated process : 1
94.Allocated process : 2
95.Safely allocated。