山东建筑大学信计专业操作系统实验报告.docx

山东建筑大学信计专业操作系统实验报告.docx

《山东建筑大学信计专业操作系统实验报告.docx》由会员分享，可在线阅读，更多相关《山东建筑大学信计专业操作系统实验报告.docx（22页珍藏版）》请在冰豆网上搜索。

山东建筑大学信计专业操作系统实验报告

实验一、进程管理与进程同步

实验目的：

了解进程管理的实现方法，理解和掌握处理进程同步问题的方法。

实验内容：

实现银行家算法和读者-写者问题的写者优先算法。

实验步骤：

银行家算法：

（1）针对3类资源、5个进程的情况，设计相应的数据结构，分别表示每个进程占用各类资源的情况；

（2）编程实现安全性算法函数，编制主函数，动态输入资源的占用情况，进程的资源申请，调用安全性函数，实现银行家算法；

（3）测试：

输入可分配和不可分配的请求，测试系统的正确性

读者-写者问题的写者优先算法：

（1）首先建立各种资源文件，即四个类文件（Reader、Writer、Source、ReadWrite）

（2）使用java提供的管程来模拟实现进程之间的同步关系。

总结：

本次实验提高了我们的编程能力，我们利用了程序模拟了操作系统的进程同步机制和安全性算法，很好的掌握了银行家算法的思想，以及利用银行家算法找安全序列，利用安全序列不免处理机死锁。

本次实验在开始时我们准备还存在一些问题，没有很好的充分准备，以至于在实验中出现一些问题，实验进度比较缓慢，机会是留给有准备的人的，让我们在这里真正理解到了这个道理，但在老师的细心辅导下，我们都成功的完成了本次实验。

附录：

银行家算法代码：

银行家（Banker）：

importjava.util.Scanner;

publicclassBanker{

intm;

intn;

int[][]max;

int[][]maxbak;//备份用

int[][]allocation;

int[][]allocationbak;//备份用

int[][]need;

int[][]needbak;//备份用

int[]available;

int[]availablebak;//备份用

publicBanker（）{

Scanners=newScanner（System.in）;

System.out.println（"初始化=============="）;

System.out.print（"请依次输入系统中的【进程数】和【资源类型数】：

"）;

m=s.nextInt（）;

n=s.nextInt（）;

max=newint[m][n];

maxbak=newint[m][n];

allocation=newint[m][n];

allocationbak=newint[m][n];

need=newint[m][n];

needbak=newint[m][n];

available=newint[n];

availablebak=newint[n];

for（inti=0;i

System.out.print（"请依次输入第"+i+"进程的各资源数：

"）;

for（intj=0;j

max[i][j]=s.nextInt（）;

maxbak[i][j]=max[i][j];

}

}

for（inti=0;i

System.out.print（"请依次输入第"+i+"进程中已分配资源的数量：

"）;

for（intj=0;j

allocation[i][j]=s.nextInt（）;

allocationbak[i][j]=allocation[i][j];

}

}

for（inti=0;i

for（intj=0;j

need[i][j]=max[i][j]-allocation[i][j];

needbak[i][j]=need[i][j];

}

}

for（inti=0;i

System.out.print（"请输入系统中第"+i+"种资源的剩余量：

"）;

available[i]=s.nextInt（）;

availablebak[i]=available[i];

}

System.out.println（"初始化结果============="）;

System.out

.println（"MAXALLOCATIONNEEDAVAILABLE"）;

for（inti=0;i

System.out.print（"P"+i+":

"）;

for（intj=0;j

if（max[i][j]>9）{//如果是两位数，控制格式，在数字前少输出一个""。

System.out.print（max[i][j]+""）;

}else{

System.out.print（""+max[i][j]+""）;

}

}

System.out.print（""）;

for（intj=0;j

if（allocation[i][j]>9）{

System.out.print（allocation[i][j]+""）;

}else{

System.out.print（""+allocation[i][j]+""）;

}

}

System.out.print（""）;

for（intj=0;j

if（need[i][j]>9）{

System.out.print（need[i][j]+""）;

}else{

System.out.print（""+need[i][j]+""）;

}

}

if（i==0）{

System.out.print（""）;

for（intj=0;j

if（available[j]>9）{

System.out.print（available[j]+""）;

}else{

System.out.print（""+available[j]+""）;

}

}

}

System.out.println（）;

}

System.out.println（"=====完成初始化====="）;

System.out.println（）;

}

publicvoiddeadlockAvoidance（）{

int[]security=newint[m];

boolean[]param=newboolean[m];

int[]tar=newint[n];

intcount=0;

intnum1=m+1;//计数器,每循环一遍所有进程就自减1

intnum2=m;//计数器，每遇到一个被满足的进程就自减1

while（num1>0）{//如果num1==0，则说明依次循环下来没有能够满足的进程，因此中止

for（inti=0;i

if（param[i]==false）{//只有没有被满足的进程才可以进入内层循环

param[i]=true;

for（intj=0;j

tar[j]=available[j]-need[i][j];

if（tar[j]<0）{

param[i]=false;

}

}

if（param[i]==true）{

for（intk=0;k

available[k]=available[k]+allocation[i][k];

}

security[count]=i;//记录以满足的进程号

count++;

num2--;

}

}

}

num1--;

while（（num2==0）&&（num1>0））{

System.out.print（"【安全序列】为：

"）;

for（inti=0;i

if（i==（m-1））{

System.out.print（"P"+security[i]）;

}else{

System.out.print（"P"+security[i]+"-->"）;

}

}

System.out.println（）;

System.out.println（"=====【死锁避免】结束====="）;

System.out.println（）;

return;

}

while（（num1==0）&&（num2>0））{

System.out.println（"抱歉！

没有【安全序列】！

"）;

System.out.println（"=====【死锁避免】结束====="）;

System.out.println（）;

return;

}

}

}

publicvoiddeadlockDetection（）{

Scannersc=newScanner（System.in）;

intkey;

int[]security=newint[m];

boolean[]param=newboolean[m];

int[]temp=newint[n];

int[]tar=newint[n];

intcount=0;

intnum1=m+1;

intnum2=m;

for（inti=0;i

max[i][j]=maxbak[i][j];

allocation[i][j]=allocationbak[i][j];

need[i][j]=needbak[i][j];

available[j]=availablebak[j];

}

}

System.out.println（）;

System.out.println（"死锁检测============"）;

System.out.println（"如果您此时想申请系统资源请输入【进程号】和"+n+"种【资源量】，系统将帮您判断是否可行。

"）;

System.out.print（"您输入的进程号为：

"）;

key=sc.nextInt（）;

for（inti=0;i

System.out.print（"您要申请的第"+i+"种资源的数量为：

"）;

temp[i]=sc.nextInt（）;

}

for（inti=0;i

allocation[key][i]=allocation[key][i]+temp[i];

need[key][i]=need[key][i]-temp[i];

if（need[key][i]<0）{

System.out.println（"申请资源大于所需资源，系统【不能】分配资源！

"）;

for（intk=0;k

for（intj=0;j

if（k==0）{

available[j]=availablebak[j];

}

max[k][j]=maxbak[k][j];

allocation[k][j]=allocationbak[k][j];

need[k][j]=needbak[k][j];

}

}

return;

}

available[i]=available[i]-temp[i];

if（available[i]<0）{

System.out.println（"申请资源大于系统所剩资源，系统【不能】分配资源！

"）;

for（intk=0;k

for（intj=0;j

if（k==0）{

available[j]=availablebak[j];

}

max[k][j]=maxbak[k][j];

allocation[k][j]=allocationbak[k][j];

need[k][j]=needbak[k][j];

}

}

return;

}

}

System.out.println（"申请资源时各进程的状态============="）;

System.out

.println（"MAXALLOCATIONNEEDAVAILABLE"）;

for（inti=0;i

System.out.print（"P"+i+":

"）;

for（intj=0;j

if（max[i][j]>9）{

System.out.print（max[i][j]+""）;

}else{

System.out.print（""+max[i][j]+""）;

}

}

System.out.print（""）;

for（intj=0;j

if（allocation[i][j]>9）{

System.out.print（allocation[i][j]+""）;

}else{

System.out.print（""+allocation[i][j]+""）;

}

}

System.out.print（""）;

for（intj=0;j

if（need[i][j]>9）{

System.out.print（need[i][j]+""）;

}else{

System.out.print（""+need[i][j]+""）;

}

}

if（i==0）{

System.out.print（""）;

for（intj=0;j

if（available[j]>9）{

System.out.print（available[j]+""）;

}else{

System.out.print（""+available[j]+""）;

}

}

}

System.out.println（）;

}

System.out.println（"=====完成状态展示====="）;

System.out.println（）;

while（num1>0）{//如果num1==0，则说明依次循环下来没有能够满足的进程，因此中止

for（inti=0;i

if（param[i]==false）{//只有没有被满足的进程才可以进入内层循环

param[i]=true;

for（intj=0;j

tar[j]=available[j]-need[i][j];

if（tar[j]<0）{

param[i]=false;

}

}

if（param[i]==true）{

for（intk=0;k

available[k]=available[k]+allocation[i][k];

}

security[count]=i;//记录以满足的进程号

count++;

num2--;

}

}

}

num1--;

while（（num2==0）&&（num1>0））{

System.out.print（"【安全序列】为：

"）;

for（inti=0;i

if（i==（m-1））{

System.out.print（"P"+security[i]）;

}else{

System.out.print（"P"+security[i]+"-->"）;

}

}

System.out.println（）;

System.out.println（"可以产生新的安全序列！

系统【能】将申请的资源分配给P"+key+"！

"）;

System.out.println（"=====死锁检测结束====="）;

System.out.println（）;

return;

}

while（（num1==0）&&（num2>0））{

System.out.println（"抱歉！

【没有】安全序列！

"）;

System.out.println（"系统【不能】将申请的资源分配给P"+key+"！

"）;

System.out.println（"=====死锁检测结束====="）;

System.out.println（）;

return;

}

}

}

}

测试类（BankerTest）：

importjava.util.*;

publicclassBankerTest{

publicstaticvoidmain（String[]args）{

Scannerscanner=newScanner（System.in）;

Bankertb=newBanker（）;

tb.deadlockAvoidance（）;//死锁避免

intgate=1;

while（gate!

=0）{

tb.deadlockDetection（）;//死锁检测

System.out.println（"如果您要继续分配资源请输入\"1\"，退出请输入\"0\""）;

System.out.print（"您输入的值为：

"）;

gate=scanner.nextInt（）;

System.out.println（）;

}

System.out.println（"使用愉快！

期待您下次使用！

"）;

}

}

读者-写者问题的写者优先算法

资源文件（Source）：

publicclassSource{

//资源是否可以读或者可以写

privatebooleanvalueset;

//写入的资源

privateStringsource;

publicSource（）{

super（）;

this.valueset=false;

}

publicsynchronizedStringread（）{

if（!

valueset）{

try{

System.out.println（"写者还未将信息写入，进入等待状态......"）;

wait（）;

}catch（InterruptedExceptione）{

e.printStackTrace（）;

}

}else{

}

this.valueset=false;

notify（）;

System.out.println（"当前读到的信息：

"+this.source）;

returnthis.source;

}

publicsynchronizedvoidwrite（Stringsource）{

if（valueset）{

try{

System.out.println（"读者还未将信息读走，进入等待状态......"）;

wait（）;

}catch（InterruptedExceptione）{

e.printStackTrace（）;

}

}else{

this.source=source;

}

this.valueset=true