1.3w字干貨，詳解死鎖！

作者 | 王磊

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

轉(zhuǎn)載請聯(lián)系授權(quán)（微信ID：GG_Stone

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

1.死鎖演示

死鎖的形成分為兩個方面，一個是使用內(nèi)置鎖 synchronized 形成的死鎖，另一種是使用顯式鎖 Lock 實現(xiàn)的死鎖，接下來我們分別來看。

1.1 死鎖 synchronized 版

public class DeadLockExample {
    public static void main(String[] args) {
        Object lockA = new Object(); // 創(chuàng)建鎖 A
        Object lockB = new Object(); // 創(chuàng)建鎖 B

        // 創(chuàng)建線程 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(); // 運行線程

        // 創(chuàng)建線程 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(); // 運行線程
    }
}

以上程序的執(zhí)行結(jié)果如下：

從上述結(jié)果可以看出，線程 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(); // 創(chuàng)建鎖 A
        Lock lockB = new ReentrantLock(); // 創(chuàng)建鎖 B

        // 創(chuàng)建線程 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(); // 運行線程

        // 創(chuàng)建線程 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(); // 運行線程
    }
}

以上程序的執(zhí)行結(jié)果如下：

2.死鎖產(chǎn)生原因

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

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

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

3.死鎖排查工具

如果程序出現(xiàn)死鎖問題，可通過以下 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”來發(fā)現(xiàn)死鎖問題了，如下圖所示：

jstack 用于生成 Java 虛擬機當前時刻的線程快照，“-l”表示長列表（long），打印關(guān)于鎖的附加信息。

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

3.2 jconsole

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

然后選擇要調(diào)試的程序，如下圖所示：

之后點擊連接進入，選擇“不安全的連接”進入監(jiān)控主頁，如下圖所示：

之后切換到“線程”模塊，點擊“檢測死鎖”按鈕，如下圖所示：

之后稍等片刻就會檢測出死鎖的相關(guān)信息，如下圖所示：

3.3 jvisualvm

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

稍等幾秒之后，jvisualvm 中就會出現(xiàn)本地的所有 Java 程序，如下圖所示：

雙擊選擇要調(diào)試的程序：

單擊鼠標進入“線程”模塊，如下圖所示：

從上圖可以看出，當我們切換到線程一欄之后就會直接顯示出死鎖信息，之后點擊“線程 Dump”生成死鎖的詳情信息，如下圖所示：

3.4 jmc

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

jmc 主頁信息如下：

之后選中要排查的程序，右鍵“啟動 JMX 控制臺”查看此程序的詳細內(nèi)容，如下圖所示：

然后點擊“線程”，勾中“死鎖檢測”就可以發(fā)現(xiàn)死鎖和死鎖的詳情信息，如下圖所示：

4.死鎖解決方案

4.1 死鎖解決方案分析

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

• 互斥條件：系統(tǒng)特性，不能被破壞。
• 請求和保持條件：可以被破壞。
• 不可剝奪條件：系統(tǒng)特性，不能被破壞。
• 環(huán)路等待條件：可以被破壞。

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

4.2 解決方案1：順序鎖

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

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

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

此時我們只需要將線程 1 和線程 2 獲取鎖的順序進行統(tǒng)一，也就是線程 1 和線程 2 同時執(zhí)行之后，都先獲取鎖 A，再獲取鎖 B，執(zhí)行流程如下圖所示：因為只有一個線程能成功獲取到鎖 A，沒有獲取到鎖 A 的線程就會等待先獲取鎖 A，此時得到鎖 A 的線程繼續(xù)獲取鎖 B，因為沒有線程爭搶和擁有鎖 B，那么得到鎖 A 的線程就會順利的擁有鎖 B，之后執(zhí)行相應(yīng)的代碼再將鎖資源全部釋放，然后另一個等待獲取鎖 A 的線程就可以成功獲取到鎖資源，執(zhí)行后續(xù)的代碼，這樣就不會出現(xiàn)死鎖的問題了。

順序鎖的實現(xiàn)代碼如下所示：

public class SolveDeadLockExample {
    public static void main(String[] args) {
        Object lockA = new Object(); // 創(chuàng)建鎖 A
        Object lockB = new Object(); // 創(chuàng)建鎖 B
        // 創(chuàng)建線程 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(); // 運行線程
        // 創(chuàng)建線程 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(); // 運行線程
    }
}

以上程序的執(zhí)行結(jié)果如下：

從上述執(zhí)行結(jié)果可以看出，程序并沒有出現(xiàn)死鎖的問題。

4.3 解決方案2：輪詢鎖

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

輪詢鎖的實現(xiàn)需要使用到 ReentrantLock 的 tryLock 方法，具體實現(xià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(); // 創(chuàng)建鎖 A
        Lock lockB = new ReentrantLock(); // 創(chuàng)建鎖 B

        // 創(chuàng)建線程 1(使用輪詢鎖)
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 調(diào)用輪詢鎖
                pollingLock(lockA, lockB);
            }
        });
        t1.start(); // 運行線程

        // 創(chuàng)建線程 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.");
                }
            }
            // 等待一秒再繼續(xù)執(zhí)行
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

以上程序的執(zhí)行結(jié)果如下：

從上述結(jié)果可以看出，以上代碼也沒有出現(xiàn)死鎖的問題。

4.4 輪詢鎖優(yōu)化

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

4.4.1 問題1：死循環(huán)

以上簡易版的輪詢鎖，如果遇到有一個線程一直霸占或者長時間霸占鎖資源的情況，就會導致這個輪詢鎖進入死循環(huán)的狀態(tài)，它會嘗試一直獲取鎖資源，這樣就會造成新的問題，帶來不必要的性能開銷，具體示例如下。

反例

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(); // 創(chuàng)建鎖 A
        Lock lockB = new ReentrantLock(); // 創(chuàng)建鎖 B

        // 創(chuàng)建線程 1(使用輪詢鎖)
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 調(diào)用輪詢鎖
                pollingLock(lockA, lockB);
            }
        });
        t1.start(); // 運行線程

        // 創(chuàng)建線程 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 {
                    // 如果此處代碼未執(zhí)行，線程 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.");
                }
            }
            // 等待一秒再繼續(xù)執(zhí)行
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

以上代碼的執(zhí)行結(jié)果如下：

從上述結(jié)果可以看出，線程 1 輪詢鎖進入了死循環(huán)的狀態(tài)。

優(yōu)化版

針對以上死循環(huán)的情況，我們可以改進的思路有以下兩種：

1. 添加最大次數(shù)限制：如果經(jīng)過了 n 次嘗試獲取鎖之后，還未獲取到鎖，則認為獲取鎖失敗，執(zhí)行失敗策略之后終止輪詢（失敗策略可以是記錄日志或其他操作）；
2. 添加最大時長限制：如果經(jīng)過了 n 秒嘗試獲取鎖之后，還未獲取到鎖，則認為獲取鎖失敗，執(zhí)行失敗策略之后終止輪詢。

以上策略任選其一就可以解決死循環(huán)的問題，出于實現(xiàn)成本的考慮，我們可以采用輪詢最大次數(shù)的方式來改進輪詢鎖，具體實現(xià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(); // 創(chuàng)建鎖 A
        Lock lockB = new ReentrantLock(); // 創(chuàng)建鎖 B

        // 創(chuàng)建線程 1(使用輪詢鎖)
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 調(diào)用輪詢鎖
                pollingLock(lockA, lockB, 3);
            }
        });
        t1.start(); // 運行線程

        // 創(chuàng)建線程 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：最大輪詢次數(shù)
     */
    public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {
        // 輪詢次數(shù)計數(shù)器
        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.");
                }
            }

            // 判斷是否已經(jīng)超過最大次數(shù)限制
            if (count++ > maxCount) {
                // 終止循環(huán)
                System.out.println("輪詢鎖獲取失敗,記錄日志或執(zhí)行其他失敗策略");
                return;
            }

            // 等待一秒再繼續(xù)嘗試獲取鎖
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

以上代碼的執(zhí)行結(jié)果如下：

從以上結(jié)果可以看出，當我們改進之后，輪詢鎖就不會出現(xiàn)死循環(huán)的問題了，它會嘗試一定次數(shù)之后終止執(zhí)行。

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(); // 創(chuàng)建鎖 A
        Lock lockB = new ReentrantLock(); // 創(chuàng)建鎖 B

        // 創(chuàng)建線程 1(使用輪詢鎖)
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 調(diào)用輪詢鎖
                pollingLock(lockA, lockB, 3);
            }
        });
        t1.start(); // 運行線程

        // 創(chuàng)建線程 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(); // 釋放鎖
                    }
                    // 等待一秒之后繼續(xù)執(zhí)行
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t2.start(); // 運行線程
    }

    /**
     * 輪詢鎖
     */
    public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {
        // 循環(huán)次數(shù)計數(shù)器
        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.");
                }
            }

            // 判斷是否已經(jīng)超過最大次數(shù)限制
            if (count++ > maxCount) {
                // 終止循環(huán)
                System.out.println("輪詢鎖獲取失敗,記錄日志或執(zhí)行其他失敗策略");
                return;
            }

            // 等待一秒再繼續(xù)嘗試獲取鎖
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

以上代碼的執(zhí)行結(jié)果如下：

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

優(yōu)化版

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

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(); // 創(chuàng)建鎖 A
        Lock lockB = new ReentrantLock(); // 創(chuàng)建鎖 B

        // 創(chuàng)建線程 1(使用輪詢鎖)
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 調(diào)用輪詢鎖
                pollingLock(lockA, lockB, 3);
            }
        });
        t1.start(); // 運行線程

        // 創(chuàng)建線程 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(); // 釋放鎖
                    }
                    // 等待一秒之后繼續(xù)執(zhí)行
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t2.start(); // 運行線程
    }

    /**
     * 輪詢鎖
     */
    public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {
        // 循環(huán)次數(shù)計數(shù)器
        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.");
                }
            }

            // 判斷是否已經(jīng)超過最大次數(shù)限制
            if (count++ > maxCount) {
                // 終止循環(huán)
                System.out.println("輪詢鎖獲取失敗,記錄日志或執(zhí)行其他失敗策略");
                return;
            }

            // 等待一定時間(固定時間 + 隨機時間)之后再繼續(xù)嘗試獲取鎖
            try {
                Thread.sleep(300 + rdm.nextInt(8) * 100); // 固定時間 + 隨機時間
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

以上代碼的執(zhí)行結(jié)果如下：

從上述結(jié)果可以看出，線程 1（輪詢鎖）加入隨機等待時間之后就不會出現(xiàn)線程餓死的問題了。

5.總結(jié)

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