檢查死鎖與Locked ownable synchronizers(轉載)

經過jstack可快速檢查線程的死鎖信息，用法以下：

# 獲取JVM ID(JAVA 進程ID)，經過參數lv能夠獲取更詳細的JAVA方法調用信息 jps -lv # 獲得JVM ID後，執行jstack命令，這裏假定爲123 # 將結果重定向到文件，更便於查看 jstack -l 123 >> d:/123.txt

• 1
• 2
• 3
• 4
• 5

翻到頁底，可發現明顯的死鎖信息：

Java stack information for the threads listed above:
===================================================
"Thread-1": at com.mirana.concurrent.LockedOwnThread.run(LockedOwnThread.java:47) - waiting to lock <0x000000076c5806f8> (a java.lang.Class for java.lang.Object) - locked <0x000000076c636568> (a java.lang.Class for com.mirana.concurrent.LockedOwnThread) - locked <0x000000076c6392f0> (a com.mirana.concurrent.LockedOwnThread) "Thread-0": at com.mirana.concurrent.LockedOwnThread$AThread.run(LockedOwnThread.java:27) - waiting to lock <0x000000076c636568> (a java.lang.Class for com.mirana.concurrent.LockedOwnThread) - locked <0x000000076c5806f8> (a java.lang.Class for java.lang.Object) Found 1 deadlock.

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

從輸出信息中，可明顯發覺兩個線程彼此鎖定了對方須要的鎖（0x000000076c636568與0x000000076c5806f8）。

在打印的堆棧信息中，咱們還發現了以下信息：

"Thread-0" #11 prio=5 os_prio=0 tid=0x000000001e902000 nid=0x5b34c waiting for monitor entry [0x000000001f5bf000] java.lang.Thread.State: BLOCKED (on object monitor) at com.mirana.concurrent.LockedOwnThread$AThread.run(LockedOwnThread.java:27) - waiting to lock <0x000000076c636538> (a java.lang.Class for com.mirana.concurrent.LockedOwnThread) - locked <0x000000076c5806f8> (a java.lang.Class for java.lang.Object) Locked ownable synchronizers: - None

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

Locked ownable synchronizers是個什麼東東？按照官方定義

一個可持有的同步器多半是線程獨有而且使用了AbstractOwnableSynchronizer(或是其子類)去實現它的同步特性，ReentrantLock與ReentrantReadWriteLock就是JAVA平臺提供的兩個例子。

咱們將程序改成以下形式，依舊爲死鎖形式：
```java
static class AThread extends Thread { private ReentrantLock lock1; private ReentrantLock lock2; /** * @param lock1 * @param lock2 */ public AThread(ReentrantLock lock1, ReentrantLock lock2) { super(); this.lock1 = lock1; this.lock2 = lock2; } public void run() { try { lock1.lock(); Thread.sleep(3000); // 必須獲取兩個鎖後才執行操做 lock2.lock(); System.out.println("A: I have all Locks!"); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock2.unlock(); lock1.unlock(); } } } static class BThread extends Thread { private ReentrantLock lock1; private ReentrantLock lock2; /** * @param lock1 * @param lock2 */ public BThread(ReentrantLock lock1, ReentrantLock lock2) { super(); this.lock1 = lock1; this.lock2 = lock2; } public void run() { try { lock2.lock(); Thread.sleep(1000); // 必須獲取兩個鎖後才執行操做 lock1.lock(); System.out.println("B: I have all Locks!"); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock1.unlock(); lock2.unlock(); } } } // 測試程序主函數 public static void main(String[] args) throws InterruptedException { final ReentrantLock lock1 = new ReentrantLock(); final ReentrantLock lock2 = new ReentrantLock(); new AThread(lock1, lock2).start(); new BThread(lock1, lock2).start(); } <div class="se-preview-section-delimiter"></div> 

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76
• 77
• 78
• 79
• 80
• 81
• 82
• 83
• 84
• 85

最後打印線程的堆棧信息，出現的內容以下：

"Thread-1" #12 prio=5 os_prio=0 tid=0x000000001ef5a000 nid=0x1c2c waiting on condition [0x000000001fcbf000] java.lang.Thread.State: WAITING (parking) at sun.misc.Unsafe.park(Native Method) - parking to wait for <0x000000076c637ca0> (a java.util.concurrent.locks.ReentrantLock$NonfairSync) at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175) at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:836) at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(AbstractQueuedSynchronizer.java:870) at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(AbstractQueuedSynchronizer.java:1199) at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLock.java:209) at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285) at com.mirana.concurrent.LockedOwnThread$BThread.run(LockedOwnThread.java:70) Locked ownable synchronizers: - <0x000000076c637cd0> (a java.util.concurrent.locks.ReentrantLock$NonfairSync)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

發現ReentrantLock與內置鎖有以下3點不一樣： 
1. 等待的對象不一樣，內置鎖是「monitor entry」（監視器進入點），而ReentrantLock是「condition」(條件)； 
2. 線程的狀態不一樣，內置鎖是「BLOCKED」，而ReentrantLock是「WAITING」； 
3. 鎖定的同步器不一樣，內置鎖沒有，而ReentrantLock則指向持有的同步器；

結論

經過jstack可快速檢查到死鎖狀況，並能給出衝突的鎖與監測對象，另外，內置鎖對象與ReentrantLock在運行中表現出大相徑庭的狀態。

 

原文地址：https://blog.csdn.net/yiifaa/article/details/76013837