作者 | 王磊

來源 | Java中文社群（ID：javacn666）

轉載請聯系授權（微信ID：GG_Stone

死鎖（Dead Lock）指的是兩個或兩個以上的運算單元（進程、線程或協程），都在等待對方停止執行，以取得系統資源，但是沒有一方提前退出，就稱為死鎖。

死鎖示例代碼如下：

public class DeadLockExample {public static void main(String[] args) {Object lockA = new Object(); // 創建鎖 AObject lockB = new Object(); // 創建鎖 B// 創建線程 1Thread t1 = new Thread(new Runnable() {@Overridepublic void run() {synchronized (lockA) {System.out.println("線程 1:獲取到鎖 A!");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("線程 1:等待獲取 B...");synchronized (lockB) {System.out.println("線程 1:獲取到鎖 B!");}}}});t1.start(); // 運行線程// 創建線程 2Thread t2 = new Thread(new Runnable() {@Overridepublic void run() {synchronized (lockB) {System.out.println("線程 2:獲取到鎖 B!");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("線程 2:等待獲取 A...");synchronized (lockA) {System.out.println("線程 2:獲取到鎖 A!");}}}});t2.start(); // 運行線程} }

以上程序的執行結果如下：

從上述結果可以看出，線程 1 和線程 2 都進入了死鎖狀態，相互都在等待對方釋放鎖。

從上述示例分析可以得出，產生死鎖需要滿足以下 4 個條件：

互斥條件：指運算單元（進程、線程或協程）對所分配到的資源具有排它性，也就是說在一段時間內某個鎖資源只能被一個運算單元所占用。

請求和保持條件：指運算單元已經保持至少一個資源，但又提出了新的資源請求，而該資源已被其它運算單元占有，此時請求運算單元阻塞，但又對自己已獲得的其它資源保持不放。

不可剝奪條件：指運算單元已獲得的資源，在未使用完之前，不能被剝奪。

環路等待條件：指在發生死鎖時，必然存在運算單元和資源的環形鏈，即運算單元正在等待另一個運算單元占用的資源，而對方又在等待自己占用的資源，從而造成環路等待的情況。

只有這 4 個條件同時滿足，才會造成死鎖的問題。

那么也就是說，要產生死鎖必須要同時滿足以上 4 個條件才行，那我們就可以通過破壞任意一個條件來解決死鎖問題了。

死鎖解決方案分析

接下來我們來分析一下，產生死鎖的 4 個條件，哪些是可以破壞的？哪些是不能被破壞的？

• 互斥條件：系統特性，不能被破壞。

• 請求和保持條件：可以被破壞。

• 不可剝奪條件：系統特性，不能被破壞。

• 環路等待條件：可以被破壞。

通過上述分析，我們可以得出結論，我們只能通過破壞請求和保持條件或者是環路等待條件，從而來解決死鎖的問題，那上線，我們就先從破壞“環路等待條件”開始來解決死鎖問題。

解決方案1：順序鎖

所謂的順序鎖指的是通過有順序的獲取鎖，從而避免產生環路等待條件，從而解決死鎖問題的。

當我們沒有使用順序鎖時，程序的執行可能是這樣的：

線程 1 先獲取了鎖 A，再獲取鎖 B，線程 2 與 線程 1 同時執行，線程 2 先獲取鎖 B，再獲取鎖 A，這樣雙方都先占用了各自的資源（鎖 A 和鎖 B）之后，再嘗試獲取對方的鎖，從而造成了環路等待問題，最后造成了死鎖的問題。

此時我們只需要將線程 1 和線程 2 獲取鎖的順序進行統一，也就是線程 1 和線程 2 同時執行之后，都先獲取鎖 A，再獲取鎖 B，執行流程如下圖所示：

因為只有一個線程能成功獲取到鎖 A，沒有獲取到鎖 A 的線程就會等待先獲取鎖 A，此時得到鎖 A 的線程繼續獲取鎖 B，因為沒有線程爭搶和擁有鎖 B，那么得到鎖 A 的線程就會順利的擁有鎖 B，之后執行相應的代碼再將鎖資源全部釋放，然后另一個等待獲取鎖 A 的線程就可以成功獲取到鎖資源，執行后續的代碼，這樣就不會出現死鎖的問題了。

順序鎖的實現代碼如下所示：

public class SolveDeadLockExample {public static void main(String[] args) {Object lockA = new Object(); // 創建鎖 AObject lockB = new Object(); // 創建鎖 B// 創建線程 1Thread t1 = new Thread(new Runnable() {@Overridepublic void run() {synchronized (lockA) {System.out.println("線程 1:獲取到鎖 A!");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("線程 1:等待獲取 B...");synchronized (lockB) {System.out.println("線程 1:獲取到鎖 B!");}}}});t1.start(); // 運行線程// 創建線程 2Thread t2 = new Thread(new Runnable() {@Overridepublic void run() {synchronized (lockA) {System.out.println("線程 2:獲取到鎖 A!");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("線程 2:等待獲取B...");synchronized (lockB) {System.out.println("線程 2:獲取到鎖 B!");}}}});t2.start(); // 運行線程} }

以上程序的執行結果如下：

從上述執行結果可以看出，程序并沒有出現死鎖的問題。

解決方案2：輪詢鎖

輪詢鎖是通過打破“請求和保持條件”來避免造成死鎖的，它的實現思路簡單來說就是通過輪詢來嘗試獲取鎖，如果有一個鎖獲取失敗，則釋放當前線程擁有的所有鎖，等待下一輪再嘗試獲取鎖。

輪詢鎖的實現需要使用到 ReentrantLock 的 tryLock 方法，具體實現代碼如下：

import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;public class SolveDeadLockExample {public static void main(String[] args) {Lock lockA = new ReentrantLock(); // 創建鎖 ALock lockB = new ReentrantLock(); // 創建鎖 B// 創建線程 1(使用輪詢鎖)Thread t1 = new Thread(new Runnable() {@Overridepublic void run() {// 調用輪詢鎖pollingLock(lockA, lockB);}});t1.start(); // 運行線程// 創建線程 2Thread t2 = new Thread(new Runnable() {@Overridepublic void run() {lockB.lock(); // 加鎖System.out.println("線程 2:獲取到鎖 B!");try {Thread.sleep(1000);System.out.println("線程 2:等待獲取 A...");lockA.lock(); // 加鎖try {System.out.println("線程 2:獲取到鎖 A!");} finally {lockA.unlock(); // 釋放鎖}} catch (InterruptedException e) {e.printStackTrace();} finally {lockB.unlock(); // 釋放鎖}}});t2.start(); // 運行線程}/*** 輪詢鎖*/public static void pollingLock(Lock lockA, Lock lockB) {while (true) {if (lockA.tryLock()) { // 嘗試獲取鎖System.out.println("線程 1:獲取到鎖 A!");try {Thread.sleep(1000);System.out.println("線程 1:等待獲取 B...");if (lockB.tryLock()) { // 嘗試獲取鎖try {System.out.println("線程 1:獲取到鎖 B!");} finally {lockB.unlock(); // 釋放鎖System.out.println("線程 1:釋放鎖 B.");break;}}} catch (InterruptedException e) {e.printStackTrace();} finally {lockA.unlock(); // 釋放鎖System.out.println("線程 1:釋放鎖 A.");}}// 等待一秒再繼續執行try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}} }

以上程序的執行結果如下：

從上述結果可以看出，以上代碼也沒有出現死鎖的問題。

總結

本文介紹了解決死鎖的 2 種方案：

• 第 1 種順序鎖：通過改變獲取鎖的順序也就打破“環路請求條件”來避免死鎖問題的發生；

• 第 2 種輪詢鎖：通過輪詢的方式也就是打破“請求和擁有條件”來解決死鎖問題。它的實現思路是，通過自旋的方式來嘗試獲取鎖，在獲取鎖的途中，如果有任何一個鎖獲取失敗，則釋放之前獲取的所有鎖，等待一段時間之后再次執行之前的流程，這樣就避免一個鎖一直被（一個線程）占用的尷尬了，從而避免了死鎖問題。

參考 & 鳴謝

《Java并發編程實戰》

---

原創并發文章推薦

1.線程的故事：我的3位母親成就了優秀的我！

2.線程池的7種創建方式，強烈推薦你用它...

3.輕量級鎖一定比重量級鎖快嗎？

4.這樣終止線程，竟然會導致服務宕機？

5.漫畫：如何證明sleep不釋放鎖，而wait釋放鎖？

6.池化技術到達有多牛？看了這個對比嚇我一跳！

7.求求你，別再用wait和notify了！

8.Semaphore自白：限流器用我就對了！

9.CountDownLatch：別浪，等人齊再團！

10.CyclicBarrier：人齊了，老司機就發車了！

11.Java中用戶線程和守護線程區別這么大？

12.ThreadLocal不好用？那是你沒用對！

13.ThreadLocal內存溢出代碼演示和原因分析！

14.SimpleDateFormat線程不安全的5種解決方案！

15.synchronized 加鎖 this 和 class 的區別！

16.synchronized 優化手段之鎖膨脹機制！

17.synchronized 中的 4 個優化，你知道幾個？

18.ReentrantLock 中的 4 個坑！

19.圖解：為什么非公平鎖的性能更高？

20.死鎖的 4 種排查工具 ！

---

創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎

總結

以上是生活随笔為你收集整理的死锁终结者：顺序锁和轮询锁！的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。