併發程式設計之死鎖解析

莫那·魯道發表於2019-03-01
程式設計
併發程式設計之死鎖解析

前言

在 Java 的併發程式設計中，有一個問題需要特別注意，那就是死鎖，如果發生了死鎖，基本就是重啟，而重啟將會丟失執行中的資料。所以，瞭解死鎖的形成並排查死鎖到預防死鎖成了一個重要的問題。

我們瞭解任何一個事情的步驟是：what，how，why，why not。

1. 什麼是死鎖？

我們還是直接寫一段程式碼來看看：

package hello;

public class DeadLock {

  public static void main(String[] args) {

    new Thread(() -> {
      try {
         new DeadLock().resource1();
      } catch (InterruptedException e) {
      }
    }
    ).start();

    new Thread(() -> {
      try {
         new DeadLock().resource2();
      } catch (InterruptedException e) {
      }
    }
    ).start();
  }

  void resource1() throws InterruptedException {

    synchronized ("resource1") {
      System.out.println("獲取資源1");
       // 等待 1 秒讓另一個執行緒拿到鎖
      Thread.sleep(1000);
      resource2();
    }


  }

  void resource2() throws InterruptedException {
    synchronized ("resource2") {
      System.out.println("獲取資源2");
      // 等待 1 秒讓另一個執行緒拿到鎖
      Thread.sleep(1000);
      resource1();
    }
  }
}


複製程式碼

上面的程式碼中，我們啟用了兩個執行緒，分別搶佔2個資源，但這兩個資源又分別被不同的物件（字串）鎖住了。當第一個執行緒呼叫 resource1 方法，進入同步塊，拿到鎖，並等待 1 秒鐘讓另一個執行緒進入 resource2 同步塊，當第二個執行緒進入同步塊後，注意：此時， 拿著 resourec1 鎖的執行緒企圖拿到 resource2 的鎖，但這個時候，拿著 resource2 的執行緒也想去拿 resource1 的鎖。於是就出現了互相僵持的情況，誰也無法拿到對方的鎖，整個系統就卡死了。

這種情況就是死鎖。

像我們現在寫的程式碼是自己故意造出來的死鎖，我們能夠發現，那如果是線上環境怎麼辦，假如我們的系統卡死了，我們怎麼知道到底是哪一段程式碼出現了問題，有沒有可能使死鎖的問題。也就是如何檢測死鎖。

2. 如何檢測死鎖？

由於死鎖極難通過人工的方式查出來，因此JDK 提供了命令來檢測某個java程式中心執行緒的情況，並排查有沒有死鎖。上面命令呢？ jps , 用來檢視java 程式的程式號，當然在 Linux 中也可以通過別的方式獲取， jstack 程式號命令則可以答應對應程式的棧資訊，並找到死鎖。

我們就剛剛的程式，在 windows 上使用該命令。

C:Usersstateis0>jps
11060
2084 Launcher
10712 RemoteMavenServer
18040 Jps
11820 DeadLock





C:Usersstateis0>jstack 11820
2017-12-29 18:52:38
Full thread dump Java HotSpot(TM) Client VM (25.131-b11 mixed mode):

"DestroyJavaVM" #11 prio=5 os_prio=0 tid=0x051fe800 nid=0x1e0c waiting on condition [0x00000000]
   java.lang.Thread.State: RUNNABLE

"Thread-1" #10 prio=5 os_prio=0 tid=0x18777800 nid=0x5664 waiting for monitor entry [0x18e0f000]
   java.lang.Thread.State: BLOCKED (on object monitor)
        at hello.DeadLock.resource1(DeadLock.java:31)
        - waiting to lock <0x07415a50> (a java.lang.String)
        at hello.DeadLock.resource2(DeadLock.java:43)
        - locked <0x0742bd18> (a java.lang.String)
        at hello.DeadLock.lambda$main$1(DeadLock.java:20)
        at hello.DeadLock$$Lambda$2/4983748.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:748)

"Thread-0" #9 prio=5 os_prio=0 tid=0x18776c00 nid=0x4dc4 waiting for monitor entry [0x18d7f000]
   java.lang.Thread.State: BLOCKED (on object monitor)
        at hello.DeadLock.resource2(DeadLock.java:41)
        - waiting to lock <0x0742bd18> (a java.lang.String)
        at hello.DeadLock.resource1(DeadLock.java:33)
        - locked <0x07415a50> (a java.lang.String)
        at hello.DeadLock.lambda$main$0(DeadLock.java:11)
        at hello.DeadLock$$Lambda$1/5592464.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:748)

"Service Thread" #8 daemon prio=9 os_prio=0 tid=0x186e4c00 nid=0x172c runnable [0x00000000]
   java.lang.Thread.State: RUNNABLE

"C1 CompilerThread0" #7 daemon prio=9 os_prio=2 tid=0x186af000 nid=0x53f8 waiting on condition [0x00000000]
   java.lang.Thread.State: RUNNABLE

"Monitor Ctrl-Break" #6 daemon prio=5 os_prio=0 tid=0x1861e800 nid=0x3928 runnable [0x18b3f000]
   java.lang.Thread.State: RUNNABLE
        at java.net.SocketInputStream.socketRead0(Native Method)
        at java.net.SocketInputStream.socketRead(SocketInputStream.java:116)
        at java.net.SocketInputStream.read(SocketInputStream.java:171)
        at java.net.SocketInputStream.read(SocketInputStream.java:141)
        at sun.nio.cs.StreamDecoder.readBytes(StreamDecoder.java:284)
        at sun.nio.cs.StreamDecoder.implRead(StreamDecoder.java:326)
        at sun.nio.cs.StreamDecoder.read(StreamDecoder.java:178)
        - locked <0x07861da0> (a java.io.InputStreamReader)
        at java.io.InputStreamReader.read(InputStreamReader.java:184)
        at java.io.BufferedReader.fill(BufferedReader.java:161)
        at java.io.BufferedReader.readLine(BufferedReader.java:324)
        - locked <0x07861da0> (a java.io.InputStreamReader)
        at java.io.BufferedReader.readLine(BufferedReader.java:389)
        at com.intellij.rt.execution.application.AppMainV2$1.run(AppMainV2.java:64)

"Attach Listener" #5 daemon prio=5 os_prio=2 tid=0x179c0800 nid=0x40a0 waiting on condition [0x00000000]
   java.lang.Thread.State: RUNNABLE

"Signal Dispatcher" #4 daemon prio=9 os_prio=2 tid=0x17985c00 nid=0x5004 runnable [0x00000000]
   java.lang.Thread.State: RUNNABLE

"Finalizer" #3 daemon prio=8 os_prio=1 tid=0x17972400 nid=0x41a8 in Object.wait() [0x17cff000]
   java.lang.Thread.State: WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        - waiting on <0x0ca1b830> (a java.lang.ref.ReferenceQueue$Lock)
        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:143)
        - locked <0x0ca1b830> (a java.lang.ref.ReferenceQueue$Lock)
        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:164)
        at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:209)

"Reference Handler" #2 daemon prio=10 os_prio=2 tid=0x17960000 nid=0x4ef0 in Object.wait() [0x17c6f000]
   java.lang.Thread.State: WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        - waiting on <0x0ca1b9d0> (a java.lang.ref.Reference$Lock)
        at java.lang.Object.wait(Object.java:502)
        at java.lang.ref.Reference.tryHandlePending(Reference.java:191)
        - locked <0x0ca1b9d0> (a java.lang.ref.Reference$Lock)
        at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:153)

"VM Thread" os_prio=2 tid=0x1795a800 nid=0x3f54 runnable

"VM Periodic Task Thread" os_prio=2 tid=0x18739400 nid=0x4a14 waiting on condition

JNI global references: 229

// 找到一個死鎖
Found one Java-level deadlock:
=============================
"Thread-1":
  waiting to lock monitor 0x17978de4 (object 0x07415a50, a java.lang.String),
  which is held by "Thread-0"
"Thread-0":
  waiting to lock monitor 0x1797a974 (object 0x0742bd18, a java.lang.String),
  which is held by "Thread-1"

Java stack information for the threads listed above:
===================================================
"Thread-1":
        at hello.DeadLock.resource1(DeadLock.java:31)
         // 等待 0x07415a50 鎖
        - waiting to lock <0x07415a50> (a java.lang.String)
        at hello.DeadLock.resource2(DeadLock.java:43)
        // 持有 0x0742bd18
        - locked <0x0742bd18> (a java.lang.String)
        at hello.DeadLock.lambda$main$1(DeadLock.java:20)
        at hello.DeadLock$$Lambda$2/4983748.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:748)
"Thread-0":
        at hello.DeadLock.resource2(DeadLock.java:41)
        // 等待 0x0742bd18 鎖
        - waiting to lock <0x0742bd18> (a java.lang.String)
        at hello.DeadLock.resource1(DeadLock.java:33)
        // 持有 0x07415a50
        - locked <0x07415a50> (a java.lang.String)
        at hello.DeadLock.lambda$main$0(DeadLock.java:11)
        at hello.DeadLock$$Lambda$1/5592464.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:748)

// 發現了一個死鎖
Found 1 deadlock.


C:Usersstateis0>
複製程式碼

Thread-1 waiting to lock <0x07415a50> locked <0x0742bd18>
Thread-0 waiting to lock <0x0742bd18> locked <0x07415a50>

我們首先使用 jps 命令找到 java 程式號，然後使用 jstack 程式號 列印程式棧的資訊，其中，在最後的部分，jstack 告訴我們，他找到了一個死鎖，其中又詳細的資訊：Thread-1 執行緒（這裡我們沒有給執行緒其合適的名字，如果線上上，給執行緒起一個合適的名字將更有利於排查）持有 String 型別的編號為 0x07415a50 的鎖，等待編號為 0x07415a50 的鎖 ， 但這個鎖由 Thread-0 持有，於此同時，Thread-0 和 Thread-1 相反。Thread-0 執行緒持有 0x07415a50 的鎖，等待 0x07415a50 的鎖。我們的註釋裡也寫上了。

那麼發生了死鎖，該怎麼辦呢？最簡單的辦法就是重啟，重啟之後，對 jstack 中列印的堆疊資訊中的程式碼進行修改。重新發布。當然還有一些高階策略，比如讓程式回滾到死鎖前的狀態，然後讓他們順序進入同步塊。

3. 死鎖有哪些形成的原因

一般來說，要出現死鎖問題需要滿足以下條件：

  1. 互斥條件：一個資源每次只能被一個執行緒使用。

  2. 請求與保持條件：一個程式因請求資源而阻塞時，對已獲得的資源保持不放。

  3. 不剝奪條件：程式已獲得的資源，在未使用完之前，不能強行剝奪。

  4. 迴圈等待條件：若干程式之間形成一種頭尾相接的迴圈等待資源關係。

死鎖是由四個必要條件導致的，所以一般來說，只要破壞這四個必要條件中的一個條件，死鎖情況就應該不會發生。

如果想要打破互斥條件，我們需要允許程式同時訪問某些資源，這種方法受制於實際場景，不太容易實現條件；

打破不可搶佔條件，這樣需要允許程式強行從佔有者那裡奪取某些資源，或者簡單一點理解，佔有資源的程式不能再申請佔有其他資源，必須釋放手上的資源之後才能發起申請，這個其實也很難找到適用場景；

程式在執行前申請得到所有的資源，否則該程式不能進入準備執行狀態。這個方法看似有點用處，但是它的缺點是可能導致資源利用率和程式併發性降低；

避免出現資源申請環路，即對資源事先分類編號，按號分配。這種方式可以有效提高資源的利用率和系統吞吐量，但是增加了系統開銷，增大了程式對資源的佔用時間。

4 總結

併發程式設計中的坑很多，尤其死鎖，造成的問題基本只能靠重啟來解決，如果遇到了資料儲存在記憶體中但沒有持久化的話，那麼重啟將出現很大的問題。因此我們在用鎖的時候，一定要小心。避免出現死鎖，如果出現了死鎖，則可以使用 jstack 命令檢視執行緒是否有死鎖。用以排查問題。

總之併發的坑很多，樓主以後將會多多分析。

good luck ！！！！

相關文章