Java多線程（二）——線程安全、線程同步、線程間通信

上一篇博文：Java多線程（一） —— 線程的狀態詳解中詳細介紹了線程的五種狀態及狀態間的轉換。本文著重介紹了線程安全的相關知識點，包括線程同步和鎖機制、線程間通信以及相關面試題的總結

多個線程在執行同一段代碼的時候，每次的執行結果和單線程執行的結果都是一樣的，不存在執行結果的二義性，就可以稱作是線程安全的。

講到線程安全問題，其實是指多線程環境下對共享資源的訪問可能會引起此共享資源的不一致性。因此，為避免線程安全問題，應該避免多線程環境下對此共享資源的並發訪問。

線程安全問題多是由全局變數和靜態變數引起的，當多個線程對共享數據只執行讀操作，不執行寫操作時，一般是線程安全的；當多個線程都執行寫操作時，需要考慮線程同步來解決線程安全問題。

線程同步：將操作共享數據的代碼行作為一個整體，同一時間只允許一個線程執行，執行過程中其他線程不能參與執行。目的是為了防止多個線程訪問一個數據對象時，對數據造成的破壞。

（1）同步方法（synchronized）

對共享資源進行訪問的方法定義中加上synchronized關鍵字修飾，使得此方法稱為同步方法。可以簡單理解成對此方法進行了加鎖，其鎖對象為當前方法所在的對象自身。多線程環境下，當執行此方法時，首先都要獲得此同步鎖（且同時最多只有一個線程能夠獲得），只有當線程執行完此同步方法後，才會釋放鎖對象，其他的線程才有可能獲取此同步鎖，以此類推...格式如下：

public synchronized void run {
// ....
}

（2）同步代碼塊（synchronized）

使用同步方法時，使得整個方法體都成為了同步執行狀態，會使得可能出現同步範圍過大的情況，於是，針對需要同步的代碼可以直接另一種同步方式——同步代碼塊來解決。格式如下：

synchronized (obj) {
// ....
}

其中，obj為鎖對象，因此，選擇哪一個對象作為鎖是至關重要的。一般情況下，都是選擇此共享資源對象作為鎖對象。

（3）同步鎖（Lock）

使用Lock對象同步鎖可以方便地解決選擇鎖對象的問題，唯一需要注意的一點是Lock對象需要與資源對象同樣具有一對一的關係。Lock對象同步鎖一般格式為：

class X {
// 顯示定義Lock同步鎖對象，此對象與共享資源具有一對一關係
private final Lock lock = new ReentrantLock;

public void m{
// 加鎖
lock.lock;

//... 需要進行線程安全同步的代碼

// 釋放Lock鎖
lock.unlock;
}
}

什麼時候需要同步：

（1）可見性同步：在以下情況中必須同步： 1）讀取上一次可能是由另一個線程寫入的變數 ；2）寫入下一次可能由另一個線程讀取的變數

（2）一致性同步：當修改多個相關值時，您想要其它線程原子地看到這組更改—— 要麼看到全部更改，要麼什麼也看不到。

這適用於相關數據項（如粒子的位置和速率）和元數據項（如鏈表中包含的數據值和列表自身中的數據項的鏈）。

在某些情況中，您不必用同步來將數據從一個線程傳遞到另一個，因為 JVM 已經隱含地為您執行同步。這些情況包括：

1. 由靜態初始化器（在靜態欄位上或 static{} 塊中的初始化器）
2. 初始化數據時
3. 訪問 final 欄位時
4. 在創建線程之前創建對象時
5. 線程可以看見它將要處理的對象時

鎖的原理：

• Java中每個對象都有一個內置鎖
• 當程序運行到非靜態的synchronized同步方法上時，自動獲得與正在執行代碼類的當前實例（this實例）有關的鎖。獲得一個對象的鎖也稱為獲取鎖、鎖定對象、在對象上鎖定或在對象上同步。
• 當程序運行到synchronized同步方法或代碼塊時才該對象鎖才起作用。
• 一個對象只有一個鎖。所以，如果一個線程獲得該鎖，就沒有其他線程可以獲得鎖，直到第一個線程釋放（或返回）鎖。這也意味著任何其他線程都不能進入該對象上的synchronized方法或代碼塊，直到該鎖被釋放。
• 釋放鎖是指持鎖線程退出了synchronized同步方法或代碼塊。

鎖與同步要點：

1）、只能同步方法，而不能同步變數和類；

2）、每個對象只有一個鎖；當提到同步時，應該清楚在什麼上同步？也就是說，在哪個對象上同步？

3）、不必同步類中所有的方法，類可以同時擁有同步和非同步方法。

4）、如果兩個線程要執行一個類中的synchronized方法，並且兩個線程使用相同的實例來調用方法，那麼一次只能有一個線程能夠執行方法，另一個需要等待，直到鎖被釋放。也就是說：如果一個線程在對象上獲得一個鎖，就沒有任何其他線程可以進入（該對象的）類中的任何一個同步方法。

5）、如果線程擁有同步和非同步方法，則非同步方法可以被多個線程自由訪問而不受鎖的限制。

6）、線程睡眠時，它所持的任何鎖都不會釋放。

7）、線程可以獲得多個鎖。比如，在一個對象的同步方法裡面調用另外一個對象的同步方法，則獲取了兩個對象的同步鎖。

8）、同步損害並發性，應該儘可能縮小同步範圍。同步不但可以同步整個方法，還可以同步方法中一部分代碼塊。

9）、在使用同步代碼塊時候，應該指定在哪個對象上同步，也就是說要獲取哪個對象的鎖。

10）、同步靜態方法，需要一個用於整個類對象的鎖，這個對象是就是這個類（XXX.class)。

線程不能獲得鎖會怎麼樣：如果線程試圖進入同步方法，而其鎖已經被佔用，則線程在該對象上被阻塞。實質上，線程進入該對象的的一種池中，必須在哪裡等待，直到其鎖被釋放，該線程再次變為可運行或運行為止。

線程死鎖：當兩個線程被阻塞，每個線程都在等待另一個線程時就發生死鎖。有一些設計方法能幫助避免死鎖，如始終按照預定義的順序獲取鎖這一策略。

線程同步小結

1、線程同步的目的是為了保護多個線程反問一個資源時對資源的破壞。

2、線程同步方法是通過鎖來實現，每個對象都有且僅有一個鎖，這個鎖與一個特定的對象關聯，線程一旦獲取了對象鎖，其他訪問該對象的線程就無法再訪問該對象的其他同步方法。

3、對於靜態同步方法，鎖是針對這個類的，鎖對象是該類的Class對象。靜態和非靜態方法的鎖互不干預。一個線程獲得鎖，當在一個同步方法中訪問另外對象上的同步方法時，會獲取這兩個對象鎖。

4、對於同步，要時刻清醒在哪個對象上同步，這是關鍵。

5、編寫線程安全的類，需要時刻注意對多個線程競爭訪問資源的邏輯和安全做出正確的判斷，對「原子」操作做出分析，並保證原子操作期間別的線程無法訪問競爭資源。

6、當多個線程等待一個對象鎖時，沒有獲取到鎖的線程將發生阻塞。

7、死鎖是線程間相互等待鎖鎖造成的，在實際中發生的概率非常的小。真讓你寫個死鎖程序，不一定好使，呵呵。但是，一旦程序發生死鎖，程序將死掉。

wait：導致當前線程等待並使其進入到等待阻塞狀態。直到其他線程調用該同步鎖對象的notify或notifyAll方法來喚醒此線程。

• void wait(long timeout) -- 導致當前線程等待，直到其他線程調用此對象的 notify 方法或 notifyAll 方法，或者超過指定的時間量。
• void wait(long timeout, int nanos) -- 導致當前線程等待，直到其他線程調用此對象的 notify 方法或 notifyAll 方法，或者其他某個線程中斷當前線程，或者已超過某個實際時間量。

notify：喚醒在此同步鎖對象上等待的單個線程，如果有多個線程都在此同步鎖對象上等待，則會任意選擇其中某個線程進行喚醒操作，只有當前線程放棄對同步鎖對象的鎖定，才可能執行被喚醒的線程。

notifyAll：喚醒在此同步鎖對象上等待的所有線程，只有當前線程放棄對同步鎖對象的鎖定，才可能執行被喚醒的線程。

這三個方法主要都是用於多線程中，但實際上都是Object類中的本地方法。因此，理論上，任何Object對象都可以作為這三個方法的主調，在實際的多線程編程中，只有同步鎖對象調這三個方法，才能完成對多線程間的線程通信。

注意點：

1.wait方法執行後，當前線程立即進入到等待阻塞狀態，其後面的代碼不會執行；

2.notify/notifyAll方法執行後，將喚醒此同步鎖對象上的（任意一個-notify()/所有-notifyAll()）線程對象，但是，此時還並沒有釋放同步鎖對象，也就是說，如果notify/notifyAll後面還有代碼，還會繼續進行，知道當前線程執行完畢才會釋放同步鎖對象；

3.notify/notifyAll執行後，如果右面有sleep方法，則會使當前線程進入到阻塞狀態，但是同步對象鎖沒有釋放，依然自己保留，那麼一定時候後還是會繼續執行此線程，接下來同2；

4.wait/notify/nitifyAll完成線程間的通信或協作都是基於不同對象鎖的，因此，如果是不同的同步對象鎖將失去意義，同時，同步對象鎖最好是與共享資源對象保持一一對應關係；

5.當wait線程喚醒後並執行時，是接著上次執行到的wait方法代碼後面繼續往下執行的。

1. 線程和進程有什麼區別？

答：一個進程是一個獨立(self contained)的運行環境，它可以被看作一個程序或者一個應用。而線程是在進程中執行的一個任務。線程是進程的子集，一個進程可以有很多線程，每條線程並行執行不同的任務。不同的進程使用不同的內存空間，而所有的線程共享一片相同的內存空間。別把它和棧內存搞混，每個線程都擁有單獨的棧內存用來存儲本地數據。

2. 如何在Java中實現線程？比較這種種方式

答：創建線程有兩種方式：

（1）繼承 Thread 類，擴展線程。

（2）實現 Runnable 介面。

繼承Thread類的方式有它固有的弊端，因為Java中繼承的單一性，繼承了Thread類就不能繼承其他類了；同時也不符合繼承的語義，Dog跟Thread沒有直接的父子關係，繼承Thread只是為了能擁有一些功能特性。

而實現Runnable介面，①避免了單一繼承的局限性，②同時更符合面向對象的編程方式，即將線程對象進行單獨的封裝，③而且實現介面的方式降低了線程對象(Dog)和線程任務(run方法中的代碼)的耦合性，④如上面所述，可以使用同一個Dog類的實例來創建並開啟多個線程，非常方便的實現資源的共享。實際上Thread類也是實現了Runnable介面。實際開發中多是使用實現Runnable介面的方式。

3. 啟動一個線程是調用run還是start方法？

答：啟動一個線程是調用start方法，使線程所代表的虛擬處理機處於可運行狀態，這意味著它可以由JVM 調度並執行，這並不意味著線程就會立即運行。run方法是線程啟動後要進行回調（callback）的方法。

4. wait和sleep比較

共同點：

1). 他們都是在多線程的環境下，sleep方法和對象的wait方法都可以讓線程暫停執行，都可以在程序的調用處阻塞指定的毫秒數，並返回。

2). wait和sleep都可以通過interrupt方法打斷線程的暫停狀態 ，從而使線程立刻拋出InterruptedException。

如果線程A希望立即結束線程B，則可以對線程B對應的Thread實例調用interrupt方法。如果此刻線程B正在wait/sleep /join，則線程B會立刻拋出InterruptedException，在catch {} 中直接return即可安全地結束線程。 需要注意的是，InterruptedException是線程自己從內部拋出的，並不是interrupt方法拋出的。對某一線程調用 interrupt時，如果該線程正在執行普通的代碼，那麼該線程根本就不會拋出InterruptedException。但是，一旦該線程進入到 wait/sleep/join後，就會立刻拋出InterruptedException 。

不同點：

1). Thread類的方法：sleep,yield等

Object類的方法：wait和notify等

2). 每個對象都有一個鎖來控制同步訪問。Synchronized關鍵字可以和對象的鎖交互，來實現線程的同步。

sleep方法讓當前線程暫停執行指定的時間，將執行機會（CPU）讓給其他線程，但是對象的鎖依然保持，休眠結束後線程會自動回到就緒狀態;

wait方法導致當前線程放棄對象的鎖（線程暫停執行），進入對象的等待池（wait pool），只有調用對象的notify方法（或notifyAll()方法）時才能喚醒等待池中的線程進入等鎖池（lock pool），如果線程重新獲得對象的鎖就可以進入就緒狀態。

3). wait，notify和notifyAll只能在同步控制方法或者同步控制塊裡面使用，而sleep可以在任何地方使用

4). sleep必須捕獲異常，而wait，notify和notifyAll不需要捕獲異常

所以sleep和wait方法的最大區別是：

sleep睡眠時，保持對象鎖，仍然佔有該鎖；

而wait睡眠時，釋放對象鎖。

但是wait和sleep都可以通過interrupt方法打斷線程的暫停狀態，從而使線程立刻拋出InterruptedException（但不建議使用該方法）。

5. sleep方法和yield方法有什麼區別？

① sleep方法給其他線程運行機會時不考慮線程的優先順序，因此會給低優先順序的線程以運行的機會；yield方法只會給相同優先順序或更高優先順序的線程以運行的機會；

② 線程執行sleep方法後轉入阻塞（blocked）狀態，而執行yield方法後轉入就緒（ready）狀態；

③ sleep方法需要聲明拋出InterruptedException，而yield方法沒有聲明任何異常；

④ sleep方法比yield方法（跟操作系統CPU調度相關）具有更好的可移植性。

6. 線程類的一些常用方法：

• sleep: 強迫一個線程睡眠Ｎ毫秒，是一個靜態方法，調用此方法要處理InterruptedException異常；
• join: 讓一個線程等待另一個線程完成才繼續執行；
• yeild: 線程讓步，暫停當前正在執行的線程對象讓出CPU資源，將當前線程從運行狀態轉換到就緒狀態並執行其他優先順序相同或更高的線程；
• isAlive: 判斷一個線程是否存活。
• activeCount: 程序中活躍的線程數。
• enumerate: 枚舉程序中的線程。
• currentThread: 得到當前線程。
• isDaemon: 一個線程是否為守護線程。
• setDaemon: 設置一個線程為守護線程。(用戶線程和守護線程的區別在於，是否等待主線程依賴於主線程結束而結束)
• setName: 為線程設置一個名稱。
• setPriority: 設置一個線程的優先順序。
• wait：使一個線程處於等待（阻塞）狀態，並且釋放所持有的對象的鎖；
• notify：喚醒一個處於等待狀態的線程，當然在調用此方法的時候，並不能確切的喚醒某一個等待狀態的線程，而是由JVM確定喚醒哪個線程，而且與優先順序無關；
• notityAll：喚醒所有處於等待狀態的線程，該方法並不是將對象的鎖給所有線程，而是讓它們競爭，只有獲得鎖的線程才能進入就緒狀態；

7. 同步代碼塊和同步方法的區別

兩者的區別主要體現在同步鎖上面。對於實例的同步方法，因為只能使用this來作為同步鎖，如果一個類中需要使用到多個鎖，為了避免鎖的衝突，必然需要使用不同的對象，這時候同步方法不能滿足需求，只能使用同步代碼塊(同步代碼塊可以傳入任意對象)；或者多個類中需要使用到同一個鎖，這時候多個類的實例this顯然是不同的，也只能使用同步代碼塊，傳入同一個對象。

8. 對比synchronized和Lock

1)、synchronized是關鍵字，就和if...else...一樣，是語法層面的實現，因此synchronized獲取鎖以及釋放鎖都是Java虛擬機幫助用戶完成的；ReentrantLock是類層面的實現，因此鎖的獲取以及鎖的釋放都需要用戶自己去操作。特別再次提醒，ReentrantLock在lock完了，一定要手動unlock，一般放在finally語句塊中。

2)、synchronized簡單，簡單意味著不靈活，而ReentrantLock的鎖機制給用戶的使用提供了極大的靈活性。這點在Hashtable和ConcurrentHashMap中體現得淋漓盡致。synchronized一鎖就鎖整個Hash表，而ConcurrentHashMap則利用ReentrantLock實現了鎖分離，鎖的只是segment而不是整個Hash表

3)、synchronized是不公平鎖，而ReentrantLock可以指定鎖是公平的還是非公平的

4)、synchronized實現等待/通知機制通知的線程是隨機的，ReentrantLock實現等待/通知機制可以有選擇性地通知

5)、和synchronized相比，ReentrantLock提供給用戶多種方法用於鎖信息的獲取，比如可以知道lock是否被當前線程獲取、lock被同一個線程調用了幾次、lock是否被任意線程獲取等等

總結起來，我認為如果只需要鎖定簡單的方法、簡單的代碼塊，那麼考慮使用synchronized，複雜的多線程處理場景下可以考慮使用ReentrantLock。

參考鏈接：

http://www.importnew.com/21136.html

http://lavasoft.blog.51cto.com/62575/99155/

http://www.cnblogs.com/lwbqqyumidi/p/3821389.html

喜歡這篇文章嗎？立刻分享出去讓更多人知道吧！