操作系统实验报告-利用银行家算法避免死锁

计算机操作系统实验报告题目利用银行家算法避免死锁

一、实验目得:

１、加深了解有关资源申请、避免死锁等概念,并体会与了解死锁与避免死锁得具体实施方法。

２、要求编写与调试一个系统动态分配资源得简单模拟程序,观察死锁产生得条件,并采用银行家算法,有效得防止与避免死锁得发生。

二、实验内容:

用银行家算法实现资源分配:

设计五个进程{p0,ｐ1,p2，ｐ３,p4}共享三类资源{Ａ,B,C}得系统,例如,｛A，Ｂ，C}得资源数量分别为1０,5,7。进程可动态地申请资源与释放资源,系统按进程得申请动态地分配资源,要求程序具有显示与打印各进程得某一个时刻得资源分配表与安全序列;显示与打印各进程依次要求申请得资源号以及为某进程分配资源后得有关资源数据。

三、问题分析与设计:

1、算法思路:

先对用户提出得请求进行合法性检查,即检查请求就是否大于需要得,就是否大于可利用得。若请求合法,则进行预分配,对分配后得状态调用安全性算法进行检查。若安全,则分配;若不安全,则拒绝申请,恢复到原来得状态，拒绝申请。

2、银行家算法步骤:

(１)如果Ｒequestｉ

(2)如果Rｅｑｕｅsｔ

（３)系统试探把要求得资源分配给进程Pi，并修改下面数据结构中得数值:

Aｖailable=Aｖaiｌable-Ｒequest[i];

Aｌｌoｃａtｉon=Aｌlｏcａｔion＋Reqｕest;

Need＝Need－Request；

（4)系统执行安全性算法,检查此次资源分配后,系统就是否处于安全状态。

3、安全性算法步骤:

（1)设置两个向量

①工作向量Work。它表示系统可提供进程继续运行所需要得各类资源数目,执行安全算法开始时,Wｏrk=Allｏcaｔioｎ;

②布尔向量Fiｎiｓh。它表示系统就是否有足够得资源分配给进程,使之运行完成，开始时先做Finish[ｉ]=fａlse，当有足够资源分配给进程时,令Fiｎiｓｈ[i]=tｒuｅ。

(2)从进程集合中找到一个能满足下述条件得进程:

①Fiｎish[i]＝faｌse

②Ｎｅｅｄ

如找到,执行步骤（3);否则,执行步骤(4)。

(3)当进程P获得资源后，可顺利执行，直至完成,并释放出分配给它得资源，故应执行:

Work=Wｏｒk+Aｌｌｏcａtion;

Fｉnish［i]＝true;

转向步骤（2)。

(4)如果所有进程得Finish[i]=true，则表示系统处于安全状态;否则,系统处于不安全状态。

４、流程图:

系统主要过程流程图

银行家算法流程图

安全性算法流程图

5、主要数据结构

假设有Ｍ个进程Ｎ类资源，则有如下数据结构:

inｔ max[M*Ｎ] M个进程对Ｎ类资源得最大需求量

ｉnt availabｌe[N] 系统可用资源数

ｉnt aｌloｃａtｅd［M*Ｎ] M个进程已经得到N类资源得资源量

int need[M*N] Ｍ个进程还需要N类资源得资源量

inｔ worｋed[］系统提供给进程继续运行所需得各类资源数目

四、源代码

impoｒｔ jａva、ａwｔ、＊;

iｍport javax、swinｇ、*;

ｉｍport jaｖa、utiｌ、*；

imporｔjavａ、ａwｔ、event、*；

impｏｒt jａvａx、sｗing、border、*；

puｂｌic ｃlass ＯsＢanker extends JFrame { // 界面设计

ＪLaｂel laｂelInｆo;

JＬabel lａbｅlＩnfｏ１;

?int rｅsourｃeNuｍ, pｒocessＮuｍ;

int coｕnt = 0;

?JBｕｔtｏｎｂuttonRｅｑuest, buttoｎＳetIniｔ，ｂutton， buttｏn1，bｕｔtonseaｒｃh，bｕtton２;

JＴextField tf1, tｆ2；

JTexｔField［] texｔＡｖaiｌaｂｌe;

JTｅxｔField[][］textＡlloｃation;

?ＪTextField[］[］ tｅxtＮeed;

ＪＴextFiｅld textProceｓsＮame;

?ＪTｅｘtＦieｌｄ［] textRequesｔ；

iｎt avａilabｌe［］；

iｎt max[］[];

inｔｎeed[][］；

?iｎt allocated[][］；

?int SaｆeSeｑuence[];

int requｅsｔ[];

boｏlean Finish[];

?ｉnt workｅd[];

boolean flａｇ= false;

JFraｍe f１；

JFrame ｆ2;

?JＦrａｍe f3；

JTeｘtArea jt；

?void disｐlay() {

Border borｄeｒ = BorｄｅｒＦactｏｒy、creａｔｅＬowerｅｄBeveｌBｏｒｄe ｒ();

?Border bｏrｄeｒＴitled = BoｒdｅrFactoｒy、creatｅTｉtｌeｄBordｅr(ｂorder， "按钮区")；

?textAvaｉlａｂｌｅ= neｗＪTexｔFieｌd[5];

??tｅｘtAｌlocａtioｎ = new JTextＦield[６][5];

?textNeed = new JTextField[6][５]；

?textＰroｃｅｓｓＮａme = new JTextFiｅld("")；

?textProcessName、sｅtEnableｄ(falｓｅ);

?textRequest = ｎew JTｅxｔFｉeｌｄ[5]；

?tf1 = new ＪＴexｔＦield（20);

?tｆ２ = new JＴextFiｅld(2０);

??lａbelＩnｆｏ = nｅw JLaｂeｌ(＂请先输入资源个数与进程个数(1～６),后单击确定");

?JPanel ｃｏnｔeｎｔPａne;

cｏntentＰaｎｅ = (ＪPanｅl） this、ｇetContentPａｎe();

??contentPane、setLayouｔ(ｎull)；

cｏｎtｅｎtＰane、setBaｃｋgroｕnｄ(Color、pink);

?labelInｆｏ、seｔBounds(50, 10， 300, ４0);

ｌabｅlInfo、sｅtOpaｑuｅ(ｔｒｕｅ）;

labｅlＩnfo、setForeｇｒｏuｎd(Coloｒ、rｅd);

ｌaｂeｌIｎfo、ｓetBacｋｇrounｄ(Ｃolor、ｐiｎk);

cｏntｅntPaｎe、add(ｌabelＩｎfo, nulｌ）;

ＪＬａbel ｂ1 = ｎeｗ JLａｂｅl("资源个数:＂)；

?ｂ1、setForｅground(Color、ｂｌｕｅ);

??JLabel b2 = new JLａbel（"进程个数:＂)；

?ｂ2、sｅtＦorｅｇｒound(Color、bｌue)；

??b１、ｓetBounds(50, 8０, 80, 30）;

ｃonｔentPａnｅ、adｄ（ｂ１, null);

ｔf１、setBoundｓ(1８0, 8０, １70, 30）;

??cｏｎtentPanｅ、ａdd(tf1, null);

?b２、sｅｔBｏuｎds(50， 150, ８0, 30)；

?coｎtenｔPaｎe、ａdd(b2, null);

?tf2、setBｏｕｎds(1８0， 150, １７0, 30);

?ｃｏｎtentＰane、aｄd（ｔf2, ｎｕｌｌ）;

?buｔｔon1 ＝ new JBｕｔtｏn("确定"）；

?buｔtoｎ = new ＪButtｏn("重置");

buｔton1、setBｏｕnds(80, 200， 80, ３０）;

??ｃｏｎtentPane、add(buｔton1, null);

??button、setBounds(２2０, 2０0, 80, 3０）;

?contentPane、adｄ(button, nulｌ）;

ｔｈis、ｓｅtSize(400，３0０);

??this、setResｉｚable(false);

?thiｓ、sｅtＴｉtle（"银行家算法（ＳＸJ）＂);

?thｉs、setLocatｉonＲelatiｖeＴｏ(null)；

?ｔhｉs、setDefaultClｏsｅOｐerａtion(ＥXＩT＿ON_CLOSE)；

?thiｓ、setＶｉｓiｂle(truｅ);

??f１ = nｅw JＦrame(）;

?labelInfo1 ＝ nｅw ＪＬaｂel(＂请先输入最大需求与分配矩阵,然后单击初始化"）;

??ＪPaｎｅl ｃontｅntPane１;

?cｏｎtentPaｎｅ１＝（ＪＰanｅl） f１、getＣontｅｎtPanｅ(）;

?cｏntentPane１、sｅtLａｙout(ｎull）;

??contentPane1、sｅtＢａckgrouｎd(Colｏr、ｐink);

?ｌabelＩnfo1、sｅｔOpaquｅ(tｒue);

??labelIｎfo1、setＢouｎdｓ(75, 10，４00, 40）;

?labｅlInfo１、seｔBackgroｕnｄ(Ｃolor、ｐｉnk）；

?labelInfo1、sｅtFｏregroｕｎd（Color、blｕe)；

??cｏntｅntＰane1、ａdd(labｅlInfo1, null）;

?JＬaｂel lａbelAvailableLaｂｅl = new ＪLabeｌ（"AllRｅsoｕｒｃe：")；

ＪLabel labｅlNｅeｄLabｅl = new ＪLaｂｅl("ＭaxＮeｅd:＂）;

JLａbel laｂeｌAlloｃaｔionＬabｅl = new JLaｂel（"alｌocatｅd:");

??JLabｅl ｌaｂeｌRｅｑuｅｓtLabｅl ＝nｅw ＪLａbel("rｅqueｓｔ prｏｃesｓ："); ?labeｌNeedＬabel、setBounds(７5，９0，１０0， 20);

?// ｘ,y,widtｈ,heiｇht

?conteｎtPanｅ1、add（lａbｅｌNｅedＬabel, nｕlｌ);

??lａｂｅlAllｏcatｉonLaｂel、setBｏunds（75, 2４0, 100， 20);

?conteｎtPaｎe1、add(labelAlｌocationLabel, null)；

?lａｂｅlAvａｉlａbｌeLａbel、seｔBounds(75, 70, 10０，２0)；

?conｔentPａｎe１、ａｄd(laｂeｌＡvailabｌeＬａbeｌ, nuｌｌ）;

?laｂeｌReqｕｅstLaｂeｌ、sｅtBｏunｄs(７5, 400, 100, 2０);

??cｏnｔentPａne1、add(lａbeｌRｅquesｔＬabｅl, nulｌ);

?JＬａbel[] lａｂeｌProcｅssＬａbel１ = { neｗ JLａbeｌ(＂进程1＂), neｗJLabｅl("进程2＂）,

???ｎew ＪLabｅｌ(＂进程3＂), ｎew ＪLabeｌ（"进程４"）， neｗＪLabel（"进程５"),

ｎｅw JＬａbｅl（＂进程6"）｝；

JＬaｂeｌ[] lａbelＰrｏceｓsＬabel2 = { ｎew ＪＬabel("进程1"), neｗ JL ａbｅl("进程2"),

?new JＬａｂel("进程３＂), new JＬaｂel("进程4"), new JＬabel("进程5"),

?nｅw ＪLａｂeｌ（"进程6＂) ｝;

?JＰａｎeｌｐＰanel1 ＝ｎｅw JPanel(), pPanel2 ＝ neｗＪPaｎel（)，ｐPa ｎｅｌ3 ＝ new JＰａnel(), ｐＰanel4 = neｗ JＰaｎel（）;

?pPanel1、ｓｅtLayout(ｎuｌl);

?ｐPaｎel2、sｅｔLaｙout(nｕll）;

/*

* pPanel4、seｔLayoｕt(nｕll)； pPａnel４、setBounds(440，1２0,90,2７0);

* pPanel4、setBoｒder(ｂordeｒTitled）;

?*/

?bｕttonSeｔIniｔ = ｎｅw ＪButtoｎ（"初始化＂)；

?butｔonsｅarcｈ= ｎｅw JBｕtｔｏn（"检测安全性");

?bｕｔton2 = new JBｕtton(＂重置");

?buttｏnRequｅsｔ = new JButton("请求资源"）;

?buｔtonSetＩnit、setBｏundｓ(420, 1４0, 100, 30)；

?ｃonｔentＰanｅ1、aｄｄ（ｂutｔonSｅtIniｔ, nuｌl);

??buttonｓearch、ｓetBｏｕndｓ（420, 240, １0０, 30);

?ｃonｔｅｎｔＰanｅ1、aｄd(buttｏｎｓｅａrch, nuｌl）；

buｔton２、setＢoundｓ(4２0, 340， 100, 30);

coｎtentPane1、ａdd(button2, null）;

??buttｏnRｅquｅst、setＢｏunds(4２0， 425, 100， 30)；

?ｃonteｎtＰａne1、add（buttonRｅquest, null);

??for （int pi = 0; pi ＜6; pi++） {

?lａbｅlPｒocessLabel1[ｐi]、setＢouｎｄs(0, 0 ＋pi * 20， 60, 20); ??lａbｅlPｒｏcesｓＬaｂel2［ｐｉ]、sｅtBounds(０, 0 ＋ pi ＊ 20, 60, 20)；??}

pＰaｎeｌ1、setBoｕnｄｓ(7５, １20，６0, １２0);

?pPanel２、setBoｕｎds（75, 270，６0, 1２０);

??for (ｉnｔ pi = ０; pi ＜ 6; pi++) {

??pPanel１、ａdｄ（lａbelProcｅｓsLabel1［pi]， null);

??ｐPａnｅｌ2、ａdd(lａbelProｃeｓsLabeｌ２[ｐｉ］, nｕlｌ）;

｝

??contenｔPａnｅ1、add（ｐPanel1);

contｅnｔＰane1、aｄd(ｐPaｎｅl2);

contentPaｎe1、aｄｄ(ｐＰaneｌ4)；

??ｆoｒ (inｔ si ＝0; si < 5; si++)

??for (ｉnt pi ＝０; ｐi < 6；ｐi++) {

??ｔｅｘtNeed[pi][si] = neｗＪＴｅxtＦield（）;

?textNeｅd[pi][si]

???、seｔBoｕndｓ(150 + sｉ＊ 5０, 1２0 + pi * 20, 50, ２０);

??texｔNeed［pi][ｓi]、seｔＥdiｔaｂle(falｓe);

?textＡｌlocａtion[ｐi][ｓi］ = new JＴeｘtＦield();

ｔｅｘtAllｏcation[ｐｉ］[si］、sｅｔBounds(15０ + ｓi * ５0，27０ + pｉ * 2０,

50， 2０)；

?tｅｘtAｌloｃaｔion[pｉ][sｉ］、setＥdｉｔablｅ(falｓe）；

?}

?ｆｏｒ (int si = ０; si < ５; ｓi++) ｛

???ｔextＡvａiｌａｂlｅ[ｓｉ] = new JTexｔField(）；

??ｔextAvａｉlaｂｌe[sｉ]、seｔEdｉtaｂｌe（fａlse）;

??teｘtAvaｉlable[si]、setBｏunds(1５0 + ｓｉ * 50, 70, ５0, 2０）;

??teｘtReｑuｅsｔ［si] ＝new JTｅxtField（)；

??ｔexｔRｅqueｓt[si]、seｔＥditａble（ｆaｌse）;

???texｔRequest[ｓi]、sｅtBouｎdｓ（1５0 + si * 5０, 430, ５0, 20）;

??ｃontｅntPａｎe１、ａdd（ｔｅxtAvaiｌaｂle[ｓi], ｎｕｌl);

ｃonｔｅｎtPanｅ1、add(textReqｕest[si］， nulｌ）;

??}

??ｆoｒ (int ｐi = 0; ｐｉ < 6；ｐi++)

fｏr (int si = ０; ｓi < 5; si＋＋） {

??coｎtｅntPanｅ1、ａdd(textNeeｄ[pi］[ｓi]， null)；

??contｅｎtPanｅ1、add(textＡｌlocａtion[pi］[ｓi], null）;

??}

?tｅｘtＰrocｅssNamｅ、sｅtＢouｎdｓ(8０, 4３０, 50, 2０)；

?conｔeｎtPａne１、add(teｘtＰrocessName，nｕｌl）;

?f1、setＳize（５50，５00);

??ｆ1、ｓｅtResiｚaｂlｅ（false);

f１、sｅｔTitｌe("银行家算法(SXJ)");

?f1、setLocationRｅlatiｖeTｏ(nuｌｌ);

?f1、setDeｆaultCloｓeＯperaｔion(ＥXIT＿ＯN_CLOSE）;

?／／ f1、sｅtＶisiｂle(true）;

?f1、setVｉｓible(falsｅ);

?f2 = new JFｒame（"安全序列显示框");

??jt ＝ nｅw JTextAｒea(7５, 4０)；

?jt、sｅtBackgroｕｎd(Coloｒ、pｉnk）;

?ｊt、sｅtＦｏregroｕnｄ(Cｏlor、blue);

?JScｒｏlｌPanｅ scrollPaｎe = ｎeｗ JScrollＰane(jt)； // 加滚动条

?scｒoｌlPane、seｔＢｏｒdeｒ(BordｅrFactoｒy、creａteLoweｒeｄBevelＢorder （))；／/ 边界

?(f２、getCｏｎｔentPaｎe（))、add(scrollＰane);

f２、ｓetＳｉze(45０，400);

f2、ｓｅtResizａble(false)；

?f2、seｔＤefaｕltＣｌoseOperａｔｉon（ＥXＩT_ON_ＣLOSＥ);

?f2、sｅtVｉsiｂlｅ(faｌｓe);

?bｕｔｔonSｅｔInit、setEnabｌed(ｆalsｅ）；

?ｂuttonReｑｕest、setEnabled（ｆaｌse）;

?buttｏnseａrch、sｅtＥｎaｂled(falｓe);

?buｔｔon１、ａｄdActiｏnＬiｓtｅner(ｎeｗＡcｔｉoｎListeｎeｒ（) { pubｌｉｃ vｏｉd ａctｉｏnPerformed(ＡctionEvenｔ e) {

?/／ lａｂelIｎfｏ、seｔTexｔ("请先初始化allocａtｅd与Maｘneed,后单击初始化按钮")；

??f1、sｅtVisiｂｌｅ(ｔrue);

?buttonＳetIｎit、sｅtEnabled(truｅ);

????reｓouｒｃeNum = Inteｇeｒ、pａrｓeＩｎt(tf1、getText（）);

?prｏcessNｕm = Intｅgｅr、parseInt(tf2、ｇetTeｘt());

??for (int i = 0; i < prｏcessNum； i++) {

??fｏr (ｉnt j ＝０; j < resｏuｒceNｕm; j++) {

?textNeed[i]［ｊ]、setＥdiｔable（true)；

???tｅｘtAｌlｏcａtion［i][ｊ］、setＥdｉtable(ｔrｕe);

?teｘtAvａｉlaｂle［j］、ｓetEdiｔａｂle(true);

????}

????}

??｝);

??ｂuttoｎSｅtInｉｔ、ａddActｉoｎLｉstener(new ＡｃtｉonＬiｓteneｒ（) { ?pｕbliｃｖoｉd aｃtionPerｆorｍed(ActiｏnEｖenｔｅ) ｛

?Init（）;

???buｔtonｓｅａrｃh、ｓetＥnabled（tｒｕe);

?}

});

?buｔtonｓeａrch、aｄdAcｔiｏnＬistenｅｒ(ｎeｗ ActiｏnLｉstener() ｛

??public ｖoiｄ actｉonPerfｏrｍed(ActionEvenｔ e) {

?count = ０;

??SafeＳｅquenｃe = new int[pｒｏceｓsNｕm］;

??worｋｅd ＝ｎew ｉｎt[ｒeｓｏurcｅNum]；

Ｆiniｓh = new booleaｎ[processＮuｍ］;

?cｏpyVecｔoｒ（workｅd, ａvaiｌable）;

??Safety（0）;

????jｔ、appeｎd（＂安全序列数量：" + coｕｎt);

?iｆ（fｌag) {

??labｅlＩnｆo1、setTｅxt("当前系统状态：安全");

????ｆ2、ｓetＶｉsｉble(tｒue)；

???bｕttｏnRequest、setEnabled（truｅ)；

??textPrｏcesｓNａmｅ、setEnabled(ｔrｕe）;

??ｆｏr (int i = 0；ｉ < reｓouｒcｅNｕm; i+＋) {

???ｔexｔＲequest[i］、ｓetEdｉtaｂle（true);

??}

} else {

??ｌabelIｎｆo１、setText("当前系统状态:不安全＂);

??｝

??ｂutｔonSetInit、setEｎａｂlｅd(faｌse);

???｝

?});

??buttｏnＲeｑueｓt、ａddAcｔiｏｎＬiｓtener(ｎeｗ ActiｏｎLｉstener() {

???pｕｂｌiｃ voｉd ａctioｎPerｆoｒmｅd(AｃtｉoｎＥvｅｎt e）｛

??coｕｎt = ０;

???for (ｉnｔ i ＝ 0；i < proｃesｓNum; i++) ｛

???Finｉsh[i] = false；

?}

??jt、setＴext（"");

???flag = false;

?ＲequestRｅｓｏｕrce();

}

??}）;

button２、addＡctionLisｔener(nｅw ＡｃtionＬistｅｎer() {

?pubｌic vｏiｄ actionPｅrforｍed（ActionＥvent e) {

? * tｆ1、seｔText(""); tｆ2、ｓeｔText(＂");

?? */

???f2、ｓeｔVisible(falsｅ);

????jt、sｅｔText("");

ｆor (int i = 0； i < ｐrｏcessNum; i++) ｛

??ｆor (int j ＝ 0; j < ｒesouｒceNum; ｊ++) ｛

????tｅｘtＮeeｄ［i][ｊ]、ｓetTexｔ("");

??ｔｅxtAlloｃａtion[ｉ][j]、setText（"＂)；

?????ｔｅｘtAｖａilａble[j]、seｔＴext("＂);

???ｔextＲeｑuest［ｊ]、sｅtＴexｔ("");

// tｅxｔNeed[i]［j]、sｅtEｄitable(fａlsｅ)；

????// teｘｔＡｌlocａtion[i]［ｊ]、setEdｉtable(falsｅ)；

??／/ tｅxｔAｖaｉlable[j]、seｔEdｉtａble(ｆalse);

??textＲｅqｕest［ｊ]、ｓeｔEditable(falsｅ）;

???teｘtProcesｓＮaｍｅ、setＴｅｘt("");

???Finish［i] = ｆalsｅ;

?}

???}

???flａｇ= ｆaｌｓｅ;

???buttｏnseａrｃh、setＥnaｂled(ｆalse)；

???// lａbｅlIｎｆo、setＴext("请先输入资源个数与进程个数,后单击确定"); ???｝

?});

?buｔton、ａdｄActｉonLｉsｔener（new AｃtｉonListｅｎｅr（) ｛

???ｐublic voｉｄ aｃｔionPｅｒformed（AcｔｉonＥvent e) {

?ｔf1、ｓｅtText（"＂);

???tｆ2、setText("");

??f2、setＶisible(ｆalse）;

jt、sｅｔＴexｔ("");

??ｆｌag = false;

??}

??});

?}

?vｏid copyVeｃtｏr(iｎt[] v1, ｉnｔ[］ v2) {

??for (iｎt i = 0; ｉ< v1、lｅnｇth; i++）

??ｖ1[i] = v2[i];

?}

?void Add（ｉｎt[］v１，ｉｎt[］ v2) ｛

??for （ｉnt ｉ = 0; i < v1、length; ｉ++)

v1[i］ += v２[i］;

?}

voｉｄ Sub(iｎt[］ v１, iｎt［] v2) {

?foｒ (ｉnt i = 0; i < v1、length; i＋+)

??v1[i] -= v２[i］;

}

?booｌean Smalｌｅr(inｔ[] v１, ｉnｔ[] v2) ｛

?ｂooleａｎ value ＝ truｅ;

for （ｉnt i = ０; ｉ＜ｖ1、lenｇtｈ; i＋+)

?iｆ (v１[i] ＞v2[i]) {

??valuｅ = ｆalse;

????break；

??}

?return ｖalue;

?｝

public staｔic void main（Sｔring[] args) {

ＯsBaｎker oｂ＝ new OsBanｋer（）；

oｂ、dｉｓpｌay();

?／/ Sysｔｅm、out、prｉntln(" "＋ｃoｕｎｔ）;

?}

?void Inｉｔ() // 初始化操作矩阵

｛

??availａble = new iｎｔ[resｏurcｅＮum];

??for (inｔｉ＝０; i < rｅｓoｕｒceNum; i++) {

?ａvaｉlable[i] = Intｅger、paｒseIｎt(textＡvailａble[i]、gｅtTeｘt()); ??}

?max = ｎew iｎｔ[proceｓsNum］[ｒeｓouｒcｅNum];

aｌlocaｔeｄ = new inｔ［processNum］[ｒesouｒｃeNｕm]；

ｎｅed = new iｎt[processNum］［resoｕrceＮｕm]；

?ｆｏｒ（int ｉ= 0；ｉ < pｒoｃｅsｓNum; i++）｛

??foｒ(ｉnt j ＝ 0； j < reｓoｕrceNuｍ; j++) ｛

?mａx[ｉ][j] ＝ Intｅgeｒ、parseInｔ(tｅxｔNｅed[ｉ]［j]、getTexｔ()）；??allｏcａｔed[i］[j] = Ｉｎtｅｇer、parｓeIｎｔ（textAｌｌocａｔiｏｎ[ｉ][j]

??、getＴext(））;

｝

?}

??for (iｎt ｉ＝ 0; ｉ< resｏｕrcｅNum；ｉ＋+)

??for (iｎt j = 0; j < processNum; ｊ+＋)

???ｎeeｄ[ｊ]［ｉ］＝ max［j][i] - alｌocａｔed［j][i]；

?for (inｔi = ０; i < reｓoｕｒcｅNum; i++)

??foｒ (int ｊ = 0; ｊ < processＮuｍ; j＋+） {

???availaｂle[i] －＝aｌｌｏcatｅｄ[j][i];

???if (aｖailablｅ［i］< ０) {

?labelInfｏ、sｅtTexｔ("您输入得数据有误，请重新输入＂);

???｝

?}

｝

?vｏｉｄSafeｔy(int ｎ) /／查找所有安全序列

?{

?if (ｎ == ｐｒoｃｅｓsＮum） {

counｔ+＋;

??fｏr （ｉnt i = ０; i < processＮum; i＋+) {

???jt、ａppend("进程" + （SafｅSｅqｕence[ｉ］ + １) + " ");

?}

?jｔ、ａppenｄ(＂＼n"）;

??flag = tｒue;

??ｒetｕrn;

}

ｆor (int i = 0; i < ｐrocessＮuｍ; i++) ｛

??if (Finｉsｈ[i］ == false) {

?booleａn ＯK = true;

??ｆｏr (inｔｊ = ０； j < resoｕｒｃeＮum; j++) ｛

?iｆ (nｅed[i][j］> ｗoｒｋeｄ[j]) ｛

??OK = fａlse;

???ｂｒeaｋ;

????｝

??}

ｉf (ＯK) {

??for (int j ＝ 0; j ＜ resoｕｒceNum； j+＋) ｛

??ｗｏrｋed［j] +＝ allocaｔed[i][j]；

}

Finish[ｉ] = true；

?SafeＳequｅnce[n] = i;

Sａfety(ｎ + 1）；

??Finish[ｉ] = ｆalse;

??SaｆeSeqｕence[ｎ] = －1；

???／/ num++;

????foｒ(ｉnt j = 0; ｊ< reｓoｕｒceNｕm; j＋+）｛

???worｋed[j] -= ａlloｃated[ｉ][ｊ］；

???}

??｝

?}

?}

?}

?ｖoid ＲequesｔResｏurｃe(） { ／/ 请求资源

??jt、seｔＴexｔ(""）;

??iｎt proceｓsnａme = （Intｅgｅr、ｐａrsｅIｎt(ｔeｘtProceｓｓNaｍｅ、getText()）- 1);

??ｒequesｔ = new int[resourceNuｍ];

??for (int i = 0; i < rｅsouｒcｅＮum; i＋+) {

ｒeqｕesｔ[i］＝ Iｎtｅger、ｐarseＩｎt(teｘｔＲeqｕest[ｉ]、getTex

ｔ())；

}

?if (!Smａｌler(request, need［prｏceｓsname］)) {

??ｌａbelIｎｆo、ｓeｔTexｔ("资源请求不符该进程得需求量、＂);

?｝ｅlsｅif (!Smaｌleｒ（rｅquest， availaｂｌe）) {

?labelInfo1、setTｅxt("可用资源不足以满足请求,进程需要等待、");

} else {

Sub(aｖailabｌe, ｒequest);

Add(ａｌloｃated[pｒｏceｓｓｎame]， request);

??Sub(nｅed[pｒoceｓsｎame], requeｓt)；

?ｃopyVector（ｗｏrkeｄ, ａvailable);

???Ｓａfety(0);

if (ｆｌaｇ) {

???labelInfo1、setText（"可立即分配给该进程！");

??} elsｅ {

????ｌａbｅｌＩnｆｏ１、sｅtTｅｘt（"分配后导致系统处于不安全状态!,不可立即分配＂)；

??Aｄd(available, reqｕest）;

??Ｓub(alｌocateｄ[prｏcｅssｎame］, rｅquｅsｔ);

?Ａdd（need［prｏcessname]， request);

??}

}

?/／ }

｝

}

五、实验结果:

初始界面:

初始化:

检测安全性:

请求资源：

(1)进程2（1，0,2)

(２）进程5(3,3,0)

(3）进程1（０,2，0)

六、遇到得问题及不足之处:

１、程序编写得时候规定最大资源数与最大进程数均<=6。

２、程序直接初始化了6个进程框,既浪费了内存空间,又对可视化界面得美观造成影响。

３、未对输入异常进行处理:比如在请求资源得第一个方框中只能填入进程得数字编号，当填入得为非整数时,程序会抛出异常。

4、未解决进程名中对字符串得处理，直接固定进程名为数字,用户不能直接输入原有得进程名,造成不好得用户体验。