我见过的关于notify()和notifyAll()区别的最简洁的代码

http://blog.csdn.net/cloudeagle_bupt/article/details/21378283

转自:  http://wangacidlemon.iteye.com/blog/398623

wait()方法表示，放弃当前对资源的占有权，等啊等啊，一直等到有人通知我，我才会运行后面的代码。 
notify()方法表示，当前的线程已经放弃对资源的占有， 
通知等待的线程来获得对资源的占有权，但是只有一个线程能够从wait状态中恢复， 
然后继续运行wait()后面的语句； 
notifyAll()方法表示，当前的线程已经放弃对资源的占有， 
通知所有的等待线程从wait()方法后的语句开始运行。 
读出什么区别没有？ 
上例子，先是一个nofiyAll()的例子： 

Java代码  

1. package com.thread.wait;  
2.   
3. public class Wait {  
4.     private int counter = 0;  
5.     private String name = null;  
6.     public Wait(int counter,String name){  
7.         this.counter = counter;  
8.         this.name = name;  
9.     }  
10.       
11.     public synchronized void doSomthing(){  
12.         int tempCounter = --counter;  
13.         if(tempCounter <= 0){  
14.             customizedNotifyAll();  
15.         }  
16.         else  
17.         {  
18.             while(tempCounter > 0){  
19.                 try {  
20.                     System.out.println(Thread.currentThread().getName()+"-<"+name+tempCounter+">"+"will invoke WAIT()");  
21.                     --tempCounter;  
22.                     wait();  
23.                       
24.                       
25.                 } catch (InterruptedException e) {  
26.                     e.printStackTrace();  
27.                     notifyAll();  
28.                 }  
29.                 System.out.println(Thread.currentThread().getName()+"-<"+name+tempCounter+">"+"has been ACTIVED");  
30.             }  
31.             customizedNotifyAll();  
32.   
33.         }  
34.           
35.     }  
36.       
37.     public void customizedNotifyAll(){  
38.         notifyAll();  
39.         System.out.println(Thread.currentThread().getName()+"-<"+name+counter+">"+"::"+"INVOKED NOTIFYALL() AND FINISHED");  
40.     }  
41.   
42. }  

Java代码  

1. package com.thread.wait;  
2.   
3. public class TestThread implements Runnable {  
4.       
5.     private Wait wait;  
6.       
7.     public TestThread(Wait wait){  
8.         this.wait = wait;  
9.     }  
10.     public void run() {  
11.           
12.         wait.doSomthing();  
13.     }  
14.       
15.     public static void main(String [] args){  
16.         Wait wait = new Wait(4,"DAVID");  
17.         Thread  t1 = new Thread(new TestThread(wait));  
18.         Thread  t2 = new Thread(new TestThread(wait));  
19.         Thread  t3 = new Thread(new TestThread(wait));  
20.         Thread  t4 = new Thread(new TestThread(wait));  
21.         t1.start();  
22.         t2.start();  
23.         t3.start();  
24.         t4.start();  
25.     }  
26.   
27. }  

运行的结果： 
Thread-0-<DAVID3>will invoke WAIT() 
Thread-1-<DAVID2>will invoke WAIT() 
Thread-2-<DAVID1>will invoke WAIT() 
Thread-3-<DAVID0>::INVOKED NOTIFYALL() AND FINISHED 
Thread-0-<DAVID2>has been ACTIVED 
Thread-0-<DAVID2>will invoke WAIT() 
Thread-1-<DAVID1>has been ACTIVED 
Thread-1-<DAVID1>will invoke WAIT() 
Thread-2-<DAVID0>has been ACTIVED 
Thread-2-<DAVID0>::INVOKED NOTIFYALL() AND FINISHED 
Thread-0-<DAVID1>has been ACTIVED 
Thread-0-<DAVID1>will invoke WAIT() 
Thread-1-<DAVID0>has been ACTIVED 
Thread-1-<DAVID0>::INVOKED NOTIFYALL() AND FINISHED 
Thread-0-<DAVID0>has been ACTIVED 
Thread-0-<DAVID0>::INVOKED NOTIFYALL() AND FINISHED 
看到了吧，一旦调用notifyAll（）方法，所有的等待线程都会从调用wait()方法的地方继续运行起来。 
这个运行结果可能每次都不一样，有时候只有两个线程运行完成而其余两个线程在等待其它线程调用notifyAll()方法，有时候只有三个线程运行完成，而另一个还在等待中。 
由于本文是讲解notify以及notifyAll方法，所以对上面的原因不多加以解释。 
然后是notify()方法的例子： 
就是将wait类中的customizedNotifyAll()方法中的notifyAll()方法换成notify()方法 
运行结果： 
Thread-1-<DAVID3>will invoke WAIT() 
Thread-0-<DAVID2>will invoke WAIT() 
Thread-2-<DAVID1>will invoke WAIT() 
Thread-3-<DAVID0>::INVOKED NOTIFYALL() AND FINISHED 
Thread-1-<DAVID2>has been ACTIVED 
Thread-1-<DAVID2>will invoke WAIT() 
Did you see that?所有的等待线程中，只有一个线程运行完成了，而其它的线程还在傻傻地等待，poor guys! 
每次运行的结果会不一样，但是始终只有一个线程能够运行完成。 
Summary： 
notify()方法只是让一个线程从wait中恢复过来，至于具体是哪个，那就得看那些线程的运气了(不设置优先级的情况下)，继续执行后面的语句； 
notifyAll()方法是让所有的线程从wait中恢复过来，继续执行后面的语句。