對死鎖問題的理解 · 那些年踩過的坑

對于我們開發者來說，出去面試的時候，經常會被問到一個問題，請談談你對死鎖問題的理解？但是很多人都不能系統地回答出核心原理，有的人不知道如何排查死鎖問題，有的人則不知道如何來解決死鎖問題。那么到底該怎么系統地回答這個問題呢？今天我們就來聊聊這個話題。在這節課，我會先給你介紹下死鎖的概念，然后基于一個小場景，來模擬死鎖問題的產生，并利用工具來排查死鎖問題，最后我們再來看怎么在開發過程中避免死鎖問題的產生。 # 死鎖的概念死鎖一般發生在多線程執行的過程中，也就是兩個或兩個以上的線程在執行的時候，因為爭奪資源會造成線程間互相等待，這種情況就是產生了死鎖問題，在沒有外力作用的情況下，這些線程會一直相互等待，沒辦法繼續運行。就比如這張圖（圖 1），你可以看到有兩個資源，資源 1 和資源 2，和兩個線程，分別為線程 A 和線程 B。線程 A 在已經獲取了資源 2 的情況下，期望獲取線程 B 持有的資源 1；而線程 B 在已經獲取了資源 1 的情況下，期望獲取線程 A 持有的資源 2，那么線程 A 和線程 B 就處于了相互等待的死鎖狀態。在沒有外力干涉的情況下，線程 A 和線程 B 就會一直處于相互等待狀態，不能處理其他任務，那這兩個線程也就白白浪費掉了。死鎖產生的四個必要條件對應死鎖的概念，我們來看線程死鎖問題產生的條件。相信你在學習操作系統時，就知道線程死鎖需要四個必要條件：第一，互斥條件。指的是多個線程不能同時使用同一個資源，比如線程 A 已經持有的資源，不能同時在被線程 B 持有。如果線程 B 請求獲取被線程 A 已經占有的資源，那線程 B 只能等，等到這個資源被線程 A 釋放。第二，持有并等待條件。指的是當線程 A 已經持有了資源 1，又提出想申請資源 2，但是資源 2 已經被線程 C 占有了，所以線程 A 就會處于等待狀態，但它在等待資源 2 的同時并不會釋放自己已經獲取的資源 1。第三，不可剝奪條件。是指線程 A 獲取到資源 1 后，在自己使用完之前不能被其它線程比如線程 B 搶占使用。如果線程 B 也想使用資源 1，只能在線程 A 使用完主動釋放后獲取。第四，環路等待條件。在發生死鎖的時候，必然存在一個線程，也就是資源的環形鏈，比如線程 A 已經獲取了資源 2，但是請求獲取資源 1；線程 B 已經獲取了資源 1，但是請求獲取資源 2，這就會形成一個線程和資源請求等待的環形圖。死鎖只有同時滿足互斥、持有并等待、不可剝奪、環路等待這四個條件的時候才會發生。那么，我們該如何盡早排查死鎖問題呢？ # 模擬死鎖問題與排查下面我們使用 Java 代碼來模擬一個死鎖場景： ~~~ public class DeadLockDemo { ... // 1. 創建資源 private static Object resourceA = new Object(); private static Object resourceB = new Object(); public static void main(String[] args) { //2. 創建線程 A Thread threadA = createThreadA(); //3. 創建線程 B Thread threadB = createThreadB(); //4. 啟動線程 threadA.start(); threadB.start(); } } ~~~ ~~~ private static Thread createThreadA() { Thread threadA = new Thread(() -> { //2.1 嘗試獲取資源 A synchronized (resourceA) { System.out.println(Thread.currentThread() + " got ResourceA"); //2.2 休眠 1s try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread() + "waiting get ResourceB"); //2.3 嘗試獲取資源 B synchronized (resourceB) { System.out.println(Thread.currentThread() + "got ResourceB"); } } }, "ThreadA"); return threadA; } ~~~ ~~~ private static Thread createThreadB() { Thread threadB = new Thread(() -> { //3.1 嘗試獲取資源 B synchronized (resourceB) { System.out.println(Thread.currentThread() + " got ResourceB"); //3.2 休眠 1s try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread() + "waiting get ResourceA"); //3.3 嘗試獲取資源 A synchronized (resourceA) { System.out.println(Thread.currentThread() + "got ResourceA"); } } }, "ThreadB"); return threadB; } ~~~ 你可以看到，代碼 1 創建了兩個資源對象，分別為 resourceA 和 resourceB；代碼 2createThreadA 方法創建了一個名稱為 ThreadA 的線程，這個線程啟動后會先執行代碼 2.1 的 synchronized 塊試圖獲取 resourceA 上的對象鎖，它獲取成功后會休眠 1 秒，然后執行代碼 2.3 嘗試使用 synchronized 塊獲取 resourceB 上的對象鎖。代碼 3createThreadB 是創建了一個名稱為 ThreadB 的線程，這個線程啟動后會先執行代碼 3.1 的 synchronized 塊試圖獲取 resourceB 上的對象鎖，它獲取成功后也會休眠 1 秒，然后執行代碼 2.3 嘗試使用 synchronized 塊獲取 resourceA 上的對象鎖。代碼 4 則啟動兩個線程運行；運行上面代碼后，可能會輸出這樣的結果： ~~~ Thread[ThreadA,5,main] got ResourceA Thread[ThreadB,5,main] got ResourceB Thread[ThreadA,5,main]waiting get ResourceB Thread[ThreadB,5,main]waiting get ResourceA ~~~ 從這段輸出中，我們可以發現 ThreadA 一直卡到獲取 ResourceB 的地方，ThreadB 則一直卡在獲取 ResourceA 的地方，從而導致程序無法正常向下運行。那么為啥會卡到這里呢？下面我們使用 JDK 自帶的打印線程堆棧的 jstack pid（進程 ID）命令，看下當前 JVM 中的線程堆棧，對應上面輸出結果的一個線程堆棧是這樣的： ~~~ Found one Java-level deadlock: ============================= "ThreadB": waiting to lock monitor 0x00007f886e832168 (object 0x000000076b839ff0, a java.lang.Object), which is held by "ThreadA" "ThreadA": waiting to lock monitor 0x00007f886e8349f8 (object 0x000000076b83a000, a java.lang.Object), which is held by "ThreadB" Java stack information for the threads listed above: =================================================== "ThreadB": at org.mysql.DeadLockDemo.lambda$main$1(DeadLockDemo.java:49) - waiting to lock <0x000000076b839ff0> (a java.lang.Object) - locked <0x000000076b83a000> (a java.lang.Object) at org.mysql.DeadLockDemo$$Lambda$2/577405636.run(Unknown Source) at java.lang.Thread.run(Thread.java:748) "ThreadA": at org.mysql.DeadLockDemo.lambda$main$0(DeadLockDemo.java:31) - waiting to lock <0x000000076b83a000> (a java.lang.Object) - locked <0x000000076b839ff0> (a java.lang.Object) at org.mysql.DeadLockDemo$$Lambda$1/2011482127.run(Unknown Source) at java.lang.Thread.run(Thread.java:748) Found 1 deadlock. ~~~ 從這個線程堆棧我們可以知道什么呢？有一處死鎖。其中 ThreadB 獲取到了地址為 0x000000076b83a000 的對象（resourceB）的鎖，然后等待獲取地址為 0x000000076b839ff0 的對象（resourceA）的鎖；而 ThreadA 獲取到了地址 0x000000076b839ff0 對象（resourceA）的鎖，然后等待獲取地址為 0x000000076b83a000 的對象（resourceB）的鎖。這解釋了 ThreadA 為啥一直卡到獲取 ResourceB 的地方，而 ThreadB 一直卡在獲取 ResourceA 的地方。經過我們剛才的分析，就能知道代碼是出現了死鎖問題，導致線程被阻塞，從而導致被阻塞的線程不能繼續向下運行了。那我們該怎么修改前面那段代碼，從而避免死鎖呢？ # 如何避免死鎖問題的產生剛才我們也說了，死鎖的產生需要同時滿足四個必要條件，反過來說，預防死鎖就只需要我們至少破壞其中一個條件。最常見的并且可行的就是使用資源有序分配法來破壞循環等待條件，從而避免死鎖的產生。那什么是資源有序分配呢？比如前面的代碼例子，ThreadA 是先嘗試獲取 ResourceA，然后嘗試獲取資源 ResourceB；而 ThreadB 則是先嘗試獲取資源 ResourceB，然后嘗試獲取資源 ResourceA；這就不是資源有序分配的，因為 ThreadA 和 ThreadB 獲取資源的順序不一樣。資源有序分配是指當 ThreadA 是先嘗試獲取 ResourceA，然后嘗試獲取資源 ResourceB 時，ThreadB 也是先嘗試獲取 ResourceA，然后嘗試獲取資源 ResourceB；或者當 ThreadA 是先嘗試獲取 ResourceB，然后嘗試獲取資源 ResourceA，ThreadB 也是先嘗試獲取 ResourceB，然后嘗試獲取資源 ResourceA。也就是 ThreadA 和 ThreadB 總是以相同的順序申請自己想要的資源。我們可以使用資源有序分配法修改上面的例子，其中我們保持 createThreadA 方法，不變，createThreadB 代碼修改為： ~~~ private static Thread createThreadB() { Thread threadB = new Thread(() -> { //3.1 嘗試獲取資源 A synchronized (resourceA) { System.out.println(Thread.currentThread() + " got ResourceA"); //3.2 休眠 1s try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread() + "waiting get ResourceB"); //3.3 嘗試獲取資源 B synchronized (resourceB) { System.out.println(Thread.currentThread() + "got ResourceB"); } } }, "ThreadB"); return threadB; } ~~~ 你可以看到，代碼 ThreadA 是先嘗試獲取 ResourceA，然后嘗試獲取資源 ResourceB；ThreadB 則也是先嘗試獲取 ResourceA，然后嘗試獲取資源 ResourceB，符合資源有序分配的原則。然后運行剛才那段代碼，一個可能的輸出結果是這樣的： ~~~ Thread[ThreadA,5,main] got ResourceA Thread[ThreadA,5,main]waiting get ResourceB Thread[ThreadA,5,main]got ResourceB Thread[ThreadB,5,main] got ResourceA Thread[ThreadB,5,main]waiting get ResourceB Thread[ThreadB,5,main]got ResourceB ~~~ 我們可以看到 ThreadA 先后獲取到資源 ResourceA 和 ResourceB，然后線程 B 也先后獲取到資源 ResourceA 和 ResourceB，最后程序正常終止運行，就不會出現死鎖現象。好了，關于線程死鎖問題的產生與避免，我們今天就講到這里。簡單來說，死鎖問題的產生是由兩個或兩個以上線程并行執行的時候，爭奪資源而互相等待造成的。死鎖只有同時滿足互斥、持有并等待、不可剝奪、環路等待這四個條件的時候才會發生，所以要避免死鎖問題，最簡單的辦法就是用資源有序分配法來破壞循環等待條件。在日常開發環境中，死鎖問題的發生還是比較常見的，比如批量更新數據庫時，如果不在插入前使用資源有序分配法對批量數據根據唯一鍵排序，也會發生死鎖現象的。所以，建議你在開發過程中，要有多線程并發的思維，從并發的角度去思考，再結合資源有序分配原則，就可以大大避免死鎖問題的發生。