今天在和導師討論Java多執行緒程式設計的同步問題時，發現自己對同步程式碼塊、wait()方法、notify()方法和notifyAll()方法的理解不太清晰，於是在網上查閱資料，可是結果眾說紛紜，又在導師的啟發和指導下結合程式設計驗證後得出如下結論。

1. Java中的每一個物件例項都有一個鎖標記和鎖池，鎖標記預設允許進入。當一個執行緒嘗試進入以該物件為鎖的同步程式碼塊時，JVM會執行獲取鎖的操作，該操作首先檢視鎖標記是否為允許進入：

   • 如果允許進入，則JVM將該標記改為不允許進入後，允許該執行緒進入該同步程式碼塊執行。
   • 如果不允許進入，則JVM不改動該標記（保持為不允許進入狀態），同時儲存該執行緒的上下文環境後將其休眠，並加入鎖池中。

2. 當允許進入該同步程式碼塊中執行的執行緒退出該同步程式碼塊時，JVM執行釋放鎖的操作，該操作會檢查鎖池中是否存在休眠的執行緒：

   • 如果鎖池不為空，則JVM選取一個鎖池中的執行緒將其移出，併為其恢復上下文環境，喚醒並讓其參與執行緒排程。（因為休眠前剛好進入要進入同步程式碼塊，所以當其獲取到CPU執行許可權後就開始執行同步程式碼塊中的程式碼了）
   • 如果鎖池為空，則JVM將該同步程式碼塊的鎖標記置為允許進入即可。

3. 當在同步程式碼塊中執行wait()操作時，JVM的執行流程如下：

   1. 對該物件執行釋放鎖的操作（見2）。
   2. 儲存本執行緒的上下文環境，將本執行緒加入該物件的等待池中，然後休眠不再參與CPU排程。

4. 當同步程式碼塊中的程式碼執行notify方法時，JVM會從目標物件的等待池中選出一個執行緒並將其移到鎖池中；而如果執行的是notifyAll方法，則將等待池中的所有執行緒一併加入鎖池中。需要注意的是，無論notify方法還是notifyAll方法，都只是在等待池與鎖池之間進行移動操作，並不會喚醒任何執行緒。只有當前執行緒退出同步程式碼塊後，JVM才會從鎖池中選出一個執行緒讓其繼續執行。（由於進入等待池的執行緒在休眠前儲存了上下文環境，所以其在繼續執行後是從wait()之中恢復並執行的，保證了執行結果的一致性）

   下面通過一段程式碼對以上所述進行驗證：

   import java.util.concurrent.TimeUnit;
   
   public
    
    class CMTTest {
   public static void main(String[] args) {
           Object co = new Object();
           System.out.println(co);
   
           for (int i = 0; i < 5; i++) {
               MyThread t = new MyThread("Thread" + i, co);
               t.start();
           }
   
           try {
               TimeUnit.SECONDS.sleep(20);
               synchronized (co) {
                   System.out.println("Main Thread entered syn block...begin to invoke notifyAll()");
                   co.notifyAll();
                   System.out.println("Main Thread return from notifyAll()...begin to sleep");
                   TimeUnit.SECONDS.sleep(2);
                   System.out.println("Main Thread quit from syn block.");         
               }
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   
   static class MyThread extends Thread {
       private String name;
       private Object co;
   
       public MyThread(String name, Object o) {
               this.name = name;
               this.co = o;
       }
   
   @Override
       public void run() {
           try {
               System.out.println(name + " trying to enter syn block.");
               synchronized (co) {
                   System.out.println(name + " entered the syn block.Now sleep 2s...");
                   TimeUnit.SECONDS.sleep(2);
                   System.out.println(name + " returm from sleep, begin to invoke wait()...");
                   co.wait();
                   System.out.println(name + " returm from wait()");
                   int nLoopTime = 3;
                   while(nLoopTime != 0) {
                       System.out.println(name + " is in loop for " + nLoopTime + " time");
                       TimeUnit.SECONDS.sleep(1);
                       nLoopTime--;
                   }
               }
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   }
   }

   這段程式碼的執行結果如下：

   [email protected]70dea4e
   Thread0 trying to enter syn block.
   Thread1 trying to enter syn block.
   Thread0 entered the syn block.Now sleep 2s...
   Thread2 trying to enter syn block.
   Thread3 trying to enter syn block.
   Thread4 trying to enter syn block.
   Thread0 returm from sleep, begin to invoke wait()...
   Thread4 entered the syn block.Now sleep 2s...
   Thread4 returm from sleep, begin to invoke wait()...
   Thread3 entered the syn block.Now sleep 2s...
   Thread3 returm from sleep, begin to invoke wait()...
   Thread2 entered the syn block.Now sleep 2s...
   Thread2 returm from sleep, begin to invoke wait()...
   Thread1 entered the syn block.Now sleep 2s...
   Thread1 returm from sleep, begin to invoke wait()...
   Main Thread entered syn block...begin to invoke notifyAll()
   Main Thread return from notifyAll()...begin to sleep
   Main Thread quit from syn block.
   Thread1 returm from wait()
   Thread1 is in loop for 3 time
   Thread1 is in loop for 2 time
   Thread1 is in loop for 1 time
   Thread2 returm from wait()
   Thread2 is in loop for 3 time
   Thread2 is in loop for 2 time
   Thread2 is in loop for 1 time
   Thread3 returm from wait()
   Thread3 is in loop for 3 time
   Thread3 is in loop for 2 time
   Thread3 is in loop for 1 time
   Thread4 returm from wait()
   Thread4 is in loop for 3 time
   Thread4 is in loop for 2 time
   Thread4 is in loop for 1 time
   Thread0 returm from wait()
   Thread0 is in loop for 3 time
   Thread0 is in loop for 2 time
   Thread0 is in loop for 1 time

   從中可以看出以下幾點：

   1. 同步程式碼塊在同一時間只允許一個執行緒進入
   2. 在同步程式碼塊中呼叫wait()方法會執行釋放鎖的操作
   3. 呼叫notifyAll方法後，處於wait()狀態的執行緒們並沒有被立刻喚醒，而是等當前執行緒退出同步程式碼塊後才順序執行
   4. 如果該notifyAll方法為notify方法，則最終只有一個執行緒能從從wait方法中返回。
   5. 最後補充一點，wait、notify和notifyAll方法是任何Object及其派生類物件都有的方法，其呼叫範圍僅限於同步方法和同步程式碼塊中，在外部直接呼叫會拋java.lang.IllegalMonitorStateException執行時異常。

   所以，之前將Java的多執行緒同步與Windows的多執行緒同步直接進行類比，特別是按照語義直接想當然地理解wait和notify、notifyAll()等方法得出的結論是錯誤的。紙上得來終覺淺，絕知此事要躬行啊！