避免死锁之银行家算法 银行家算法 操作系统

 //避免死锁之银行家算法

//2010 . 12 .22

//

#define MAX_SOURCE 10   //最大资源种类

#define MAX_PROCESS 20 //最大进程数目

 

#include <windows.h>

#include <iostream>

#include <stdio.h>

using namespace std;

 

typedef struct node

{

    char name[10];

    int max[MAX_SOURCE]; //该进程各类资源的最大需求数

    int allocation[MAX_SOURCE]; //该进程各类资源已获得的资源数

    int need[MAX_SOURCE]; //该进程还需资源数

    int finish; //标示该进程是否执行完

}PCB; //进程数据结构定义

//全局变量

int available[MAX_SOURCE];//系统中可利用资源数

int request[MAX_SOURCE]; //当前申请量

PCB p[MAX_PROCESS]; //进程序列

bool flag=true;//全局变量,记录安全与否状态

/********************************************************************************************************/

//函数声明列表

void Ini_process(PCB p[],int m, int n);   //进程初始化

void print(PCB p[],int m, int n);//打印出所有资源情况

int compare(int a[],int b[],int n); //判断进程i的Need是否小于Work

int safety(PCB p[],int m,int n); //安全性算法

/*******************************************************************************************************/

////自定义函数的实现

void Ini_process(PCB p[],int m, int n)   //进程初始化

{

    int i,j;

    for (i=0;i<m;i++)

    {

printf("/n进程p%d:",i);

printf("/n   （已分配）Allocation(");

for (j=0;j<n;j++)

printf("%d ",j+1);

printf(")=");

for (j=0;j<n;j++)

scanf("%d",&p[i].allocation[j]);

printf("/n   （仍需）Need(");

for (j=0;j<n;j++)

printf("%d ",j+1);

printf(")=");

for (j=0;j<n;j++)

scanf("%d",&p[i].need[j]);

for (j=0;j<n;j++)

p[i].max[j]=p[i].allocation[j]+p[i].need[j];

    }

    printf("/n（可用）Available(");

    for (j=0;j<n;j++)

printf("%d ",j+1);

printf(")=");

    for (j=0;j<n;j++)

scanf("%d",&available[j]);

 

print(p,m,n);//打印出几个矩阵

}

void print(PCB p[],int m, int n)

{

int i=0;

int j=0;

    cout<<"最大需求矩阵：/n";

for(i=0;i<m;i++)

{

for (j=0;j<n;j++)//最大需求矩阵

{

p[i].max[j]=p[i].allocation[j]+p[i].need[j];

cout<<p[i].max[j]<<" ";

if(j==(n-1))

{

cout<<endl;

if(i==(m-1))

{

cout<<endl;

}

}

}

}

cout<<"已分配矩阵：/n";

for(i=0;i<m;i++)

{

for(j=0;j<n;j++)//已分配

{

cout<<p[i].allocation[j]<<" ";

if(j==(n-1))

{

cout<<endl;

if(i==(m-1))

{

cout<<endl;

}

}

}

}

cout<<"仍需资源：/n";

for(i=0;i<m;i++)

{

for(j=0;j<n;j++)//仍需

{

cout<<p[i].need[j]<<" ";

if(j==(n-1))

{

cout<<endl;

if(i==(m-1))

{

cout<<endl;

}

}

}

}

cout<<"可用资源：/n";

for (j=0;j<n;j++)

{

cout<<available[j]<<" ";

}

cout<<"/n/n/n";

}

int compare(int a[],int b[],int n) //判断进程i的Need是否小于Work

{

    int i;

    i=0;

    while (i<n)

    {

if (a[i]>b[i])

{

return 0;

}

i++;

    }

    if (i==n)

return 1;

}

int safety(PCB p[],int m,int n) //安全性算法

{

    int i,j,k,find;

    char safe_list[MAX_PROCESS];

    int work[MAX_PROCESS];

    for (j=0;j<n;j++)

work[j]=available[j];//初始化工作向量work

    for (i=0;i<m;i++)

p[i].finish=0;   //所有进程均标示为未检测

    k=0;

    while (1)

    {

find=0;

for (i=0;i<m;i++)

{

if (p[i].finish==0 && compare(p[i].need,work,n)) //进程i还没有检测且need<=work

{

find=1;

for (j=0;j<n;j++)

work[j]=work[j]+p[i].allocation[j];//进程i释放资源

p[i].finish=1;//标示进程i为已检测

safe_list[k]=i; //把进程i并入安全序列

k++;

}

}

if (!find)

break;

}

    i=0;

    while (i<m)

    {

        if (p[i].finish==0)

        {

flag=false;

printf("/nSafety=0!该状态不安全！/n");

return 0;

        }

        i++;

    }

    if (i==m)

    {

        printf("/nSafety=1，该状态安全");

        printf("/n/n安全序列={");

for (i=0;i<m;i++)

printf("p%d,",safe_list[i]);

        printf("}/n");

        return 1;

    }

}

//主函数

int main(int argc, char* argv[])

{   

int requ_no,i,j;

int M,N;

do{

cout<<"***************************************************************"<<endl;

cout<<"                        避免死锁之银行家算法                   "<<endl;

cout<<"                 学生：***           指导老师：***          "<<endl;

cout<<"***************************************************************"<<endl;

printf("/n输入资源种类数:");

scanf("%d",&N);

printf("/n输入进程数:");

scanf("%d",&M);

Ini_process(p,M,N);

Sleep(1000);

cout<<"正在检测系统是否安全……/n";

Sleep(3000);//睡眠

safety(p,M,N);

}while(!flag);//如果不安全重新输入

 

getchar();

printf("/n/n有没有请求资源的进程(y/n)?/n");

while(getchar()=='y')

{

printf("/n输入请求资源的进程号(以0开始)：/n");

scanf("%d",&requ_no);//接收进程号

printf("/np%d: requset(",requ_no);

for (j=0;j<N;j++)

printf("%d ",j+1);

printf(")=");

for (j=0;j<N;j++)

scanf("%d",&request[j]);//接收请求资源的状况

/***********************************************************************/

/* 试分配 */

if (compare(request,p[requ_no].need,N) && compare(request,available,N))

{

for (j=0;j<N;j++)//试分配，修改相关值

{

available[j]=available[j]-request[j];

p[requ_no].allocation[j]=p[requ_no].allocation[j]+request[j];

p[requ_no].need[j]=p[requ_no].need[j]-request[j];

}

cout<<"/n/n/n";

            cout<<"试分配后:/n";

Sleep(1000);

//cout<<"最大需求矩阵：/n";

for(i=0;i<M;i++)//修改Max矩阵的值

{

for (j=0;j<N;j++)

{

p[i].max[j]=p[i].allocation[j]+p[i].need[j];

}

}

print(p,M,N);//打印出试分配后的资源情况

safety(p,M,N);//安全性检测

if(!flag)//如果不安全

{

for (j=0;j<N;j++)//还原到试分配之前

{

available[j]=available[j]+request[j];

p[requ_no].allocation[j]=p[requ_no].allocation[j]-request[j];

p[requ_no].need[j]=p[requ_no].need[j]+request[j];

}

cout<<"/n/n/n";

cout<<"返回分配前状态:/n";

                Sleep(1000);

for(i=0;i<M;i++)

{

for (j=0;j<N;j++)//最大需求矩阵

{

p[i].max[j]=p[i].allocation[j]+p[i].need[j];

}

}

print(p,M,N);//打印出试分配之前的资源状况

}

}

else if(!compare(request,p[requ_no].need,N))

cout<<"所请求资源数超过need，无法分配资源！/n";

else if(!compare(request,available,N))

printf("/n无足够资源, 进程等待!/n"); //不安全

/**************************************************************************/

}

return 0;

}