操作系统实验二—银行家算法

最新推荐文章于 2021-12-10 15:12:39 发布
最新推荐文章于 2021-12-10 15:12:39 发布
阅读量2.4k 收藏 14
点赞数
文章标签： 操作系统 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a508475/article/details/106470541
版权

一、实验目的
1、了解什么是操作系统安全状态和不安全状态；
2、了解如何避免系统死锁；
3、理解银行家算法是一种最有代表性的避免死锁的算法，掌握其实现原理及实现过程。

二、实验内容
根据银行家算法的基本思想，编写和调试一个实现动态资源分配的模拟程序，并能够有效避免死锁的发生。
三、 实验原理
进程申请资源时，系统通过一定的算法判断本次申请是否不可能产生死锁（处于安全状态）。若可能产生死锁（处于不安全状态），则暂不进行本次资源分配，以避免死锁。算法有著名的银行家算法。
1、什么是系统的安全状态和不安全状态？
所谓安全状态，是指如果系统中存在某种进程序列＜P1，P2，…，Pn＞，系统按该序列为每个进程分配其所需要的资源，直至最大需求，则最终能使每个进程都可顺利完成，称该进程序列＜P1，P2，…，Pn，＞为安全序列。
如果不存在这样的安全序列，则称系统处于不安全状态。
2、银行家算法
把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。
为保证资金的安全，银行家规定:
(1) 当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客;
(2) 顾客可以分期贷款，但贷款的总数不能超过最大需求量;
(3) 当银行家现有的资金不能满足顾客尚需的贷款数额时,对顾客的贷款可推迟支付,但总能使顾客在有限的时间里得到贷款;
(4) 当顾客得到所需的全部资金后,一定能在有限的时间里归还所有的资金。

操作系统按照银行家制定的规则设计的银行家算法为：
（1）进程首次申请资源的分配：如果系统现存资源可以满足该进程的最大需求量，则按当前的申请量分配资源，否则推迟分配。
（2）进程在执行中继续申请资源的分配：若该进程已占用的资源与本次申请的资源之和不超过对资源的最大需求量，且现存资源能满足该进程尚需的最大资源量，则按当前申请量分配资源，否则推迟分配。
（3）至少一个进程能完成：在任何时刻保证至少有一个进程能得到所需的全部资源而执行到结束。
银行家算法通过动态地检测系统中资源分配情况和进程对资源的需求情况来决定如何分配资源，并能在确保系统处于安全状态时才把资源分配给申请者，从而避免系统发生死锁。

四.实验程序及结果

#include <stdlib.h>
#include <time.h>
#include<stdio.h>
#define true 1
#define false 0
#define processNum 5
#define resourceNum 3
#define MAXINT 9999
typedef int bool;

int available[resourceNum]={3,3,2};
int maxRequest[processNum][resourceNum]={7,5,3,3,2,2,9,0,2,2,2,2,4,3,3};
int allocation[processNum][resourceNum]={0,1,0,2,0,0,3,0,2,2,1,1,0,0,2};
int need[processNum][resourceNum]={7,4,3,1,2,2,6,0,0,0,1,1,4,3,1};
bool Finish[processNum];
int safeSeries[processNum]={MAXINT, MAXINT , MAXINT , MAXINT , MAXINT};
int request[resourceNum];
bool Finish1[processNum];//已释放进程为true，未释放为false

void randon_init() //随机初始化
{
    int i, j;
    srand((unsigned) (time(NULL))); //随机数
    //scanf("%d %d",&processNum,&resourceNum);
    printf("输入进程数量上限、资源数量上限\n");
    printf("%d    %d",processNum,resourceNum);
    printf("\n当前资源可用数目\n");
    for(i = 0; i < resourceNum; i++){
        available[i] = rand() % 2 + 2;
        printf("%d   ",available[i]);
    }
    printf("\n随机生成最大需求矩阵\n");
    for(i = 0; i < processNum; i++){
        for(j = 0; j < resourceNum; j++){
            maxRequest[i][j] = (rand() % 6 + 2);
            printf("%d   ",maxRequest[i][j]);
        }
        printf("\n");
    }
    printf("随机生成已分配矩阵\n");
    for(i = 0; i < processNum; i++){
        for(j = 0; j < resourceNum; j++){
            allocation[i][j] = rand() % 4 +1;
            if (allocation[i][j] > maxRequest[i][j])
            {
            allocation[i][j] =0;
            }
            printf("%d   ",allocation[i][j]);
        }
        printf("\n");
    }
    printf("当前需求矩阵\n");
    for(i = 0; i < processNum; i++){
        for(j = 0; j < resourceNum; j++){
            need[i][j] = maxRequest[i][j] - allocation[i][j];
           printf("%d   ",need[i][j]);
        }
        printf("\n");
    }
}

void showInfo()
{
    int i,j;
    printf("当前资源剩余：");
    for(j = 0; j < resourceNum; j++){
        printf("%d ",available[j]);
    }
    printf("\n");
    printf(" PID\t Max\t\tAllocation\tNeed\n");
    for(i = 0; i < processNum; i++){
        printf(" P%d\t",i);
        for(j = 0; j < resourceNum; j++){
            printf("%d ",maxRequest[i][j]);
        }
        printf("\t\t");
        for(j = 0; j < resourceNum; j++){
            printf("%d ",allocation[i][j]);
        }
        printf("\t\t");
        for(j = 0; j < resourceNum; j++){
            printf("%d ",need[i][j]);
        }
        printf("\n");
    }
}

bool isSafe()
{
    int i,j,k;
    int trueFinished = 0;
    int work[resourceNum];
    for(i = 0; i < resourceNum; i++){
        work[i]=available[i];
    }

    for(i = 0; i < processNum; i++){
        Finish[i]=false;
    }
    i = 0;
    int temp=0,temp0=0,flag=0;
    

    while(trueFinished != processNum){
        int j =0;
        if(Finish[i]!= true){
            for(j = 0; j < resourceNum; j++){
                if(need[i][j] > work[j]){break;}
            }
        }
        if(j == resourceNum){
            Finish[i]=true;
            SafeInfo(work,i);
            for(k = 0; k < resourceNum; k++){
                work[k]+=allocation[i][k];
            }
            
            safeSeries[trueFinished++] = i;
        }
        i++;
        if(i >= processNum)
        {
        	if(flag==0)
        	{
        		temp=trueFinished;
        		temp0=trueFinished;        		
			}
            i = i % processNum;         
            if(flag==1){
            temp=trueFinished;
            if(temp == temp0)
                break;
            else
            	temp0=temp;
            }        
            flag=1;
        }
        temp = trueFinished;
    }

    if(trueFinished == processNum){
        printf("\n系统安全！\n\n安全序列为：");
        for(i = 0; i < processNum; i++){
            printf("%d ",safeSeries[i]);
        }
       
        return true;
    }
    printf("******系统不安全！******\n");
    
    return false;
}

void SafeInfo(int *work, int i)
{
    int j;
    printf(" P%d\t",i);
    for(j = 0; j < resourceNum; j++){
        printf("%d ",work[j]);
    }
    printf("\t\t");
    for(j = 0; j < resourceNum; j++){
        printf("%d ",need[i][j]);
    }
    printf("\t ");
    for(j = 0; j < resourceNum; j++){
        printf("%d ",allocation[i][j]);
    }
    printf("\t\t");
    for(j = 0; j < resourceNum; j++){
        printf("%d ",allocation[i][j]+work[j]);
    }
    printf("\n");
}

void  resource_release(int curProcess)
{
    for(int i = 0; i < resourceNum; i++){
        available[i] += maxRequest[curProcess][i];
        maxRequest[curProcess][i] = 0;
        allocation[curProcess][i]=0;
    }
    Finish1[curProcess] = true;
}

//银行家算法
int main()
{
    int i,j,curProcess;
    int wheInit = 0;
    printf("是否使用内置数据？0是，1否：");
    scanf("%d",&wheInit);
    if(wheInit)
        randon_init();  //可以不使用，选用内置的数据进行测试
    printf("---------------------------------------------------------\n");
    showInfo();
    printf("\n系统安全情况分析\n");
    printf(" PID\t Work\t\tNeed\tAllocation\tWork+Allocation\n");
    if(isSafe()){
        printf("\n---------------------------------------------------------\n");
        printf("\n输入要分配的进程：");
        scanf("%d",&curProcess);
        while(!Finish1[curProcess])
        {
        printf("\n输入要分配给进程P%d的资源：",curProcess);
        for(j = 0; j < resourceNum; j++){
            scanf("%d", &request[j]);
        }
        for(j = 0; j < resourceNum; j++){
            if(request[j] <= need[curProcess][j])continue;
            else{printf("ERROR！\n");break;}
        }
        if(j == resourceNum){
            for(j = 0; j < resourceNum; j++){
                if(request[j] <= need[curProcess][j])continue;
                else{printf("资源不足，等待中！\n");break;}
            }
         if(j == resourceNum){
                for(j = 0; j < resourceNum; j++){
                    available[j] -= request[j];
                    allocation[curProcess][j] += request[j];
                    need[curProcess][j] -= request[j];
                }
                printf("\n系统安全情况分析\n");
                printf(" PID\t Work\t\tNeed\tAllocation\tWork+Allocation\n");
                if(isSafe()){
                    printf("分配成功！\n");
                    showInfo();
                    printf("P%d执行完成\n",curProcess);
                    resource_release(curProcess);     //资源释放
                    showInfo();
                }else{
                    for(j = 0; j < resourceNum; j++){
                        available[j] += request[j];
                        allocation[curProcess][j] -= request[j];
                        need[curProcess][j] += request[j];
                    }
                    printf("分配失败！\n");
                    showInfo();
                    }
                }
            }
      if(Finish[curProcess]==Finish1[curProcess])
      { 
      int  r=curProcess;
      printf("\n输入0-4以外的数结束,其他继续:");
      scanf("%d",&curProcess);
      if(r==curProcess)
      {
      printf("\n输入0-4以外的数或重复输入结束,该进程已完成，请重新输入:");
      scanf("%d",&curProcess);      
      }
      if(curProcess>4||curProcess<0) return 0;}
      }
     
    }
}



/*
测试一：
是否使用内置数据？0是，1否：1
输入进程数量上限、资源数量上限
5    3
当前资源可用数目
3   2   3   
随机生成最大需求矩阵
5   4   6   
3   6   5   
3   4   4   
6   7   4   
5   7   7   
随机生成已分配矩阵
1   3   3   
3   3   2   
2   1   2   
3   4   1   
3   4   1   
当前需求矩阵
4   1   3   
0   3   3   
1   3   2   
3   3   3   
2   3   6   
---------------------------------------------------------
当前资源剩余：3 2 3 
 PID	 Max		Allocation	Need
 P0	5 4 6 		1 3 3 		4 1 3 
 P1	3 6 5 		3 3 2 		0 3 3 
 P2	3 4 4 		2 1 2 		1 3 2 
 P3	6 7 4 		3 4 1 		3 3 3 
 P4	5 7 7 		3 4 1 		2 3 6 

系统安全情况分析
 PID	 Work		Need	Allocation	Work+Allocation
******系统不安全！******

测试二：
是否使用内置数据？0是，1否：1
输入进程数量上限、资源数量上限
5    3
当前资源可用数目
2   3   2   
随机生成最大需求矩阵
2   3   6   
6   2   6   
4   2   3   
3   3   6   
4   4   3   
随机生成已分配矩阵
1   3   1   
4   0   4   
2   0   2   
1   3   2   
1   1   3   
当前需求矩阵
1   0   5   
2   2   2   
2   2   1   
2   0   4   
3   3   0   
---------------------------------------------------------
当前资源剩余：2 3 2 
 PID	 Max		Allocation	Need
 P0	2 3 6 		1 3 1 		1 0 5 
 P1	6 2 6 		4 0 4 		2 2 2 
 P2	4 2 3 		2 0 2 		2 2 1 
 P3	3 3 6 		1 3 2 		2 0 4 
 P4	4 4 3 		1 1 3 		3 3 0 

系统安全情况分析
 PID	 Work		Need	Allocation	Work+Allocation
 P1	2 3 2 		2 2 2 	 4 0 4 		6 3 6 
 P2	6 3 6 		2 2 1 	 2 0 2 		8 3 8 
 P3	8 3 8 		2 0 4 	 1 3 2 		9 6 10 
 P4	9 6 10 		3 3 0 	 1 1 3 		10 7 13 
 P0	10 7 13 		1 0 5 	 1 3 1 		11 10 14 

系统安全！

安全序列为：1 2 3 4 0 
---------------------------------------------------------

输入要分配的进程：1

输入要分配给进程P1的资源：2 2 2 

系统安全情况分析
 PID	 Work		Need	Allocation	Work+Allocation
 P1	0 1 0 		0 0 0 	 6 2 6 		6 3 6 
 P2	6 3 6 		2 2 1 	 2 0 2 		8 3 8 
 P3	8 3 8 		2 0 4 	 1 3 2 		9 6 10 
 P4	9 6 10 		3 3 0 	 1 1 3 		10 7 13 
 P0	10 7 13 		1 0 5 	 1 3 1 		11 10 14 

系统安全！

安全序列为：1 2 3 4 0 分配成功！
当前资源剩余：0 1 0 
 PID	 Max		Allocation	Need
 P0	2 3 6 		1 3 1 		1 0 5 
 P1	6 2 6 		6 2 6 		0 0 0 
 P2	4 2 3 		2 0 2 		2 2 1 
 P3	3 3 6 		1 3 2 		2 0 4 
 P4	4 4 3 		1 1 3 		3 3 0 
P1执行完成
当前资源剩余：6 3 6 
 PID	 Max		Allocation	Need
 P0	2 3 6 		1 3 1 		1 0 5 
 P1	0 0 0 		0 0 0 		0 0 0 
 P2	4 2 3 		2 0 2 		2 2 1 
 P3	3 3 6 		1 3 2 		2 0 4 
 P4	4 4 3 		1 1 3 		3 3 0 

输入0-4以外的数结束,其他继续:2

输入要分配给进程P2的资源：2 2 1

系统安全情况分析
 PID	 Work		Need	Allocation	Work+Allocation
 P0	4 1 5 		1 0 5 	 1 3 1 		5 4 6 
 P1	5 4 6 		0 0 0 	 0 0 0 		5 4 6 
 P2	5 4 6 		0 0 0 	 4 2 3 		9 6 9 
 P3	9 6 9 		2 0 4 	 1 3 2 		10 9 11 
 P4	10 9 11 		3 3 0 	 1 1 3 		11 10 14 

系统安全！

安全序列为：0 1 2 3 4 分配成功！
当前资源剩余：4 1 5 
 PID	 Max		Allocation	Need
 P0	2 3 6 		1 3 1 		1 0 5 
 P1	0 0 0 		0 0 0 		0 0 0 
 P2	4 2 3 		4 2 3 		0 0 0 
 P3	3 3 6 		1 3 2 		2 0 4 
 P4	4 4 3 		1 1 3 		3 3 0 
P2执行完成
当前资源剩余：8 3 8 
 PID	 Max		Allocation	Need
 P0	2 3 6 		1 3 1 		1 0 5 
 P1	0 0 0 		0 0 0 		0 0 0 
 P2	0 0 0 		0 0 0 		0 0 0 
 P3	3 3 6 		1 3 2 		2 0 4 
 P4	4 4 3 		1 1 3 		3 3 0 

输入0-4以外的数结束,其他继续:3

输入要分配给进程P3的资源：2 0 4

系统安全情况分析
 PID	 Work		Need	Allocation	Work+Allocation
 P1	6 3 4 		0 0 0 	 0 0 0 		6 3 4 
 P2	6 3 4 		0 0 0 	 0 0 0 		6 3 4 
 P3	6 3 4 		0 0 0 	 3 3 6 		9 6 10 
 P4	9 6 10 		3 3 0 	 1 1 3 		10 7 13 
 P0	10 7 13 		1 0 5 	 1 3 1 		11 10 14 

系统安全！

安全序列为：1 2 3 4 0 分配成功！
当前资源剩余：6 3 4 
 PID	 Max		Allocation	Need
 P0	2 3 6 		1 3 1 		1 0 5 
 P1	0 0 0 		0 0 0 		0 0 0 
 P2	0 0 0 		0 0 0 		0 0 0 
 P3	3 3 6 		3 3 6 		0 0 0 
 P4	4 4 3 		1 1 3 		3 3 0 
P3执行完成
当前资源剩余：9 6 10 
 PID	 Max		Allocation	Need
 P0	2 3 6 		1 3 1 		1 0 5 
 P1	0 0 0 		0 0 0 		0 0 0 
 P2	0 0 0 		0 0 0 		0 0 0 
 P3	0 0 0 		0 0 0 		0 0 0 
 P4	4 4 3 		1 1 3 		3 3 0 

输入0-4以外的数结束,其他继续:4

输入要分配给进程P4的资源：3 3 0

系统安全情况分析
 PID	 Work		Need	Allocation	Work+Allocation
 P0	6 3 10 		1 0 5 	 1 3 1 		7 6 11 
 P1	7 6 11 		0 0 0 	 0 0 0 		7 6 11 
 P2	7 6 11 		0 0 0 	 0 0 0 		7 6 11 
 P3	7 6 11 		0 0 0 	 0 0 0 		7 6 11 
 P4	7 6 11 		0 0 0 	 4 4 3 		11 10 14 

系统安全！

安全序列为：0 1 2 3 4 分配成功！
当前资源剩余：6 3 10 
 PID	 Max		Allocation	Need
 P0	2 3 6 		1 3 1 		1 0 5 
 P1	0 0 0 		0 0 0 		0 0 0 
 P2	0 0 0 		0 0 0 		0 0 0 
 P3	0 0 0 		0 0 0 		0 0 0 
 P4	4 4 3 		4 4 3 		0 0 0 
P4执行完成
当前资源剩余：10 7 13 
 PID	 Max		Allocation	Need
 P0	2 3 6 		1 3 1 		1 0 5 
 P1	0 0 0 		0 0 0 		0 0 0 
 P2	0 0 0 		0 0 0 		0 0 0 
 P3	0 0 0 		0 0 0 		0 0 0 
 P4	0 0 0 		0 0 0 		0 0 0 

输入0-4以外的数结束,其他继续:0  

输入要分配给进程P0的资源：1 0 5

系统安全情况分析
 PID	 Work		Need	Allocation	Work+Allocation
 P0	9 7 8 		0 0 0 	 2 3 6 		11 10 14 
 P1	11 10 14 		0 0 0 	 0 0 0 		11 10 14 
 P2	11 10 14 		0 0 0 	 0 0 0 		11 10 14 
 P3	11 10 14 		0 0 0 	 0 0 0 		11 10 14 
 P4	11 10 14 		0 0 0 	 0 0 0 		11 10 14 

系统安全！

安全序列为：0 1 2 3 4 分配成功！
当前资源剩余：9 7 8 
 PID	 Max		Allocation	Need
 P0	2 3 6 		2 3 6 		0 0 0 
 P1	0 0 0 		0 0 0 		0 0 0 
 P2	0 0 0 		0 0 0 		0 0 0 
 P3	0 0 0 		0 0 0 		0 0 0 
 P4	0 0 0 		0 0 0 		0 0 0 
P0执行完成
当前资源剩余：11 10 14 
 PID	 Max		Allocation	Need
 P0	0 0 0 		0 0 0 		0 0 0 
 P1	0 0 0 		0 0 0 		0 0 0 
 P2	0 0 0 		0 0 0 		0 0 0 
 P3	0 0 0 		0 0 0 		0 0 0 
 P4	0 0 0 		0 0 0 		0 0 0 

输入0-4以外的数结束,其他继续:0

输入0-4以外的数或重复输入结束,该进程已完成，请重新输入:0

*/

发现分配bug，修改后：

#include <stdlib.h>
#include <time.h>
#include<stdio.h>
#define true 1
#define false 0
#define processNum 5
#define resourceNum 3
#define MAXINT 9999
typedef int bool;

int available[resourceNum]={3,3,2};
int maxRequest[processNum][resourceNum]={7,5,3,3,2,2,9,0,2,2,2,2,4,3,3};
int allocation[processNum][resourceNum]={0,1,0,2,0,0,3,0,2,2,1,1,0,0,2};
int need[processNum][resourceNum]={7,4,3,1,2,2,6,0,0,0,1,1,4,3,1};
bool Finish[processNum];
int safeSeries[processNum]={MAXINT, MAXINT , MAXINT , MAXINT , MAXINT};
int request[resourceNum];
bool Finish1[processNum];//已释放进程为true，未释放为false

void randon_init() //随机初始化
{
    int i, j;
    srand((unsigned) (time(NULL))); //随机数
    //scanf("%d %d",&processNum,&resourceNum);
    printf("输入进程数量上限、资源数量上限\n");
    printf("%d    %d",processNum,resourceNum);
    printf("\n当前资源可用数目\n");
    for(i = 0; i < resourceNum; i++){
        available[i] = rand() % 2 + 2;
        printf("%d   ",available[i]);
    }
    printf("\n随机生成最大需求矩阵\n");
    for(i = 0; i < processNum; i++){
        for(j = 0; j < resourceNum; j++){
            maxRequest[i][j] = (rand() % 6 + 2);
            printf("%d   ",maxRequest[i][j]);
        }
        printf("\n");
    }
    printf("随机生成已分配矩阵\n");
    for(i = 0; i < processNum; i++){
        for(j = 0; j < resourceNum; j++){
            allocation[i][j] = rand() % 4 +1;
            if (allocation[i][j] > maxRequest[i][j])
            {
            allocation[i][j] =0;
            }
            printf("%d   ",allocation[i][j]);
        }
        printf("\n");
    }
    printf("当前需求矩阵\n");
    for(i = 0; i < processNum; i++){
        for(j = 0; j < resourceNum; j++){
            need[i][j] = maxRequest[i][j] - allocation[i][j];
           printf("%d   ",need[i][j]);
        }
        printf("\n");
    }
}

void showInfo()
{
    int i,j;
    printf("当前资源剩余：");
    for(j = 0; j < resourceNum; j++){
        printf("%d ",available[j]);
    }
    printf("\n");
    printf(" PID\t Max\t\tAllocation\tNeed\n");
    for(i = 0; i < processNum; i++){
        printf(" P%d\t",i);
        for(j = 0; j < resourceNum; j++){
            printf("%d ",maxRequest[i][j]);
        }
        printf("\t\t");
        for(j = 0; j < resourceNum; j++){
            printf("%d ",allocation[i][j]);
        }
        printf("\t\t");
        for(j = 0; j < resourceNum; j++){
            printf("%d ",need[i][j]);
        }
        printf("\n");
    }
}

bool isSafe()
{
    int i,j,k;
    int trueFinished = 0;
    int work[resourceNum];
    for(i = 0; i < resourceNum; i++){
        work[i]=available[i];
    }

    for(i = 0; i < processNum; i++){
        Finish[i]=false;
    }
    i = 0;
    int temp=0,temp0=0,flag=0;
    

    while(trueFinished != processNum){
        int j =0;
        if(Finish[i]!= true){
            for(j = 0; j < resourceNum; j++){
                if(need[i][j] > work[j]){break;}
            }
        }
        if(j == resourceNum){
            Finish[i]=true;
            SafeInfo(work,i);
            for(k = 0; k < resourceNum; k++){
                work[k]+=allocation[i][k];
            }
            
            safeSeries[trueFinished++] = i;
        }
        i++;
        if(i >= processNum)
        {
        	if(flag==0)
        	{
        		temp=trueFinished;
        		temp0=trueFinished;        		
			}
            i = i % processNum;         
            if(flag==1){
            temp=trueFinished;
            if(temp == temp0)
                break;
            else
            	temp0=temp;
            }        
            flag=1;
        }
        temp = trueFinished;
    }

    if(trueFinished == processNum){
        printf("\n系统安全！\n\n安全序列为：");
        for(i = 0; i < processNum; i++){
            printf("%d ",safeSeries[i]);
        }
       
        return true;
    }
    printf("******系统不安全！******\n");
    
    return false;
}

void SafeInfo(int *work, int i)
{
    int j;
    printf(" P%d\t",i);
    for(j = 0; j < resourceNum; j++){
        printf("%d ",work[j]);
    }
    printf("\t\t");
    for(j = 0; j < resourceNum; j++){
        printf("%d ",need[i][j]);
    }
    printf("\t ");
    for(j = 0; j < resourceNum; j++){
        printf("%d ",allocation[i][j]);
    }
    printf("\t\t");
    for(j = 0; j < resourceNum; j++){
        printf("%d ",allocation[i][j]+work[j]);
    }
    printf("\n");
}

void  resource_release(int curProcess)
{
    for(int i = 0; i < resourceNum; i++){
        available[i] += maxRequest[curProcess][i];
        maxRequest[curProcess][i] = 0;
        allocation[curProcess][i]=0;
    }
    Finish1[curProcess] = true;
}

void bank()
{
 int i,j,curProcess;
    int wheInit = 0;
    printf("是否使用内置数据？0是，1否：");
    scanf("%d",&wheInit);
    if(wheInit)
        randon_init();  //可以不使用，选用内置的数据进行测试
    printf("---------------------------------------------------------\n");
    showInfo();
    printf("\n系统安全情况分析\n");
    printf(" PID\t Work\t\tNeed\tAllocation\tWork+Allocation\n");
    if(isSafe()){
        printf("\n---------------------------------------------------------\n");
        printf("\n输入要分配的进程：");
        scanf("%d",&curProcess);
        while(!Finish1[curProcess])
        {
        printf("\n输入要分配给进程P%d的资源：",curProcess);
        for(j = 0; j < resourceNum; j++){
            scanf("%d", &request[j]);
        }
        for(j = 0; j < resourceNum; j++){
            if(request[j] <= need[curProcess][j])continue;
            else{printf("ERROR！\n");break;}
        }
        if(j == resourceNum){
            for(j = 0; j < resourceNum; j++){
                if(request[j] <= need[curProcess][j])continue;
                else{printf("资源不足，等待中！\n");break;}
            }
         if(j == resourceNum){
                for(j = 0; j < resourceNum; j++){
                    available[j] -= request[j];
                    allocation[curProcess][j] += request[j];
                    need[curProcess][j] -= request[j];
                }
                printf("\n系统安全情况分析\n");
                printf(" PID\t Work\t\tNeed\tAllocation\tWork+Allocation\n");
                if(isSafe()){
                    printf("分配成功！\n");
                    showInfo();
                    printf("P%d执行完成\n",curProcess);
                    int all=1;
                    for(j = 0; j < resourceNum; j++){
                    if( allocation[curProcess][j]< maxRequest[curProcess][j]) all=0;
                }
                    if(all)
                    {
                    resource_release(curProcess);     //资源释放
                    showInfo();
                    }
                }else{
                    for(j = 0; j < resourceNum; j++){
                        available[j] += request[j];
                        allocation[curProcess][j] -= request[j];
                        need[curProcess][j] += request[j];
                    }
                    printf("分配失败！\n");
                    showInfo();
                    }
                }
            }
      if(Finish[curProcess]==Finish1[curProcess])
      { 
      int  r=curProcess;
      printf("\n输入0-4以外的数结束,其他继续:");
      scanf("%d",&curProcess);
      if(r==curProcess)
      {
      printf("\n输入0-4以外的数或重复输入结束,该进程已完成，请重新输入:");
      scanf("%d",&curProcess);      
      }
      if(curProcess>4||curProcess<0) return 0;
      }
      else
      {
         printf("\n输入要分配的进程：");
         scanf("%d",&curProcess);
         Finish1[curProcess]=false;
      }
     
    }
}}

int main()
{
   bank();
}
云的风下清潭
关注
  • 0
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
实验2银行家算法
11-17
银行家算法的实验指导
银行家算法 实验
学习笔记，相关教程 分享
05-16 773
银行家算法是一种最有代表性的避免死锁的算法。 在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。 为实现银行家算法，系统必须设置若干数据结构。
计算机操作系统-实验二：银行家算法
04-28
计算机操作系统-实验二：银行家算法 操作系统 操作系统报告 操作系统实验 银行家算法
操作系统实验二 银行家算法
06-13
包括实验题目，代码及运行结果 实验2 银行家算法（2学时） 一、实验目的 理解银行家算法，掌握进程安全性检查的方法及资源分配的方法。 二、实验内容 编写程序实现银行家算法，并验证程序的正确性。 三、实验要求 编制模拟银行家算法的程序，并以下面给出的例子验证所编写的程序的正确性。 例子：某系统有A、B、C、D 4类资源共5个进程（P0、P1、P2、P3、P4）共享，各进程对资源的需求和分配情况如下表所示。 进程 已占资源 最大需求数 A B C D A B C D P0 0 0 1 2 0 0 1 2 P1 1 0 0 0 1 7 5 0 P2 1 3 5 4 2 3 5 6 P3 0 6 3 2 0 6 5 2 P4 0 0 1 4 0 6 5 6 现在系统中A、B、C、D 4类资源分别还剩1、5、2、0个，请按银行家算法回答下列问题： （1）现在系统是否处于安全状态？ （2）如果现在进程P1提出需求（0、4、2、0）个资源的请求，系统能否满足它的请求？
银行家算法
夜晚22:00
03-30 861
我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。 为保证资金的安全,银行家规定: (1) 当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客; (2) 顾客可以分期贷款,但贷款的总数不能超过最大需求量; (3) 当银行家现有的资金不能满足顾客尚需的贷款数额时,对顾客的贷款可推迟支付,但总能使顾客在有限
操作系统实验二银行家算法
06-17
在本实验中，银行家算法被用来有效地分配三种类型的资源：A、B和C，它们的数量分别为10、15和12。系统中有5个并发执行的进程，这些进程通过进程控制块（PCB）进行管理，其中包含了进程名、需要的资源总数、已分配的...
操作系统实验二 银行家算法.rar
05-19
操作系统实验二：银行家算法 银行家算法是操作系统中一种重要的资源分配策略，主要用于避免系统的死锁问题。这个实验旨在让学生深入理解死锁的概念，并通过实际操作来掌握银行家算法的实现过程。在这个实验中，我们...
操作系统实验二——银行家算法
08-29
操作系统中的死锁问题是一个...通过这个实验，学生可以深入理解银行家算法的工作原理，掌握如何预防死锁，并在实践中应用C语言编程技巧。这样的练习有助于提升对操作系统中资源管理的理解，以及解决实际问题的能力。
计算机操作系统实验二 银行家算法
05-22
银行家算法是操作系统中用于预防死锁的一种策略，它的核心思想是预先分配资源，但不立即全部给予，而是根据安全性的判断来决定是否分配。在本实验中，学生需要通过编写C语言程序来模拟银行家算法，理解其原理并防止...
操作系统实验2 银行家算法
HYK_DJ5201314的博客
05-14 3196
操作系统实验2 银行家算法 1．目的和要求 银行家算法（Banker’s Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。 2．实验内容 ①数据结构： 可利用资源向量Availabl。是个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目。如果Available[j]=K，则表示系统中现有Rj类资源K个。 2）最大需求矩阵Max。这是一个n
操作系统实验 银行家算法 实验报告及附录代码
01-23
银行家算法实验（包括系统安全性检验） 文档附录附有代码。
操作系统实验 文档+实验目的+原理+内容+结果+小结 银行家算法
12-17
操作系统实验 文档+实验目的+原理+内容+结果+小结 进程优先调度算法文档，银行家算法.个人专利，倾情奉献~~~~~~~~~~~~~~~~~~~~~~~
计算机操作系统实验—银行家算法
12-08
5 银行家算法实现 5.1 实验类型 设计型（4学时）。 5.2 实验目的 1) 理解死锁避免相关内容； 2) 掌握银行家算法主要流程； 3) 掌握安全性检查流程。 5.3 实验描述 本实验主要对操作系统中的死锁预防部分的理论进行实验。要求实验者设计一个程序，该程序可对每一次资源申请采用银行家算法进行分配。 5.4 实验内容 1) 设计多个资源（≥3）； 2) 设计多个进程（≥3）； 3) 设计银行家算法相关的数据结构； 4) 动态进行资源申请、分配、安全性检测并给出分配结果。 5.5 实验要求 1) 编写程序完成实验内容； 2) 画出安全性检测函数流程图； 3) 撰写实验报告。 5.6 测试要求 1) 进行Request请求，输入参数为进程号、资源号和资源数； 2) 进行3次以上的Request请求； 3) 至少进行1次资源数目少于可用资源数，但不安全的请求。 5.7 相关知识 5.7.1 银行家算法的数据结构 1) 可利用资源向量Available。其中每个元素代表每类资源的数目。 2) 最大需求矩阵Max。其中每个元素代表每个进程对于每类资源的最大需求量。Max[i，j]=K表示i进程对于j类资源的最大需求量为K。 3) 分配矩阵Allocation。其中每个元素代表每个进程已得到的每类资源的数目。 4) 需求矩阵Need。其中每个元素代表每个进程还需要的每类资源的数目。 5.7.2 银行家算法 Request i [j]=K表示进程Pi需要K个j类资源。 1） 如果Request i [j]≤Need[i , j]，便转向步骤2，否则认为出错。 2） 如果Request i [j]≤Available[j]，便转向步骤3，否则表示无足够资源，Pi需等待； 3） 系统尝试分配资源给Pi； 4） 系统进行安全性检查，检查此次资源分配后，系统是否安全。如果安全，则正式分配资源，否则撤销此次分配。 5.7.3 安全性算法 1） 设置两个向量：工作向量Work和Finish。算法开始时Work=Available；Finish表示系统是否有足够的资源分配给进程，使之运行完成，开始时，令Finish[i]=False；如果有足够的资源分配给进程，则令Finish[i]=True。 2） 从进程集合中找到一个能满足下列条件的进程：Finish[i]=False；Need[i，j] ≤ Work[j]，若找到，执行步骤3），否则，执行步骤4）； 3） Pi获得所需资源后，可顺利执行指导完成，并释放它占有的资源。并执行： Work[j]=Work[j]+Allocation[i , j]； Finish[i] = True； 到第2）步。 4) 直到所有Finish[i]=True，表示系统处于安全状态；否则系统处于不安全状态。 5.8 实验设备 PC机1台，要求安装DOS7.1、Turbo C3.0、Windows2000。 5.9 实验成绩评定 实验成绩评定方式包含实验报告成绩、实验过程成绩两个部分，其中实验过程成绩占60%、实验报告成绩占40%，如果其中任何一个部分成绩不及格，则总成绩按不及格处理。 5.10 实验报告 按照实验目的、实验内容、实验要求、实验设备、测试等部分进行组织。 5.11 实验思考 1） 针对死锁有哪些可行方案？ 2） 死锁解除的难点是什么？
银行家算法 实验报告
07-25
实验目的和要求 目的 1、 理解银行家算法。 2、 掌握进程安全性检查的方法与资源分配的方法。 要求 1、 模拟一个银行家算法； 2、 初始化时让系统拥有一定的资源； 3、 用键盘输入的方式申请资源； 4、 如果预分配后，系统处于安全状态，则修改系统的资源分配情况； 5、如果预分配后，系统处于不安全状态，则提示不能满足请求，
银行家算法实验报告
07-19
银行家算法代码展示
操作系统实验：实验二、银行家算法
qq_45714068的博客
12-10 2586
实验二、银行家算法 （一） 目的和要求 银行家算法是由Dijkstra设计的最具有代表性的避免死锁的算法。本实验要求用高级语言编写一个银行家的模拟算法。通过本实验可以对预防死锁和银行家算法有更深刻的认识。 （二） 实验内容 1、 设置数据结构 包括可利用资源向量（Availiable）,最大需求矩阵（Max）,分配矩阵（Allocation）,需求矩阵（Need） 2、 设计安全性算法 设置工作向量Work 表示系统可提供进程继续运行可利用资源数目，Finish 表示系统是否有足够的资源分配给进程 （三）
操作系统实验：银行家算法
qq_50542009的博客
06-26 6389
一．实验目的： 银行家算法是一种最有代表性的避免死锁的算法。通过编写一个模拟动态资源分配的银行家算法程序，进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念，并掌握避免死锁的具体实施方法。 二．实验要求： 程序可以针对不同进程的请求进行判断，并决定是否满足其需求。算法程序需要设计合理的数据结构，对资源情况、进程相关数据进行存储。 三. 实验内容： 在避免死锁方法中允许进程动态地申请资源，用户请求分配资源时，首先对用户提出的请求进行合法性检查...
浅谈银行家算法
MJ_911的博客
04-03 893
银行家算法 目的：避免死锁的产生。 算法思想： 1、假分配检测：Request < Need Request < Available 2、安全序列检测算法 实例列举： 某系统有R1，R2，R3共3中资源，在T0时刻P0，P1，P2，P3和P4这5个进程对资源的占用和需求情况如下表1，此时系统的可用资源向量为(3,3,2)。试问： 1、T0时刻系统是否存在安全序列？ 2、P1请求资源：P...
操作系统实验：银行家算法实现与死锁避免
"操作系统实验二银行家算法，通过模拟银行家算法避免死锁，合理分配系统资源，增强对进程同步和死锁原理的理解。实验涉及3类资源A、B、C，5个并发进程，使用时间片轮转调度，并自动生成进程及其需求，随机申请资源。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值