轉自：http://blog.csdn.net/zyplus/article/details/6672775
在JAVA中，是沒有類似於PV操作、進程互斥等相關的方法的。JAVA的進程同步是通過synchronized()來實現的，需要說明的是，JAVA的synchronized()方法類似於操作系統概念中的互斥內存塊，在JAVA中的Object類型中，都是帶有一個內存鎖的，在有線程獲取該內存鎖后，其它線程無法訪問該內存，從而實現JAVA中簡單的同步、互斥操作。明白這個原理，就能理解為什么synchronized(this)與synchronized(static XXX)的區別了，synchronized就是針對內存區塊申請內存鎖，this關鍵字代表類的一個對象，所以其內存鎖是針對相同對象的互斥操作，而static成員屬於類專有，其內存空間為該類所有成員共有，這就導致synchronized()對static成員加鎖，相當於對類加鎖，也就是在該類的所有成員間實現互斥，在同一時間只有一個線程可訪問該類的實例。如果只是簡單的想要實現在JAVA中的線程互斥，明白這些基本就已經夠了。但如果需要在線程間相互喚醒的話就需要借助Object.wait(), Object.nofity()了。
Obj.wait()，與Obj.notify()必須要與synchronized(Obj)一起使用，也就是wait,與notify是針對已經獲取了Obj鎖進行操作，從語法角度來說就是Obj.wait(),Obj.notify必須在synchronized(Obj){...}語句塊內。從功能上來說wait就是說線程在獲取對象鎖后，主動釋放對象鎖，同時本線程休眠。直到有其它線程調用對象的notify()喚醒該線程，才能繼續獲取對象鎖，並繼續執行。相應的notify()就是對對象鎖的喚醒操作。但有一點需要注意的是notify()調用后，並不是馬上就釋放對象鎖的，而是在相應的synchronized(){}語句塊執行結束，自動釋放鎖后，JVM會在wait()對象鎖的線程中隨機選取一線程，賦予其對象鎖，喚醒線程，繼續執行。這樣就提供了在線程間同步、喚醒的操作。Thread.sleep()與Object.wait()二者都可以暫停當前線程，釋放CPU控制權，主要的區別在於Object.wait()在釋放CPU同時，釋放了對象鎖的控制。
單單在概念上理解清楚了還不夠，需要在實際的例子中進行測試才能更好的理解。對Object.wait()，Object.notify()的應用最經典的例子，應該是三線程打印ABC的問題了吧，這是一道比較經典的面試題，題目要求如下：
建立三個線程，A線程打印10次A，B線程打印10次B,C線程打印10次C，要求線程同時運行，交替打印10次ABC。這個問題用Object的wait()，notify()就可以很方便的解決。代碼如下：
1 public class MyThreadPrinter2 implements Runnable { 2 3 private String name; 4 private Object prev; 5 private Object self; 6 7 private MyThreadPrinter2(String name, Object prev, Object self) { 8 this.name = name; 9 this.prev = prev; 10 this.self = self; 11 } 12 13 @Override 14 public void run() { 15 int count = 10; 16 while (count > 0) { 17 synchronized (prev) { 18 synchronized (self) { 19 System.out.print(name); 20 count--; 21 22 self.notify(); 23 } 24 try { 25 prev.wait(); 26 } catch (InterruptedException e) { 27 e.printStackTrace(); 28 } 29 } 30 31 } 32 } 33 34 public static void main(String[] args) throws Exception { 35 Object a = new Object(); 36 Object b = new Object(); 37 Object c = new Object(); 38 MyThreadPrinter2 pa = new MyThreadPrinter2("A", c, a); 39 MyThreadPrinter2 pb = new MyThreadPrinter2("B", a, b); 40 MyThreadPrinter2 pc = new MyThreadPrinter2("C", b, c); 41 42 43 new Thread(pa).start(); 44 new Thread(pb).start(); 45 new Thread(pc).start(); } 46 }
先來解釋一下其整體思路，從大的方向上來講，該問題為三線程間的同步喚醒操作，主要的目的就是ThreadA->ThreadB->ThreadC->ThreadA循環執行三個線程。為了控制線程執行的順序，那么就必須要確定喚醒、等待的順序，所以每一個線程必須同時持有兩個對象鎖，才能繼續執行。一個對象鎖是prev，就是前一個線程所持有的對象鎖。還有一個就是自身對象鎖。主要的思想就是，為了控制執行的順序，必須要先持有prev鎖，也就前一個線程要釋放自身對象鎖，再去申請自身對象鎖，兩者兼備時打印，之后首先調用self.notify()釋放自身對象鎖，喚醒下一個等待線程，再調用prev.wait()釋放prev對象鎖，終止當前線程，等待循環結束后再次被喚醒。運行上述代碼，可以發現三個線程循環打印ABC，共10次。程序運行的主要過程就是A線程最先運行，持有C,A對象鎖，后釋放A,C鎖，喚醒B。線程B等待A鎖，再申請B鎖，后打印B，再釋放B，A鎖，喚醒C，線程C等待B鎖，再申請C鎖，后打印C，再釋放C,B鎖，喚醒A。看起來似乎沒什么問題，但如果你仔細想一下，就會發現有問題，就是初始條件，三個線程按照A,B,C的順序來啟動，按照前面的思考，A喚醒B，B喚醒C，C再喚醒A。但是這種假設依賴於JVM中線程調度、執行的順序。具體來說就是，在main主線程啟動ThreadA后，需要在ThreadA執行完，在prev.wait()等待時，再切回線程啟動ThreadB，ThreadB執行完，在prev.wait()等待時，再切回主線程，啟動ThreadC，只有JVM按照這個線程運行順序執行，才能保證輸出的結果是正確的。而這依賴於JVM的具體實現。考慮一種情況，如下：如果主線程在啟動A后，執行A，過程中又切回主線程，啟動了ThreadB,ThreadC，之后，由於A線程尚未釋放self.notify，也就是B需要在synchronized(prev)處等待，而這時C卻調用synchronized(prev)獲取了對b的對象鎖。這樣，在A調用完后，同時ThreadB獲取了prev也就是a的對象鎖，ThreadC的執行條件就已經滿足了，會打印C，之后釋放c,及b的對象鎖，這時ThreadB具備了運行條件，會打印B，也就是循環變成了ACBACB了。這種情況，可以通過在run中主動釋放CPU，來進行模擬。代碼如下：
1 public void run() { 2 int count = 10; 3 while (count > 0) { 4 synchronized (prev) { 5 synchronized (self) { 6 System.out.print(name); 7 count--; 8 try{ 9 Thread.sleep(1); 10 } 11 catch (InterruptedException e){ 12 e.printStackTrace(); 13 } 14 15 self.notify(); 16 } 17 try { 18 prev.wait(); 19 } catch (InterruptedException e) { 20 e.printStackTrace(); 21 } 22 } 23 24 } 25 }
運行后的打印結果就變成了ACBACB了。為了避免這種與JVM調度有關的不確定性。需要讓A,B,C三個線程以確定的順序啟動，最終代碼如下：
1 2 public class MyThreadPrinter2 implements Runnable { 3 4 private String name; 5 private Object prev; 6 private Object self; 7 8 private MyThreadPrinter2(String name, Object prev, Object self) { 9 this.name = name; 10 this.prev = prev; 11 this.self = self; 12 } 13 14 @Override 15 public void run() { 16 int count = 10; 17 while (count > 0) { 18 synchronized (prev) { 19 synchronized (self) { 20 System.out.print(name); 21 count--; 22 try{ 23 Thread.sleep(1); 24 } 25 catch (InterruptedException e){ 26 e.printStackTrace(); 27 } 28 29 self.notify(); 30 } 31 try { 32 prev.wait(); 33 } catch (InterruptedException e) { 34 e.printStackTrace(); 35 } 36 } 37 38 } 39 } 40 41 public static void main(String[] args) throws Exception { 42 Object a = new Object(); 43 Object b = new Object(); 44 Object c = new Object(); 45 MyThreadPrinter2 pa = new MyThreadPrinter2("A", c, a); 46 MyThreadPrinter2 pb = new MyThreadPrinter2("B", a, b); 47 MyThreadPrinter2 pc = new MyThreadPrinter2("C", b, c); 48 49 50 new Thread(pa).start(); 51 Thread.sleep(10); 52 new Thread(pb).start(); 53 Thread.sleep(10); 54 new Thread(pc).start(); 55 Thread.sleep(10); 56 } 57 } 58 59
這樣才可以完美的解決該問題。通過這個例子也是想說明一下，很多理論、概念如Obj.wait(),Obj.notify()等，理解起來，比較簡單，但是在實際的應用當中，這里卻是往往出現問題的地方。需要更加深入的理解。並在解決問題的過程中不斷加深對概念的掌握。