java wait notify

在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()就能夠很方便的解決。代碼以下：

publicclass MyThreadPrinter2 implements Runnable {

private String name;
private Object prev;
private Object self;

private MyThreadPrinter2(String name, Object prev, Object self) {
this.name = name;
this.prev = prev;
this.self = self;
    }

@Override
publicvoid run() {
int count = 10;
while (count > 0) {
synchronized (prev) {
synchronized (self) {
                    System.out.print(name);
                    count--;

                    self.notify();
                }
try {
                    prev.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }

publicstaticvoid main(String[] args) throws Exception {
        Object a = new Object();
        Object b = new Object();
        Object c = new Object();
        MyThreadPrinter2 pa = new MyThreadPrinter2("A", c, a);
        MyThreadPrinter2 pb = new MyThreadPrinter2("B", a, b);
        MyThreadPrinter2 pc = new MyThreadPrinter2("C", b, c);


new Thread(pa).start();
new Thread(pb).start();
new Thread(pc).start();    }
}

    先來解釋一下其總體思路，從大的方向上來說，該問題爲三線程間的同步喚醒操做，主要的目的就是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，來進行模擬。代碼以下：

publicvoid run() {
int count = 10;
while (count > 0) {
synchronized (prev) {
synchronized (self) {
                System.out.print(name);
                count--;
try{
                Thread.sleep(1);
                }
catch (InterruptedException e){
                 e.printStackTrace();
                }

                self.notify();
            }
try {
                prev.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

   運行後的打印結果就變成了ACBACB了。爲了不這種與JVM調度有關的不肯定性。須要讓A,B,C三個線程以肯定的順序啓動，最終代碼以下：

publicclass MyThreadPrinter2 implements Runnable {

private String name;
private Object prev;
private Object self;

private MyThreadPrinter2(String name, Object prev, Object self) {
this.name = name;
this.prev = prev;
this.self = self;
    }

@Override
publicvoid run() {
int count = 10;
while (count > 0) {
synchronized (prev) {
synchronized (self) {
                    System.out.print(name);
                    count--;
try{
                    Thread.sleep(1);
                    }
catch (InterruptedException e){
                     e.printStackTrace();
                    }

                    self.notify();
                }
try {
                    prev.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }

publicstaticvoid main(String[] args) throws Exception {
        Object a = new Object();
        Object b = new Object();
        Object c = new Object();
        MyThreadPrinter2 pa = new MyThreadPrinter2("A", c, a);
        MyThreadPrinter2 pb = new MyThreadPrinter2("B", a, b);
        MyThreadPrinter2 pc = new MyThreadPrinter2("C", b, c);


new Thread(pa).start();
        Thread.sleep(10);
new Thread(pb).start();
        Thread.sleep(10);
new Thread(pc).start();
        Thread.sleep(10);
    }
}

      這樣才能夠完美的解決該問題。經過這個例子也是想說明一下，不少理論、概念如Obj.wait(),Obj.notify()等，理解起來，比較簡單，可是在實際的應用當中，這裏倒是每每出現問題的地方。須要更加深刻的理解。並在解決問題的過程當中不斷加深對概念的掌握。