实验06 线程应用及线程并发库Word文档格式.docx
《实验06 线程应用及线程并发库Word文档格式.docx》由会员分享，可在线阅读，更多相关《实验06 线程应用及线程并发库Word文档格式.docx（17页珍藏版）》请在冰豆网上搜索。
System.out.println（"
SubProcedure"
+i）;
shouldBeSub=false;
notify（）;
publicsynchronizedvoidaddMainProcedure（）{
if（shouldBeSub）{
=mainTimes;
MainProcedure"
}
publicclassSingleProcedureimplementsRunnable{
privateinttimes;
privateStringtype;
privateManageProceduremanageProcedure;
publicSingleProcedure（inttimes,Stringtype,
ManageProceduremanageProcedure）{
this.times=times;
this.type=type;
this.manageProcedure=manageProcedure;
@Override
publicvoidrun（）{
if（type.equals（"
sub"
））{
for（inti=0;
times;
manageProcedure.addSubProcedure（）;
}else{
manageProcedure.addMainProcedure（）;
importjava.util.Scanner;
publicclassText{
publicstaticvoidmain（String[]args）{
intsubTimes,mainTimes,totalTimes;
Scannerscanner=newScanner（System.in）;
System.out
.println（"
PleaseInputTheSubTimes&
&
MainTimes&
TheTotalTimes"
）;
subTimes=scanner.nextInt（）;
mainTimes=scanner.nextInt（）;
totalTimes=scanner.nextInt（）;
ManageProceduremanageProcedure=newManageProcedure（subTimes,
mainTimes）;
SingleProceduresubProcedure=newSingleProcedure（totalTimes,"
manageProcedure）;
SingleProceduremainProcedure=newSingleProcedure（totalTimes,"
main"
ThreadsubThread=newThread（subProcedure）;
ThreadmainThread=newThread（mainProcedure）;
subThread.start（）;
mainThread.start（）;
实验题2设计4个线程，其中2个线程每次对count增加1，另外两个线程每次对count减1。
publicSingleProcedure（intrunTimes,StringtypeString,
this.times=runTimes;
type=typeString;
publicsynchronizedvoidrun（）{
Add"
manageProcedure.add（）;
manageProcedure.substract（）;
privateintcount;
publicManageProcedure（）{
count=0;
publicsynchronizedvoidadd（）{
++count;
System.out.println（"
Thread"
+Thread.currentThread（）.getName（）
+"
TheCount:
"
+getCount（））;
publicsynchronizedvoidsubstract（）{
--count;
publicintgetCount（）{
returncount;
packagecn.jp.me.text;
importcn.jp.me.ManageProcedure;
importcn.jp.jme.SingleProcedure;
ManageProceduremanageProcedure=newManageProcedure（）;
SingleProceduresingleAdd=newSingleProcedure（100/2,"
SingleProceduresingleSubstract=newSingleProcedure（
100/2,"
substract"
manageProcedure）;
ThreadaddOne=newThread（singleAdd）;
addOne.setName（"
AddOneThread"
ThreadaddTwo=newThread（singleAdd）;
addTwo.setName（"
AddTwoThread"
ThreadsubstractOne=newThread（singleSubstract）;
substractOne.setName（"
SubstractOneThread"
ThreadsubstractTwo=newThread（singleSubstract）;
substractTwo.setName（"
SubstractTwoThread"
addOne.start（）;
addTwo.start（）;
substractOne.start（）;
substractTwo.start（）;
实验题3CyclicBarrier是一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点。
在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时CyclicBarrier很有用。
因为该barrier在释放等待线程后可以重用，所以称它为循环的barrier。
题目要求：
（1）要在公司大厅集合、然后参观陈云故居；
（2）参观完后集合、准备去淀水湖参观（有3辆车、对应3个线程）；
说明：
必须等大家都到齐了才能去下个地方、比如说在公司集合、3辆车子都到了才能出发等。
要求：
用java线程并发库的CyclicBarrier类模拟上述参观过程。
importjava.util.concurrent.BrokenBarrierException;
importjava.util.concurrent.CyclicBarrier;
privateCyclicBarrierbarrier;
publicSingleProcedure（CyclicBarrierbarrier）{
this.barrier=barrier;
arrivesDaTing\nAndStartWaitting"
try{
barrier.await（）;
}catch（InterruptedException|BrokenBarrierExceptione）{
e.printStackTrace（）;
arrivesChenYunGuJu\nAndStartWaitting"
importcn.jp.me.SingleProcedure;
CyclicBarrierbarrier=newCyclicBarrier（3,newRunnable（）{
@Override
publicvoidrun（）{
System.out.println（"
AllarearrivedandStarttonextplace"
}）;
SingleProcedurecomponent=newSingleProcedure（barrier）;
ThreadbusOne=newThread（component）;
busOne.setName（"
BusOne"
ThreadbusTwo=newThread（component）;
busTwo.setName（"
BusTwo"
ThreadbusThree=newThread（component）;
busThree.setName（"
BusThree"
busOne.start（）;
busTwo.start（）;
busThree.start（）;
实验题4某图书馆邀请一著名作家签名售书，大家去买书，具体情况如下：
（1）买书的读者很多必须排队，作家签好名的书不多（但是他还会看书的销售的情况，一般满了10本（假设）就不会再签了）；
（2）有的书还没有签名，这样排在前面的同学就可以买到书、排在后面的就必须等有了签过名的书才能买；
（3）已经签好名的书可以放在ArrayBlockingQueue中,签好名的书不断的向这个队列里放，而买书的读者不断的从里面取书，如没有签名的书，就必须等，书有10本了，作家就停下来休息。
买书的每个读者都可以看作一个线程、作家签名也可以看作是一个线程；
（4）排在前面的读者先买。
编写程序，模拟上述过程。
publicclassAuthorimplementsRunnable{
privateCommonDatadata;
publicAuthor（CommonDatadata）{
this.data=data;
for（inti=0;
data.getTimes（）;
SignABook（）;
e.printStackTrace（）;
privatevoidSignABook（）throwsInterruptedException{
while（data.getNumber（）==10）{
System.out
.println（"
ThereAre10Books.TheAuthorChouldRestAWhile"
Thread.sleep（4000）;
data.setSign（data.getSign（）+1）;
;
TheAuthorSignNO."
+data.getSign（）+"
book"
data.put（"
TheAuthorSignNo."
Book"
ThereAre"
+data.getNumber（）+"
BooksSigned"
publicclassReaderimplementsRunnable{
publicReader（CommonDatadata）{
buyABook（）;
privatevoidbuyABook（）throwsInterruptedException{
while（data.getNumber（）==0）{
ThereDoesNotExistBooksSigned.MustWait……"
Thread.sleep（3000）;
data.setBuy（data.getBuy（）+1）;
BuyTheNo."
+data.getBuy（）+"
Book"
System.out.println（data.getFirBook（）+"
BeBought"
importjava.util.concurrent.ArrayBlockingQueue;
publicclassCommonData{
privateArrayBlockingQueue<
String>
queue;
privateintbuy,sign;
publicCommonData（inttimes）{
queue=newArrayBlockingQueue<
（10）;
buy=0;
sign=0;
publicintgetNumber（）{
returnqueue.size（）;
publicStringgetFirBook（）throwsInterruptedException{
returnqueue.take（）;
publicvoidput（Stringelem）throwsInterruptedException{
queue.put（elem）;
publicintgetTimes（）{
returntimes;
publicintgetBuy（）{
returnbuy;
publicvoidsetBuy（intbuy）{
this.buy=buy;
publicintgetSign（）{
returnsign;
publicvoidsetSign（intsign）{
this.sign=sign;
CommonDatadata=newCommonData（100）;
Authorauthor=newAuthor（data）;
Readerreader=newReader（data）;
newThread（author）.start（）;
newThread（reader）.start（）;
实验题5模拟拥有一定数量账户的银行，把随机产生的钱在不同账号之间进行转移交易。
每个账号都有一个线程，在每笔交易中，都会从线程所服务的账户中随机取出一定数额的钱转移到另一个随机账户中。
提示：
设计一个Bank类，它有一个transfer方法，该方法将一定数额的钱从一个账户转移到另一个账户，如源账户没有足够余额，该方法直接返回。
importjava.text.Normalizer.Form;
publicclassBank{
privateinttotalAccountNum;
privateint[]balance;
publicBank（intaccountNum）{
totalAccountNum=accountNum;
balance=newint[accountNum+1];
publicsynchronizedvoidtransfer（intfrom,intto,intamount）{
TheChangeFrom"
+from+"
To"
+to）;
if（balance[from]>
=amount）{
BeforeTransferTheBalanceOf"
+
升级会员 