Java:当线程等待对象时,是否释放所有监视器?

发布于 2024-11-14 16:14:36 字数 419 浏览 2 评论 0原文

在线程可以等待对象之前,它必须获取该对象的监视器。然后释放监视器,并且线程在唤醒后尝试重新获取它。

但是,当线程调用 wait 时,该线程持有的其他监视器会发生什么情况?

考虑这个例子:

   Object a = // ...
   Object b = // ...

   synchronized(a)
   {
       synchronized(b)
       {
           b.wait();
           // continue
       }
   }

当线程调用b.wait()时,它会释放ab两者上的锁吗? code>,还是只有 b

Before a thread can wait on an object, it has to acquire a monitor on that object. The monitor is then released, and the thread attempts to re-acquired it once it awakes.

But what happens to other monitors the thread holds when it calls wait?

Consider this example:

   Object a = // ...
   Object b = // ...

   synchronized(a)
   {
       synchronized(b)
       {
           b.wait();
           // continue
       }
   }

When the thread calls b.wait(), will it release the locks on both a and b, or only b?

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(3

情绪少女 2024-11-21 16:14:36

只有b

此类问题的权威来源是 Java 语言规范。本例中的相关部分是 17.8 等待集和通知< /a>:

设线程t为在对象m上执行wait方法的线程,并设ntm 执行的锁定操作数尚未与解锁操作匹配。发生以下操作之一。

  • [...]
  • 否则,将发生以下序列:

    1. 线程t被添加到对象m的等待集中,并在m<上执行n个解锁操作/em>
    2. [...]


Only b.

The authoritarian source for these type of questions is the Java Language Specification. The relevant section in this case is 17.8 Wait Sets and Notification:

Let thread t be the thread executing the wait method on object m, and let n be the number of lock actions by t on m that have not been matched by unlock actions. One of the following actions occurs.

  • [...]
  • Otherwise, the following sequence occurs:

    1. Thread t is added to the wait set of object m, and performs n unlock actions on m.
    2. [...]
○闲身 2024-11-21 16:14:36

来自对象类:

当前线程必须拥有该线程
对象的监视器。线程释放
此监视器的所有权并等待
直到另一个线程通知线程
等待该对象的监视器
通过调用唤醒
通知方法或notifyAll方法。
然后线程等待,直到它可以
重新获得监视器的所有权并
恢复执行。

因此,调用 b.wait() 仅释放 b 上的锁。

From the Java API documentation of the Object class:

The current thread must own this
object's monitor. The thread releases
ownership of this monitor and waits
until another thread notifies threads
waiting on this object's monitor to
wake up either through a call to the
notify method or the notifyAll method.
The thread then waits until it can
re-obtain ownership of the monitor and
resumes execution.

So, calling b.wait() releases the lock on b only.

执手闯天涯 2024-11-21 16:14:36

仅据我所知 b.这是僵局的典型根源。

AFAIK only b. It's a classic source of deadlocks.

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文