pv操作习题.docx

pv操作习题.docx

《pv操作习题.docx》由会员分享，可在线阅读，更多相关《pv操作习题.docx（17页珍藏版）》请在冰豆网上搜索。

pv操作习题

设一民航售票系统有n个售票处。

每个售票处通过终端访问系统中的公用数据区，假定公用数据区中分别用R1、R2、R3、…Rn表示×月×日×次航班的现存票数。

设P1、P2、P3、Pn表示各售票处的处理进程，试用信号量实现进程间的互斥关系

Vars:

semaphore:

=1;

begin

parbegin

processPi:

begin

repeat

Wait（s）;

按旅客定票要求找到Rk

ifRk>=1thenbegin

Rk=Rk-1;

Signal（s）;

输出一张票；

end;

elsebegin

Signal（s）;

输出“票已售完”；

end;

untilfalse;

end

parend

end

生产围棋的工人不小心把相等数量的黑子和白子混装在一个箱子里，现要用自动分拣系统把黑子和白子分开，该系统由两个并发执行的进程组成，功能如下：

（1）进程A专门拣黑子，进程B专门拣白子；

（2）每个进程每次只拣一个子，当一个进程在拣子时不允许另一个进程去拣子；

s:

semaphore:

=1;

　　　parbegin

　　　　processA：

begin

　　　　L1:

Wait（s）;

　　　　　拣黑子；

　　　　　Signal（s）;

　　　　　gotoL1;

　　　　end;

　　　　processB：

begin

　　　　L2:

Wait（s）;

　　　　　拣白子；

　　　　　Signal（s）;

　　　　　gotoL2;

　　　　end;

　　　parend;

某车站售票厅共有20个售票窗口，任何时刻最多可容纳20名购票者进入，当售票厅中少于20名购票者时，厅外的购票者可立即进入，否则需要在外面等待。

每个购票者可看成一个进程。

s:

semaphore=20;

　　parbegin

　　　processPi（i=1,2,……）

　　　　beginWait（s）;

　　　　　进入售票厅；

　　　　　购票；

　　　　　退出；

　　　　　Signal（s）;

　　　　end;

　　　parend

有座东西方向架设、可双向通行的单车道简易桥，最大负荷为4辆汽车。

请定义合适的信号量，正确使用wait/signal操作，实现双向车辆的过桥过程。

信号量应该有4个：

S,初值为1,代表桥的互斥使用的信号量；Scounteast,初值为1,代表由东向西行驶的桥上的车辆计数器的互斥使用；

Scountwest,初值为1,代表由西向东行驶的桥上的车辆计数器的互斥使用；

Scount4,初值为4,代表桥上车辆的计数信号量。

varS,Scounteast,Scounwest,Scount4:

semaphore；

S:

=1；Scounteast＝1；

Scountwest:

=1；Scount4:

=4；

Counteast，Countwest：

integer；

Counteast:

=0；Countwest:

=0；

Cobegin,

processeast（i）

begin

P（Scounteast）;

ifCounteast=0thenP（S）;

Counteast:

=Counteast+l;

V（Scounteast）;

P（Scount4）;

上桥：

过桥：

下桥；

V（Scount4）;

P（Scounteast）;

Counteast:

=Counteast-1;

ifCounteast=0thenV（S）;

V（Scounteast）;

end;

processwest（i）

begin

P（Scountwest）;

ifCountwest=0thenP（S）;

Countwest:

=Countwest+1;

V（Scountwest）;

P（Scount4）;

上桥；过桥：

下桥：

V（Scount4）;

P（Scountwest）;

Countwest:

=Countwest-l;

ifCountwest=0thenV（S）;

V（Scountwest）;

end;

Coend

有一单向行驶的公路桥，每次只允许一辆汽车通过。

当汽车到达桥头时，若桥上无车，便可上桥；否则需等待，直到桥上的汽车下桥为止，若每一辆汽车为一个进程，请用Wait、Signal操作原语保证汽车按要求过桥。

汽车进程：

Pi（i=1,2,3,…）

到达桥头；

P（S）；

上桥行驶；

到达桥另一端；

V（S）；

某超市门口为顾客准备了100辆手推车，每位顾客在进去买东西时取一辆推车，在买完东西结完帐以后再把推车还回去。

试用Wait/Signal操作正确实现顾客进程的同步互斥关系。

semaphoreS_CartNum=100;//空闲的手推车数量，初值为100

voidconsumer（void）//顾客进程

{

Wait（S_CartNum）;

买东西；

结帐；

Signal（S_CartNum）;

}

桌子上有一个水果盘，每一次可以往里面放入一个水果。

爸爸专向盘子中放苹果，儿子专等吃盘子中的苹果。

把爸爸、儿子看作二个进程，试用Wait/Signal操作使这四个进程能正确地并发执行。

⏹semaphoreS_PlateNum;//盘子容量，初值为1

⏹semaphoreS_AppleNum;//苹果数量，初值为0

父while（TRUE）

{

Wait（S_PlateNum）;

往盘子中放入一个苹果；

Signal（S_AppleNum）;

}

子while（TRUE）

{

Wait（S_AppleNum）;

从盘中取出苹果；

Signal（S_PlateNum）;

吃苹果;

}

桌上有一空盘，允许存放一只水果，爸爸可向盘中放苹果，也可向盘中放桔子，儿子专等吃盘中的桔子，女儿专等吃盘中的苹果。

规定当盘空时一次只能放一只水果供吃者取用。

请用Wait/Signal原语实现爸爸、儿子、女儿三个并发进程的同步。

intS=1;//S表示盘子是否为空；

intSa=0;//Sa表示盘中是否有苹果；

intSb=0;//Sb表示盘中是否有桔子；

父亲while（TRUE）

{

Wait（S）;

将水果放入盘中;

if（放入的是桔子）

Signal（Sb）;

Else

Signal（Sa）;

}

儿子while（TRUE）

{

Wait（Sb）;

从盘中取出桔子；

Signal（S）;

吃桔子;

}

女儿while（TRUE）

{

Wait（Sa）;

从盘中取出苹果；

Signal（S）;

吃苹果;

}

父亲-母亲-儿子-女儿一个苹果或桔子

信号量：

s=1（空盘）;s1=0（苹果）;s2=0（桔子）;

爸爸：

while（true）{wait（s）;放苹果;signal（s1）;}

妈妈：

while（true）{wait（s）;放桔子;signal（s2）;}

儿子：

while（true）{wait（s2）;取桔子;signal（s）;}

女儿：

while（true）{wait（s1）;取苹果;signal（s）;}

父亲-母亲-儿子-女儿两个苹果或桔子

信号量：

s=2（可用）;s1=0（苹果）;s2=0（桔子）;mutex=1;

爸爸：

wait（s）;wait（mutex）;放苹果;signal（s1）;signal（mutex）;

妈妈：

wait（s）;wait（mutex）;放桔子;signal（s2）;signal（mutex）;

儿子：

wait（s2）;wait（mutex）;取桔子;signal（s）;signal（mutex）;

女儿：

wait（s1）;wait（mutex）;取苹果;signal（s）;signal（mutex）;

有一个仓库（无限大），可以存放A和B两种产品，但要求：

（1）每次只能存入一种产品（A或B）；

（2）－N＜A产品数量－B产品数量＜M

其中，N和M是正整数。

试用Wait/Signal操作描述产品A与产品B的入库过程。

intmutex=1;//互斥信号量

intsa=M-1;//表示当前允许A产品比B产品多入库的数量

intsb=N-1;//表示当前允许B产品比A产品多入库的数量

main（）

{

while

（1）

{

取一个产品；

if（取的是A产品）

{

P（sa）;

P（mutex）;

将产品入库；

V（mutex）;

V（sb）;

}

else

{

P（sb）;

P（mutex）;

将产品入库；

V（mutex）;

V（sa）;

}

}

}

某仓库存放两种零件A和B，最大数量均为m个。

有一车间不断地取A和B进行装配，每次各取一个。

为避免零件锈蚀，遵循先入库者先出库的原则。

有两个供应商分别不断地供应A、B零件（每次一个）。

为保证齐套和合理库存，当某种零件的数量比另一种的数量超过n（n

（1）问共需设置几个进程?

（2）用Wait/Signal操作解决上述问题中的同步互斥关系。

本题中给出的两种零件数量关系为：

A零件数量-B零件数量≤n

B零件数量-A零件数量≤n

A零件数量≤m

B零件数量≤m

semaphoremutex=1;

semaphoreemptya=m;

semaphoreemptyb=m;

semaphorefulla=0;

semaphorefullb=0;

semaphoresa=n;

semaphoresb=n;

main（）

{

cobegin

Provider_A（）;

Provider_B（）;

Assembling_shop（）;

conend

}

Provider_A（）

{

while（true）

{

wait（emptya）;

wait（sa）;

wait（mutex）;

将零件A放入仓库；

signal（mutex）;

signal（fulla）;

signal（sb）;

}

}

Provider_B（）

{

while（true）

{

wait（emptyb）;

wait（sb）;

wait（mutex）;

将零件A放入仓库；

signal（mutex）;

signal（fullb）;

signal（sa）;

}

}

Assembling_shop（）

{

while（true）

{

wait（fulla）;

wait（fullb）;

wait（mutex）;

装配零件;

signal（mutex）;

signal（emptya）;

signal（emptyb）;

}

}

设有两个生产者进程A、B和一个销售者进程C，他们共享一个无限大的仓库，生产者每次循环生产一个产品，然后入库供销售者销售；销售者每次循环从仓库中取出一个产品进行销售。

如果不允许同时入库，也不允许边入库边出库；而且要求生产和销售A产品和B产品的件数都满足一下关系：

-N≤A产品数量－B产品数量≤M

其中，N和M是正整数。

试用信号量机制写出A、B、C三个进程的工作流程。

intmutex=1;//互斥信号量

ints1=M;//表示当前允许A产品比B产品

多入库的数量

ints2=N;//表示当前允许B产品比A产品

多入库的数量

ints=0;//表示当前仓库中产品的总数量

intsa=0;//表示当前仓库中A产品的数量

intsb=0;//表示当前仓库中B产品的数量

intdif=0;//表示所销售的A、B产品的数量差

Process_A:

while

（1）

{

wait（s1）;

produceaproductA；

signal（s2）;

wait（mutex）;

addtheproductAtothestorehouse;

signal（mutex）;

signal（sa）;

signal（s）;

}

Process_B:

while

（1）

{

wait（s2）;

produceaproductB；

signal（s1）;

wait（mutex）;

addtheproductBtothestorehouse;

signal（mutex）;

signal（sb）;

signal（s）;

}

Process_C:

while

（1）

{

wait（s）;

ifdif<=-n{

wait（sa）;

wait（mutex）;

takeaproductA；

signal（mutex）;

dif:

=dif+1;}

elseifdif>=m{

wait（sb）;

wait（mutex）;

takeaproductB;

signal（mutex）;

dif:

=dif-1;}

else{

wait（mutex）;

takeaproduct;

signal（mutex）;

ifproduct_type=A{

wait（sa）;

dif:

=dif+1;}

else{

wait（sb）;

dif:

=dif-1;}

selltheproduct;

}

一个数据采集系统，有数据采样进程和数据处理进程及数据输出进程。

采样进程把采到的数据送入buf1中，由数据处理进程取出处理并存入buf2中，然后由数据输出进程将其从buf2中输出，试给出实现三个进程同步的算法。

信号量设置：

semphoreempty1=1;

Semphorefull1=0;

semphoreempty2=1;

sSemphorefull2=0;

Process_A（）

{

while（true）

{

采集一个数据;

Wait（empty1）;

将数据存入buf1中；

Signal（full1）;

}

}

Process_B（）

{

while（true）

{

Wait（full1）;

从buf1中取出数据;

Signal（empty1）;

处理数据;

Wait（empty2）;

将处理结果存入buf2;

Signal（full2）;

}

}

Process_C（）

{

while（true）

{

Wait（full2）;

从buf2中取出结果；

Signal（empty2）;

打印输出；

}

}

在天津大学与南开大学之间有一条弯曲的小路，这条路上每次每个方向上只允许一辆自行车通过。

但其中有一个小的安全岛M，同时允许两辆自行车停留，可供两辆自行车已从两端进入小路的情况下错车使用。

begin

   t:

=1;s:

=1;l:

=1;k:

=1;m=2;

   cobegin

   Process_T2N（）

       begin

           wait（t）;

wait（l）;

           通过L路段;

wait（m）;

           进入安全岛M；

           signal（l）;

wait（k）;

           通过K路段

           signal（m）;

signal（k）;

signal（t）;

       end

Process_N2T（）

       begin

         wait（s）;

wait（k）;

通过K路段;

wait（m）;

进入安全岛M;

signal（k）;

wait（l）;

通过L路段;

signal（m）;

signal（l）;

signal（s）;

       end

   coend

end