JAVA例115118及实验6062.docx

JAVA例115118及实验6062.docx

《JAVA例115118及实验6062.docx》由会员分享，可在线阅读，更多相关《JAVA例115118及实验6062.docx（14页珍藏版）》请在冰豆网上搜索。

JAVA例115118及实验6062

例11.5

//filenameApp11_5.java

classThreadSaleimplementsRunnable//创建Runnable接口类，模拟航班售票窗口

{

privateinttickets=10;//私有变量tickets代表机票数，是共享数据

publicvoidrun（）

{

while（true）

{

if（tickets>0）

System.out.println（Thread.currentThread（）.getName（）+"售机票第"+tickets--+"号"）;

else

System.exit（0）;

}

}

}

publicclassApp11_5//再构造另一个类，在他的main（）方法中创建并启动3个线程对象

{

publicstaticvoidmain（String[]args）

{

ThreadSalet=newThreadSale（）;//只创建一个实现Runnable接口的售票类对象t

Threadt1=newThread（t,"第一售票窗口"）;//用此对象t作为参数创建3个线程，第二个参数为线程名

Threadt2=newThread（t,"第二售票窗口"）;

Threadt3=newThread（t,"第三售票窗口"）;

t1.start（）;

t2.start（）;

t3.start（）;

}

}

例11.6

//filenameApp11_6.java

classMbank//模拟银行账户类

{

privatestaticintsum=2000;//初始存款额为2000

publicstaticvoidtake（intk）

{

inttemp=sum;

temp-=k;

try

{

Thread.sleep（（int）（1000*Math.random（）））;

}

catch（InterruptedExceptione）

{}

sum=temp;

System.out.println（"sum="+sum）;

}

}

classCustomerextendsThread//模拟用户取款线程类

{

publicvoidrun（）

{

for（inti=1;i<=4;i++）

Mbank.take（100）;

}

}

publicclassApp11_6

{

publicstaticvoidmain（String[]args）

{

Customerc1=newCustomer（）;

Customerc2=newCustomer（）;

c1.start（）;

c2.start（）;

}

}

例11.7

//filenameApp11_7.java

classMbank//模拟银行账户类

{

privatestaticintsum=2000;//初始存款额为2000

publicsynchronizedstaticvoidtake（intk）//限制take（）为同步方法

{

inttemp=sum;

temp-=k;//变量temp中保存的是每个线程处理的值

try

{

Thread.sleep（（int）（1000*Math.random（）））;

}

catch（InterruptedExceptione）

{}

sum=temp;

System.out.println（"sum="+sum）;

}

}

classCustomerextendsThread//模拟用户取款线程类

{

publicvoidrun（）

{

for（inti=1;i<=4;i++）

Mbank.take（100）;

}

}

publicclassApp11_7//调用线程的主类

{

publicstaticvoidmain（String[]args）

{

Customerc1=newCustomer（）;

Customerc2=newCustomer（）;

c1.start（）;

c2.start（）;

}

}

例11.8

//filenameApp11_8.java

publicclassApp11_8

{

publicstaticvoidmain（String[]args）

{

Ticketst=newTickets（10）;//新建一个票类对象t，总票数作为参数

newProducer（t）.start（）;//以票类对象t为参数创建存票线程对象，并启动

newConsumer（t）.start（）;//以同一票类对象t为参数创建售票线程对象，并启动

}

}

classTickets//票类

{

protectedintsize;//总票数

intNumber=0;//票号

booleanavailable=false;//表示当前是否有票可售

publicTickets（intsize）//构造方法，传入总票数参数

{

this.size=size;

}

publicsynchronizedvoidput（）//同步方法，实现存票功能

{

if（available）//如果还有存票待售，则存票线程等待

try{wait（）;}

catch（Exceptione）{}

System.out.println（"存入第【"+（++Number）+"】号票"）;

available=true;

notify（）;//存票后唤醒售票线程开始售票

}

publicsynchronizedvoidsell（）//同步方法，实现售票功能

{

if（!

available）//如果没有存票，则售票线程等待

try{wait（）;}

catch（Exceptione）{}

System.out.println（"售出第【"+（Number）+"】号票"）;

available=false;

notify（）;//售票后唤醒存票线程开始存票

if（Number==size）Number=size+1;//售完最后一张票后，设置一个结束标志

//number>size表示售票结束

}

}

classProducerextendsThread//存票线程类

{

Ticketst=null;

publicProducer（Ticketst）//构造方法,使两线程共享票类对象

{

this.t=t;

}

publicvoidrun（）

{

while（t.Number

t.put（）;

}

}

classConsumerextendsThread//售票线程类

{

Ticketst=null;

publicConsumer（Ticketst）//构造方法,使两线程共享票类对象

{

this.t=t;

}

publicvoidrun（）

{

while（t.Number<=t.size）

t.sell（）;

}

}

实验60

//Sale.java

publicclassSale

{

publicstaticvoidmain（String[]args）

{

SaleTicketst=newSaleTickets（）;

Threadt1=newThread（t）;

Threadt2=newThread（t）;

Threadt3=newThread（t）;

Threadt4=newThread（t）;

t1.start（）;

t2.start（）;

t3.start（）;

t4.start（）;

}

}

classSaleTicketsimplementsRunnable

{

privateinttickets=1;

publicvoidrun（）

{

while（true）

{

if（tickets<=100）

System.out.println（Thread.currentThread（）.getName（）+"销售第"+tickets+++"票"）;

else

break;

}

}

}

实验61

//TryDaemeon.java

publicclassTryDaemon

{

publicstaticvoidmain（String[]args）

{

Threadt=newThread（newDaemonThread（））;

t.setDaemon（true）;

t.start（）;

System.out.println（"main（）方法结束"）;

}

}

classDaemonThreadimplementsRunnable

{

publicvoidrun（）

{

while（true）

System.out.println（"线程正在运行"）;

}

}

实验62

//ThreadSynchronized.java

classcommon

{

privatecharch;

privatebooleanavailable=false;

synchronizedcharget（）

{

while（available==false）

try{wait（）;}

catch（InterruptedExceptione）{}

available=false;

notify（）;

returnch;

}

synchronizedvoidput（charnewch）

{

if（available）//代码1

ch=newch;

available=true;

notify（）;//代码2

}

}

classproducerextendsThread

{

privatecommoncomm;

publicproducer（commonthiscomm）

{

comm=thiscomm;

}

publicvoidrun（）

{

charc;

for（c='a';c<='e';c++）

{

System.out.println（"生产的数据是：

"+c）;

comm.put（c）;

}

}

}

classconsumerextendsThread

{

privatecommoncomm;

publicconsumer（commonthiscomm）

{

comm=thiscomm;

}

publicvoidrun（）

{

charc;

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

{

c=comm.get（）;

System.out.println（"消费者得到的数据是：

"+c）;

}

}

}

publicclassThreadSynchronized

{

publicstaticvoidmain（String[]args）

{

commoncomm=newcommon（）;

producerp=newproducer（comm）;

consumerc=newconsumer（comm）;

p.start（）;

c.start（）;

}

}