【避免死锁的银行家算法】操作系统原理与实践教程实验

由于滕艳平所写的《操作系统原理与实践教程》这本书的后面的实验在格式上比较乱，且不容易看懂，所以自己在看懂之后写了代码并且在适当的位置后面给予了注释，同时代码的格式更容易看，希望能够更深入了解一下避免死锁的银行家算法。

为了更快读懂代码，推荐步骤如下：

①、理解避免死锁的银行家算法的算法原理

②、由于这篇代码里面也有c++里面的一些东西，如cout<<, cin>>，具体意思在下面的备注里面，在读代码之前应该知道这是什么。

备注：

①什么是cout<

简单地说cout就像是c语言中的printf，其中<<后面的内容是输出的内容：

如：cout<<"你好";

就是输出‘你好’。

再比如：cout<allocation:";

其中j是变量，所以不用引号。假设j=1。

输出结果是：先换行，然后输出p1->allocation:

②什么是cin>>?

简单地说cin就是c语言里面的scanf。

如：cin>>k;

就是让你输入变量k的值。

总之这2个东西就是输入输出。但是在使用之前必须加

#include 
using namespace std ;

滕艳平这本书是

#include 

但是运行的时候会报错，即使全部代码打一样也会有报错。
比如：
①、main函数中调用的函数被放在了main函数之后也会报错。
②、滕那本书safecheck函数里面有p[i].state=='W'，但是W改成R也对。

如果想深入了解这2个东西，建议查更多详细的资料

/*避免死锁的银行家算法*/ 
#include 
using namespace std ;
struct PCB{
       char state; //进程的状态
       int request; //需求量 
       int max;   //最大需求量 
       int allocation;  //当前已经分配给该进程的资源数量 
};

/*输出每个进程的编号，最大需求量，当前请求量，已分配量和状态*/
void show(struct PCB p[],int av)
{
	int i;
	cout<request:";  //输入当前进程的需求量 
						cin>>p[i].request;
					}while(p[i].request>(p[i].max-p[i].allocation));    //当输入的需求量不符合条件，执行重新输入 
					break;  //当前进程的资源安排好之后，跳出当前循环 
				}
				else
					i++;
			} 
		}
		if(p[i].request<=av){  //判断分配的资源是否小于可获得的总资源个数 
			av=av-p[i].request;  //系统剩余资源减少 
			p[i].allocation=p[i].allocation+p[i].request;
			p[i].request=0;  //置当前进程的需求量为0 
			if(p[i].max==p[i].allocation){
				av=av+p[i].allocation; //完成该进程，释放该进程所占的资源，归还给系统
				p[i].state='E'; //将该进程的状态置为完成状态 
				p[i].allocation=0;
				p[i].request=0;
			}
			j=0;
			while(j<3){
				if((p[j].request<=av)&&(p[j].state=='W')){
					av=av+p[j].allocation;
					p[j].request=0;
					p[j].state='E';
					p[j].allocation=0;
				}
				if((p[j].max=p[i].max)&&(finish[i]==false)){
				work=p[i].allocation+work; //完成该进程，并且归还该进程使用的资源给系统 
				finish[i]=true;  //标志该进程已经完成 
				order[j]=i;    //将该进程的下标加入已经完成的进程的序列中 
				j++;
				if(p[i].state=='R')
					p[i].allocation=temp;   //恢复该进程的资源拥有量值 
			}
		}
		k++;
	}
	for(i=0;i<3;i++)
		if(finish[i]==true)
			f++;   // f用来存放能够顺利完成的进程的个数 ,能够顺利完成的个数加1
	if(f==3){   //所有进程都能够顺利完成，返回true表示这种分配方式安全 
			//showorder(order);
		return true;   
	}
	else   //所有进程不能都顺利完成，返回false表示这种分配方式不安全 
		return false;
}

/* 银行家算法*/ 
void bankallocation(struct PCB p[],int av){
	int k;
	int request;
	int f;
	int i;
	show(p,av);
	while(1){
		request=0;
		k=-1;
		do{
			if(k!=-1)
				cout<NO.:";
				cin>>k;
			}while(p[k].state!='R');
			do{
				cout<request:";
				cin>>request;
			}while(request>(p[k].max-p[k].allocation));
			if(request>av){
				p[k].request=request;
				p[k].state='W';
				break;
			}
			p[k].allocation=p[k].allocation+request;
			av=av-request;
		}while(safecheck(p,av)!=true);
		if(p[k].allocation==p[k].max){
			p[k].state='E';
			av=av+p[k].allocation;
			p[k].allocation=0;
		}
		for(i=0;i<3;i++){
			if((p[i].state=='W')&&(p[i].request<=av)){
				if(safecheck(p,av)==true){
					p[i].allocation=p[i].request+p[i].allocation;
					av=av-p[i].request;
					p[i].request=0;
					p[i].state='R';
					if(p[i].max==p[i].allocation){
						p[i].state='E';
						av=av+p[i].allocation;
						p[i].allocation=0;
					}
				}
				else{
					cout<max:";  //打印：pi->max ,其中i是变量 
         cin>>process[i].max;  //输入一个进程的资源最大需求量 
         if(process[i].max>10){   //如果当前进程的需求量大于系统该资源的最大量 
             cout<allocation:";  
                  cin>>process[i].allocation;//否则输入当前进程对该资源的拥有量 
              }
              while((process[i].allocation>process[i].max)||(available-process[i].allocation<0));  //当输入的进程的拥有量大于了进程需要的最大量
			  																					//  或者大于了系统可提供的最大量，重新执行循环体输入当前进程对该资源的拥有量 
              available=available-process[i].allocation;  //系统中该资源的剩余量（进程对该资源可获得的量）减少 
              process[i].request=0;  // 置该进程的资源需求量为0 
              process[i].state='R';   //置该进程的状态为R 
         }
     }
     show(process,available);
     cout<>i; 
	 } while(!((i==1)||(i==2)));
	 if(i==1){
	 	randomallocation(process,available);
	 }
	 else{
	 	do{
	 		if(safecheck(process,available)==false){
	 			cout<>k; 
				}while((k!=1)&&(k!=2));
				if(k==2){   //执行重置 
					available=10;   //置系统资源为10 
					for(j=0;j<3;j++){   //依次对3个进程执行重置资源拥有量 
						cout<allocation:";
						cin>>process[j].allocation;   //输入当前资源的拥有量 
						available=available-process[j].allocation;  //系统资源量减少（减去刚刚分配的） 
					}
				}
	 		}
	 		else{  //安全性检查结果为安全 
	 			k=0;
	 			break;
	 		}
	 	}while(k==2);
	 	if(k==1) return -1;
	 	else if(k==0)   //如果安全性检查结果为安全，执行银行家算法 
	 		bankallocation(process,available);
	 }	 
}

运行结果：