操作系统课程设计-银行家算法

银行家算法实现
本文介绍了一个基于银行家算法的资源分配程序实现。该程序通过随机生成进程的最大需求矩阵和已分配资源矩阵,并进行一系列资源分配操作,判断系统是否处于安全状态。此外,还实现了进程资源请求的功能。

选了这个题目的同学有福了,可以参考一下~~~

有一些注释……?

另外……如果执行结果是乱码,把#define N 40改为更大的数。

多说一句:如果真的有帮助,麻烦给个评论再走呗~~~

  1 #include <iostream>
  2 #include <cstring>
  3 #include <cstdlib>
  4 #include <ctime> 
  5 #define N 40 
  6 #define MM "Max_Matrix.txt"
  7 #define AM "Allocation_Matrix.txt"
  8 using namespace std;
  9 typedef struct Banker{
 10     int Max[N][N];
 11     int Allocation[N][N];
 12     int Need[N][N];
 13     int Availiable[N][N];
 14     int Work[N][N];
 15     int All_Resource[N][N];
 16     int Safe_Sequel[N];
 17     bool Visited[N][N];
 18     bool Finish[N][N];
 19     int Request[N];
 20 }BK;
 21 void Create_Random_Progress(){
 22     FILE *fp1,*fp2;
 23     fp1=fopen(MM,"w+");
 24     fp2=fopen(AM,"w+");
 25     if(fp1&&fp2){
 26         system("cls");
 27         cout<<"开始初始化进程……"<<endl;    
 28         int number;
 29         srand((unsigned) time(NULL)); //用时间做种,每次产生随机数不一样
 30         char Space=' ';
 31         char Enter='\n';
 32         for (int i=1; i<28; i++){
 33             number = rand() % 7; //产生0-6随机数
 34             fprintf(fp1,"%d",number);
 35             if(i%3!=0&&i!=1)
 36                 fprintf(fp1,"%c",Space);
 37             if(i%3==0)
 38                 fprintf(fp1,"%c",Enter);
 39             if(i==1)
 40                 fprintf(fp1,"%c",Space);
 41         }
 42         for (int i=1; i<28; i++){
 43             number = rand() % 7; //产生0-6的随机数
 44             fprintf(fp2,"%d",number);
 45             if(i%3!=0&&i!=1)
 46                 fprintf(fp2,"%c",Space);
 47             if(i%3==0)
 48                 fprintf(fp2,"%c",Enter);
 49             if(i==1)
 50                 fprintf(fp2,"%c",Space);
 51         }
 52         cout<<"初始化完成。"<<endl;
 53     }
 54     else
 55         cout<<"出现错误,请检查磁盘剩余空间。"<<endl;
 56     fclose(fp1);
 57     fclose(fp2);
 58 }
 59 void Banker_Get_Matrix_Max(){
 60     Banker b;
 61     FILE *fp;
 62     fp=fopen(MM,"r");
 63     int a;
 64     int i=1;
 65     while(i<5){
 66         for(int j=1;j<4;j++){
 67             if(fscanf(fp,"%d",&a)!=EOF)
 68                 b.Max[i][j]=a;
 69             }
 70         i++;
 71     }
 72     fclose(fp);
 73 }
 74 void Banker_Get_Matrix_Allocation(){
 75     Banker b;
 76     FILE *fp;
 77     fp=fopen(AM,"r");
 78     int a;
 79     int i=1;
 80     while(i<5){
 81         for(int j=1;j<4;j++){
 82             if(fscanf(fp,"%d",&a)!=EOF)
 83                 b.Allocation[i][j]=a;
 84             }
 85         i++;
 86     }
 87     fclose(fp);
 88 }
 89 void Banker_Get_Matrix_Completed(){
 90     Banker b;
 91     for(int i=1;i<5;i++)
 92         for(int j=1;j<4;j++){
 93             while(b.Max[i][j]-b.Allocation[i][j]<0)
 94                 b.Allocation[i][j]--;
 95         }
 96 }
 97 void Banker_Get_Matrix_Need(){
 98     Banker b;
 99     for(int i=1;i<5;i++)
100         for(int j=1;j<4;j++)
101             b.Need[i][j]=b.Max[i][j]-b.Allocation[i][j];
102 }
103 void Banker_Print_InitList(){
104     Banker b; 
105     printf("进程号    最 大 需 求 量 Max    已分配资源Allocation\n");
106     for(int i=1;i<5;i++){
107         cout<<"  "<<i<<"\t";
108         for(int j=1;j<4;j++)
109             cout<<b.Max[i][j]<<"    "; 
110         for(int j=1;j<4;j++){
111             cout<<b.Allocation[i][j]<<"    ";
112             if(j%3==0)
113                 cout<<endl;    
114         }
115     }
116 }
117 void Banker_Rest_Resource(){
118     Banker b;
119     cout<<"请输入此时系统可用资源向量:";
120     for(int i=1;i<4;i++)
121         cin>>b.Availiable[1][i];
122 }
123 void Banker_Get_All_Resource(){
124     Banker b;
125     int t=0;
126     for(int i=1;i<4;i++)
127         for(int j=1;j<5;j++){
128             t+=b.Allocation[j][i];
129             if(j%4==0){
130                 b.All_Resource[1][i]=t;
131                 t=0;    
132             }
133         }
134     for(int i=1;i<4;i++)
135         b.All_Resource[1][i]+=b.Availiable[1][i];
136     cout<<"系统资源向量总数:("; 
137     for(int i=1;i<4;i++){
138         cout<<b.All_Resource[1][i];
139         if(i<3)
140             cout<<",";
141     }
142     cout<<")"<<endl;
143 }
144 void Banker_Print_Need(){
145     Banker b;
146     cout<<"进程对资源的需求矩阵:"<<endl;
147     for(int i=1;i<5;i++)
148         for(int j=1;j<4;j++){
149             cout<<b.Need[i][j]<<"    ";
150             if(j%3==0) 
151                 cout<<endl;
152         }
153 }
154 /*int Banker_Safety_Algorithm_Test(){
155     Banker b;
156     for(int i=1;i<4;i++)
157         b.Work[1][i]=b.Availiable[1][i];
158     for(int i=1;i<5;i++){
159         int counter=0;
160         for(int j=1;j<4;j++){
161             if(b.Work[1][j]-b.Need[i][j]>=0)
162                 counter++;
163             if(counter==3)
164                 b.Finish[i][j]=true;
165         }
166     }    
167     int t=0;
168     for(int i=1;i<5;i++)
169         if(b.Finish[i][j]==true)
170             t++;
171     if(t==0){
172         cout<<"没有任何资源能让这些任务执行完成。"<<endl;
173         return 0;    
174     }else
175         return 1;
176 }*/
177 int Banker_Safety_Algorithm(){//int test
178     Banker b;
179     memset(b.Finish,false,sizeof(b.Finish)); 
180     memset(b.Visited,false,sizeof(b.Visited));
181     memset(b.Safe_Sequel,0,sizeof(b.Safe_Sequel));
182 //    if
183 //    if(test==0)
184 //        return 0;
185     int res=1;
186     for(int i=1;i<4;i++)
187         b.Work[1][i]=b.Availiable[1][i];
188     for(int r=1;r<5;r++){
189         for(int i=1;i<5;i++){
190             int counter=0;
191             for(int j=1;j<4;j++){
192                 if(b.Work[1][j]-b.Need[i][j]>=0)
193                     counter++;
194                 if(counter==3)
195                     b.Finish[i][j]=true;
196                 if(b.Finish[i][3]==true&&b.Visited[i][3]==false){
197                     for(int k=1;k<4;k++){
198                         b.Work[1][k]+=b.Allocation[i][k];
199                         b.Visited[i][3]=true;
200                         
201                     }
202                 b.Safe_Sequel[res]=i;
203                 res++;    
204                 }
205             }
206         }
207     }
208     int safe=1;
209     for(int i=1;i<5;i++)
210         if(b.Finish[i][3])
211             safe++;
212     if(safe==5){
213         cout<<"至少存在安全序列:";
214         for(int i=1;i<safe;i++)
215             cout<<b.Safe_Sequel[i]<<"\t";
216         cout<<"可使进程安全执行完毕。"<<endl;
217         return 1; 
218     }else
219         cout<<"系统资源不足。"<<endl;
220     return 0;    
221 }
222 /*    for(int i=1;i<5;i++){
223             for(int j=1;j<4;j++)
224                 
225                 }*/
226 //    }
227 void Banker_Get_Request(){
228     Banker b;
229     int n;
230     cout<<"请输入要申请资源的进程号和申请的各项资源数量:";
231     cin>>n;
232     for(int i=1;i<4;i++){
233         cin>>b.Request[i];
234         b.Need[n][i]+=b.Request[i];
235     }
236 }
237 int main()
238 {
239     int n;
240     char ch='y';
241     while(ch=='y'){
242         Create_Random_Progress();
243         Banker_Get_Matrix_Max();
244         Banker_Get_Matrix_Allocation();
245         Banker_Get_Matrix_Completed();
246         Banker_Get_Matrix_Need();
247         Banker_Print_InitList();
248         Banker_Rest_Resource();
249         Banker_Get_All_Resource();
250         Banker_Print_Need();
251         if(Banker_Safety_Algorithm()){
252             Banker_Get_Request();
253             Banker_Print_Need();
254             Banker_Safety_Algorithm();
255         }else
256             cout<<"系统资源不足,禁止申请。"<<endl;
257         cout<<"您还要做什么事情吗?"<<endl;
258         ch=getchar();
259         ch=getchar();
260         system("cls");
261     }
262     cout<<"再见。"<<endl;
263     return 0;
264 }

 

转载于:https://www.cnblogs.com/ArtistofCodeMartial/p/8490974.html

设计一个n个并发进程共享m个系统资源的程序以实现银行家算法。要求: 1) 简单的选择界面; 2) 能显示当前系统资源的占用和剩余情况。 3) 为进程分配资源,如果进程要求的资源大于系统剩余的资源,不与分配并且提示分配不成功; 4) 撤销作业,释放资源。 编写和调试一个系统动态分配资源的简单模拟程序,观察死锁产生的条件,并采用适当的算法,有效地防止和避免死锁的发生。 银行家算法分配资源的原则是:系统掌握每个进程对资源的最大需求量,当进程要求申请资源时,系统就测试该进程尚需资源的最大量,如果系统中现存的资源数大于或等于该进程尚需求资源最大量时,就满足进程的当前申请。这样就可以保证至少有一个进程可能得到全部资源而执行到结束,然后归还它所占有的全部资源供其它进程使用。 银行家算法中的数据结构 (1)可利用资源向量Available(一维数组) 是一个含有m个元素,其中的每一个元素代表一类可利用的资源数目,其初值是系统中所配置的该类全部可用资源数目。如果Available[j]=k, 表示系统中现有Rj类资源k个。 (2)最大需求矩阵Max(二维数组) m的矩阵,它定义了系统中n个进程中的每一个进程对m类资源的最大需求。如果Max(i,j)=k, 表示进程i需要Rj类资源的最大数目为k。 (3)分配矩阵Allocation(二维数组) m的矩阵,它定义了系统中每一类资源当前已分配给每一进程的资源数。如果Allocation(i,j)=k, 表示进程i当前已分得Rj类资源k个。 (4)需求矩阵Need (二维数组) 是一个含有n*m的矩阵,用以表示每一个进程尚需的各类资源数。如果Need(i,j)=k, 表示进程i还需要Rj类资源k个,方能完成其任务。 Need(i,j)= Max(i,j)-Allocation(i,j)
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值