深入淺出Java多執行緒程式設計(轉)

深入淺出Java多執行緒程式設計(轉)[@more@]一：理解多執行緒

多執行緒是這樣一種機制，它允許在程式中併發執行多個指令流，每個指令流都稱為一個執行緒，彼此間互相獨立。執行緒又稱為輕量級程式，它和程式一樣擁有獨立的執行控制，由作業系統負責排程，區別在於執行緒沒有獨立的儲存空間，而是和所屬程式中的其它執行緒共享一個儲存空間，這使得執行緒間的通訊遠較程式簡單。

多個執行緒的執行是併發的，也就是在邏輯上“同時”，而不管是否是物理上的“同時”。如果系統只有一個CPU，那麼真正的“同時”是不可能的，但是由於CPU的速度非常快，使用者感覺不到其中的區別，因此我們也不用關心它，只需要設想各個執行緒是同時執行即可。
多執行緒和傳統的單執行緒在程式設計上最大的區別在於，由於各個執行緒的控制流彼此獨立，使得各個執行緒之間的程式碼是亂序執行的，由此帶來的執行緒排程，同步等問題，將在以後探討。

　　二：在Java中實現多執行緒

我們不妨設想，為了建立一個新的執行緒，我們需要做些什麼？很顯然，我們必須指明這個執行緒所要執行的程式碼，而這就是在Java中實現多執行緒我們所需要做的一切！

真是神奇！Java是如何做到這一點的？透過類！作為一個完全物件導向的語言，Java提供了類 java.lang.Thread 來方便多執行緒程式設計，這個類提供了大量的方法來方便我們控制自己的各個執行緒，我們以後的討論都將圍繞這個類進行。

那麼如何提供給 Java 我們要執行緒執行的程式碼呢？讓我們來看一看 Thread 類。Thread 類最重要的方法是 run() ，它為Thread 類的方法 start() 所呼叫，提供我們的執行緒所要執行的程式碼。為了指定我們自己的程式碼，只需要覆蓋它！

　　方法一：繼承 Thread 類，覆蓋方法 run()，我們在建立的 Thread 類的子類中重寫 run() ,加入執行緒所要執行的程式碼即可。下面是一個例子：
public class MyThread extends Thread {
　int count= 1, number;
　public MyThread(int num) {
　　number = num;
　　System.out.println("建立執行緒 " + number);
　}
　public void run() {
　　while(true) {
　　　System.out.println("執行緒 " + number + ":計數 " + count);
　　　if(++count== 6) return;
　　}
　}
　public static void main(String args[]) {
　　for(int i = 0; i < 5; i++) new MyThread(i+1).start();
　}
}

這種方法簡單明瞭，符合大家的習慣，但是，它也有一個很大的缺點，那就是如果我們的類已經從一個類繼承（如小程式必須繼承自 Applet 類），則無法再繼承 Thread 類，這時如果我們又不想建立一個新的類，應該怎麼辦呢？

我們不妨來探索一種新的方法：我們不建立 Thread 類的子類，而是直接使用它，那麼我們只能將我們的方法作為引數傳遞給 Thread 類的例項，有點類似回撥函式。但是 Java 沒有指標，我們只能傳遞一個包含這個方法的類的例項。那麼如何限制這個類必須包含這一方法呢？當然是使用介面！（雖然抽象類也可滿足，但是需要繼承，而我們之所以要採用這種新方法，不就是為了避免繼承帶來的限制嗎？）
Java 提供了介面 java.lang.Runnable 來支援這種方法。

　　方法二：實現 Runnable 介面

Runnable 介面只有一個方法 run()，我們宣告自己的類實現 Runnable 介面並提供這一方法，將我們的執行緒程式碼寫入其中，就完成了這一部分的任務。但是 Runnable 介面並沒有任何對執行緒的支援，我們還必須建立 Thread 類的例項，這一點透過 Thread 類的建構函式public Thread(Runnable target);來實現。下面是一個例子：
public class MyThread implements Runnable {
　int count= 1, number;
　public MyThread(int num) {
　　number = num;
　　System.out.println("建立執行緒 " + number);
　}
　public void run() {
　　while(true) {
　　　System.out.println("執行緒 " + number + ":計數 " + count);
　　　if(++count== 6) return;
　　}
　}
　public static void main(String args[]) {
　　for(int i = 0; i < 5; i++) new Thread(new MyThread(i+1)).start();
　}
}

嚴格地說，建立 Thread 子類的例項也是可行的，但是必須注意的是，該子類必須沒有覆蓋 Thread 類的 run 方法，否則該執行緒執行的將是子類的 run 方法，而不是我們用以實現Runnable 介面的類的 run 方法，對此大家不妨試驗一下。

　　使用 Runnable 介面來實現多執行緒使得我們能夠在一個類中包容所有的程式碼，有利於封裝，它的缺點在於，我們只能使用一套程式碼，若想建立多個執行緒並使各個執行緒執行不同的程式碼，則仍必須額外建立類，如果這樣的話，在大多數情況下也許還不如直接用多個類分別繼承 Thread 來得緊湊。

　　綜上所述，兩種方法各有千秋，大家可以靈活運用。

　　下面讓我們一起來研究一下多執行緒使用中的一些問題。
　三：執行緒的四種狀態

　　1. 新狀態：執行緒已被建立但尚未執行（start() 尚未被呼叫）。

　　2. 可執行狀態：執行緒可以執行，雖然不一定正在執行。CPU 時間隨時可能被分配給該執行緒，從而使得它執行。

　　3. 死亡狀態：正常情況下 run() 返回使得執行緒死亡。呼叫 stop()或 destroy() 亦有同樣效果，但是不被推薦，前者會產生異常，後者是強制終止，不會釋放鎖。

　　4. 阻塞狀態：執行緒不會被分配 CPU 時間，無法執行。

　　四：執行緒的優先順序

執行緒的優先順序代表該執行緒的重要程度，當有多個執行緒同時處於可執行狀態並等待獲得 CPU 時間時，執行緒排程系統根據各個執行緒的優先順序來決定給誰分配 CPU 時間，優先順序高的執行緒有更大的機會獲得 CPU 時間，優先順序低的執行緒也不是沒有機會，只是機會要小一些罷了。

你可以呼叫 Thread 類的方法 getPriority() 和 setPriority()來存取執行緒的優先順序，執行緒的優先順序界於1(MIN_PRIORITY)和10(MAX_PRIORITY)之間，預設是5(NORM_PRIORITY)。

　　五：執行緒的同步

由於同一程式的多個執行緒共享同一片儲存空間，在帶來方便的同時，也帶來了訪問衝突這個嚴重的問題。Java語言提供了專門機制以解決這種衝突，有效避免了同一個資料物件被多個執行緒同時訪問。

　　由於我們可以透過 private 關鍵字來保證資料物件只能被方法訪問，所以我們只需針對方法提出一套機制，這套機制就是 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 塊。語法如下：

synchronized(syncObject) {
//允許訪問控制的程式碼
}

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

為了解決對共享儲存區的訪問衝突，Java 引入了同步機制，現在讓我們來考察多個執行緒對共享資源的訪問，顯然同步機制已經不夠了，因為在任意時刻所要求的資源不一定已經準備好了被訪問，反過來，同一時刻準備好了的資源也可能不止一個。為了解決這種情況下的訪問控制問題，Java 引入了對阻塞機制的支援。

阻塞指的是暫停一個執行緒的執行以等待某個條件發生（如某資源就緒），學過作業系統的同學對它一定已經很熟悉了。Java 提供了大量方法來支援阻塞，下面讓我們逐一分析。

　　1. sleep() 方法：sleep() 允許 指定以毫秒為單位的一段時間作為引數，它使得執行緒在指定的時間內進入阻塞狀態，不能得到CPU 時間，指定的時間一過，執行緒重新進入可執行狀態。

　　典型地，sleep() 被用在等待某個資源就緒的情形：測試發現條件不滿足後，讓執行緒阻塞一段時間後重新測試，直到條件滿足為止。

　　2. suspend() 和 resume() 方法：兩個方法配套使用，suspend()使得執行緒進入阻塞狀態，並且不會自動恢復，必須其對應的resume() 被呼叫，才能使得執行緒重新進入可執行狀態。典型地，suspend() 和 resume() 被用在等待另一個執行緒產生的結果的情形：測試發現結果還沒有產生後，讓執行緒阻塞，另一個執行緒產生了結果後，呼叫 resume() 使其恢復。

　　3. yield() 方法：yield() 使得執行緒放棄當前分得的 CPU 時間，但是不使執行緒阻塞，即執行緒仍處於可執行狀態，隨時可能再次分得 CPU 時間。呼叫 yield() 的效果等價於排程程式認為該執行緒已執行了足夠的時間從而轉到另一個執行緒。

　　4. wait() 和 notify() 方法：兩個方法配套使用，wait() 使得執行緒進入阻塞狀態，它有兩種形式，一種允許指定以毫秒為單位的一段時間作為引數，另一種沒有引數，前者當對應的 notify() 被呼叫或者超出指定時間時執行緒重新進入可執行狀態，後者則必須對應的 notify() 被呼叫。

初看起來它們與 suspend() 和 resume() 方法對沒有什麼分別，但是事實上它們是截然不同的。區別的核心在於，前面敘述的所有方法，阻塞時都不會釋放佔用的鎖（如果佔用了的話），而這一對方法則相反。

　　上述的核心區別導致了一系列的細節上的區別。

首先，前面敘述的所有方法都隸屬於 Thread 類，但是這一對卻直接隸屬於 Object 類，也就是說，所有物件都擁有這一對方法。初看起來這十分不可思議，但是實際上卻是很自然的，因為這一對方法阻塞時要釋放佔用的鎖，而鎖是任何物件都具有的，呼叫任意物件的 wait() 方法導致執行緒阻塞，並且該物件上的鎖被釋放。而呼叫 任意物件的notify()方法則導致因呼叫該物件的 wait() 方法而阻塞的執行緒中隨機選擇的一個解除阻塞（但要等到獲得鎖後才真正可執行）。

其次，前面敘述的所有方法都可在任何位置呼叫，但是這一對方法卻必須在 synchronized 方法或塊中呼叫，理由也很簡單，只有在synchronized 方法或塊中當前執行緒才佔有鎖，才有鎖可以釋放。同樣的道理，呼叫這一對方法的物件上的鎖必須為當前執行緒所擁有，這樣才有鎖可以釋放。因此，這一對方法呼叫必須放置在這樣的 synchronized 方法或塊中，該方法或塊的上鎖物件就是呼叫這一對方法的物件。若不滿足這一條件，則程式雖然仍能編譯，但在執行時會出現 IllegalMonitorStateException 異常。

wait() 和 notify() 方法的上述特性決定了它們經常和synchronized 方法或塊一起使用，將它們和作業系統的程式間通訊機制作一個比較就會發現它們的相似性：synchronized方法或塊提供了類似於作業系統原語的功能，它們的執行不會受到多執行緒機制的干擾，而這一對方法則相當於 block 和wakeup 原語（這一對方法均宣告為 synchronized）。它們的結合使得我們可以實現作業系統上一系列精妙的程式間通訊的演算法（如訊號量演算法），並用於解決各種複雜的執行緒間通訊問題。

　　關於 wait() 和 notify() 方法最後再說明兩點：

第一：呼叫 notify() 方法導致解除阻塞的執行緒是從因呼叫該物件的 wait() 方法而阻塞的執行緒中隨機選取的，我們無法預料哪一個執行緒將會被選擇，所以程式設計時要特別小心，避免因這種不確定性而產生問題。

第二：除了 notify()，還有一個方法 notifyAll() 也可起到類似作用，唯一的區別在於，呼叫 notifyAll() 方法將把因呼叫該物件的 wait() 方法而阻塞的所有執行緒一次性全部解除阻塞。當然，只有獲得鎖的那一個執行緒才能進入可執行狀態。

談到阻塞，就不能不談一談死鎖，略一分析就能發現，suspend() 方法和不指定超時期限的 wait() 方法的呼叫都可能產生死鎖。遺憾的是，Java 並不在語言級別上支援死鎖的避免，我們在程式設計中必須小心地避免死鎖。

以上我們對 Java 中實現執行緒阻塞的各種方法作了一番分析，我們重點分析了 wait() 和 notify() 方法，因為它們的功能最強大，使用也最靈活，但是這也導致了它們的效率較低，較容易出錯。實際使用中我們應該靈活使用各種方法，以便更好地達到我們的目的。

　　七：守護執行緒

守護執行緒是一類特殊的執行緒，它和普通執行緒的區別在於它並不是應用程式的核心部分，當一個應用程式的所有非守護執行緒終止執行時，即使仍然有守護執行緒在執行，應用程式也將終止，反之，只要有一個非守護執行緒在執行，應用程式就不會終止。守護執行緒一般被用於在後臺為其它執行緒提供服務。

　　可以透過呼叫方法 isDaemon() 來判斷一個執行緒是否是守護執行緒，也可以呼叫方法 setDaemon() 來將一個執行緒設為守護執行緒。

　　八：執行緒組

執行緒組是一個 Java 特有的概念，在 Java 中，執行緒組是類ThreadGroup 的物件，每個執行緒都隸屬於唯一一個執行緒組，這個執行緒組線上程建立時指定並線上程的整個生命期內都不能更改。你可以透過呼叫包含 ThreadGroup 型別引數的 Thread 類建構函式來指定執行緒屬的執行緒組，若沒有指定，則執行緒預設地隸屬於名為 system 的系統執行緒組。

在 Java 中，除了預建的系統執行緒組外，所有執行緒組都必須顯式建立。在 Java 中，除系統執行緒組外的每個執行緒組又隸屬於另一個執行緒組，你可以在建立執行緒組時指定其所隸屬的執行緒組，若沒有指定，則預設地隸屬於系統執行緒組。這樣，所有執行緒組組成了一棵以系統執行緒組為根的樹。

Java 允許我們對一個執行緒組中的所有執行緒同時進行操作，比如我們可以透過呼叫執行緒組的相應方法來設定其中所有執行緒的優先順序，也可以啟動或阻塞其中的所有執行緒。

　　Java 的執行緒組機制的另一個重要作用是執行緒安全。執行緒組機制允許我們透過分組來區分有不同安全特性的執行緒，對不同組的執行緒進行不同的處理，還可以透過執行緒組的分層結構來支援不對等安全措施的採用。Java 的 ThreadGroup 類提供了大量的方法來方便我們對執行緒組樹中的每一個執行緒組以及執行緒組中的每一個執行緒進行操作。

　　九：總結

在本文中，我們講述了 Java 多執行緒程式設計的方方面面，包括建立執行緒，以及對多個執行緒進行排程、管理。我們深刻認識到了多執行緒程式設計的複雜性，以及執行緒切換開銷帶來的多執行緒程式的低效性，這也促使我們認真地思考一個問題：我們是否需要多執行緒？何時需要多執行緒？

多執行緒的核心在於多個程式碼塊併發執行，本質特點在於各程式碼塊之間的程式碼是亂序執行的。我們的程式是否需要多執行緒，就是要看這是否也是它的內在特點。

假如我們的程式根本不要求多個程式碼塊併發執行，那自然不需要使用多執行緒；假如我們的程式雖然要求多個程式碼塊併發執行，但是卻不要求亂序，則我們完全可以用一個迴圈來簡單高效地實現，也不需要使用多執行緒；只有當它完全符合多執行緒的特點時，多執行緒機制對執行緒間通訊和執行緒管理的強大支援才能有用武之地，這時使用多執行緒才是值得的。