傳統線程互斥和同步通信

傳統的線程互斥和同步通信是通過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             @Override
14             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             @Override
14             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 luchao
26  *
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()增加一次判斷，增加程式的嚴謹性。因為，在沒有被通知、中斷或超時的情況下，線程還可以喚醒一個所謂的虛假喚醒。