`
- 浏览:
1264275 次
-
#include<iostream>
usingnamespacestd;
int**allocate,*total,**need,*require;
intnum_process,num_resource;
boolisDeadLock(intc=0);
boolfindFinish();
voidprintALL(int**b_allocate,int**b_need,int*b_total);
boolisAllFinish(int**);
intmain()
...{
cin>>num_process>>num_resource;
need=newint*[num_process];
allocate=newint*[num_process];
total=newint[num_resource];
require=newint[num_resource];
inti,q;
for(i=0;i<num_process;i++)
...{
need[i]=newint[num_resource];
allocate[i]=newint[num_resource];
}
//definethenumberofeachresource
for(i=0;i<num_resource;i++)
cin>>total[i];
for(i=0;i<num_resource;i++)
cout<<total[i];
//definetheprocessesgethowmuchresource
for(i=0;i<num_process;i++)
for(q=0;q<num_resource;q++)
cin>>allocate[i][q];
//cheaktheresourcehasenoughtoallocate
for(i=0;i<num_resource;i++)
for(q=0;q<num_process;q++)
...{if(total[i]-allocate[q][i]>=0)
total[i]-=allocate[q][i];
else
...{
cerr<<"error!";
return1;
}
}
//definehowmuchresourceswilleachprocessstillneedtogettofinishitselfnow
for(i=0;i<num_process;i++)
for(q=0;q<num_resource;q++)
cin>>need[i][q];
printALL(allocate,need,total);
//cheaktheallocateisdeadlockornot
if(isDeadLock())
...{
cerr<<"deadLock";
return1;
}
else
cout<<"Systemissafe"<<endl;
//autotest
inttest;
cout<<"choose1:autotest, else:customtest. ";
cin>>test;
if(test==1)
...{
isDeadLock(test);
}
//customtest
else
...{
while(isAllFinish(need))
...{
for(i=0;i<num_process;i++)
...{
cout<<i<<":requirehowmuchresource?"<<endl;
for(q=0;q<num_resource;q++)
cin>>require[q];
//determinethedataofrequireisright
for(q=0;q<num_resource;q++)
...{
if(total[q]<require[q]||need[i][q]<require[q])
...{
cout<<"errordatainformation"<<endl;
i--;
break;
}
total[q]-=require[q];
need[i][q]-=require[q];
allocate[i][q]+=require[q];
}
if(isDeadLock(1))
...{
i--;
cout<<"Systemisindeadlockstate"<<endl;
}
else
cout<<"Systemissafe......"<<endl;
}
}
}
return0;
}
//ifalltheprocessesarefinished,thenreturntrue;
boolisAllFinish(int**b_need)
...{
inti,q;
for(i=0;i<num_process;i++)
for(q=0;q<num_resource;q++)
...{
if(b_need[i][q]!=0)
returnfalse;
}
returntrue;
}
//ifitisdeadlock,thenreturntrue;elsereturnfalse
boolisDeadLock(intc)//cisaflagtoshowtheinformationornot.
...{
int**backup_allocate,**backup_need,*backup_total;
backup_need=newint*[num_process];
backup_allocate=newint*[num_process];
backup_total=newint[num_resource];
inti,q;
for(i=0;i<num_process;i++)
...{
backup_need[i]=newint[num_resource];
backup_allocate[i]=newint[num_resource];
}
for(i=0;i<num_process;i++)
for(q=0;q<num_resource;q++)
...{
backup_need[i][q]=need[i][q];
backup_allocate[i][q]=allocate[i][q];
}
for(i=0;i<num_resource;i++)
backup_total[i]=total[i];
//returnfindFinish();
if(c!=0)
printALL(backup_allocate,backup_need,backup_total);
intflag=0,count=0;
while(!isAllFinish(backup_need))
...{
count=0;
for(i=0;i<num_process;i++)
...{for(q=0;q<num_resource;q++)
...{
if(backup_need[i][q]>backup_total[q])
...{
flag=0;
break;
}
flag=1;
}
//findafinishingprocessandcollecttheresource
if(flag==1)
...{
count++;
for(q=0;q<num_resource;q++)
...{
backup_total[q]+=backup_allocate[i][q];
backup_allocate[i][q]=0;
backup_need[i][q]=0;
}
}
printALL(backup_allocate,backup_need,backup_total);
}
//if(c!=0)
//printALL(backup_allocate,backup_need,backup_total);
//ifnoprocessisfinished,itmeansnoresourceiscollectonce.Thenthedeadlockappears.
if(count==0)
...{
delete[]backup_total;
for(i=0;i<num_process;i++)
...{delete[]backup_allocate[i];
delete[]backup_need[i];
}
delete[]backup_allocate;
delete[]backup_need;
returntrue;
}
}
returnfalse;
}
voidprintALL(int**b_allocate,int**b_need,int*b_total)
...{
inti,q;
cout<<"Allocate need"<<endl;
for(i=0;i<num_process;i++)
...{
for(q=0;q<num_resource;q++)
...{
cout<<b_allocate[i][q]<<"";
}
cout<<" ";
for(q=0;q<num_resource;q++)
cout<<b_need[i][q]<<"";
cout<<endl;
}
cout<<"total"<<endl;
for(i=0;i<num_resource;i++)
cout<<b_total[i]<<"";
cout<<endl;
}
/**//*
boolfindFinish()
{
inti,q,flag=0,count=0;
for(i=0;i<num_process;i++)
{for(q=0;q<num_resource;q++)
{
if(need[i][q]>total[q])
{
flag=0;
break;
}
flag=1;
}
if(flag==1)
{
count++;
for(q=0;q<num_resource;q++)
{
total[q]+=allocate[i][q];
allocate[i][q]=0;
}
}
}
if(count!=0)
returntrue;
returnfalse;
}*/
分享到:
Global site tag (gtag.js) - Google Analytics
相关推荐
银行家算法pdf文献打包 共9篇 解晨,王瑜.多资源银行家算法研究与实现[J].电脑知识与技术,2013,9(18):4229-4233. 摘要:在通常情况下,计算机的资源有限,比如只有一台打印机或者只有有限的内存,并且很多资源是独占性...
银行家算法是操作系统中进程管理领域的一个重要概念,主要用于避免死锁的发生,通过预先分配资源的方式确保系统的安全性。此算法由计算机科学领域的先驱之一、图灵奖得主Edsger Dijkstra提出,其核心思想是在系统...
### 银行家算法详解 #### 一、引言 银行家算法是操作系统中用于避免死锁的一种重要策略,其基本思想源自于银行信贷体系的管理方式。在本篇报告中,我们将深入探讨银行家算法的核心原理及其具体实现过程,并通过一...
《银行家算法C语言实现详解》 银行家算法是一种经典的资源分配策略,旨在预防系统中的死锁问题。在多道程序设计系统中,多个进程可能会同时请求多种资源,如果资源分配不当,可能导致进程无法继续执行,形成死锁。...
银行家算法银行家算法银行家算法银行家算法
Java实现银行家算法(GUI界面)A+报告 银行家算法是操作系统中避免死锁的一种经典算法,由Dijkstra提出。该算法可以有效地避免操作系统中出现死锁的问题。本文将详细介绍如何使用银行家算法来处理操作系统给进程分配...
银行家算法找出所有安全序列.cpp银行家算法找出所有安全序列.cpp银行家算法找出所有安全序列.cpp银行家算法找出所有安全序列.cpp银行家算法找出所有安全序列.cpp银行家算法找出所有安全序列.cpp银行家算法找出所有...
《银行家算法与安全性算法详解》 银行家算法和安全性算法是操作系统中资源调度的重要理论,主要用于预防死锁的发生,确保系统的安全性。在多任务环境下,资源的合理分配至关重要,这两种算法为此提供了科学的解决...
用银行家算法防止死锁。 二、实验目的 死锁会引起计算机工作僵死,造成整个系统瘫痪。因此,死锁现 象是操作系统特别是大型系统中必须设法防止的。通过本次实验,使 学生掌握死锁的概念和产生死锁的原因和必要条件,...
(1)若进程P1请求资源,发出请求向量Request1(1,0,2),编写程序用银行家算法判断系统能否将资源分配给它; (2)若进程P2提出请求Request(0,1,0),用银行家算法程序验证系统能否将资源分配给它。
仿真模拟银行家算法对死锁的避免。 所谓安全状态是指系统能按某种进程顺序,来为每个进程pi分配所需的资源,直至满足每个进程对资源的最大需求,使每个进程都可顺利地完成。如果系统无法找到这样一个序列,则系统...
银行家算法是操作系统中一种经典的资源分配策略,用于预防死锁的发生。该算法由艾兹格·迪杰斯特拉在1965年提出,旨在确保系统资源的安全分配,以避免系统进入无法恢复的状态,即死锁。在这个压缩包文件中,包含了一...
银行家算法是操作系统中一种经典的资源分配策略,用于预防死锁的发生。它的核心思想是确保系统在任何时候都不会处于不安全状态,从而避免资源饥饿和系统的崩溃。本程序以可视化的方式展示了这一过程,使得用户能够...
《银行家算法Java实现带UI界面详解》 银行家算法,由荷兰计算机科学家艾兹格·迪科斯彻提出,是一种预防死锁的策略,它主要用于操作系统中资源的分配,以确保系统的安全性。该算法的核心在于预先分配一部分资源,...
《银行家算法在操作系统中的应用——Java实现及图形界面》 银行家算法是操作系统中用于避免死锁的一种著名策略,由艾兹格·迪杰斯特拉在1965年提出。它主要用于解决资源分配问题,确保系统的安全性,防止因不当的...
银行家算法是操作系统中一种著名的资源分配策略,用于预防死锁的发生。它的设计目标是确保系统在面临资源请求时能够避免出现死锁状态,保证系统的安全性。本项目以C语言实现银行家算法,旨在帮助开发者深入理解该...
操作系统中的银行家算法是一种著名的资源分配策略,用于避免系统的死锁情况。在计算机科学中,尤其是在操作系统设计中,死锁是指多个进程互相等待对方释放资源而无法继续执行的状态。银行家算法通过预分配和检查安全...
根据给定的信息,我们可以分析并总结出与“银行家算法”相关的知识点,这些知识点主要集中在操作系统中的资源分配和死锁避免策略上。 ### 银行家算法简介 银行家算法是操作系统中一种用于避免死锁的安全算法。该...
《银行家算法在VC++环境下的实现》 银行家算法是计算机系统中解决并发进程资源分配问题,防止死锁的一种经典策略。它由E.F.科恩于1965年提出,主要用于确保系统的安全性。在多任务并行运行的环境中,如果进程之间对...