Code:

1. /*  
2. 名称：银行家算法演示  
3. 作者：杜琪  
4. 时间：2010.11.14
5. 作用：  
6. 演示银行家算法的作用和操作过程：  
7. 1、判断此刻系统是否处于安全状态  
8. 2、输入某一进程的请求资源，然后利用银行家算法判断是否可以  
9. 找到一个安全序列，如果可以，将该进程申请的资源分配出去，  
10. 并且输出安全序列。  
11. */  
12. #include<stdio.h>   
13. #define RN  3//资源的数目为3   
14. #define PN  5//进程数目为5   
15.   
16.   
17. /*各个函数声明*/  
18. void Init();//初始化界面函数声明   
19. int Banker(int i,int Requist[]);//银行家函数声明   
20. bool Security(int s[],int t[][RN],int p[][RN]);//安全性检查函数声明   
21.   
22. void main()   
23. {//主函数，程序入口    
24.     /*初始化银行家算法中所用到的数据结构和变量*/  
25.     int Available[RN]={3,3,2};//可利用资源向量   
26.     int Max[PN][RN]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};//最大需求矩阵，它定义了系统中PN个进程   
27.                                                               //中的每一个进程对RN类资源的最大需求   
28.     int Allocation[PN][RN]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//分配矩阵，表示当前系统中每一个进程获得的   
29.                                                             //的每一类资源数目   
30.     int Need[PN][RN]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};//表示一个进程上需要的各类资源的数目     
31.     int P1[]={1,0,2};//P1数组存放进程1请求的资源   
32.     int P4[]={3,3,0};   
33.     int P0[]={0,1,0};   
34.     int i=0;//表示哪个进程请求资源   
35.     bool flag1;   
36.     /*问题背景初始化*/  
37.     Init();   
38.     /*判断当前时刻系统是否处于安全状态*/  
39.     flag1=Security(Available,Need,Allocation);   
40.     if(flag1)   
41.     {   
42.         printf(“/n”);   
43.         printf(“当前系统处于安全状态！/n”);   
44.     }   
45.     else  
46.     {   
47.         printf(“/n”);   
48.         printf(“当前系统处于不安全状态！/n”);   
49.     }   
50. //  进程P1请求资源，Requist(1,0,2)   
51.     i=1;   
52.     Banker(i,P1);   
53.     printf(“/n”);   
54. /*  进程p4请求资源，Requist(3,3,0)  
55.     i=4;  
56.     Banker(i,P4);  
57.     printf(“/n”);  
58.     进程p0请求资源，Requist(0,2,0)  
59.     i=0;  
60.     Banker(i,P0);  
61.     进程p0请求资源，Requist(0,1,0) */  
62. }   
63.   
64. /*界面初始化函数的定义*/  
65. void Init()   
66. {   
67.     int i,j;   
68.     /*初始化银行家算法中所用到的数据结构和变量*/  
69.     int Available[RN]={3,3,2};//可利用资源向量   
70.     int Max[PN][RN]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};//最大需求矩阵，它定义了系统中PN个进程   
71.                                                               //中的每一个进程对RN类资源的最大需求   
72.     int Allocation[PN][RN]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//分配矩阵，表示当前系统中每一个进程获得的   
73.                                                             //的每一类资源数目   
74.     int Need[PN][RN]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};//表示一个进程上需要的各类资源的数目   
75.     printf(“T0时刻的资源分配图如下:/n”);   
76.     printf(“各个资源最大需求矩阵如下:/n”);   
77.     printf(”   A B C/n”);   
78.     for(i=0;i<PN;i++)   
79.     {   
80.         printf(“p%d:”,i);   
81.         for(j=0;j<RN;j++)   
82.             printf(“%d “,Max[i][j]);   
83.         printf(“/n”);   
84.     }   
85.     printf(“各个资源分配矩阵如下:/n”);   
86.     printf(”   A B C/n”);   
87.     for(i=0;i<PN;i++)   
88.     {   
89.         printf(“p%d:”,i);   
90.         for(j=0;j<RN;j++)   
91.             printf(“%d “,Allocation[i][j]);   
92.         printf(“/n”);   
93.     }   
94.     printf(“各个资源需求矩阵如下:/n”);   
95.     printf(”   A B C/n”);   
96.     for(i=0;i<PN;i++)   
97.     {   
98.         printf(“p%d:”,i);   
99.         for(j=0;j<RN;j++)   
100.             printf(“%d “,Need[i][j]);   
101.         printf(“/n”);   
102.     }   
103.     printf(“可利用资源向量如下:/n”);   
104.     printf(”   A B C/n”);   
105.     printf(”   “);   
106.     for(i=0;i<RN;i++)   
107.     {   
108.         printf(“%d “,Available[i]);   
109.     }      
110.     printf(“/n”);   
111. }   
112.   
113. /*银行家算法函数的定义*/  
114. int Banker(int i,int p[])   
115. {   
116.     int Available[RN]={3,3,2};//可利用资源向量   
117.     int Allocation[PN][RN]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//分配矩阵，表示当前系统中每一个进程获得的   
118.                                                             //的每一类资源数目   
119.     int Need[PN][RN]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};//表示一个进程上需要的各类资源的数目     
120.     int Requist[RN];   
121.     for(int m=0;m<RN;m++)   
122.     {   
123.         Requist[m]=p[m];   
124.     }   
125.     int j;   
126.     bool flag1=1;//   
127.     bool flag2=1;   
128.     bool flag3=1;   
129.     for(j=0;j<RN;j++)   
130.     {   
131.         if(Requist[j]>Need[i][j])   
132.         {   
133.             flag1=0;   
134.             printf(“进程%d需要的资源已超过它宣布的最大值!”,i);   
135.             break;   
136.         }   
137.     }   
138.     if(flag1)   
139.     {   
140.         for(j=0;j<RN;j++)   
141.         {   
142.             if(Requist[j]>Available[j])   
143.             {   
144.                 flag2=0;   
145.                 printf(“没有足够的资源，进程%d必须等待。”,i);   
146.                 break;   
147.             }   
148.         }   
149.         if(flag2)   
150.         {   
151.             for(j=0;j<RN;j++)//系统试探着把资源分配给进程i   
152.             {   
153.                 Available[j]=Available[j]-Requist[j];   
154.                 Allocation[i][j]=Allocation[i][j]+Requist[j];   
155.                 Need[i][j]=Need[i][j]-Requist[j];   
156.             }   
157.             flag3=Security(Available,Need,Allocation);//执行安全性检查，当第i个进程发出请求后，如果分配给它它所要的资源，系统是否处于安全状态   
158.             if(flag3)//如果系统处于安全状态，banker()返回1,正式将资源分配给进程i   
159.             {   
160.                 return 1;   
161.             }   
162.             else  
163.             {   
164.                 //系统处于不安全状态,先将本次的试探分配作废，恢复到原来的资源分配状态   
165.                 for(j=0;j<RN;j++)   
166.                 {   
167.                     Available[j]=Available[j]+Requist[j];   
168.                     Allocation[i][j]=Allocation[i][j]-Requist[j];   
169.                     Need[i][j]=Need[i][j]+Requist[j];      
170.                 }   
171.             }   
172.         }   
173.     }   
174.     return 0;   
175. }    
176.   
177. /*安全性检查算法函数的定义*/  
178. bool Security(int Available[],int Need[][RN],int Allocation[][RN])   
179. {   
180.     int bian;   
181.     bool flag1,flag2;   
182.     flag1=true;   
183.     int m,n;   
184.     int Work[RN];   
185.     for(m=0;m<RN;m++)   
186.     {   
187.         Work[m]=Available[m];   
188.     }   
189.     bool Finish[PN]={0,0,0,0,0};   
190.     while(flag1)   
191.     {   
192.         bian=0;   
193.         for(m=0;m<PN;m++)   
194.         {   
195.             flag2=true;   
196.             if(!Finish[m])   
197.             {   
198.                 for(n=0;n<RN;n++)   
199.                 {   
200.                     if(Need[m][n]>Work[n])   
201.                     {   
202.                         flag2=0;   
203.                         break;   
204.                     }   
205.                 }   
206.                 if(flag2)   
207.                 {   
208.                     bian=1;   
209.                     for(n=0;n<RN;n++)   
210.                     {   
211.                         Work[n]=Work[n]+Allocation[m][n];   
212.                     }   
213.                     printf(“p%d/t”,m);   
214.                     Finish[m]=true;   
215.                 }   
216.             }   
217.         }   
218.         if(bian==0)   
219.         {   
220.             flag1=0;   
221.         }   
222.     }   
223.     return 1;   
224. }