银行家算法(操作技巧系统)

《操作系统》实验报告
题目：银行家算法
班级：网络工程
姓名：朱锦涛
学号：E31314037
一、实验目的
用代码实现银行家算法，了解通过银行家算法避免死锁的思想。

通过代码的具体实现，加深对算法的核心的理解。

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

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

当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。

若超过则拒绝分配资源，若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配。

三、实验内容
源程序：
#include<stdio.h>
#include<time.h>
#include<stdlib.h>
typedef struct Procedure
{
i nt Max[3]; //满足此进程需要三类资源的数量
i nt Allocation[3]; //系统已经为该进程分配的资源情况i nt Need[3]; //该进程还需要资源数量
i nt flag; //标志位，执行完之前为0，执行完之后为1 c har p; //在执行完之后，给出相应的编号，如P1，P2 s truct Procedure * pNext;
}Pro,*PNODE; //如果系统资源足够多的话，那么所有的安全序列的数量就会是5*4*3*2*1=120个
PNODE create_list(int &len);
void traverse_list(PNODE pHead);
int cnt_exe(PNODE pHead,int *system,int i); //计算目前系统能够执行的进程数
int work(PNODE pHead,int *system);
int main()
{
i nt ok;
i nt len;
s rand(time(0));
i nt system[3] = {rand()%5+10,rand()%5+2,rand()%5+5}; p rintf("系统中可用的各类资源数分别
为:%d %d %d\n",system[0],system[1],system[2]);
P ro *pHead = create_list(len);
t raverse_list(pHead);
i nt cnt = cnt_exe(pHead,system,3);
i f(cnt == 0)
{
printf("对不起，不存在安全序列\n");
return 0;
}
e lse
{
int ok = work(pHead,system);
if(ok == len)
printf("恭喜！存在安全序列！\n");
else
printf("很抱歉！不存在安全序列！\n"); }
r eturn 0;
}
PNODE create_list(int &len)
{
i nt i,j;
c har c = 'A'; //用来临时存放用户输入的结点的值
//分配了一个不存放有效数据的头结点
P NODE pHead = (PNODE)malloc(sizeof(Pro));
i f (NULL == pHead)
{
printf("分配失败, 程序终止!\n");
exit(-1);
}
P NODE pTail = pHead;
p Tail->pNext = NULL;
p rintf("请输入您需要生成的链表节点的个数:"); s canf("%d", &len);
f or (i=0; i<len; ++i)
{
PNODE pNew = (PNODE)malloc(sizeof(Pro));
if (NULL == pNew)
{
printf("分配失败, 程序终止!\n");
exit(-1);
}
for(j=0;j<3;j++)
{
pNew->Max[j] = rand()%5+4;
pNew->Allocation[j] = rand()%5;
pNew->Need[j] = pNew->Max[j] -
pNew->Allocation[j];
}
pNew->flag = 0;
pNew->p = c;
pTail->pNext = pNew;
pNew->pNext = NULL;
pTail = pNew;
c++;
}
r eturn pHead;
}
void traverse_list(PNODE pHead) {
P NODE p = pHead->pNext;
i nt i = 1;
w hile (NULL != p)
{
printf("第%d个资源的需要资源总数各为:%d %d %d",i, p->Max[0],p->Max[1],p->Max[2]);
printf("\n");
printf("第%d个资源已分配资源总数各为:%d %d %d",i, p->Allocation[0],p->Allocation[1],p->Allocation[2]);
printf("\n");
printf("第%d个资源还需要资源总数各为:%d %d %d",i, p->Need[0],p->Need[1],p->Need[2]);
printf("\n");
printf("\n");
p = p->pNext;
i++;
}
p rintf("\n");
r eturn;
}
^` int cnt_exe(PNODE pHead,int *system,int i)
{
P NODE p;
p = pHead->pNext; //p指向第一个节点
i nt count = 0;
w hile(p != NULL)
{
if(system[0] >= p->Need[0] && system[1] >=
p->Need[1] && system[2] >= p->Need[2])
count++;
p = p->pNext;
}
r eturn count;
}
int work(PNODE pHead,int *system)
{
P NODE p;
p = pHead->pNext; //p指向第一个节点
int ok = 0;
w hile(p != NULL)
{
if(system[0] >= p->Need[0] && system[1] >=
p->Need[1] && system[2] >= p->Need[2])
{
system[0] += p->Allocation[0];
system[1] += p->Allocation[1];
system[2] += p->Allocation[2];
p->flag = 1;
ok++;
printf("系统已经为您执行了进程：%c\n",p->p);
PNODE q;
q = pHead; //寻找q的前一个节点，方便删掉q 节点
while( q->pNext != p )
{
q = q->pNext;
}
q->pNext = p->pNext;
free(p);
p = NULL;
p = pHead->pNext;//p又重新指向第一个节点
}
else
p = p->pNext;
}
r eturn ok;
}
存在安全序列的情况：
不存在安全序列的情况：
四、实验小结
用随机数为系统分配三类资源的个数，随后系统为每个作业分配每个资源需要的个数和已经分配的资源数量，那么还需要资源的数量则有最大分配量减去已经分配的数量。

系统在队列中寻找能满足当前条件的作业，运行完之后，将其资源释放，把各类资源重新还给系统。

把运行完之后的作业从队列中删除，系统再从队列开头重新寻找下一个能执行的作业。

如果中途遇到系统无法为任何一个作业运行提供条件时，则不存在安全序列，否则，存在安全序列。

本次实验我用一个
变量检测作业数量，若执行完一个作业时，其数量加一，最后检测是否为总作业的个数。

是，则存在安全序列，否则，不存在。

通过本次试验，加深了我对银行家算法的核心的理解。