傳統線程互斥和同步通訊，傳統線程互斥

傳統線程互斥和同步通訊，傳統線程互斥

傳統的線程互斥和同步通訊是通過synchronized關鍵字和wait()、notify()方法來實現的。

首先介紹下synchronized關鍵字。

synchronized 關鍵字，它包括兩種用法：synchronized 方法和 synchronized 塊。  
1. synchronized 方法：通過在方法聲明中加入 synchronized關鍵字來聲明 synchronized 方法。如：  

public synchronized void accessVal(int newVal);  

synchronized 方法控制對類成員變數的訪問：每個類執行個體對應一把鎖，每個 synchronized 方法都必須獲得調用該方法的類執行個體的鎖方能執行，否則所屬線程阻塞，方法一旦執行，就獨佔該鎖，直到從該方法返回時才將鎖釋放，此後被阻塞的線程方能獲得該鎖，重新進入可執行狀態。這種機制確保了同一時刻對於每一個類執行個體，其所有聲明為 synchronized 的成員函數中至多隻有一個處於可執行狀態（因為至多隻有一個能夠獲得該類執行個體對應的鎖），從而有效避免了類成員變數的存取違規（只要所有可能訪問類成員變數的方法均被聲明為 synchronized）。  

在 Java 中，不光是類執行個體，每一個類也對應一把鎖，這樣我們也可將類的靜態成員函式宣告為 synchronized ，以控制其對類的靜態成員變數的訪問。  synchronized 方法的缺陷：若將一個大的方法聲明為synchronized 將會大大影響效率，典型地，若將線程類的方法 run() 聲明為synchronized ，由於線上程的整個生命期內它一直在運行，因此將導致它對本類任何 synchronized 方法的調用都永遠不會成功。當然我們可以通過將訪問類成員變數的代碼放到專門的方法中，將其聲明為 synchronized ，並在主方法中調用來解決這一問題，但是 Java 為我們提供了更好的解決辦法，那就是 synchronized 塊。  

2. synchronized 塊：通過 synchronized關鍵字來聲明synchronized 塊。文法如下：  

1 synchronized(syncObject) {  2 //允許存取控制的代碼  3 }  

synchronized 塊是這樣一個代碼塊，其中的代碼必須獲得對象 syncObject （如前所述，可以是類執行個體或類）的鎖方能執行，具體機制同前所述。由於可以針對任意代碼塊，且可任意指定上鎖的對象，故靈活性較高。  

注意：在Java中使用synchronized塊可以減少對資源的鎖定時間，適當的提高系統效能。syncronized鎖定的對象要保證是同一個對象，不然不能實現互斥的效果。對入靜態方法的互斥，要鎖定類的位元組碼對象，即類名.class。

舉例如下：

 1 public class TraditionalSynchronized { 2     public static void main(String[] args) { 3         final Outputer outputer = new Outputer(); 4         new Thread(new Runnable() { 5             @Override 6             public void run() { 7                 while(true){ 8                     outputer.outputer("love"); 9                 }10             }11         }).start();12         new Thread(new Runnable() {13             @Override14             public void run() {15                 while(true){16                     Outputer.outputer3("hite");17                 }18             }19         }).start();20         21     }22 }23 //列印字串24 class Outputer{25     public void outputer(String name){26         int len = name.length();27         synchronized (Outputer.class) {28         for (int i = 0; i < len; i++) {29                 System.out.print(name.charAt(i));30             }31         System.out.println();32         }33         34     }35     public synchronized void outputer2(String name){36         int len = name.length();37         for (int i = 0; i < len; i++) {38                 System.out.print(name.charAt(i));39         }40         System.out.println();41     }42     public static synchronized void outputer3(String name){43         int len = name.length();44         for (int i = 0; i < len; i++) {45                 System.out.print(name.charAt(i));46         }47         System.out.println();48     }49 }

線程的同步通訊是通過Object的wait()和notify()方法來實現的。wait():當前線程必須擁有此對象監視器。該線程發布對此監視器的所有權並等待，直到其他線程通過調用 notify 方法，或 notifyAll 方法通知在此對象的監視器上等待的線程醒來。然後該線程將等到重新獲得對監視器的所有權後才能繼續執行。notify():喚醒在此對象監視器上等待的單個線程。如果所有線程都在此對象上等待，則會選擇喚醒其中一個線程。選擇是任意性的，並在對實現做出決定時發生。線程通過調用其中一個 wait 方法，在對象的監視器上等待。

現在以：實現子線程迴圈10次，然後主線程迴圈100次，然後子線程再次迴圈10次，然後主線程再次迴圈100次。如此往複50次。這個例子結合線程互斥和線程通訊，來加深印象。

 1 public class TraditionalCommunication { 2     public static void main(String[] args) { 3         final Business business = new Business(); 4         new Thread(new Runnable() { 5             @Override 6             public void run() { 7                 for (int i = 0; i < 50; i++) { 8                     business.sub(i); 9                 }10             }11         }).start();12         new Thread(new Runnable() {13             @Override14             public void run() {15                 for (int i = 0; i < 50; i++) {16                     business.main(i);17                 }18             }19         }).start();20     }21 }22 23 /**24  * 在解決多線程問題是，盡量將線程同步放在類的內部解決，而不是在多線程中進行同步，這樣可以簡化程式25  * @author luchao26  *27  */28 class Business{29     private boolean isSubRun = true;30     public synchronized void sub(int n){31         while(!isSubRun){//這裡可以使用if，但是一些程式存在“假喚醒”狀態，使用while來多加一次判斷，避免“假喚醒”狀態32             try {33                 this.wait();34             } catch (InterruptedException e) {35                 e.printStackTrace();36             }37         }38         for (int i = 0; i < 10; i++) {39             System.out.println("sub: "+i+" loop of: "+n);40         }41         isSubRun = false;42         this.notify();//喚醒主線程43     }44     public synchronized void main(int n){45         while(isSubRun){46             try {47                 this.wait();48             } catch (InterruptedException e) {49                 e.printStackTrace();50             }51         }52         for (int i = 0; i < 100; i++) {53             System.out.println("main: "+i+" loop of: "+n);54         }55         isSubRun = true;56         this.notify();//喚醒子線程57     }58 }

通過上面例子做出如下總結：在做多線程編程是，盡量將線程同步放在類的內部完成，而不是通過線程來進行同步，這樣可以簡化編程難度。在synchronized方法內部通過while()增加一次判斷，增加程式的嚴謹性。因為，在沒有被通知、中斷或逾時的情況下，線程還可以喚醒一個所謂的虛假喚醒。