`
lovnet
  • 浏览: 6670791 次
  • 性别: Icon_minigender_1
  • 来自: 武汉
文章分类
社区版块
存档分类
最新评论

Java 多线程同步问题的探究(四、协作,互斥下的协作——Java多线程协作(wait、notify、notifyAll))

 
阅读更多
Java监视器支持两种线程:互斥和协作。

前面我们介绍了采用对象锁和重入锁来实现的互斥。这一篇中,我们来看一看线程的协作。

举个例子:有一家汉堡店举办吃汉堡比赛,决赛时有3个顾客来吃,3个厨师来做,一个服务员负责协调汉堡的数量。为了避免浪费,制作好的汉堡被放进一个能装有10个汉堡的长条状容器中,按照先进先出的原则取汉堡。如果容器被装满,则厨师停止做汉堡,如果顾客发现容器内的汉堡吃完了,就可以拍响容器上的闹铃,提醒厨师再做几个汉堡出来。此时服务员过来安抚顾客,让他等待。而一旦厨师的汉堡做出来,就会让服务员通知顾客,汉堡做好了,让顾客继续过来取汉堡。

这里,顾客其实就是我们所说的消费者,而厨师就是生产者。容器是决定厨师行为的监视器,而服务员则负责监视顾客的行为。

在JVM中,此种监视器被称为等待并唤醒监视器。
转载注明出处:http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
在这种监视器中,一个已经持有该监视器的线程,可以通过调用监视对象的wait方法,暂停自身的执行,并释放监视器,自己进入一个等待区,直到监视器内的其他线程调用了监视对象的notify方法。当一个线程调用唤醒命令以后,它会持续持有监视器,直到它主动释放监视器。而这之后,等待线程会苏醒,其中的一个会重新获得监视器,判断条件状态,以便决定是否继续进入等待状态或者执行监视区域,或者退出。

请看下面的代码:

1.publicclassNotifyTest{
2.privateStringflag="true";
3.
4.classNotifyThreadextendsThread{
5.publicNotifyThread(Stringname){
6.super(name);
7.}
8.publicvoidrun(){
9.try{
10.sleep(3000);//推迟3秒钟通知
11.}catch(InterruptedExceptione){
12.e.printStackTrace();
13.}
14.
15.flag="false";
16.flag.notify();
17.}
18.};
19.
20.classWaitThreadextendsThread{
21.publicWaitThread(Stringname){
22.super(name);
23.}
24.
25.publicvoidrun(){
26.
27.while(flag!="false"){
28.System.out.println(getName()+"beginwaiting!");
29.longwaitTime=System.currentTimeMillis();
30.try{
31.flag.wait();
32.}catch(InterruptedExceptione){
33.e.printStackTrace();
34.}
35.waitTime=System.currentTimeMillis()-waitTime;
36.System.out.println("waittime:"+waitTime);
37.}
38.System.out.println(getName()+"endwaiting!");
39.
40.}
41.}
42.
43.publicstaticvoidmain(String[]args)throwsInterruptedException{
44.System.out.println("MainThreadRun!");
45.NotifyTesttest=newNotifyTest();
46.NotifyThreadnotifyThread=test.newNotifyThread("notify01");
47.WaitThreadwaitThread01=test.newWaitThread("waiter01");
48.WaitThreadwaitThread02=test.newWaitThread("waiter02");
49.WaitThreadwaitThread03=test.newWaitThread("waiter03");
50.notifyThread.start();
51.waitThread01.start();
52.waitThread02.start();
53.waitThread03.start();
54.}
55.
56.}

转载注明出处:http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
这段代码启动了三个简单的wait线程,当他们处于等待状态以后,试图由一个notify线程来唤醒。
转载注明出处:http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
运行这段程序,你会发现,满屏的java.lang.IllegalMonitorStateException,根本不是你想要的结果。
转载注明出处:http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
请注意以下几个事实:
1. 任何一个时刻,对象的控制权(monitor)只能被一个线程拥有。
2. 无论是执行对象的wait、notify还是notifyAll方法,必须保证当前运行的线程取得了该对象的控制权(monitor)。
3. 如果在没有控制权的线程里执行对象的以上三种方法,就会报java.lang.IllegalMonitorStateException异常。
4. JVM基于多线程,默认情况下不能保证运行时线程的时序性。

也就是说,当线程在调用某个对象的wait或者notify方法的时候,要先取得该对象的控制权,换句话说,就是进入这个对象的监视器。
转载注明出处:http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
通过前面对同步的讨论,我们知道,要让一个线程进入某个对象的监视器,通常有三种方法:
转载注明出处:http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
1: 执行对象的某个同步实例方法
2: 执行对象对应的同步静态方法
3: 执行对该对象加同步锁的同步块

显然,在上面的例程中,我们用第三种方法比较合适。

于是我们将上面的wait和notify方法调用包在同步块中。

1.synchronized(flag){
2.flag="false";
3.flag.notify();
4.}

转载注明出处:http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
1.synchronized(flag){
2.while(flag!="false"){
3.System.out.println(getName()+"beginwaiting!");
4.longwaitTime=System.currentTimeMillis();
5.try{
6.flag.wait();
7.}catch(InterruptedExceptione){
8.e.printStackTrace();
9.}
10.waitTime=System.currentTimeMillis()-waitTime;
11.System.out.println("waittime:"+waitTime);
12.}
13.System.out.println(getName()+"endwaiting!");
14.}



但是,运行这个程序,我们发现事与愿违。那个非法监视器异常又出现了。。。
转载注明出处:http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
我们注意到,针对flag的同步块中,我们实际上已经更改了flag对对象的引用: flag="false";
转载注明出处:http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
显然,这样一来,同步块也无能为力了,因为我们根本不是针对唯一的一个对象在进行同步。

我们不妨将flag封装到JavaBean或者数组中去,这样用JavaBean对象或者数组对象进行同步,就可以达到既能修改里面参数又不耽误同步的目的。

1.privateStringflag[]={"true"};


1.synchronized(flag){
2.flag[0]="false";
3.flag.notify();
4.}



1.synchronized(flag){
2.flag[0]="false";
3.flag.notify();
4.}synchronized(flag){
5.while(flag[0]!="false"){
6.System.out.println(getName()+"beginwaiting!");
7.longwaitTime=System.currentTimeMillis();
8.try{
9.flag.wait();
10.
11.}catch(InterruptedExceptione){
12.e.printStackTrace();
13.}


运行这个程序,看不到异常了。但是仔细观察结果,貌似只有一个线程被唤醒。利用jconsole等工具查看线程状态,发现的确还是有两个线程被阻塞的。这是为啥呢?

程序中使用了flag.notify()方法。只能是随机的唤醒一个线程。我们可以改用flag.notifyAll()方法。这样,所有被阻塞的线程都会被唤醒了。

最终代码请读者自己修改,这里不再赘述。

好了,亲爱的读者们,让我们回到开篇提到的汉堡店大赛问题当中去,来看一看厨师、服务生和顾客是怎么协作进行这个比赛的。

首先我们构造故事中的三个次要对象:汉堡包、存放汉堡包的容器、服务生

publicclassWaiter{//服务生,这是个配角,不需要属性。
}

classHamberg{
//汉堡包
privateintid;//汉堡编号
privateStringcookerid;//厨师编号
publicHamberg(intid,Stringcookerid){
this.id=id;
this.cookerid=cookerid;
System.out.println(
this.toString()+"wasmade!");
}

@Override
publicStringtoString(){
return"#"+id+"by"+cookerid;
}

}

classHambergFifo{
//汉堡包容器
List<Hamberg>hambergs=newArrayList<Hamberg>();//借助ArrayList来存放汉堡包
intmaxSize=10;//指定容器容量

//放入汉堡
public<TextendsHamberg>voidpush(Tt){
hambergs.add(t);
}

//取出汉堡
publicHambergpop(){
Hambergh
=hambergs.get(0);
hambergs.remove(
0);
returnh;
}

//判断容器是否为空
publicbooleanisEmpty(){
returnhambergs.isEmpty();
}

//判断容器内汉堡的个数
publicintsize(){
returnhambergs.size();
}

//返回容器的最大容量
publicintgetMaxSize(){
returnthis.maxSize;
}
}

接下来我们构造厨师对象:

classCookerimplementsRunnable{
//厨师要面对容器
HambergFifopool;
//还要面对服务生
Waiterwaiter;

publicCooker(Waiterwaiter,HambergFifohambergStack){
this.pool=hambergStack;
this.waiter=waiter;
}
//制造汉堡
publicvoidmakeHamberg(){
//制造的个数
intmadeCount=0;
//因为容器满,被迫等待的次数
intfullFiredCount=0;
try{

while(true){
//制作汉堡前的准备工作
Thread.sleep(1000);
if(pool.size()<pool.getMaxSize()){
synchronized(waiter){
//容器未满,制作汉堡,并放入容器。
pool.push(newHamberg(++madeCount,Thread.currentThread().getName()));
//说出容器内汉堡数量
System.out.println(Thread.currentThread().getName()+":Thereare"
+pool.size()+"Hambergsinall");
//让服务生通知顾客,有汉堡可以吃了
waiter.notifyAll();
System.out.println("###Cooker:waiter.notifyAll():"+
" Hi!Customers,wegotsomenewHambergs!
");
}
}
else{
synchronized(pool){
if(fullFiredCount++<10){
//发现容器满了,停止做汉堡的尝试。
System.out.println(Thread.currentThread().getName()+
"
:HambergPoolisFull,Stopmakinghamberg");
System.out.println("###Cooker:pool.wait()");
//汉堡容器的状况使厨师等待
pool.wait();
}else{
return;
}
}

}

//做完汉堡要进行收尾工作,为下一次的制作做准备。
Thread.sleep(1000);

}
}
catch(Exceptione){
madeCount
--;
e.printStackTrace();
}
}

publicvoidrun(){

makeHamberg();

}
}

接下来,我们构造顾客对象:

classCustomerimplementsRunnable{
//顾客要面对服务生
Waiterwaiter;
//也要面对汉堡包容器
HambergFifopool;
//想要记下自己吃了多少汉堡
intateCount=0;
//吃每个汉堡的时间不尽相同
longsleeptime;
//用于产生随机数
Randomr=newRandom();

publicCustomer(Waiterwaiter,HambergFifopool){
this.waiter=waiter;
this.pool=pool;
}

publicvoidrun(){

while(true){

try{
//取汉堡
getHamberg();
//吃汉堡
eatHamberg();
}
catch(Exceptione){
synchronized(waiter){
System.out.println(e.getMessage());
//若取不到汉堡,要和服务生打交道
try{
System.out.println(
"###Customer:waiter.wait():"+
" Sorry,Sir,thereisnohambergsleft,pleasewait!
");
System.out.println(Thread.currentThread().getName()

+
":OK,Waitingfornewhambergs");
//服务生安抚顾客,让他等待。
waiter.wait();
continue;
}
catch(InterruptedExceptionex){
ex.printStackTrace();
}
}
}
}
}

privatevoideatHamberg(){
try{
//吃每个汉堡的时间不等
sleeptime=Math.abs(r.nextInt(3000))*5;
System.out.println(Thread.currentThread().getName()
+":I'meatingthehambergfor"+sleeptime+"milliseconds");

Thread.sleep(sleeptime);
}
catch(Exceptione){
e.printStackTrace();
}
}

privatevoidgetHamberg()throwsException{
Hamberghamberg
=null;

synchronized(pool){
try{
//在容器内取汉堡
hamberg=pool.pop();

ateCount
++;
System.out.println(Thread.currentThread().getName()

+
":IGot"+ateCount+"Hamberg"+hamberg);
System.out.println(Thread.currentThread().getName()

+
":Therearestill"+pool.size()+"hambergsleft");


}
catch(Exceptione){
pool.notifyAll();
System.out.println(
"###Customer:pool.notifyAll()");
thrownewException(Thread.currentThread().getName()+
"
:OHMYGOD!!!!Nohambergsleft,Waiter![Ringthebellbesidesthehambergpool]");

}
}
}
}

转载注明出处:http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
最后,我们构造汉堡店,让这个故事发生:
转载注明出处:http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
publicclassHambergShop{

Waiterwaiter
=newWaiter();
HambergFifohambergPool
=newHambergFifo();
Customerc1
=newCustomer(waiter,hambergPool);
Customerc2
=newCustomer(waiter,hambergPool);
Customerc3
=newCustomer(waiter,hambergPool);
Cookercooker
=newCooker(waiter,hambergPool);

publicstaticvoidmain(String[]args){
HambergShophambergShop
=newHambergShop();
Threadt1
=newThread(hambergShop.c1,"Customer1");
Threadt2
=newThread(hambergShop.c2,"Customer2");
Threadt3
=newThread(hambergShop.c3,"Customer3");
Threadt4
=newThread(hambergShop.cooker,"Cooker1");
Threadt5
=newThread(hambergShop.cooker,"Cooker2");
Threadt6
=newThread(hambergShop.cooker,"Cooker3");
t4.start();
t5.start();
t6.start();
try{
Thread.sleep(
10000);
}
catch(Exceptione){
}

t1.start();
t2.start();
t3.start();
}
}

运行这个程序吧,然后你会看到我们汉堡店的比赛进行的很好,只是不

知道那些顾客是不是会被撑到。。。
转载注明出处:http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
读到这里,有的读者可能会想到前面介绍的重入锁ReentrantLock。
有的读者会问:如果我用ReentrantLock来代替上面这些例程当中的 synchronized块,是不是也可以呢?感兴趣的读者不妨一试。
转载注明出处:http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
但是在这里,我想提前给出结论,就是,
如果用ReentrantLock的lock()和unlock()方法代替上面的synchronized块,那么上面这些程序还是要抛出 java.lang.IllegalMonitorStateException异常的,不仅如此,你甚至还会看到线程死锁。原因就是当某个线程调用第三方对象的wait或者notify方法的时候,并没有进入第三方对象的监视器,于是抛出了异常信息。但此时,程序流程如果没有用finally来处理 unlock方法,那么你的线程已经被lock方法上锁,并且无法解锁。程序在java.util.concurrent框架的语义级别死锁了,你用 JConsole这种工具来检测JVM死锁,还检测不出来。
转载注明出处:http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
正确的做法就是,只使用ReentrantLock,而不使用wait或者notify方法。因为ReentrantLock已经对这种互斥和协作进行了概括。所以,根据你程序的需要,请单独采用重入锁或者synchronized一种同步机制,最好不要混用。
转载注明出处:http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/

好了,我们现在明白:转载注明出处:http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
1. 线程的等待或者唤醒,并不是让线程调用自己的wait或者notify方法,而是通过调用线程共享对象的wait或者notify方法来实现。
2. 线程要调用某个对象的wait或者notify方法,必须先取得该对象的监视器。
3. 线程的协作必须以线程的互斥为前提,这种协作实际上是一种互斥下的协作
分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics