wait(),notify(),notifyAll()不属于Thread类,而是属于Object基本类,也就是说每个对像都有wait(),notify(),notifyAll()的功能.由于都个对像都有锁,锁是每个对像的基本 ,当然操作锁的要领也是最基本了.

　　先看java doc如何说:

　　wait导致当前的线程等待，直到其他线程调用此对象的 notify() 要领或 notifyAll() 要领。当前的线程必须拥有此对象监视器。该线程揭晓对此监视器的一切权并等待，直到其他线程议决调用 notify 要领，或 notifyAll 要领告诉在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得 对监视器的一切权后才能继续执行.

　　notify唤醒在此对象监视器上等待的单个线程。假如一切线程都在此对象上等待，则会挑选唤醒其中一个线程。直到当前的线程放弃此对象上的锁定，才能继续执行被唤醒的线程。此要领只应由作为此对象监视器的一切者的线程来调用.

　　"当前的线程必须拥有此对象监视器"与"此要领只应由作为此对象监视器的一切者的线程来调用"表明 wait要领与notify要领必须在同步块内执行,即synchronized(obj之内).

　　调用对像wait要领后,当火线程释放对像锁,进入等待形状 .直到其他线程(也只好是其他线程)议决 notify 要领，或 notifyAll.该线程重新获得 对像锁.

　　继续执行,记得线程必须重新获得 对像锁才能继续执行.由于 synchronized代码块内没有锁是寸步无法走的.看一个很经典的例子:

　　Code：　　

  1. package ProductAndConsume; 
  2.  
  3. 　　import java.util.List; 
  4.  
  5. 　　public class Consume implements Runnable{ 
  6.  
  7. 　　private List container = null; 
  8.  
  9. 　　private int count; 
  10.  
  11. 　　public Consume(List lst){ 
  12.  
  13. 　　this.container = lst; 
  14.  
  15. 　　} 
  16.  
  17. 　　public void run() { 
  18.  
  19. 　　while(true){ 
  20.  
  21. 　　synchronized (container) { 
  22.  
  23. 　　if(container.size()== 0){ 
  24.  
  25. 　　try { 
  26.  
  27. 　　container.wait();//放弃锁 
  28.  
  29. 　　} catch (InterruptedException e) { 
  30.  
  31. 　　e.printStackTrace(); 
  32.  
  33. 　　} 
  34.  
  35. 　　} 
  36.  
  37. 　　try { 
  38.  
  39. 　　Thread.sleep(100); 
  40.  
  41. 　　} catch (InterruptedException e) { 
  42.  
  43. 　　// TODO Auto-generated catch block 
  44.  
  45. 　　e.printStackTrace(); 
  46.  
  47. 　　} 
  48.  
  49. 　　container.remove(0); 
  50.  
  51. 　　container.notify(); 
  52.  
  53. 　　System.out.println("我吃了"+(++count)+"个"); 
  54.  
  55. } 
  56.  
  57.   
  58.  
  59. 　　} 
  60.  
  61. 　　} 
  62.  
  63. 　　} 
  64.  
  65. 　　package ProductAndConsume; 
  66.  
  67. 　　import java.util.List; 
  68.  
  69. 　　public class Product implements Runnable { 
  70.  
  71. 　　private List container = null; 
  72.  
  73. 　　private int count; 
  74.  
  75. 　　public Product(List lst) { 
  76.  
  77. 　　this.container = lst; 
  78.  
  79. 　　} 
  80.  
  81. 　　public void run() { 
  82.  
  83. 　　while (true) { 
  84.  
  85. 　　synchronized (container) { 
  86.  
  87. 　　if (container.size() > MultiThread.MAX) { 
  88.  
  89. 　　try { 
  90.  
  91. 　　container.wait(); 
  92.  
  93. 　　} catch (InterruptedException e) { 
  94.  
  95. 　　e.printStackTrace(); 
  96.  
  97. 　　} 
  98.  
  99. 　　} 
  100.  
  101. 　　try { 
  102.  
  103. 　　Thread.sleep(100); 
  104.  
  105. 　　} catch (InterruptedException e) { 
  106.  
  107. 　　e.printStackTrace(); 
  108.  
  109. 　　} 
  110.  
  111. 　　container.add(new Object()); 
  112.  
  113. 　　container.notify(); 
  114.  
  115. 　　System.out.println("我消费了"+(++count)+"个"); 
  116.  
  117. 　} 
  118.  
  119.   
  120.  
  121. 　　} 
  122.  
  123. 　　} 
  124.  
  125. 　　} 
  126.  
  127. 　　package ProductAndConsume; 
  128.  
  129. 　　import java.util.List; 
  130.  
  131. 　　public class Product implements Runnable { 
  132.  
  133. 　　private List container = null; 
  134.  
  135. 　　private int count; 
  136.  
  137. 　　public Product(List lst) { 
  138.  
  139. 　　this.container = lst; 
  140.  
  141. 　　} 
  142.  
  143. 　　public void run() { 
  144.  
  145. 　　while (true) { 
  146.  
  147. 　　synchronized (container) { 
  148.  
  149. 　　if (container.size() > MultiThread.MAX) { 
  150.  
  151. 　　try { 
  152.  
  153. 　　container.wait(); 
  154.  
  155. 　　} catch (InterruptedException e) { 
  156.  
  157. 　　e.printStackTrace(); 
  158.  
  159. 　　} 
  160.  
  161. 　　} 
  162.  
  163. 　　try { 
  164.  
  165. 　　Thread.sleep(100); 
  166.  
  167. 　　} catch (InterruptedException e) { 
  168.  
  169. 　　e.printStackTrace(); 
  170.  
  171. 　　} 
  172.  
  173. 　　container.add(new Object()); 
  174.  
  175. 　　container.notify(); 
  176.  
  177. 　　System.out.println("我消费了"+(++count)+"个"); 
  178.  
  179. 　　} 
  180.  
  181. 　　} 
  182.  
  183. 　　} 
  184.  
  185. 　　} 
  186.  
  187. 　　package ProductAndConsume; 
  188.  
  189. 　　import java.util.ArrayList; 
  190.  
  191. 　　import java.util.List; 
  192.  
  193. 　　public class MultiThread { 
  194.  
  195. 　　private List container = new ArrayList(); 
  196.  
  197. 　　public final static int MAX = 5; 
  198.  
  199. 　　public static void main(String args[]){ 
  200.  
  201. 　　MultiThread m = new MultiThread(); 
  202.  
  203. 　　new Thread(new Consume(m.getContainer())).start(); 
  204.  
  205. 　　new Thread(new Product(m.getContainer())).start(); 
  206.  
  207. 　　new Thread(new Consume(m.getContainer())).start(); 
  208.  
  209. 　　new Thread(new Product(m.getContainer())).start(); 
  210.  
  211. 　　} 
  212.  
  213. 　　public List getContainer() { 
  214.  
  215. 　　return container; 
  216.  
  217. 　　} 
  218.  
  219. 　　public void setContainer(List container) { 
  220.  
  221. 　　this.container = container; 
  222.  
  223. }