1. 理解多線程

多線程是這樣一種機(jī)制，它允許在程序中并發(fā)執(zhí)行多個指令流，每個指令流都稱為一個線程，彼此間互相獨(dú)立。

線程又稱為輕量級進(jìn)程，它和進(jìn)程一樣擁有獨(dú)立的執(zhí)行控制，由操作系統(tǒng)負(fù)責(zé)調(diào)度，區(qū)別在于線程沒有獨(dú)立的存儲空間，而是和所屬進(jìn)程中的其它線程共享一個存儲空間，這使得線程間的通信遠(yuǎn)較進(jìn)程簡單。

多個線程的執(zhí)行是并發(fā)的，也就是在邏輯上“同時”，而不管是否是物理上的“同時”。如果系統(tǒng)只有一個CPU，那么真正的“同時”是不可能的，但是由于CPU的速度非常快，用戶感覺不到其中的區(qū)別，因此我們也不用關(guān)心它，只需要設(shè)想各個線程是同時執(zhí)行即可。

多線程和傳統(tǒng)的單線程在程序設(shè)計上最大的區(qū)別在于，由于各個線程的控制流彼此獨(dú)立，使得各個線程之間的代碼是亂序執(zhí)行的，由此帶來的線程調(diào)度，同步等問題，將在以后探討。

2. 在Java中實現(xiàn)多線程

我們不妨設(shè)想，為了創(chuàng)建一個新的線程，我們需要做些什么？很顯然，我們必須指明這個線程所要執(zhí)行的代碼，而這就是在Java中實現(xiàn)多線程我們所需要做的一切！

真是神奇！Java是如何做到這一點的？通過類！作為一個完全面向?qū)ο蟮恼Z言，Java提供了類java.lang.Thread來方便多線程編程，這個類提供了大量的方法來方便我們控制自己的各個線程，我們以后的討論都將圍繞這個類進(jìn)行。

那么如何提供給Java我們要線程執(zhí)行的代碼呢？讓我們來看一看Thread類。Thread類最重要的方法是run()，它為Thread類的方法start()所調(diào)用，提供我們的線程所要執(zhí)行的代碼。為了指定我們自己的代碼，只需要覆蓋它！

方法一：繼承Thread類，覆蓋方法run()，我們在創(chuàng)建的Thread類的子類中重寫run(),加入線程所要執(zhí)行的代碼即可。下面是一個例子：

　　public class MyThread extends Thread
　　{
　　int count= 1, number;
　　public MyThread(int num)
　　{
　　number = num;
　　System.out.println
　　("創(chuàng)建線程 " + number);
　　}
　　public void run() {
　　while(true) {
　　System.out.println
　　("線程 " + number + ":計數(shù) " + count);
　　if(++count== 6) return;
　　}
　　}
　　public static void main(String args[])
　　{
　　for(int i = 0;
　　i 〈 5; i++) new MyThread(i+1).start();
　　}
　　}

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

我們不妨來探索一種新的方法：我們不創(chuàng)建Thread類的子類，而是直接使用它，那么我們只能將我們的方法作為參數(shù)傳遞給Thread類的實例，有點類似回調(diào)函數(shù)。但是Java沒有指針，我們只能傳遞一個包含這個方法的類的實例。

那么如何限制這個類必須包含這一方法呢？當(dāng)然是使用接口！（雖然抽象類也可滿足，但是需要繼承，而我們之所以要采用這種新方法，不就是為了避免繼承帶來的限制嗎？）

Java提供了接口java.lang.Runnable來支持這種方法。

方法二：實現(xiàn)Runnable接口

Runnable接口只有一個方法run()，我們聲明自己的類實現(xiàn)Runnable接口并提供這一方法，將我們的線程代碼寫入其中，就完成了這一部分的任務(wù)。但是Runnable接口并沒有任何對線程的支持，我們還必須創(chuàng)建Thread類的實例，這一點通過Thread類的構(gòu)造函數(shù)public Thread(Runnable target);來實現(xiàn)。下面是一個例子：

　　public class MyThread implements Runnable
　　{
　　int count= 1, number;
　　public MyThread(int num)
　　{
　　number = num;
　　System.out.println("創(chuàng)建線程 " + number);
　　}
　　public void run()
　　{
　　while(true)
　　{
　　System.out.println
　　("線程 " + number + ":計數(shù) " + 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();
　　}
　　}

嚴(yán)格地說，創(chuàng)建Thread子類的實例也是可行的，但是必須注意的是，該子類必須沒有覆蓋Thread類的run方法，否則該線程執(zhí)行的將是子類的run方法，而不是我們用以實現(xiàn)Runnable接口的類的run方法，對此大家不妨試驗一下。

使用Runnable接口來實現(xiàn)多線程使得我們能夠在一個類中包容所有的代碼，有利于封裝，它的缺點在于，我們只能使用一套代碼，若想創(chuàng)建多個線程并使各個線程執(zhí)行不同的代碼，則仍必須額外創(chuàng)建類，如果這樣的話，在大多數(shù)情況下也許還不如直接用多個類分別繼承Thread來得緊湊。

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

下面讓我們一起來研究一下多線程使用中的一些問題。

3. 線程的四種狀態(tài)

1.新狀態(tài)：線程已被創(chuàng)建但尚未執(zhí)行（start()尚未被調(diào)用）。

2.可執(zhí)行狀態(tài)：線程可以執(zhí)行，雖然不一定正在執(zhí)行。CPU時間隨時可能被分配給該線程，從而使得它執(zhí)行。

3.死亡狀態(tài)：正常情況下run()返回使得線程死亡。調(diào)用stop()或destroy()亦有同樣效果，但是不被推薦，前者會產(chǎn)生異常，后者是強(qiáng)制終止，不會釋放鎖。

4.阻塞狀態(tài)：線程不會被分配CPU時間，無法執(zhí)行。

4. 線程的優(yōu)先級

線程的優(yōu)先級代表該線程的重要程度，當(dāng)有多個線程同時處于可執(zhí)行狀態(tài)并等待獲得CPU時間時，線程調(diào)度系統(tǒng)根據(jù)各個線程的優(yōu)先級來決定給誰分配CPU時間，優(yōu)先級高的線程有更大的機(jī)會獲得CPU時間，優(yōu)先級低的線程也不是沒有機(jī)會，只是機(jī)會要小一些罷了。

你可以調(diào)用Thread類的方法getPriority()和setPriority()來存取線程的優(yōu)先級，線程的優(yōu)先級界于1(MIN_PRIORITY)和10(MAX_PRIORITY)之間，缺省是5(NORM_PRIORITY)。

5. 線程的同步

由于同一進(jìn)程的多個線程共享同一片存儲空間，在帶來方便的同時，也帶來了訪問沖突這個嚴(yán)重的問題。Java語言提供了專門機(jī)制以解決這種沖突，有效避免了同一個數(shù)據(jù)對象被多個線程同時訪問。

由于我們可以通過private關(guān)鍵字來保證數(shù)據(jù)對象只能被方法訪問，所以我們只需針對方法提出一套機(jī)制，這套機(jī)制就是synchronized關(guān)鍵字，它包括兩種用法：synchronized方法和synchronized塊。

1.synchronized方法：通過在方法聲明中加入synchronized關(guān)鍵字來聲明synchronized方法。如：

public synchronized void accessVal(int newVal);

synchronized方法控制對類成員變量的訪問：每個類實例對應(yīng)一把鎖，每個synchronized方法都必須獲得調(diào)用該方法的類實例的鎖方能執(zhí)行，否則所屬線程阻塞，方法一旦執(zhí)行，就獨(dú)占該鎖，直到從該方法返回時才將鎖釋放，此后被阻塞的線程方能獲得該鎖，重新進(jìn)入可執(zhí)行狀態(tài)。

這種機(jī)制確保了同一時刻對于每一個類實例，其所有聲明為synchronized的成員函數(shù)中至多只有一個處于可執(zhí)行狀態(tài)（因為至多只有一個能夠獲得該類實例對應(yīng)的鎖），從而有效避免了類成員變量的訪問沖突（只要所有可能訪問類成員變量的方法均被聲明為synchronized）。

在Java中，不光是類實例，每一個類也對應(yīng)一把鎖，這樣我們也可將類的靜態(tài)成員函數(shù)聲明為synchronized，以控制其對類的靜態(tài)成員變量的訪問。

synchronized方法的缺陷：若將一個大的方法聲明為synchronized將會大大影響效率，典型地，若將線程類的方法run()聲明為synchronized，由于在線程的整個生命期內(nèi)它一直在運(yùn)行，因此將導(dǎo)致它對本類任何synchronized方法的調(diào)用都永遠(yuǎn)不會成功。當(dāng)然我們可以通過將訪問類成員變量的代碼放到專門的方法中，將其聲明為synchronized，并在主方法中調(diào)用來解決這一問題，但是Java為我們提供了更好的解決辦法，那就是synchronized塊。

2.synchronized塊：通過synchronized關(guān)鍵字來聲明synchronized塊。語法如下：

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

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

7. 線程的阻塞

為了解決對共享存儲區(qū)的訪問沖突，Java引入了同步機(jī)制，現(xiàn)在讓我們來考察多個線程對共享資源的訪問，顯然同步機(jī)制已經(jīng)不夠了，因為在任意時刻所要求的資源不一定已經(jīng)準(zhǔn)備好了被訪問，反過來，同一時刻準(zhǔn)備好了的資源也可能不止一個。為了解決這種情況下的訪問控制問題，Java引入了對阻塞機(jī)制的支持。

阻塞指的是暫停一個線程的執(zhí)行以等待某個條件發(fā)生（如某資源就緒），學(xué)過操作系統(tǒng)的同學(xué)對它一定已經(jīng)很熟悉了。Java提供了大量方法來支持阻塞，下面讓我們逐一分析。

1.sleep()方法：sleep()允許指定以毫秒為單位的一段時間作為參數(shù)，它使得線程在指定的時間內(nèi)進(jìn)入阻塞狀態(tài)，不能得到CPU時間，指定的時間一過，線程重新進(jìn)入可執(zhí)行狀態(tài)。典型地，sleep()被用在等待某個資源就緒的情形：測試發(fā)現(xiàn)條件不滿足后，讓線程阻塞一段時間后重新測試，直到條件滿足為止。

2.suspend()和resume()方法：兩個方法配套使用，suspend()使得線程進(jìn)入阻塞狀態(tài)，并且不會自動恢復(fù)，必須其對應(yīng)的resume()被調(diào)用，才能使得線程重新進(jìn)入可執(zhí)行狀態(tài)。典型地，suspend()和resume()被用在等待另一個線程產(chǎn)生的結(jié)果的情形：測試發(fā)現(xiàn)結(jié)果還沒有產(chǎn)生后，讓線程阻塞，另一個線程產(chǎn)生了結(jié)果后，調(diào)用resume()使其恢復(fù)。

3.yield()方法：yield()使得線程放棄當(dāng)前分得的CPU時間，但是不使線程阻塞，即線程仍處于可執(zhí)行狀態(tài)，隨時可能再次分得CPU時間。調(diào)用yield()的效果等價于調(diào)度程序認(rèn)為該線程已執(zhí)行了足夠的時間從而轉(zhuǎn)到另一個線程。

4.wait()和notify()方法：兩個方法配套使用，wait()使得線程進(jìn)入阻塞狀態(tài)，它有兩種形式，一種允許指定以毫秒為單位的一段時間作為參數(shù)，另一種沒有參數(shù)，前者當(dāng)對應(yīng)的notify()被調(diào)用或者超出指定時間時線程重新進(jìn)入可執(zhí)行狀態(tài)，后者則必須對應(yīng)的notify()被調(diào)用。

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

上述的核心區(qū)別導(dǎo)致了一系列的細(xì)節(jié)上的區(qū)別。

首先，前面敘述的所有方法都隸屬于Thread類，但是這一對卻直接隸屬于Object類，也就是說，所有對象都擁有這一對方法。初看起來這十分不可思議，但是實際上卻是很自然的，因為這一對方法阻塞時要釋放占用的鎖，而鎖是任何對象都具有的，調(diào)用任意對象的wait()方法導(dǎo)致線程阻塞，并且該對象上的鎖被釋放。

而調(diào)用任意對象的notify()方法則導(dǎo)致因調(diào)用該對象的wait()方法而阻塞的線程中隨機(jī)選擇的一個解除阻塞（但要等到獲得鎖后才真正可執(zhí)行）。

其次，前面敘述的所有方法都可在任何位置調(diào)用，但是這一對方法卻必須在synchronized方法或塊中調(diào)用，理由也很簡單，只有在synchronized方法或塊中當(dāng)前線程才占有鎖，才有鎖可以釋放。

同樣的道理，調(diào)用這一對方法的對象上的鎖必須為當(dāng)前線程所擁有，這樣才有鎖可以釋放。因此，這一對方法調(diào)用必須放置在這樣的synchronized方法或塊中，該方法或塊的上鎖對象就是調(diào)用這一對方法的對象。若不滿足這一條件，則程序雖然仍能編譯，但在運(yùn)行時會出現(xiàn)IllegalMonitorStateException異常。

wait()和notify()方法的上述特性決定了它們經(jīng)常和synchronized方法或塊一起使用，將它們和操作系統(tǒng)的進(jìn)程間通信機(jī)制作一個比較就會發(fā)現(xiàn)它們的相似性：synchronized方法或塊提供了類似于操作系統(tǒng)原語的功能，它們的執(zhí)行不會受到多線程機(jī)制的干擾，而這一對方法則相當(dāng)于block和wakeup原語（這一對方法均聲明為synchronized）。

它們的結(jié)合使得我們可以實現(xiàn)操作系統(tǒng)上一系列精妙的進(jìn)程間通信的算法（如信號量算法），并用于解決各種復(fù)雜的線程間通信問題。關(guān)于wait()和notify()方法最后再說明兩點：

第一：調(diào)用notify()方法導(dǎo)致解除阻塞的線程是從因調(diào)用該對象的wait()方法而阻塞的線程中隨機(jī)選取的，我們無法預(yù)料哪一個線程將會被選擇，所以編程時要特別小心，避免因這種不確定性而產(chǎn)生問題。

第二：除了notify()，還有一個方法notifyAll()也可起到類似作用，唯一的區(qū)別在于，調(diào)用notifyAll()方法將把因調(diào)用該對象的wait()方法而阻塞的所有線程一次性全部解除阻塞。當(dāng)然，只有獲得鎖的那一個線程才能進(jìn)入可執(zhí)行狀態(tài)。

談到阻塞，就不能不談一談死鎖，略一分析就能發(fā)現(xiàn)，suspend()方法和不指定超時期限的wait()方法的調(diào)用都可能產(chǎn)生死鎖。遺憾的是，Java并不在語言級別上支持死鎖的避免，我們在編程中必須小心地避免死鎖。

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

8. 守護(hù)線程

守護(hù)線程是一類特殊的線程，它和普通線程的區(qū)別在于它并不是應(yīng)用程序的核心部分，當(dāng)一個應(yīng)用程序的所有非守護(hù)線程終止運(yùn)行時，即使仍然有守護(hù)線程在運(yùn)行，應(yīng)用程序也將終止，反之，只要有一個非守護(hù)線程在運(yùn)行，應(yīng)用程序就不會終止。守護(hù)線程一般被用于在后臺為其它線程提供服務(wù)。

可以通過調(diào)用方法isDaemon()來判斷一個線程是否是守護(hù)線程，也可以調(diào)用方法setDaemon()來將一個線程設(shè)為守護(hù)線程。

9. 線程組

線程組是一個Java特有的概念，在Java中，線程組是類ThreadGroup的對象，每個線程都隸屬于唯一一個線程組，這個線程組在線程創(chuàng)建時指定并在線程的整個生命期內(nèi)都不能更改。

你可以通過調(diào)用包含ThreadGroup類型參數(shù)的Thread類構(gòu)造函數(shù)來指定線程屬的線程組，若沒有指定，則線程缺省地隸屬于名為system的系統(tǒng)線程組。

在Java中，除了預(yù)建的系統(tǒng)線程組外，所有線程組都必須顯式創(chuàng)建。在Java中，除系統(tǒng)線程組外的每個線程組又隸屬于另一個線程組，你可以在創(chuàng)建線程組時指定其所隸屬的線程組，若沒有指定，則缺省地隸屬于系統(tǒng)線程組。這樣，所有線程組組成了一棵以系統(tǒng)線程組為根的樹。

Java允許我們對一個線程組中的所有線程同時進(jìn)行操作，比如我們可以通過調(diào)用線程組的相應(yīng)方法來設(shè)置其中所有線程的優(yōu)先級，也可以啟動或阻塞其中的所有線程。

Java的線程組機(jī)制的另一個重要作用是線程安全。線程組機(jī)制允許我們通過分組來區(qū)分有不同安全特性的線程，對不同組的線程進(jìn)行不同的處理，還可以通過線程組的分層結(jié)構(gòu)來支持不對等安全措施的采用。

Java的ThreadGroup類提供了大量的方法來方便我們對線程組樹中的每一個線程組以及線程組中的每一個線程進(jìn)行操作。

以上就是動力節(jié)點小編介紹的"零基礎(chǔ)Java線程學(xué)習(xí)的詳細(xì)總結(jié)"，希望對大家有幫助，如有疑問，請在線咨詢，有專業(yè)老師隨時為您服務(wù)。