操作系统课程设计论文银行家算法.docx

操作系统课程设计论文银行家算法.docx

《操作系统课程设计论文银行家算法.docx》由会员分享，可在线阅读，更多相关《操作系统课程设计论文银行家算法.docx（44页珍藏版）》请在冰豆网上搜索。

操作系统课程设计论文银行家算法

计算机科学与工程学院

课程设计报告

题目全称：

银行家算法的实现

课程名称：

计算机操作系统

指导老师：

职称：

序号

学生姓名

学号

班号

成绩

1

2

3

4

5

6

7

8

9

10

指导老师评语：

签字：

第一章摘要

银行家算法是最有代表性的避免死锁的算法，由于该算法能用于银行系统现金贷款的发放而得名。

其实现思想是：

允许进程动态地申请资源，系统在每次实施资源分配之前，先计算资源分配的安全性，若此次资源分配安全（即资源分配后，系统能按某种顺序来为每个进程分配其所需的资源，直至最大需求，使每个进程都可以顺利地完成），便将资源分配给进程，否则不分配资源，让进程等待。

此次课程设计实现了银行家算法的模拟

关键词：

银行家算法死锁操作系统资源分配。

第二章绪论

2.1进程并发控制的必要性

控制工作流程，管理资源，为用户服务，是操作系统的主要功能。

在资源管理中，操作系统的任务是使各种系统资源得到充分合理的应用，解决用户作业因为资源而产生的矛盾，并合理地让用户在合适的时间内得到其应有的服务。

现代操作系统引入了多道程序设计技术，允许多个进程同时驻留内存并发执行。

若干个进程将不可避免地会竞争系统资源，如果操作系统不能协调多个进程对系统资源的竞争和共享，将会导致执行结果异常，系统不稳定、失效等多种问题，因此操作系统提供了多种机制实现对进程的并发控制。

2.2进程死锁的定义

操作系统利用了包括软件方法、硬件方法、信号量方法、管程方法以及消息传递方法等机制实现了对若干进程的同步与互斥的控制，但是要确保进程之间能够正常通信、合理分配系统资源、提高系统的运行效率还需要解决进程的死锁问题。

死锁可以描述为，当多个进程在执行过程中，因为竞争资源或执行时推进的顺序不当而造成的一种相互阻塞的现象，若无外力作用，它们都将无法推进下去。

2.3产生死锁的原因

一、竞争资源引起进程死锁

当系统中供多个进程共享的资源如打印机、公用队列的等，其数目不足以满足诸进程的需要时，会引起诸进程对资源的竞争而产生死锁。

（1）可剥夺资源和不可剥夺资源

　　系统中的资源可以分为两类，一类是可剥夺资源，是指某进程在获得这类资源后，该资源可以再被其他进程或系统剥夺。

例如，优先权高的进程可以剥夺优先权低的进程的处理机。

又如，内存区可由存储器管理程序，把一个进程从一个存储区移到另一个存储区，此即剥夺了该进程原来占有的存储区，甚至可将一进程从内存调到外存上，可见，CPU和主存均属于可剥夺性资源。

另一类资源是不可剥夺资源，当系统把这类资源分配给某进程后，再不能强行收回，只能在进程用完后自行释放，如磁带机、打印机等。

（2）竞争不可剥夺资源

　　在系统中所配置的不可剥夺资源，由于它们的数量不能满足诸进程运行的需要，会使进程在运行过程中，因争夺这些资源而陷于僵局。

例如，系统中只有一台打印机R1和一台磁带机R2，可供进程P1和P2共享。

假定PI已占用了打印机R1，P2已占用了磁带机R2，若P2继续要求打印机R1，P2将阻塞；P1若又要求磁带机，P1也将阻塞。

于是，在P1和P2之间就形成了僵局，两个进程都在等待对方释放自己所需要的资源，但是它们又都因不能继续获得自己所需要的资源而不能继续推进，从而也不能释放自己所占有的资源，以致进入死锁状态。

　　（3）竞争临时资源

　　打印机资源属于可顺序重复使用型资源，称为永久资源。

还有一种所谓的临时资源，这是指由一个进程产生，被另一个进程使用，短时间后便无用的资源，故也称为消耗性资源，如硬件中断、信号、消息、缓冲区内的消息等，它也可能引起死锁。

例如，SI，S2，S3是临时性资源，进程P1产生消息S1，又要求从P3接收消息S3；进程P3产生消息S3，又要求从进程P2处接收消息S2；进程P2产生消息S2，又要求从P1处接收产生的消息S1。

二、进程推进顺序不当引起死锁

　　由于进程在运行中具有异步性特征，这可能使P1和P2两个进程按下述两种顺序向前推进。

（1）进程推进顺序合法

　　当进程P1和P2并发执行时，如果按照下述顺序推进：

P1：

Request（R1）;P1：

Request（R2）;P1:

Relese（R1）;P1:

Relese（R2）;P2：

Request（R2）;P2：

Request（R1）;P2:

Relese（R2）;P2:

Relese（R1）;这两个进程便可顺利完成，这种不会引起进程死锁的推进顺序是合法的。

（2）进程推进顺序非法

若P1保持了资源R1,P2保持了资源R2，系统处于不安全状态，因为这两个进程再向前推进，便可能发生死锁。

例如，当P1运行到P1：

Request（R2）时，将因R2已被P2占用而阻塞；当P2运行到P2：

Request（R1）时，也将因R1已被P1占用而阻塞，于是发生进程死锁。

2.4死锁产生的必要条件

虽然进程在运行过程中，可能发生死锁，但死锁的发生也必须具备一定的条件，死锁的发生必须具备以下四个必要条件。

（1）互斥条件：

指进程对所分配到的资源进行排它性使用，即在一段时间内某资源只由一个进程占用。

如果此时还有其它进程请求资源，则请求者只能等待，直至占有资源的进程用毕释放。

（2）占有且等待：

指进程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求进程阻塞，但又对自己已获得的其它资源保持不放。

　　（3）非剥夺：

指进程已获得的资源，在未使用完之前，不能被其他进程强行剥夺。

（4）循环等待：

在系统中存在一个由若干进程形成的环形请求链，其中的每一个进程均占有一些资源，同时又申请请求链中下一个进程所咱有的资源，如图2-1.

互斥，占有且等待，非剥夺这三个条件是死锁产生的必要条件，但不是充分条件。

互斥条件是临界资源固有的属性，保证进程胡此访问临界资源是必要的，不能因为互斥会导致死锁而禁止互斥。

循环等待是前3个条件可能产生的结果，只有存在互斥，占有且等待与非剥夺三个条件时，才可能出现循环等待。

只要系统出现了循环等待，则一定出现死锁。

图2-1进程循环等待：

死锁

2.5解决死锁的方法

解决死锁的方法可以按解决死锁的时机分为四类：

（1）预防死锁。

　　这是一种较简单和直观的事先预防的方法。

方法是通过设置某些限制条件，去破坏产生死锁的四个必要条件中的一个或者几个，来预防发生死锁。

预防死锁是一种较易实现的方法，已被广泛使用。

但是由于所施加的限制条件往往太严格，严格限制了系统资源的分配和使用，可能会导致系统资源利用率和系统吞吐量降低。

（2）避免死锁。

　　该方法同样是属于事先预防的策略，但它并不须事先采取各种限制措施去破坏产生死锁的的四个必要条件，而是在资源的动态分配过程中，用某种方法去防止系统进入不安全状态，从而避免发生死锁。

这种方法并不严格显示产生死锁的4个必要条件。

（3）检测死锁。

　　这种方法并不须事先采取任何限制性措施，也不必检查系统是否已经进入不安全区，此方法允许系统在运行过程中发生死锁。

但可通过系统所设置的检测机构，及时地检测出死锁的发生，并精确地确定与死锁有关的进程和资源，然后采取适当措施，从系统中将已发生的死锁清除掉。

（4）解除死锁。

这是与检测死锁相配套的一种措施。

当检测到系统中已发生死锁时，须将进程从死锁状态中解脱出来。

常用的实施方法是撤销或挂起一些进程，以便回收一些资源，再将这些资源分配给已处于阻塞状态的进程，使之转为就绪状态，以继续运行。

死锁的检测和解除措施，有可能使系统获得较好的资源利用率和吞吐量，但在实现上难度也最大。

第三章项目介绍

3.1概述

银行家算法是一种代表性的避免死锁的算法。

避免死锁的方法通过资源分配之前预测是否会导致死锁，决定是否进行此次资源分配。

由于计算机在计算和预测方面具有较高的优势，可以再每次进行资源请求时，通过计算预测盖茨资源分配是否会导致死锁。

只有不会导致死锁的资源请求才实施分配。

在进程申请资源的时候，系统调用银行家算法来检测此次分配会不会导致死锁的发生，及判断此次分配的安全性。

若检测到此次分配是安全的，则分配给申请进程所申请的资源，若检测到此次分配是不安全的，则不分配资源，相应的进程等待。

我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。

为保证资金的安全,银行家规定:

（1）当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客;　　

（2）顾客可以分期贷款,但贷款的总数不能超过最大需求量;　　

（3）当银行家现有的资金不能满足顾客尚需的贷款数额时,对顾客的贷款可推迟支付,但总能使顾客在有限的时间里得到贷款;　　

（4）当顾客得到所需的全部资金后,一定能在有限的时间里归还所有的资金.

3.2设计目的

本次设目的计是在windows环境下，模拟银行家算法的实现。

3.3成员介绍

组长：

吴凯设计实现，运行及结果分析；

组员：

陈攀设计思想，答辩PPT；

刘绍洋算法分析，程序流程图；

邓茜项目概述，绪论，答辩；

陈珂宇课程摘要。

第四章设计思想

4.1概述

为了能够清楚地看到银行家算法的实现过程，可以在VC下设计一个对话框。

通过该对话框可以了解资源分配的情况。

操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。

当进程在执行中继续申请资源时，先测试该进程本次申请的资源数是否超过了该资源所剩余的总量。

若超过则拒绝分配资源，若能满足则按当前的申请量分配资源，否则也要推迟分配。

实现银行家算法可以分为三个过程：

1.数据初始化阶段。

在这个阶段程序读入可用资源向量，每个进程最大资源需求向量，每个进程已分配资源向量。

并根据读入的每个进程的最大需求向量和已分配资源向量，求出每个进程的需求向量。

2.调用银行家算法。

根据申请进程和该进程所申请的资源向量，调用安全性算法判断此次分配是否安全。

3.调用安全性算法。

假设系统为此进程分配所申请的资源，并假设进程得到的资源满足所需要的最大资源时，该进程得到执行并释放所得到的全部资源。

然后系统再找到一个还在等待资源分配的，系统可以为之足够分配资源的进程，并假设该进程得到执行，然后释放资源。

入此次分配可以让所有的进程都得到执行，则表明这次分配是安全的，否则就是不安全的。

由于银行家算法必须预先知道每个进程所需要的资源总量和系统资源的分配情况，所以设置几个数组代表资源分配情况：

Available[MAX_SOURCE]：

每个元素代表一类可用资源的数目；

Max[MAX_PROGRESS][MAX_SOURCE]：

代表每个进程对一类资源的最大需求

数；

Need[MAX_PROGRESS][MAX_SOURCE]：

代表每个进程对尚需的各类资源数；

Allocation[MAX_PROGRESS][MAX_SOURCE]：

代表每个进程已经分配到的资源数。

所以，文件的初始化阶段，即对着四个数组的初始化。

在程序的执行过程中，若申请资源的进程和所申请的资源向量都合法，则调用安全性算法判断分配是否安全。

在安全性算法的过程中，Available，Need和Allocation都是动态的，并在消息对话框中显示出来，这样就可以动态地显示资源分配的情况。

由于这只是银行家算法的模拟，如果分配不安全，则需要重新初始化。

4.2算法设计

1.算法的数据结构

1）可利用资源向量Available

是个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目。

如果Available[j]=K，则表示系统中现有Rj类资源K个。

2）最大需求矩阵Max　　

这是一个n×m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。

如果Max[i,j]=K，则表示进程i需要Rj类资源的最大数目为K。

3）分配矩阵Allocation　　

这也是一个n×m的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。

如果Allocation[i,j]=K，则表示进程i当前已分得Rj类资源的数目为K。

4）需求矩阵Need。

这也是一个n×m的矩阵，用以表示每一个进程尚需的各类资源数。

如果Need[i,j]=K，则表示进程i还需要Rj类资源K个，方能完成其任务。

2.算法的实现

1）初始化

　　即是初始化Max，Allocation，Available，Need这四个数组。

其中Max，Allocation，Available这三个数组在程序开始前是已知的，Need数组是根据Max和Allocation计算出来的。

2）银行家算法

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

在该方法中把系统的状态分为安全状态和不安全状态，只要能使系统始终都处于安全状态，便可以避免发生死锁。

（1）如果REQUEST[i]<=NEED[REQUEST][i]，则转

（2）；否则，出错。

（2）如果REQUEST[i]<=Avalable[REQUEST][i]，则转（3）；否则，出错。

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

Avalable[i]=Avalable[i]-Request[i];　

Allocation[REQUEST][i]=Allocation[REQUEST][i]+Request[i];

Need[REQUEST][i]=Need[REQUEST][i]-Request[i];

（4）系统利用安全性算法，检查此次资源分配以后，系统是否处于安全状态。

若安全，才将资源分配给是进程Pi,完成此次分配；否则，试探分配是小，回复原来的资源分配状态，让进程Pi等待。

3）安全性检查算法

（1）设置两个工作向量：

Finish[FACT_PROGRESS]：

若Finish[n]=true,则表示该进程已经申请到了资源得到执行。

当该进程执行完毕后，释放资源。

FACT_PROGRESS代表实际进程集合的数量。

　Finish数组初始化时，全部元素置为false。

Work[FACT_SOURCE]：

初始化为Available，表示系统可提供给进程继续运行的资源集合。

FACT_SOURCE是一个全局变量，表示实际的资源种类。

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

Finish[i]==false并且Need[i][]<=Work[];如找到，则执行（3）；否则，执行（4）。

（3）这是系统找到了一个满足条件的进程，并让该进程得资源，可顺利执行，直至完成，从而释放所有的资源，执行以下操作：

Work[]=Work[]+Allocation[i][];

Need[i][]=0;

Available[i][]=Available[i][]+Allocation[i][];

Allocation[i][]=0;

Finish=true;　　

然后返回

（2）找到符合条件的进程并执行相关操作，直到没有找到符合条件的进程为止。

（4）如所有的进程Finish[]=true，则申请的资源分配可以使所有的进程都顺利执行，表示系统处于安全状态；若Finish[]数组不全为true，则表示申请资源的进程所申请的资源分配不能是系统中所有的进程都顺利得到资源并执行，系统不安全状态。

（5）

第五章设计实现

5.1界面的设计

界面中的四个编辑框：

Max,Allocation,Need,Available分别显示出这四个数中中的内容，而Request的两个编辑框用来得到申请资源分配的进程ID和申请的资源向量。

右下角的编辑框用来显示提示信息。

在开始申请资源前，必须对各个数组进行初始化。

5.2程序流程图

5.3代码设计

程序中使用到的函数列表：

voidReadMax（HWNDhwnd）;

voidWriteMax（HWNDhwnd）;

voidReadAllocation（HWNDhwnd）;

voidWriteAllocation（HWNDhwnd）;

voidWriteNeed（HWNDhwnd）;

voidReadNeed（HWNDhwnd）;

voidWriteAvailable（HWNDhwnd）;

voidReadAvailable（HWNDhwnd）;

voidInit（HWNDhwnd）;

voidRequestRead（HWNDhwnd）;

voidBanker（HWNDhwnd）;

boolSecurityCheck（HWNDhwnd）;

intFindFit（）;

在程序初始化阶段，当用户点击初始化按钮时，分别顺序调用相应的函数：

ReadMax函数，ReadAvailable函数，ReadNeed函数，ReadAllocation函数实现对每个数组的读取，然后用WriteMax函数，riteAvailable函数，WriteNeed函数，WriteAllocation函数将对应的函数些入相应的编辑框中。

当用户输入了正确的请求进程ID和申请向量的时候，点击开始按钮则启动了银行家算法和安全性算法。

启动的简单代码如下：

caseIDC_START:

{

charstrQ[20];

GetDlgItemText（hwnd,IDC_EREQUEST,strQ,20）;

charstrE[20];

GetDlgItemText（hwnd,IDC_REQUEST,strE,20）;

RequestRead（hwnd）;

Banker（hwnd）;

}

其中RequestRead函数是读入输入的请求进程ID和申请向量。

当读入请求进程的ID：

REQUEST和申请向量Request[]后，则调用银行家算法。

代码如下：

voidBanker（HWNDhwnd）

{

TCHARsetT[50];

for（intj=0;j

Available[j]=Available[j]-Request[j];

Allocation[REQUEST][j]=Allocation[REQUEST][j]+Request[j];

Need[REQUEST][j]=Need[REQUEST][j]-Request[j];

}

WriteAllocation（hwnd）;

WriteNeed（hwnd）;

WriteAvailable（hwnd）;

boolsecur=SecurityCheck（hwnd）;

if（secur==true）{

wsprintf（setT,"这次分配是安全的，可以为这个进程分配申请的资源."）;

MessageBox（hwnd,TEXT（setT）,TEXT（"成功!

"）,MB_OK）;

wsprintf（setT,"分配成功!

\r\n"）;

strcat（msg,setT）;

SetDlgItemText（hwnd,IDC_OUT,msg）;

return;

}

else{

wsprintf（setT,"按申请分配资源不安全,点击Init恢复到初始化阶段!

"）;

MessageBox（hwnd,TEXT（setT）,TEXT（"失败!

"）,MB_OK）;

wsprintf（setT,"分配失败,请重试!

\r\n"）;

strcat（msg,setT）;

SetDlgItemText（hwnd,IDC_OUT,msg）;

return;

}

}

银行家算法在实现过程中，REQUEST和Request[]（即：

申请进程ID和申请向量）的合法性可以再ReadRequest（）函数中检查，所以，这段代码是银行家算法的核心代码。

如果判断申请合法，则系统假设为进程分配申请的资源：

Available[j]=Available[j]-Request[j];

Allocation[REQUEST][j]=Allocation[REQUEST][j]+Request[j];

Need[REQUEST][j]=Need[REQUEST][j]-Request[j]

当为申请资源的进程分配资源后，系统将调用SecurityChek（）函数检查此次资源分配后系统是否处于安全状态。

SecurityCheck（）函数首先初始化两个数组：

Finish[FACT_PROGRESS]和Work[FACT_PROGRESS]，Finish数组的初始化全为false，表示一个进程是否执行。

Work数组初始化为Available，表示系统可提供给进程继续运行的资源集合。

然后程序从进程集合中找到一个进程，该进程为为执行，并且尚需的资源小于系统可用的资源（由FindFit（）函数实现）。

若系统找到这样的进程则为进程分配资源，然后假设该进程立刻得到执行，则释放资源。

然后程序在刷新一下Max,Available,Need和Allocation数组的情况，以便于了解资源的分配情况。

如果没有找到符合条件的进程，即FindFit（）函数返回FACT_PROGRESS+1，则进入判定阶段：

如果所有的进程都执行，即Finish[]数组中的所有元素都为true，则代表此次分配是安全的，否则此次分配是不安全的。

安全性算法：

boolSecurityCheck（HWNDhwnd）

{

for（inti=0;i

Finish[i]=false;

for（intj=0;j

Work[j]=Available[j];

for（intm=0;m

intfit=FindFit（）;

/******************进程得到资源，执行，释放资源*********************************/

if（fit

for（ints1=0;s1

Work[s1]=Allocation[fit][s1]+Work[s1];

Available[s1]=Available[s1]+Allocation[fit][s1];

Allocation[fit][s1]=0;

Need[fit][s1]=0;

}

Finish[fit]=true;

MessageBox（hwnd,TEXT（"查看资源情况，继续分配!

"）,TEXT（"消息"）,MB_OK）;

WriteAllocation（hwnd）;

WriteNeed（hwnd）;

WriteAvailable（hwnd）;

}

else{

boolsem_b=true;

for（int