1.3w字，一文詳解死鎖！

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

1.死鎖演示

死鎖的形成分為兩個方面，一個是使用內建鎖 synchronized 形成的死鎖，另一種是使用顯式鎖 Lock 實現的死鎖，接下來我們分別來看。

1.1 死鎖 synchronized 版

public class DeadLockExample {

    public static void main(String[] args) {

        Object lockA = new Object(); // 建立鎖 A

        Object lockB = new Object(); // 建立鎖 B

        // 建立執行緒 1

        Thread t1 = new Thread(new Runnable() {

            @Override

            public void run() {

                // 先獲取鎖 A

                synchronized (lockA) {

                    System.out.println("執行緒 1:獲取到鎖 A!");

                    try {

                        Thread.sleep(1000);

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                    // 嘗試獲取鎖 B

                    System.out.println("執行緒 1:等待獲取 B...");

                    synchronized (lockB) {

                        System.out.println("執行緒 1:獲取到鎖 B!");

                    }

                }

            }

        });

        t1.start(); // 執行執行緒

        // 建立執行緒 2

        Thread t2 = new Thread(new Runnable() {

            @Override

            public void run() {

                // 先獲取鎖 B

                synchronized (lockB) {

                    System.out.println("執行緒 2:獲取到鎖 B!");

                    try {

                        Thread.sleep(1000);

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                    // 嘗試獲取鎖 A

                    System.out.println("執行緒 2:等待獲取 A...");

                    synchronized (lockA) {

                        System.out.println("執行緒 2:獲取到鎖 A!");

                    }

                }

            }

        });

        t2.start(); // 執行執行緒

    }

}

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



從上述結果可以看出，執行緒 1 和執行緒 2 都在等待對方釋放鎖，這樣就造成了死鎖問題。

1.2 死鎖 Lock 版

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class DeadLockByReentrantLockExample {

    public static void main(String[] args) {

        Lock lockA = new ReentrantLock(); // 建立鎖 A

        Lock lockB = new ReentrantLock(); // 建立鎖 B

        // 建立執行緒 1

        Thread t1 = new Thread(new Runnable() {

            @Override

            public void run() {

                lockA.lock(); // 加鎖

                System.out.println("執行緒 1:獲取到鎖 A!");

                try {

                    Thread.sleep(1000);

                    System.out.println("執行緒 1:等待獲取 B...");

                    lockB.lock(); // 加鎖

                    try {

                        System.out.println("執行緒 1:獲取到鎖 B!");

                    } finally {

                        lockB.unlock(); // 釋放鎖

                    }

                } catch (InterruptedException e) {

                    e.printStackTrace();

                } finally {

                    lockA.unlock(); // 釋放鎖

                }

            }

        });

        t1.start(); // 執行執行緒

        // 建立執行緒 2

        Thread t2 = new Thread(new Runnable() {

            @Override

            public 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(); // 執行執行緒

    }

}

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

2.死鎖產生原因

通過以上示例，我們可以得出結論，要產生死鎖需要滿足以下 4 個條件：

1. 互斥條件：指運算單元（程序、執行緒或協程）對所分配到的資源具有排它性，也就是說在一段時間內某個鎖資源只能被一個運算單元所佔用。
2. 請求和保持條件：指運算單元已經保持至少一個資源，但又提出了新的資源請求，而該資源已被其它運算單元佔有，此時請求運算單元阻塞，但又對自己已獲得的其它資源保持不放。
3. 不可剝奪條件：指運算單元已獲得的資源，在未使用完之前，不能被剝奪。
4. 環路等待條件：指在發生死鎖時，必然存在運算單元和資源的環形鏈，即運算單元正在等待另一個運算單元佔用的資源，而對方又在等待自己佔用的資源，從而造成環路等待的情況。

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

3.死鎖排查工具

如果程式出現死鎖問題，可通過以下 4 種方案中的任意一種進行分析和排查。

3.1 jstack

我們在使用 jstack 之前，先要通過 jps 得到執行程式的程序 ID，使用方法如下：



“jps -l”可以查詢本機所有的 Java 程式，jps（Java Virtual Machine Process Status Tool）是 Java 提供的一個顯示當前所有 Java 程序 pid 的命令，適合在 linux/unix/windows 平臺上簡單檢視當前 Java 程序的一些簡單情況，“-l”用於輸出程序 pid 和執行程式完整路徑名（包名和類名）。

有了程序 ID（PID）之後，我們就可以使用“jstack -l PID”來發現死鎖問題了，如下圖所示：



jstack 用於生成 Java 虛擬機器當前時刻的執行緒快照，“-l”表示長列表（long），列印關於鎖的附加資訊。

PS：可以使用 jstack -help 檢視更多命令使用說明。

3.2 jconsole

使用 jconsole 需要開啟 JDK 的 bin 目錄，找到 jconsole 並雙擊開啟，如下圖所示：



然後選擇要除錯的程式，如下圖所示：



之後點選連線進入，選擇“不安全的連線”進入監控主頁，如下圖所示：





之後切換到“執行緒”模組，點選“檢測死鎖”按鈕，如下圖所示：



之後稍等片刻就會檢測出死鎖的相關資訊，如下圖所示：

3.3 jvisualvm

jvisualvm 也在 JDK 的 bin 目錄中，同樣是雙擊開啟：



稍等幾秒之後，jvisualvm 中就會出現本地的所有 Java 程式，如下圖所示：



雙擊選擇要除錯的程式：



單擊滑鼠進入“執行緒”模組，如下圖所示：



從上圖可以看出，當我們切換到執行緒一欄之後就會直接顯示出死鎖資訊，之後點選“執行緒 Dump”生成死鎖的詳情資訊，如下圖所示：

3.4 jmc

jmc 是 Oracle Java Mission Control 的縮寫，是一個對 Java 程式進行管理、監控、概要分析和故障排查的工具套件。它也是在 JDK 的 bin 目錄中，同樣是雙擊啟動，如下圖所示：



jmc 主頁資訊如下：



之後選中要排查的程式，右鍵“啟動 JMX 控制檯”檢視此程式的詳細內容，如下圖所示：





然後點選“執行緒”，勾中“死鎖檢測”就可以發現死鎖和死鎖的詳情資訊，如下圖所示：

4.死鎖解決方案

4.1 死鎖解決方案分析

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

• 互斥條件：系統特性，不能被破壞。
• 請求和保持條件：可以被破壞。
• 不可剝奪條件：系統特性，不能被破壞。
• 環路等待條件：可以被破壞。

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

4.2 解決方案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(); // 建立鎖 A

        Object lockB = new Object(); // 建立鎖 B

        // 建立執行緒 1

        Thread t1 = new Thread(new Runnable() {

            @Override

            public 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(); // 執行執行緒

        // 建立執行緒 2

        Thread t2 = new Thread(new Runnable() {

            @Override

            public 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(); // 執行執行緒

    }

}

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



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

4.3 解決方案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(); // 建立鎖 A

        Lock lockB = new ReentrantLock(); // 建立鎖 B

        // 建立執行緒 1(使用輪詢鎖)

        Thread t1 = new Thread(new Runnable() {

            @Override

            public void run() {

                // 呼叫輪詢鎖

                pollingLock(lockA, lockB);

            }

        });

        t1.start(); // 執行執行緒

        // 建立執行緒 2

        Thread t2 = new Thread(new Runnable() {

            @Override

            public 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();

            }

        }

    }

}

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



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

4.4 輪詢鎖優化

使用輪詢鎖雖然可以解決死鎖的問題，但並不是完美無缺的，比如以下這些問題。

4.4.1 問題1：死迴圈

以上簡易版的輪詢鎖，如果遇到有一個執行緒一直霸佔或者長時間霸佔鎖資源的情況，就會導致這個輪詢鎖進入死迴圈的狀態，它會嘗試一直獲取鎖資源，這樣就會造成新的問題，帶來不必要的效能開銷，具體示例如下。

反例

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(); // 建立鎖 A

        Lock lockB = new ReentrantLock(); // 建立鎖 B

        // 建立執行緒 1(使用輪詢鎖)

        Thread t1 = new Thread(new Runnable() {

            @Override

            public void run() {

                // 呼叫輪詢鎖

                pollingLock(lockA, lockB);

            }

        });

        t1.start(); // 執行執行緒

        // 建立執行緒 2

        Thread t2 = new Thread(new Runnable() {

            @Override

            public 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 {

                    // 如果此處程式碼未執行，執行緒 2 一直未釋放鎖資源

                    // 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();

            }

        }

    }

}

以上程式碼的執行結果如下：



從上述結果可以看出，執行緒 1 輪詢鎖進入了死迴圈的狀態。

優化版

針對以上死迴圈的情況，我們可以改進的思路有以下兩種：

1. 新增最大次數限制：如果經過了 n 次嘗試獲取鎖之後，還未獲取到鎖，則認為獲取鎖失敗，執行失敗策略之後終止輪詢（失敗策略可以是記錄日誌或其他操作）；
2. 新增最大時長限制：如果經過了 n 秒嘗試獲取鎖之後，還未獲取到鎖，則認為獲取鎖失敗，執行失敗策略之後終止輪詢。

以上策略任選其一就可以解決死迴圈的問題，出於實現成本的考慮，我們可以採用輪詢最大次數的方式來改進輪詢鎖，具體實現程式碼如下：

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(); // 建立鎖 A

        Lock lockB = new ReentrantLock(); // 建立鎖 B

        // 建立執行緒 1(使用輪詢鎖)

        Thread t1 = new Thread(new Runnable() {

            @Override

            public void run() {

                // 呼叫輪詢鎖

                pollingLock(lockA, lockB, 3);

            }

        });

        t1.start(); // 執行執行緒

        // 建立執行緒 2

        Thread t2 = new Thread(new Runnable() {

            @Override

            public 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 {

                    // 執行緒 2 忘記釋放鎖資源

                    // lockB.unlock(); // 釋放鎖

                }

            }

        });

        t2.start(); // 執行執行緒

    }

    /**

     * 輪詢鎖

     *

     * maxCount：最大輪詢次數

     */

    public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {

        // 輪詢次數計數器

        int count = 0;

        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.");

                }

            }

            // 判斷是否已經超過最大次數限制

            if (count++ > maxCount) {

                // 終止迴圈

                System.out.println("輪詢鎖獲取失敗,記錄日誌或執行其他失敗策略");

                return;

            }

            // 等待一秒再繼續嘗試獲取鎖

            try {

                Thread.sleep(1000);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

}

以上程式碼的執行結果如下：



從以上結果可以看出，當我們改進之後，輪詢鎖就不會出現死迴圈的問題了，它會嘗試一定次數之後終止執行。

4.4.2 問題2：執行緒餓死

我們以上的輪詢鎖的輪詢等待時間是固定時間，如下程式碼所示：

// 等待 1s 再嘗試獲取（輪詢）鎖

try {

    Thread.sleep(1000);

} catch (InterruptedException e) {

    e.printStackTrace();

}

這樣在特殊情況下會造成執行緒餓死的問題，也就是輪詢鎖一直獲取不到鎖的問題，比如以下示例。

反例

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(); // 建立鎖 A

        Lock lockB = new ReentrantLock(); // 建立鎖 B

        // 建立執行緒 1(使用輪詢鎖)

        Thread t1 = new Thread(new Runnable() {

            @Override

            public void run() {

                // 呼叫輪詢鎖

                pollingLock(lockA, lockB, 3);

            }

        });

        t1.start(); // 執行執行緒

        // 建立執行緒 2

        Thread t2 = new Thread(new Runnable() {

            @Override

            public void run() {

                while (true) {

                    lockB.lock(); // 加鎖

                    System.out.println("執行緒 2:獲取到鎖 B!");

                    try {

                        System.out.println("執行緒 2:等待獲取 A...");

                        lockA.lock(); // 加鎖

                        try {

                            System.out.println("執行緒 2:獲取到鎖 A!");

                        } finally {

                            lockA.unlock(); // 釋放鎖

                        }

                    } finally {

                        lockB.unlock(); // 釋放鎖

                    }

                    // 等待一秒之後繼續執行

                    try {

                        Thread.sleep(1000);

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                }

            }

        });

        t2.start(); // 執行執行緒

    }

    /**

     * 輪詢鎖

     */

    public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {

        // 迴圈次數計數器

        int count = 0;

        while (true) {

            if (lockA.tryLock()) { // 嘗試獲取鎖

                System.out.println("執行緒 1:獲取到鎖 A!");

                try {

                    Thread.sleep(100); // 等待 0.1s(獲取鎖需要的時間)

                    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.");

                }

            }

            // 判斷是否已經超過最大次數限制

            if (count++ > maxCount) {

                // 終止迴圈

                System.out.println("輪詢鎖獲取失敗,記錄日誌或執行其他失敗策略");

                return;

            }

            // 等待一秒再繼續嘗試獲取鎖

            try {

                Thread.sleep(1000);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

}

以上程式碼的執行結果如下：



從上述結果可以看出，執行緒 1（輪詢鎖）一直未成功獲取到鎖，造成這種結果的原因是：執行緒 1 每次輪詢的等待時間為固定的 1s，而執行緒 2 也是相同的頻率，每 1s 獲取一次鎖，這樣就會導致執行緒 2 會一直先成功獲取到鎖，而執行緒 1 則會一直處於“餓死”的情況，執行流程如下圖所示：

優化版

接下來，我們可以將輪詢鎖的固定等待時間，改進為固定時間 + 隨機時間的方式，這樣就可以避免因為獲取鎖的頻率一致，而造成輪詢鎖“餓死”的問題了，具體實現程式碼如下：

import java.util.Random;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class SolveDeadLockExample {

    private static Random rdm = new Random();

    public static void main(String[] args) {

        Lock lockA = new ReentrantLock(); // 建立鎖 A

        Lock lockB = new ReentrantLock(); // 建立鎖 B

        // 建立執行緒 1(使用輪詢鎖)

        Thread t1 = new Thread(new Runnable() {

            @Override

            public void run() {

                // 呼叫輪詢鎖

                pollingLock(lockA, lockB, 3);

            }

        });

        t1.start(); // 執行執行緒

        // 建立執行緒 2

        Thread t2 = new Thread(new Runnable() {

            @Override

            public void run() {

                while (true) {

                    lockB.lock(); // 加鎖

                    System.out.println("執行緒 2:獲取到鎖 B!");

                    try {

                        System.out.println("執行緒 2:等待獲取 A...");

                        lockA.lock(); // 加鎖

                        try {

                            System.out.println("執行緒 2:獲取到鎖 A!");

                        } finally {

                            lockA.unlock(); // 釋放鎖

                        }

                    } finally {

                        lockB.unlock(); // 釋放鎖

                    }

                    // 等待一秒之後繼續執行

                    try {

                        Thread.sleep(1000);

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                }

            }

        });

        t2.start(); // 執行執行緒

    }

    /**

     * 輪詢鎖

     */

    public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {

        // 迴圈次數計數器

        int count = 0;

        while (true) {

            if (lockA.tryLock()) { // 嘗試獲取鎖

                System.out.println("執行緒 1:獲取到鎖 A!");

                try {

                    Thread.sleep(100); // 等待 0.1s(獲取鎖需要的時間)

                    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.");

                }

            }

            // 判斷是否已經超過最大次數限制

            if (count++ > maxCount) {

                // 終止迴圈

                System.out.println("輪詢鎖獲取失敗,記錄日誌或執行其他失敗策略");

                return;

            }

            // 等待一定時間(固定時間 + 隨機時間)之後再繼續嘗試獲取鎖

            try {

                Thread.sleep(300 + rdm.nextInt(8) * 100); // 固定時間 + 隨機時間

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

}

以上程式碼的執行結果如下：



從上述結果可以看出，執行緒 1（輪詢鎖）加入隨機等待時間之後就不會出現執行緒餓死的問題了。

5.總結

本文介紹了死鎖的概念，以及產生死鎖的 4 個條件，排查死鎖可以通過本文提供的 4 種工具中的任意一種來檢測，從易用性和效能方面來考慮，推薦使用 jconsole 或 jvisualvm，最後我們介紹了死鎖問題的兩種解決方案：順序鎖和輪詢鎖。

​

併發原創文章推薦

1. 執行緒的 4 種建立方法和使用詳解！
2. Java中使用者執行緒和守護執行緒區別這麼大？
3. 深入理解執行緒池 ThreadPool
4. 執行緒池的7種建立方式，強烈推薦你用它...
5. 池化技術到達有多牛？看了執行緒和執行緒池的對比嚇我一跳！
6. 併發中的執行緒同步與鎖
7. synchronized 加鎖 this 和 class 的區別！
8. volatile 和 synchronized 的區別
9. 輕量級鎖一定比重量級鎖快嗎？
10. 這樣終止執行緒，竟然會導致服務宕機？
11. SimpleDateFormat執行緒不安全的5種解決方案！
12. ThreadLocal不好用？那是你沒用對！
13. ThreadLocal記憶體溢位程式碼演示和原因分析！
14. Semaphore自白：限流器用我就對了！
15. CountDownLatch：別浪，等人齊再團！
16. CyclicBarrier：人齊了，司機就可以發車了！
17. synchronized 優化手段之鎖膨脹機制！
18. synchronized 中的 4 個優化，你知道幾個？
19. ReentrantLock 中的 4 個坑！
20. 圖解：為什麼非公平鎖的效能更高？
21. 死鎖的 4 種排查工具！
22. 死鎖終結者：順序鎖和輪詢鎖！
23. 輪詢鎖在使用時遇到的問題與解決方案！

關注公號「Java中文社群」檢視更多有意思、漲知識的 Java 併發文章。