操作系统考试老师出了两道题,一个是先进先出,另一个是银行家算法,题目如下

1.请使用FCFS算法模拟进程调度。假设系统有n (n>=2) 个进程,给定进程的到达时间以及需要执行的时间长短,给出相应的执行顺序。数据以文件方式给出,文件名为data.fcfs,格式为:

文件共n(N1…Nn)行.

在Nn行中有三个数据,第n个进程的进程名,到达时间,执行时间

请根据给定数据,输出进程执行顺序到文件out.fcfs中。

输出共n行 : 根据进程执行顺序,每一行输出进程名,进程开始时间,结束时间三项(空格隔开)。

 

2 . 银行家算法是避免死锁的常用算法。假设系统有m(m>=2)种资源,n个并发进程。给定当前时刻进程-资源关系,对某个进程提出的资源请求,银行家算法判断是否可以满足该请求,如果能够满足,给出安全序列。
要求根据给定进程-资源关系模拟实现银行家算法,给出安全序列。 

给定进程-资源关系格式文件data.dijkstra: 

第一行为资源数m(m>=2).

第二行为并发进程数n(N1,N2,N3…Nn).

第三行代表可利用资源向量,有m个数,为m种资源每一个的可利用资源数(m1,m2,m3…)

之后有n(N1,N2,N3…Nn)行,每一行有一个进程名以及2*m个数,前m个代表Nn这个进程对m类资源的最大需求数, 后m个代表进程对m类资源的分配数.

最后一行为资源请求,共m+1个数,第一个数k代表进程Nk,后m个数代表进程Nk请求m种资源的数量。

请根据给定数据,输出进程Nk请求资源之后的安全序列到文件out.dijkstra中,若不满足安全状态则输出Failed。

输出格式 :  进程名N1 进程名N2 …  (中间用空格隔开)

 

1:第一道题的输入数据是这样子的

实现银行家算法和先进先出算法_对文件读写数据_#include

代码如下

1 #include<bits/stdc++.h>
2 #include<fstream>
3 using namespace std;
4 int main()
5 {
6 int line=0;
7 char a[100];//进程名称
8 int start[100];//到达时间
9 int time[100];//持续时间
10 int len=0;
11 ifstream fin("D:/data.fcfs");
12 ofstream fout("D:/data1.fcfs");
13 if(!fin || !fout){
14 cout << "wrong" << endl;
15 }
16 while(fin){
17 fin >> a[line] >> start[line] >> time[line];
18 line++;
19
20 }
21 int array[line];
22 memset(array,0,sizeof(array));
23 for(int i=0;i<line-1;i++){//根据start数组得到从小到大的一种进程序号,先来先服务
24 int min=1000;
25 int tip=-1;
26 for(int j=0;j<line-1;j++){
27 if(start[j]<min && array[j]==0){
28 min =start[j];
29 tip=j;
30 }
31 }
32 array[tip]=-1;
33 if(i==0){
34 fout<<a[tip] <<"\t"<<start[tip] << "\t" << start[tip]+time[tip] << "\n";
35 len=start[tip];
36 len+=time[tip];
37 }else{
38 fout<<a[tip] <<"\t"<<len << "\t" << len+time[tip] << "\n";
39 len+=time[tip];
40 }
41 }
42 fin.close();
43 fout.close();
44 return 0;
45 }
1 #include<bits/stdc++.h>
2 using namespace std;
3
4 int main()
5 {
6 freopen("D:/data.fcfs","r",stdin);
7 freopen("D:/data1.fcfs","w",stdout);
8 int line=0;
9 char a[100];
10 int start[100];
11 int time[100];
12 int array[100];
13 int len=0;
14 memset(array,0,sizeof(array));
15 for(int i=0;i<5;i++){
16 cin >> a[i] >> start[i] >> time[i];
17 }
18 for(int i=0;i<5;i++){
19 int min=1000;
20 int tip=-1;
21 for(int j=0;j<5;j++){
22 if(start[j]<min && array[j]==0){
23 min=start[j];
24 tip=j;
25 }
26 }
27 array[tip]=-1;
28 if(i==0){
29 cout<<a[tip] <<"\t"<<start[tip] << "\t" << start[tip]+time[tip] << "\n";
30 len=start[tip];
31 len+=time[tip];
32 }else{
33 if(len<start[tip]){
34 len=start[tip];
35 cout << len <<" " << len+time[tip] <<"\n";
36 len+=time[tip];
37 }else{
38 cout<<a[tip] <<"\t"<<len << "\t" << len+time[tip] << "\n";
39 len+=time[tip];
40 }
41 }
42 }
43 return 0;
44 }

 

输出到文件data1.fcfs

实现银行家算法和先进先出算法_对文件读写数据_i++_02

 

2:第二道题数据如下

 实现银行家算法和先进先出算法_对文件读写数据_i++_03

代码

 

1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <conio.h>
4 #include<fstream>
5 #include<iostream>
6 using namespace std;
7 # define m 50
8 int no1; //进程数
9 int no2; //资源数
10 int r;
11 ofstream fout("D:\\out.dijkstra");
12 int allocation[m][m],need[m][m],available[m],max1[m][m];
13 char name1[m],name2[m];
14 char d[5];
15 //={'A','B','C','D','E'} //定义全局变量
16 void check() //安全算法函数
17 {
18 int k,f,v=0,i,j;
19 int work[m],a[m];
20 bool finish[m];
21 r=1;
22 for(i=0;i<no1;i++)
23 finish[i]=false; // 初始化进程均没得到足够资源数并完成
24 for(i=0;i<no2;i++)
25 work[i]=available[i];//work[i]表示可提供进程继续运行的各类资源数
26 k=no1;
27 do{
28 for(i=0;i<no1;i++)
29 {
30 if(finish[i]==false)
31 {
32 f=1;
33 for(j=0;j<no2;j++)
34 if(need[i][j]>work[j])
35 f=0;
36 if(f==1) //找到还没有完成且需求数小于可提供进程继续运行的资源数的进程
37 {
38 finish[i]=true;
39 a[v++]=i; //记录安全序列号
40 for(j=0;j<no2;j++)
41 work[j]+=allocation[i][j]; //释放该进程已分配的资源
42 }
43 }
44 }
45 k--; //每完成一个进程分配,未完成的进程数就减1
46 }while(k>0);
47 f=1;
48 for(i=0;i<no1;i++) //判断是否所有的进程都完成
49 {
50 if(finish[i]==false)
51 { f=0;
52 break;
53 }
54 }
55 if(f==0) //若有进程没完成,则为不安全状态
56 {
57 printf("系统处在不安全状态!");
58 fout<<"Failed"<<endl;
59 r=0;
60 }
61 else{
62 printf("\n系统当前为安全状态,安全序列为:\n");
63 for(i=0;i<no1;i++)
64 {
65 //printf("p%d ",a[i]); //输出安全序列
66 cout<<d[a[i]]<<" ";
67 fout<<d[a[i]]<<" ";
68 }
69 fout<<endl;
70 }
71 }
72 void print() //输出函数
73 {
74 int i,j;
75 printf("\n");
76 printf("*************此时刻资源分配情况*********************\n");
77 printf("进程名/号 | Max | Allocation | Need |\n");
78 for (i = 0; i < no1; i++)
79 {
80 //printf(" p%d ",i);
81 cout<<" "<<d[i]<<" ";
82 for (j = 0; j < no2; j++)
83 {printf("%d ",max1[i][j]);}
84
85 for (j = 0; j < no2; j++)
86 {printf(" %d ",allocation[i][j]);}
87
88 for (j = 0; j < no2; j++)
89 {printf(" %d ",need[i][j]);}
90
91 printf("\n");
92 }
93 printf("\n");
94 printf("各类资源可利用的资源数为:");
95 for (j = 0; j < no2; j++)
96 {printf(" %d",available[j]);}
97 printf("\n");
98 }
99 int main(void)
100 {
101 void check();
102 void print();
103 int i,j,p=0,q=0;
104 char c;
105 //ofstream fout("D:\\out.dijkstra",ios::out);
106 ifstream fin("D:\\data.dijkstra");
107 int request[m],allocation1[m][m],need1[m][m],available1[m];
108 printf("\t\t**********************************************\n");
109 printf("\t\t* 银行家算法的设计与实现 *\n");
110 printf("\t\t**********************************************\n");
111 printf("请输入资源种类数:\n");
112 //scanf("%d",&no2);
113 //fscanf(fin,"%d",&no2);
114 fin>>no2;//3
115 printf("请输入进程总数:\n");
116 //scanf("%d",&no1);
117 //fscanf(fin,"%d",&no1);
118 fin>>no1;//5
119 printf("请输入Available矩阵\n");
120 for(i=0;i<no2;i++)
121 fin>>available[i];
122 //fscanf(fin,"%d",&available[i]); //输入已知的可用资源数
123 printf("请输入Max矩阵:\n");
124 printf("请输入Allocation矩阵:\n");
125 for(i=0;i<no1;i++)
126 {
127 fin>>d[i];
128 for(j=0;j<2*no2;j++)
129 {
130 if(j<no2)
131 fin>>max1[i][j];
132 else
133 fin>>allocation[i][j-3];
134 }
135 }
136 //fscanf(fin,"%d",&max1[i][j]);
137 //输入已知进程最大资源需求量
138 /*printf("请输入Allocation矩阵:\n");
139 for(i=0;i<no1;i++)
140 for(j=0;j<no2;j++)
141 fin>>allocation[i][j];
142 //fscanf(fin,"%d",&allocation[i][j]); //输入已知的进程已分配的资源数*/
143 for(i=0;i<no1;i++)
144 for(j=0;j<no2;j++)
145 need[i][j]=max1[i][j]-allocation[i][j]; //根据输入的两个数组计算出need矩阵的值
146
147 print(); //输出已知条件
148 check(); //检测T0时刻已知条件的安全状态
149
150 // if(r==1) //如果安全则执行以下代码
151 // {
152 // do{
153 // q=0;
154 // p=0;
155 // printf("\n请输入请求资源的进程号(0~4):\n");
156 // for(j=0;j<=10;j++)
157 // {
158 // //fscanf(fin,"%d",&i);
159 // fin>>i;
160 // i--;
161 // if(i>=no1)
162 // {
163 // printf("输入错误,请重新输入:\n");
164 // continue;
165 // }
166 // else break;
167 // }
168 // printf("\n请输入该进程所请求的资源数request[j]:\n");
169 // for(j=0;j<no2;j++)
170 // //scanf("%d",&request[j]);
171 // fin>>request[j];
172 // for(j=0;j<no2;j++)
173 // if(request[j]>need[i][j]) p=1;
174 // //判断请求是否超过该进程所需要的资源数
175 // if(p)
176 // {
177 // printf("请求资源超过该进程资源需求量,请求失败!\n");
178 // fout<<"Failed"<<endl;
179 // }
180 // else
181 // {
182 // for(j=0;j<no2;j++)
183 // if(request[j]>available[j]) q=1;
184 // //判断请求是否超过可用资源数
185 // if(q)
186 // {
187 // printf("没有做够的资源分配,请求失败!\n");
188 // fout<<"Failed"<<endl;
189 // }
190 // else //请求满足条件
191 // {
192 // for(j=0;j<no2;j++)
193 // {
194 // available1[j]=available[j];
195 // allocation1[i][j]=allocation[i][j];
196 // need1[i][j]=need[i][j];
197 // //保存原已分配的资源数,仍需要的资源数和可用的资源数
198 //
199 // available[j]=available[j]-request[j];
200 // allocation[i][j]+=request[j];
201 // need[i][j]=need[i][j]-request[j];
202 // //系统尝试把资源分配给请求的进程
203 // }
204 // print();
205 // check(); //检测分配后的安全性
206 // if(r==0) //如果分配后系统不安全
207 // {
208 // for(j=0;j<no2;j++)
209 // {
210 // available[j]=available1[j];
211 // allocation[i][j]=allocation1[i][j];
212 // need[i][j]=need1[i][j];
213 // //还原已分配的资源数,仍需要的资源数和可用的资源数
214 // }
215 // printf("返回分配前资源数\n");
216 // print();
217 // }
218 // }
219 // }printf("\n你还要继续分配吗?Y or N ?\n");
220 // //判断是否继续进行资源分配
221 // c=getche();
222 // }while(c=='y'||c=='Y');
223 // }
224 }

结果如下

实现银行家算法和先进先出算法_对文件读写数据_i++_04

因为题目只是判断当前状态的request是否处于安全状态,所以只需把当前状态的结果输出即可,如果继续求每个进程的request是否可以分配,只需把注释打开,稍微调一下代码

作者:你的雷哥

本文版权归作者所有,欢迎转载,但未经作者同意必须在文章页面给出原文连接,否则保留追究法律责任的权利。