c银行家算法总结.docx

c银行家算法总结.docx

《c银行家算法总结.docx》由会员分享，可在线阅读，更多相关《c银行家算法总结.docx（21页珍藏版）》请在冰豆网上搜索。

c银行家算法总结

算法的实现

一、初始化

由用户输入数据，别离对可利用资源向量矩阵AVAILABLE、最大需求矩阵MAX、分派矩阵ALLOCATION、需求矩阵NEED赋值。

二、银行家算法

在幸免死锁的方式中，所施加的限制条件较弱，有可能取得令人中意的系统性能。

在该方式中把系统的状态分为平安状态和不平安状态，只要能使系统始终都处于平安状态，即能够幸免发生死锁。

银行家算法的大体思想是分派资源之前,判定系统是不是是平安的;假设是,才分派。

它是最具有代表性的幸免死锁的算法。

设进程cusneed提出请求REQUEST[i]，那么银行家算法按如下规那么进行判定。

（1）若是REQUEST[cusneed][i]<=NEED[cusneed][i]，那么转

（2）；不然，犯错。

（2）若是REQUEST[cusneed][i]<=AVAILABLE[cusneed][i]，那么转（3）；不然，犯错。

（3）系统试探分派资源，修改相关数据：

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

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

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

（4）系统执行平安性检查，如平安，那么分派成立；不然试探险性分派作废，系统恢恢复状，进程等待。

三、平安性检查算法

运行平安性检查算法如下：

1）Work=Available；Finish=false；

2）寻觅知足如下条件的i:

  Finish[i]==false而且Need[i]≤Work[i]；

  若是不存在，那么转步骤4）；

3）Work=Work+Allocation[i]；Finish[i]=true；

  转步骤2）；

4）若是关于所有i，Finish[i]=true，那么系统处于平安状态，不然处于不平安状态。

（1）设置两个工作向量Work=AVAILABLE;FINISH

（2）从进程集合中找到一个知足下述条件的进程，

FINISH==false;

NEED<=Work;

如找到，执行（3）；不然，执行（4）

（3）设进程取得资源，可顺利执行，直至完成，从而释放资源。

Work+=ALLOCATION;

Finish=true;

GOTO2

（4）如所有的进程Finish=true，那么表示平安；不然系统不平安。

各算法流程图

#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;                                    /**//*m个进程,n个资源*/

void Init（）;

bool Safe（）;

void Bank（）;

int main（）

{

    Init（）;

    Safe（）;

    Bank（）;

    getchar（）;

}

//给出系统拥有的每种资源数，已经分派给每一个进程的资源数，还有每一个进程最多需要每种资源的个数，让你判定当前系统是不是平安的 

void Init（）                /**//*初始化算法*/

{

    int i,j;

    cout<<"请输入进程的数量:

";

    cin>>m;

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

";

    cin>>n;

    cout<<"请输入每一个进程最多所需的各资源数,依照"<

    for（i=0;i

    for（j=0;j

    cin>>MAX[i][j];

    cout<<"请输入每一个进程已分派的各资源数,也依照"<

    for（i=0;i

{

        for（j=0;j

{

            cin>>ALLOCATION[i][j];

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

            if（NEED[i][j]<0）

{

                cout<<"您输入的第"<

"<

                j--;

                continue;

            }

        }

    }

    cout<<"请输入各个资源现有的数量:

"<

    for（i=0;i

{

        cin>>AVAILABLE[i];

    }

}

void Bank（）                /**//*银行家算法*/

{

    int i,cusneed;

    char again;

    while

（1）

{

Restart:

        cout<<"请输入要申请资源的进程号（注:

第1个进程号为0,依次类推）"<

        cin>>cusneed;

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

        for（i=0;i

{

            cin>>REQUEST[cusneed][i];

        }

        for（i=0;i

{

            if（REQUEST[cusneed][i]>NEED[cusneed][i]）

{

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

请从头输入!

"<

                goto Restart;

            }

            if（REQUEST[cusneed][i]>AVAILABLE[i]）

{

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

请从头输入!

"<

                goto Restart;

            }

        }

        for（i=0;i

{

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

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

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

        }

        if（Safe（））

{

            cout<<"同意分派请求!

"<

        }

        else

{

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

"<

            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,否请按其它键"<

        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[i]=true;

                for（k=0;k

{

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

                }

                p[l++]=i;

                i=-1;

            }

            else

{

                continue; 

            }

        }

        if（l==m）

{

            cout<<"系统是平安的"<

            cout<<"平安序列:

"<

            for（i=0;i

{

                cout<

                if（i!

=l-1）

{

                    cout<<"-->";

                }

            }

            cout<<""<

            return true;

        }

    }

    cout<<"系统是不平安的"<

    return false;

}

、银行算法是如何幸免死锁的：

　　银行家算法是如此的：

　　1）当一个用户对资金的最大的需求量不超过银行家现有的资金时就能够够接纳该用户。

　　2）用户能够分期贷款，但贷款的总数不能超过最大需求量。

　　3）当银行家现有的资金不能知足用户的尚需贷款时，对用户的贷款可推延支付，但总能利用户在有限的时刻里取得贷款。

　　4）当用户取得所需的全数资金后，必然能在有限的时刻里归还所有资金。

　　咱们把操作系统看做是银行家，操作系统治理的资源相当于是银行家治理的资金，那么银行家算法确实是：

　　1）当一个进程第一次申请资源时，测试该进程对资源的最大的需求量，若是不超过系统现存资源时就能够够按他的当前申请量为其分派资源。

不然推延分派。

　　2）进程执行中继续申请资源时，测试该进程占用资源和本次申请资源总数有无超过最大需求量。

超过就不分派，没超过那么再测试现存资源是不是知足进程还需要的最大资源量，知足那么按当前申请量分派，不然也推延分派。

　　总之，银行家算法要保证分派资源时系统现存资源必然能知足至少一个进程所需的全数资源。

如此就能够够保证所有进程都能在有限时刻内取得需要的全数资源。

这确实是平安状态。

　　（银行家算法在操作系统的实践考试中可能会用到）