操作系统 银行家算法

是一个避免死锁（Deadlock）的著名算法，它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。

 

1).银行家算法中的数据结构

      (1).可利用资源向量Available

      (2).最大需求矩阵Max

      (3).分配矩阵Allocation

      (4).需求矩阵Need

2).银行家算法

Request请求向量，

     (1).如果Request[i] <= Need[i][j]转下步，否则它所需要的资源数已超过它所需要的最大值

     (2).如果Request[i] <= Available[i][j]转下步，否则尚无足够资源，进程需等待  

     (3).系统试分配给进程p,并修改Available,Allocation和Need

                   Available[j] -= Request[j]

                   Allocation[i][j] += Request[j]

                   Need[i][j] -= Request[j]

     (4)系统执行安全性算法，检查此次资源分配后系统是否处于安全状态.若安全，才正式分配；否则恢复原来的分配状态，让该进程等待

3).安全性算法

    (1).设置两个向量,工作向量Work,在执行安全性算法开始时 Work=Available;Finish:表示有足够的资源分配给进程，使之运行完成,Finish[i]=false;当有足够资源分配给进程时，再另Finish[i]=false

   (2).从进程集合中找到一个满足该条件的进程:

           Finish[i]=false

           Need[i][j] <= Work[j]

   (3).当进程获得资源后，可顺利执行，并修改Work向量和Finsh向量

          Work[i] += Allocation[i][j]

          Finish[i]=true

   (4).如果所有进程的Finish[i]=true说明系统处于安全状态，否则系统处于不安全状态.

#include<stdio.h>
#include <stdlib.h>
#include <string>
typedef struct process * proc;
typedef struct system * sys;

static int cur_resource = 3;



struct process{
	int process_id;
	int resource_num;
	int * Max;
	int * Allocation;
	int * Need;
	int * request;
	int Finish;
	int flag;
};


struct system{
	int resource_num;
	int * Available;
};


void scanf_num(int * li,int n){
	int i;
	for(i=0;i<n;i++){
		printf("输入第%d类资源数\n",i+1);
		scanf("%d",li);
		li ++;
	}
}

sys create_system(){
	system("cls");
	sys new_sys = (sys)malloc(sizeof(struct system));
	new_sys->resource_num = cur_resource;
	new_sys->Available = (int * )malloc((new_sys->resource_num) * sizeof(int));
	printf("输入系统拥有资源\n"); 
	scanf_num(new_sys->Available,new_sys->resource_num);
	return new_sys;
}

proc create_process(){
	system("cls");
	int i;
	proc new_process = (proc)malloc(sizeof(struct process));
	printf("输入进程编号\n");
	scanf("%d",&new_process->process_id);
	new_process->resource_num = cur_resource;
	new_process->Max = (int * )malloc((new_process->resource_num) * sizeof(int));
	printf("输入进程可执行资源数量\n");
	scanf_num(new_process->Max,new_process->resource_num);
	new_process->Allocation = (int * )malloc((new_process->resource_num) * sizeof(int));
	printf("输入进程拥有资源数量\n");
	scanf_num(new_process->Allocation,new_process->resource_num);
	new_process->Need = (int * )malloc((new_process->resource_num) * sizeof(int));
	for(i=0;i<new_process->resource_num;i++){
		new_process->Need[i] = new_process->Max[i] - new_process->Allocation[i];
	}
	new_process->Finish = 0;
	new_process->flag = 0;
	new_process->request = (int * )malloc((new_process->resource_num) * sizeof(int));	
	return new_process;
}


sys deep_copy_system(sys d1){
	int i;
	sys new_sys = (sys)malloc(sizeof(struct system));
	new_sys->resource_num = d1->resource_num;
	new_sys->Available = (int * )malloc((new_sys->resource_num) * sizeof(int));
	for(i=0;i<d1->resource_num;i++){
		new_sys->Available[i] = d1->Available[i];
	}
	return new_sys;
}


proc deep_copy_process(proc p1){
	int i;
	proc new_process = (proc)malloc(sizeof(struct process));

	new_process->process_id = p1->process_id;
	new_process->resource_num = p1->resource_num;
	new_process->Max = (int * )malloc((new_process->resource_num) * sizeof(int));
	for(i=0;i<p1->resource_num;i++){
		new_process->Max[i] = p1->Max[i];
	}
	new_process->Allocation = (int * )malloc((new_process->resource_num) * sizeof(int));
	for(i=0;i<p1->resource_num;i++){
		new_process->Allocation[i] = p1->Allocation[i];
	}
	
	new_process->Need = (int * )malloc((new_process->resource_num) * sizeof(int));
	for(i=0;i<new_process->resource_num;i++){
		new_process->Need[i] = new_process->Max[i] - new_process->Allocation[i];
	}
	new_process->Finish = p1->Finish;
	new_process->flag = p1->flag;
	new_process->request = (int * )malloc((new_process->resource_num) * sizeof(int));	
	for(i=0;i<p1->resource_num;i++){
		new_process->request[i] = p1->request[i];
	}
	return new_process;
}










void show_process_and_system(sys system,proc proc_list[],int process_num){
	int i,j,k;
	printf("|----------------------|--------------------------|--------------------------|--------------------------|--------------------------|\n");
	printf("|        进程名        |            MAX           |          Allocation      |        Need              |        available         |\n");
	for(j=0;j<process_num;j++)
	{
		printf("  \t P%d \t  ",proc_list[j]->process_id);
		for(k=0;k<3;k++){
			printf("     ");
			if(k==0){
				for(i=0;i<proc_list[j]->resource_num;i++){
						printf("    %d   ",proc_list[j]->Max[i]);
					}
					}
			if(k==1){
				for(i=0;i<proc_list[j]->resource_num;i++){
						printf("    %d   ",proc_list[j]->Allocation[i]);
					}
			}
			if(k==2){
				for(i=0;i<proc_list[j]->resource_num;i++){
						printf("    %d   ",proc_list[j]->Need[i]);
					}
			}
		}
		printf("\n");
	}
	printf("                                                                                                            ");
	for(k=0;k<system->resource_num;k++){
		printf("    %d   ",system->Available[k]);
	}
	printf("\n");
	printf("|----------------------|--------------------------|--------------------------|--------------------------|--------------------------|\n");
}


void menu(){
	printf("1：输入编号 进行请求\n");
	printf("2：            \n");
	printf("0：退出\n");
}



proc serach_process(proc proc_list[255],int process_num,int proceess_id){
	int i;
	for(i=0;i<process_num;i++){
		if(proc_list[i]->process_id==proceess_id){
			return proc_list[i];
		}
	}
	return NULL;
}




bool intchkerr(proc p_test,proc p_test_list[255],int p_num,sys s_test){
	int i,j;
	int secure_array[p_num];
	int secure_count=0;
	int flag=1;
	int all_finish=0;
	int first_flag=0; 
	while(1){
		for(i=0;i<p_num;i++){
			if(p_test_list[i]->Finish==0){
				flag =1;
				for(j=0;j<p_test_list[i]->resource_num;j++){
					if(p_test_list[i]->Need[j] <= s_test->Available[j]){
						flag=1;
						first_flag=1;
					}else{
						flag=0;
						first_flag=0;
						break;
					}
				}
				if(flag){
					for(j=0;j<s_test->resource_num;j++){
						s_test->Available[j] = s_test->Available[j] + p_test_list[i]->Allocation[j];
					}
					secure_array[secure_count] = p_test_list[i]->process_id;
					secure_count = secure_count + 1;
					p_test_list[i]->Finish = 1;
				}
			}
		}
		
		
		//printf("执行了");
		for(i=0;i<p_num;i++){
			if(p_test_list[i]->Finish==1){
				all_finish = 1;
			}else{
				all_finish = 0;
				break;
			}
		}
		if(all_finish){
			printf("安全序列为");
			for(i=0;i<p_num;i++){
				printf("P%d -->",secure_array[i]);
			}
			printf("\n");
			return 1;
		}
		
		if(all_finish==0 && first_flag==0){
			printf("无安全序列");
			printf("\n");
			return 0;
		}
	}
}











bool Banker(proc p1,proc proc_list[255],int process_num,sys system_mod){
	int i;
	sys system_test;
	proc process_test;
	proc temp;
	proc temp2;
	proc proc_list_test[255];
	
	for(i=0;i<p1->resource_num;i++){
		if(p1->request[i]>p1->Need[i]){
			printf("出错 所需要的资源超过所宣布的最大值\n");
			return 0;
		}
	}
	
	
	for(i=0;i<p1->resource_num;i++){
		if(p1->request[i]>system_mod->Available[i]){
			printf("出错 尚无足够资源\n");
			return 0;
		}
	}
	//printf("开始拷贝");
	system_test = deep_copy_system(system_mod);
	process_test = deep_copy_process(p1);
	

	
	for(i=0;i<process_num;i++){
		temp2 = proc_list[i];
		temp = deep_copy_process(temp2);
		proc_list_test[i] = temp;
	}
	
	
	
	
	
	
	
	
	
	for(i=0;i<process_test->resource_num;i++){
		system_test->Available[i] = system_test->Available[i] - process_test->request[i];
		process_test->Allocation[i] = process_test->Allocation[i] + process_test->request[i];
		process_test->Need[i] = process_test->Need[i] - process_test->request[i];
	}
	for(i=0;i<process_num;i++){
		if(proc_list_test[i]->process_id==process_test->process_id){
			proc_list_test[i] = process_test;
		}
	}
	//printf("进行安全性检查");
	if(intchkerr(process_test,proc_list_test,process_num,system_test)){
		return 1;
	}else{
		return 0;
	}
			
	
}






void menu_1(sys system_mod,proc proc_list[255],int process_num){
	system("cls");
	show_process_and_system(system_mod,proc_list,process_num);
	int process_id_in;
	proc user_serach_proc=NULL;
	int i;
	printf("输入进程编号\n");
	scanf("%d",&process_id_in);
	user_serach_proc = serach_process(proc_list,process_num,process_id_in);
	if(user_serach_proc){
		printf("输入需要的资源\n");
		scanf_num(user_serach_proc->request,user_serach_proc->resource_num);
		if(Banker(user_serach_proc,proc_list,process_num,system_mod)){
			printf("安全!!!  本次分配成功!!!\n");
		}else{
			printf("不安全!!!本次资源申请不成功!!!\n");
		}
	}else{
		printf("无此进程\n");
	}
	system("pause");
}














int main(){
	int process_num;
	int i;
	int user_input;
	proc proc_list[255];
	printf("输入资源个数\n");
	scanf("%d",&cur_resource);
	sys system_mod = create_system();
	proc proc1 = NULL;
	printf("输入进程数量\n");
	scanf("%d",&process_num); 
	for(i=0;i<process_num;i++){
		proc1 = create_process();
		proc_list[i] = proc1;
	}
	while(1){
		system("cls");
		show_process_and_system(system_mod,proc_list,process_num);
		menu();
		scanf("%d",&user_input);
		if(user_input==1){
			menu_1(system_mod,proc_list,process_num);
		}
		else if(user_input==0){
			break;
		}else{
			continue;
		}
	}
	
	return 0;
}