《计算机操作系统》实验指导书.docx

《计算机操作系统》实验指导书.docx

《《计算机操作系统》实验指导书.docx》由会员分享，可在线阅读，更多相关《《计算机操作系统》实验指导书.docx（32页珍藏版）》请在冰豆网上搜索。

《计算机操作系统》实验指导书

《计算机操作系统》实验指导书

实验一进程同步控制

【开发语言及实现平台或实验环境】

C++/JAVA

TurboC/MicrosoftVisualStudio6.0/MicrosoftVisualStudio.NET2010

【实验目的】

（1）加强对进程概念的理解,尤其是对进程的同步与互斥机制的理解。

（2）分析进程竞争资源的现象，学习解决进程互斥与同步的方法。

【实验内容】

编程模拟实现生产者-消费者进程。

【实验要求】

（1）理解利用进程控制机制；

（2）理解利用信号量进行进程同步控制原理；

（3）使用某种编程语言进行模拟实现生产者-消费者进程。

【实验原理】

（注意：

这个仅是个例子，仅供参考）

生产者-消费者问题描述的是：

有一群生产者进程在生产产品，并将这些产品提供给消费者进程去消费。

为使生产者进程与消费者进程能够并发执行，在两者之间设置了一个具有n个缓冲区的缓冲池，生产者进程将它所生产的产品放入一个缓冲区中；消费者进程可以从一个缓冲区中取走产品去消费。

尽管所有的生产者和消费者进程都是以异步方式运行的，但它们之间必须保持同步，即不允许消费者进程到一个空缓冲区去取产品；也不允许生产者进程向一个已经装满产品的缓冲区中投放产品。

这是一个同步与互斥共存的问题。

生产者—消费者问题是一个同步问题。

即生产者和消费者之间满足如下条件：

（1）消费者想接收数据时，有界缓冲区中至少有一个单元是满的。

（2）生产者想发送数据时，有界缓冲区中至少有一个单元是空的。

故设置两个信号量：

（1）empty：

说明空缓冲区的数目，初值为有界缓冲区的大小N。

（2）full：

说明已用缓冲区的数目，初值为０。

由于有界缓冲区是临界资源，因此，各生产者进程和各消费者进程之间必须互斥执行。

故设置一个互斥信号量mutex，其初值为１。

【实验步骤】

参考实验代码如下：

classQ

{

Stringname;

intnum=0;

intsize=10;

}

classProducerimplementsRunnable

{

Qq;

Producer（Qq）

{

this.q=q;

this.q.name="producer";

}

publicvoidrun（）

{

while（true）

{

synchronized（q）

{

if（q.num

{

q.num++;

System.out.println（"producer已生产第：

"+q.num+"个产品!

"）;

try{

Thread.currentThread（）.sleep（100）;

}catch（InterruptedExceptione）{

e.printStackTrace（）;

}

q.notify（）;

}

else

{

try{

System.out.println（"producerstop!

"）;

q.wait（）;

}catch（InterruptedExceptione）{

e.printStackTrace（）;

}

}

}

}

}

}

classConsumerimplementsRunnable

{

Qq;

Consumer（Qq）

{

this.q=q;

this.q.name="consumer";

}

publicvoidrun（）

{

while（true）

{

synchronized（q）

{

if（q.num>0）

{

System.out.println（"consumer要消费第：

"+q.num+"个产品!

"）;

q.num--;

try{

Thread.currentThread（）.sleep（100）;

}catch（InterruptedExceptione）{

e.printStackTrace（）;

}

q.notifyAll（）;

}

else

{

try{

System.out.println（"consumerstop!

"）;

q.wait（）;

}catch（InterruptedExceptione）{

e.printStackTrace（）;

}

}

}

}

}

}

publicclassproject

{

publicstaticvoidmain（String[]args）

{

Qq=newQ（）;

newThread（newProducer（q））.start（）;

newThread（newConsumer（q））.start（）;

}

}

实验二进程调度实验

【开发语言及实现平台或实验环境】

C++/JAVA

TurboC/MicrosoftVisualStudio6.0/MicrosoftVisualStudio.NET2010

【实验目的】

（1）加深对进程的概念及进程调度算法的理解；

（2）在了解和掌握进程调度算法的基础上，能编制出进程调度算法通用程序。

【实验内容】

编程实现进程调度算法，最少实现两种算法，比较算法的优劣，并将调试结果显示在计算机屏幕上，并检测机算和笔算的一致性。

【实验要求】

（1）了解进程调度；

（2）理解利用进程调度算法进行调度的原理；

（3）使用某种编程语言进行算法模拟。

【实验原理】

（注意：

这个仅是个例子，可以参考本例，选择其他算法进行实验）

一、例题：

设计一个有N个进程的进程调度算法。

进程调度算法：

采用最高优先数的调度算法（即把处理机分配给优先数最高的进程）。

每个进程有一个进程控制块（PCB）表示。

进程控制块可以包含如下信息：

进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。

进程的优先数及需要的运行时间可以事先人为的指定（也可以由随机数产生）。

进程的到达时间为进程的输入的时间。

进程的运行时间以时间片为单位进行计算。

每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。

就绪进程获得CPU后都只能运行一个时间片。

用已占用CPU时间加1表示。

如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤销该进程，如果运行一个时间片后，进程的已占用CPU时间还未达到所需要的运行时间，也就是进程还需要继续运行，此时应该将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。

每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。

重复以上过程，直到所要的进程都完成为止。

分析:

使用固定队列与静动态优先级结合每个优先级为0~0xFF,并且以小的数字为高优先级，大的数字为低优先级，每次皆使用循环得到最高优先级的进程并执行，然后将其动态优先级设置为最低，并将其他进程动态优先级提高，以使得每个进程都有机会运行。

进程的优先级与运行时间由随机数产生。

二、代码试例

#include

#include

#include

/*常量和状态定义*/

#definePRO_NUM0x05

#defineMAX_TIME0xFF

/*状态宏*/

#defineWAIT0x01

#defineRUN0x02

#defineFINISH0x03

#defineID_ERROR0x10

#defineMIN_PRIOR0xFF

#defineMAX_PRIOR0x00

typedefunsignedintUint32;

/*进程PCB*/

structPCB_Info

{

Uint32s_id;

Uint32s_static_prior;

Uint32s_dynamic_prior;

Uint32s_start_time;

Uint32s_need_time;

Uint32s_used_time;

Uint32s_state;

};

/*进程队列*/

PCB_Infog_queue[5];

Uint32g_time;

/*模拟进程执行函数*/

voidSimulator（）;

/*初始化5个进程函数*/

voidInit_Process（）;

/*初始化进程队列函数*/

voidInit_Queue（）;

/*创建进程函数*/

Uint32Create_Process（Uint32pri,Uint32needtime）;

/*系统运行函数*/

voidRun_Process（）;

/*得到最高优先级进程ID函数*/

Uint32Get_PriProcess（）;

/*进程时间片执行函数*/

voidWork_Process（Uint32id）;

/*改变进程状态和优先级函数*/

voidChange_Process（Uint32id）;

/*打印进程状态函数*/

voidPrint_State（）;

/*结束系统函数*/

voidEnd_Process（）;

/*入口函数*/

intmain（intargc,char*argv[]）

{

Simulator（）;

return0;

}

voidSimulator（）

{

Init_Process（）;

Run_Process（）;

End_Process（）;

}

voidInit_Process（）

{

inti;

Uint32id;

srand（（unsigned）time（NULL））;

Init_Queue（）;

for（i=0;i

{

/*在这里修改随机数的范围，建议优先级取值为0到4之间，进程工作总时间为1到10之间*/

id=Create_Process（rand（）%4,1+rand（）%10）;

if（id!

=ID_ERROR）

{

printf（"**********************************\n"）;

printf（"创建进程成功\n"）;

printf（"进程ID号为:

%d\n",id）;

printf（"进程的静态优先权为:

%d\n",g_queue[id].s_static_prior）;

printf（"进程的动态优先权为:

%d\n",g_queue[id].s_dynamic_prior）;

printf（"进程的到达时间为:

%d\n",g_queue[id].s_start_time）;

printf（"进程需要时间为:

%d\n",g_queue[id].s_need_time）;

printf（"进程已用CPU时间为:

%d\n",g_queue[id].s_used_time）;

printf（"进程的状态为:

%d\n",g_queue[id].s_state）;

printf（"\n"）;

}

else

{

printf（"创建进程失败\n"）;

}

}

}

voidInit_Queue（）

{

inti;

for（i=0;i

{

g_queue[i].s_id=i;

g_queue[i].s_dynamic_prior=MIN_PRIOR;

g_queue[i].s_need_time=0;

g_queue[i].s_start_time=0;

g_queue[i].s_static_prior=MIN_PRIOR;

g_queue[i].s_used_time=0;

g_queue[i].s_state=FINISH;

}

}

Uint32Create_Process（Uint32pri,Uint32needtime）

{

inti=0;

Uint32id=ID_ERROR;

for（i=0;i

{

if（g_queue[i].s_state==FINISH）

{

id=g_queue[i].s_id;

g_queue[i].s_dynamic_prior=MIN_PRIOR;

g_queue[i].s_need_time=needtime;

g_queue[i].s_start_time=g_time;

g_queue[i].s_state=WAIT;

g_queue[i].s_static_prior=pri;

g_queue[i].s_used_time=0x0;

break;

}

}

returnid;

}

voidRun_Process（）

{

Uint32id;

while（（id=Get_PriProcess（））!

=ID_ERROR）

{

Work_Process（id）;

Change_Process（id）;

}

}

voidPrint_State（）

{

inti;

printf（"时间进程ID\t状态已用时间需要时间开始时间静优先级动优先级\n"）;

for（i=0;i

{

printf（"%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n",g_time,g_queue[i].s_id,g_queue[i].s_state,g_queue[i].s_used_time,g_queue[i].s_need_time,

g_queue[i].s_start_time,g_queue[i].s_static_prior,g_queue[i].s_dynamic_prior）;

}

}

Uint32Get_PriProcess（）

{

Uint32id=ID_ERROR;

inti,prev_id=ID_ERROR;

Uint32prior=MIN_PRIOR*2,temp_prior;

for（i=0;i

{

if（g_queue[i].s_state!

=FINISH）

{

temp_prior=g_queue[i].s_dynamic_prior+g_queue[i].s_static_prior;

if（temp_prior<=prior）

{

id=i;

prior=temp_prior;

}

}

}

returnid;

}

voidWork_Process（Uint32id）

{

++g_time;

g_queue[id].s_state=RUN;

++g_queue[id].s_used_time;

Print_State（）;

}

voidChange_Process（Uint32id）

{

inti;

if（g_queue[id].s_need_time==g_queue[id].s_used_time）

{

g_queue[id].s_state=FINISH;

}

else

{

g_queue[id].s_dynamic_prior=MIN_PRIOR;

g_queue[id].s_state=WAIT;

}

for（i=0;i

{

if（（i!

=id）&&（g_queue[i].s_state!

=FINISH））

{

g_queue[i].s_dynamic_prior>0?

--g_queue[i].s_dynamic_prior:

g_queue[i].s_dynamic_prior=0;

}

}

}

voidEnd_Process（）

{

printf（"所有进程结束状态:

\n"）;

Print_State（）;

printf（"所有进程已经结束!

\n"）;

}

实验三银行家算法模拟

【开发语言及实现平台或实验环境】

C++/JAVA

TurboC/MicrosoftVisualStudio6.0/MicrosoftVisualStudio.NET2010

【实验目的】

（1）理解利用银行家算法避免死锁的问题；

（2）在了解和掌握银行家算法的基础上，编制银行家算法通用程序。

（3）理解和掌握安全序列、安全性算法

【实验内容】

编程实现银行家算法，能从屏幕完成资源的手动申请，算法执行结果的及时反馈等，并将调试结果显示在计算机屏幕上，并检测机算和笔算的一致性。

【实验要求】

（1）了解和理解死锁；

（2）理解利用银行家算法避免死锁的原理；

（3）使用某种编程语言模拟该算法。

【实验原理】

一、安全状态

指系统能按照某种顺序如（称为序列为安全序列），为每个进程分配所需的资源，直至最大需求，使得每个进程都能顺利完成。

二、银行家算法

假设在进程并发执行时，进程i提出请求j类资源k个后，表示为Requesti[j]=k。

系统按下述步骤进行安全检查：

（1）如果Requesti≤Needi则继续以下检查，否则显示需求申请超出最大需求值的错误。

（2）如果Requesti≤Available则继续以下检查，否则显示系统无足够资源，Pi阻塞等待。

（3）系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：

Available［j］∶=Available［j］-Requesti［j］;

Allocation［i,j］∶=Allocation［i,j］+Requesti［j］;

Need［i,j］∶=Need［i,j］-Requesti［j］;

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

若安全，才正式将资源分配给进程Pi，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。

三、安全性算法

（1）设置两个向量：

①工作向量Work:

它表示系统可提供给进程继续运行所需的各类资源数目，它含有m个元素，在执行安全算法开始时，Work∶=Available;

②Finish:

它表示系统是否有足够的资源分配给进程，使之运行完成。

开始时先做Finish［i］∶=false;当有足够资源分配给进程时，再令Finish［i］∶=true。

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

①Finish［i］=false;

②Need［i,j］≤Work［j］；若找到，执行步骤（3），否则，执行步骤（4）。

（3）当进程Pi获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：

ØWork［j］∶=Work［i］+Allocation［i,j］;

ØFinish［i］∶=true;

Øgotostep2;

（4）如果所有进程的Finish［i］=true都满足，则表示系统处于安全状态；否则，系统处于不安全状态。

【实验步骤】

参考实验步骤如下：

（1）参考下图流程编写安全性算法。

（2）编写统一的输出格式。

每次提出申请之后输出申请成功与否的结果。

如果成功还需要输出变化前后的各种数据，并且输出安全序列。

（3）参考下图所示流程图编写银行家算法。

（4）编写主函数来循环调用银行家算法。

示例：

（注意：

这个仅是个例子，可以参考本例，选择其他算法进行实验）

#include

intmain（）

{

intclaim[5][3]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};//各线程最大需求量

intallocation[5][3]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//各线程已分配资源

inti,j,k,l=0,count=0,m=0;

intC_A[5][3]={{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0}};//各进程仍需要的各类资源

intresult[5]={-1,-1,-1,-1,-1};//存放预分配成功的线程

intcurrentavail[3]={3,3,2};//当前可分配资源

printf（"银行家总共拥有的各类资源的总数：

\nABC\n1057\n"）;

printf（"银行目前仍剩下的各类资源的数量：

\nABC\n332\n"）;

printf（"各进程对各类资源的最大需求量：

\nABC\n"）;

for（i=0;i<5;i++）

{

printf（"P%d:

",i）;

for（j=0;j<3;j++）

{

printf（"%d",claim[i][j]）;

C_A[i][j]=claim[i][j]-allocation[i][j];

}

printf（"\n"）;

}

printf（"各进程已分配到的各类资源：

\nABC\n"）;

for（i=0;i<5;i++）

{

printf（"P%d:

",i）;

for（j=0;j<3;j++）

printf（"%d",allocation[i][j]）;

printf（"\n"）;

}

printf（"各进程仍需的各类资源数量：

\nABC\n"）;

for（i=0;i<5;i++）

{

printf（"P%d:

",i）;

for（j=0;j<3;j++）

printf（"%d",C_A[i][j]）;

printf（"\n"）;

}

while（result[l]==-1）//

{

for（k=0;k<5;k++）

if（result[k]==-1）

{

for（j=0;j<3;j++）

//判断各线程对各资源仍需量是否小于当前可分配资源总量,此量为正数才正常

if（C_A[k][j]<=currentavail[j]&&C_A[k][j]>=0）

{

//把满足条件的进程的已分配资源加到当前可分配资源中

currentavail[j]=currentavail[j]+allocation[k][j];

m++;

if（m==3）

{

result[l]=k;//只有ABC三类资源都满足才把相应的线程记入数组result中

m=0;

}

}

elsebreak;//否则退出循环,打印"系统不安全"

l++;

}

for（i=0;i

if（result[i]!

=-1）

{

print