Java线程转储：“等待锁定”和“停车等待”之间的区别？答案

【问题标题】：Java thread dump: Difference between "waiting to lock" and "parking to wait for"?Java线程转储：“等待锁定”和“停车等待”之间的区别？
【发布时间】：2012-07-05 10:44:26
【问题描述】：

在 Java 线程转储中，您可以看到堆栈跟踪中提到的锁。
似乎有三种信息：

1：

- locked <0x00002aab329f7fa0> (a java.io.BufferedInputStream)

2：

- waiting to lock <0x00002aaaf4ff6fa0> (a org.alfresco.repo.lock.LockServiceImpl)

3：

- parking to wait for  <0x00002aaafbf70bb8> (a java.util.concurrent.SynchronousQueue$TransferStack)

1：线程已获得对象 0x00002aab329f7fa0 上的锁定。
2&3：似乎是说线程正在等待所述对象上的锁可用...
但是 2 和 3 有什么区别？

【问题讨论】：

我问是因为我正在尝试修复这个有前途的开源锁可视化工具：gist.github.com/3039126

标签： java multithreading locking jvm thread-dump

【解决方案1】：

在使用内部锁时，您将在线程转储中获得“等待锁定”，而在使用来自 java.util.concurrent 的锁时，您将获得“停车等待”。考虑以下示例：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockTest {

    final Lock lock = new ReentrantLock(true);

    synchronized void intrinsicLock() {
        Thread th = new Thread(new Runnable() {
            public void run() {
                intrinsicLock();
            }
        }, "My thread");
        th.start();
        try {
            th.join();
        } catch (InterruptedException e) {
        }
    }

    void reentrantLock() {
        lock.lock();
        Thread th = new Thread(new Runnable() {
            public void run() {
                reentrantLock();
            }
        }, "My thread");
        th.start();
        try {
            th.join();
        } catch (InterruptedException e) {
        }
        lock.unlock();
    }


    public static void main(String[] args) {
        LockTest lockTest = new LockTest();
        lockTest.intrinsicLock();
        //lockTest.reentrantLock();
    }

}

使用lockTest.intrinsicLock()，您将获得以下线程转储：

"My thread" prio=10 tid=0x00007fffec015800 nid=0x1775 waiting for monitor entry [0x00007ffff15e5000]
   java.lang.Thread.State: BLOCKED (on object monitor)
    at LockTest.intrinsicLock(LockTest.java:9)
    - waiting to lock <0x00000007d6a33b10> (a LockTest)
    at LockTest$1.run(LockTest.java:11)
    at java.lang.Thread.run(Thread.java:662)

lockTest.reentrantLock() 产生：

"My thread" prio=10 tid=0x00007fffec082800 nid=0x17e8 waiting on condition [0x00007ffff14eb000]
   java.lang.Thread.State: WAITING (parking)
    at sun.misc.Unsafe.park(Native Method)
    - parking to wait for  <0x00000007d6a33d30> (a java.util.concurrent.locks.ReentrantLock$FairSync)
    at java.util.concurrent.locks.LockSupport.park(LockSupport.java:156)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:811)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(AbstractQueuedSynchronizer.java:842)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(AbstractQueuedSynchronizer.java:1178)
    at java.util.concurrent.locks.ReentrantLock$FairSync.lock(ReentrantLock.java:201)
    at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:262)
    at LockTest.reentrantLock(LockTest.java:22)
    at LockTest$2.run(LockTest.java:25)
    at java.lang.Thread.run(Thread.java:662)

【讨论】：

这两个州的“区别”是什么？

【解决方案2】：

在我看来，java.util.concurrent 包几乎都是使用 LockSupport.park() 方法来阻塞线程，例如属于抽象队列同步框架的 CountDownLatch、ReentrantLock。因此，您问题中的第 3 个场景意味着您的代码最终调用 LockSupport.park() 方法，因为您使用 java.util.concurrent 包中的并发类，第 2 个场景意味着您使用同步密钥并显式调用 wait() 方法。

【讨论】：