银行家算法

死锁：

死锁产生的现场：当A进程P S2信号量而B进程P S1信号量时就会产生死锁，因为S2信号量需要B进程释放，而S1信号量需要A进程释放，因此两个进程都在等相互的资源，造成死锁。

 死锁产生的条件：

互斥条件：进程要求对所分配的资源进行排它性控制，即在一段时间内某资源仅为一进程所占用。（信号量s1 s2为互斥的信号量，只能被一个进程占用）

请求和保持条件：当进程因请求资源而阻塞时，对已获得的资源保持不放。（A进程在获取s2阻塞时，一直占用s1）

不可剥夺条件：进程已获得的资源在未使用完之前，不能剥夺，只能在使用完时由自己释放。（s1只能由A进程释放，s2只能由B进程释放）

环路等待条件：在发生死锁时，必然存在一个进程--资源的环形链。（A B 进程都是环形链路）

避免死锁的算法：

银行家算法是避免死锁的一种重要方法，防止死锁的机构只能确保上述四个条件之一不出现，则系统就不会发生死锁。通过这个算法可以用来解决生活中的实际问题，如银行贷款等。 

程序实现思路银行家算法顾名思义是来源于银行的借贷业务，一定数量的本金要应多个客户的借贷周转，为了防止银行加资金无法周转而倒闭，对每一笔贷款，必须考察其是否能限期归还。在操作系统中研究资源分配策略时也有类似问题，系统中有限的资源要供多个进程使用，必须保证得到的资源的进程能在有限的时间内归还资源，以供其他进程使用资源。如果资源分配不得到就会发生进程循环等待资源，则进程都无法继续执行下去的死锁现象。
把一个进程需要和已占有资源的情况记录在进程控制中，假定进程控制块PCB其中“状态”有就绪态、等待态和完成态。当进程在处于等待态时，表示系统不能满足该进程当前的资源申请。“资源需求总量”表示进程在整个执行过程中总共要申请的资源量。显然，，每个进程的资源需求总量不能超过系统拥有的资源总数, 银行算法进行资源分配可以避免死锁. 
 
一．程序流程图：
1.初始化算法流程图：

2．银行家算法流程图：

 3.安全性算法流程图：

二．银行家算法设计:
1．设进程i提出请求Request[n]，则银行家算法按如下规则进行判断。
(1)如果Request[n]>Need[i，n]，则报错返回。
(2)如果Request[n]>Available，则进程i进入等待资源状态，返回。
(3)假设进程i的申请已获批准，于是修改系统状态：
    Available=Available-Request
    Allocation=Allocation+Request
    Need=Need-Request
(4)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。

2．安全性检查
(1)设置两个工作向量Work=Available；Finish =False
(2)从进程集合中找到一个满足下述条件的进程，
   Finish =False
   Need<=Work
   如找到，执行(3)；否则，执行(4)
(3)设进程获得资源，可顺利执行，直至完成，从而释放资源。
    Work=Work+Allocation
    Finish=True
    GO TO 2
(4)如所有的进程Finish =true，则表示安全；否则系统不安全

3．数据结构
假设有M个进程N类资源，则有如下数据结构:
#define W 10
#define R 20
int A ;                      //总进程数
int B ;                     //资源种类
int ALL_RESOURCE[W];        //各种资源的数目总和
int MAX[W] ;             //M个进程对N类资源最大资源需求量
int AVAILABLE ;          //系统可用资源数
int ALLOCATION[W] ;      //M个进程已经得到N类资源的资源量
int NEED[W] ;            //M个进程还需要N类资源的资源量
int Request ;            //请求资源个数

4主要函数说明
void showdata();           //主要用来输出资源分配情况
void changdata(int);       //主要用来输出资源分配后后的情况
void rstordata(int);       //用来恢复资源分配情况,如:银行家算法时,由于分配不安全则要恢复资源分配情况
int chkerr(int);           //银行家分配算法的安全检查
void bank()   ;             //银行家算法

银行家算法的课程设计 

VC++6.0  2013-09-23 15:29

源程序
数据结构分析：
假设有M个进程N类资源，则有如下数据结构:
#define W 10
#define R 20
int A ;                      //总进程数
int B ;                     //资源种类
int ALL_RESOURCE[W];        //各种资源的数目总和
int MAX[W] ;             //M个进程对N类资源最大资源需求量
int AVAILABLE ;          //系统可用资源数
int ALLOCATION[W] ;      //M个进程已经得到N类资源的资源量
int NEED[W] ;            //M个进程还需要N类资源的资源量
int Request ;            //请求资源个数

#include

using namespace std;

#define MAXPROCESS 50                        

#define MAXRESOURCE 100                        

int AVAILABLE[MAXRESOURCE];                    

int MAX[MAXPROCESS][MAXRESOURCE];            

int ALLOCATION[MAXPROCESS][MAXRESOURCE];    

int NEED[MAXPROCESS][MAXRESOURCE];            

int REQUEST[MAXPROCESS][MAXRESOURCE];        

bool FINISH[MAXPROCESS];                        

int p[MAXPROCESS];                            

int m,n;                                    

void Init();

bool Safe();

void Bank();

int main()

{

    Init();

    Safe();

    Bank();

return 0;

}

void Init()                

{

    int i,j;

    cout<<"\t---------------------------------------------------"<<endl;

    cout<<"\t||                                               ||"<<endl;

    cout<<"\t||                 银行家算法                    ||"<<endl;

    cout<<"\t||                                               ||"<<endl;

    cout<<"\t||                 网工124221009  游子           ||"<<endl;

    cout<<"\t||                                               ||"<<endl;

    cout<<"\t||                                  130923       ||"<<endl;

    cout<<"\t---------------------------------------------------"<<endl;

    cout<<"请输入进程的数目:";

    cin>>m;

    cout<<"请输入资源的种类:";

    cin>>n;

    cout<<"请输入每个进程最多所需的各资源数,按照"<<m<<"x"<<n<<"矩阵输入"<<endl;

    for(i=0;i

    for(j=0;j

    cin>>MAX[m][j];

    cout<<"请输入每个进程已分配的各资源数,也按照"<<m<<"x"<<n<<"矩阵输入"<<endl;

    for(i=0;i

    {

        for(j=0;j

        {

            cin>>ALLOCATION[m][j];

            NEED[m][j]=MAX[m][j]-ALLOCATION[m][j];

            if(NEED[j]<0)

            {

                cout<<"您输入的第"<<i+1<<"个进程所拥有的第"<<j+1<<"个资源数错误,请重新输入:"<<endl;

                j--;

                continue;

            }

        }

    }

    cout<<"请输入各个资源现有的数目:"<<endl;

    for(i=0;i

    {

        cin>>AVAILABLE[i];

    }

}

void Bank()                

{

    int i,cusneed;

    char again;

    while(1)

    {

        cout<<"请输入要申请资源的进程号(注:第1个进程号为0,依次类推)"<<endl;

        cin>>cusneed;

        cout<<"请输入进程所请求的各资源的数量"<<endl;

        for(i=0;i

        {

            cin>>REQUEST[cusneed][i];

        }

        for(i=0;i

        {

            if(REQUEST[cusneed]>NEED[cusneed])

            {

                cout<<"您输入的请求数超过进程的需求量!请重新输入!"<<endl;

                continue;

            }

            if(REQUEST[cusneed]>AVAILABLE)

            {

                cout<<"您输入的请求数超过系统有的资源数!请重新输入!"<<endl;

                continue;

            }

        }

        for(i=0;i

        {

            AVAILABLE[i]-=REQUEST[cusneed][i];

            ALLOCATION[cusneed][i]+=REQUEST[cusneed][i];

            NEED[cusneed][i]-=REQUEST[cusneed][i];

        }

        if(Safe())

        {

            cout<<"同意分配请求!"<<endl;

        }

        else

        {

            cout<<"您的请求被拒绝!"<<endl;

            for(i=0;i

            {

                AVAILABLE[i]+=REQUEST[cusneed][i];

                ALLOCATION[cusneed][i]-=REQUEST[cusneed][i];

                NEED[cusneed][i]+=REQUEST[cusneed][i];

            }

        }

        for(i=0;i

        {

            FINISH[i]=false;

        }

        cout<<"您还想再次请求分配吗?是请按y/Y,否请按其它键"<<endl;

        cin>>again;

        if(again=='y'||again=='Y')

        {

            continue;

        }

        break;

        }

}

bool Safe()                                    

{

    int i,j,k,l=0;

    int Work[MAXRESOURCE];                    

    for(i=0;i

    Work[i]=AVAILABLE[i];

    for(i=0;i

    {

        FINISH[i]=false;

    }

    for(i=0;i

    {    

        if(FINISH[i]==true)

        {

            continue;

        }

        else

        {

            for(j=0;j

            {

                if(NEED[i][j]>Work[j])

                {

                    break;

                }

            }

            if(j==n)

            { 

                FINISH[j]=true;

                for(k=0;k

                {

                    Work[k]+=ALLOCATION[j][k];

                }

                p[l++]=i;

                i=-1;

            }

            else

            {

                continue; 

            }

        }

        if(l==m)

        {

            cout<<"系统是安全的"<<endl;

            cout<<"安全序列:"<<endl;

            for(i=0;i

            {

                cout<<p;

                if(i!=l-1)

                {

                    cout<<"-->";

                }

            }

            cout<<""<<endl;

            return true;

        }

    }

    cout<<"系统是不安全的"<<endl;

    return false;

}