wait, notify, notifyAll and synchronized --

最新推荐文章于 2025-05-10 03:05:43 发布

转载最新推荐文章于 2025-05-10 03:05:43 发布 · 71 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://my.oschina.net/digerl/blog/33345

本文深入解析了Java中Object.notify()方法的作用及其与线程状态的关系，包括唤醒线程、运行状态和阻塞状态之间的转换，以及notify()与notifyAll()的区别和应用场景。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

为什么80%的码农都做不了架构师？>>>

Object.notify()的API是这样的：

Object.notify

Class Overview | Class Members | This Package | All Packages

Syntax

public final native void notify()

Description

Wakes up a single thread that is waiting on this object's monitor. A thread waits on an object's monitor by calling one of the wait methods.

This method should only be called by a thread that is the owner of this object's monitor. A thread becomes the owner of the object's monitor in one of three ways:

By executing a synchronized instance method of that object.
By executing the body of a synchronized statement that synchronizes on the object.
For objects of type Class, by executing a synchronized static method of that class.

Only one thread at a time can own an object's monitor.

Exceptions

IllegalMonitorStateException if the current thread is not the owner of this object's monitor.

one thought: set the threads to runnable state, thusly they got a chance to be scheduled to RUN, thusly they got a chance to acquire the lock. This way, you got a chance to choose between awake one thread or all threads. Because no one knows which is better. Because obviously there's at most one thread can get the lock. Because there's only one lock(monitor)! The only difference is that in case you choose to awake all threads, that'll cause a competition for the LOCK. But generally, either way you choosed, there's always competition. In case for notify, you choose to let the competition happen in blocking state. in another case, you let the competition happen in running state.

So for those people who has ever said that notifyAll is better than notify, I did't see any proof yet!

For wait, wait is just designed for working together with notify and notifyAll. wait() put the threads into the waiting queue, and notify, notifyAll get them out of the queue(notify can get one thread out of the queue, notifyAll can be all threads out of the queue, and, of course, put them into a new competition for the object lock).

For synchronized, there's nothing to do with the waiting status. so it also has nothing to do with the lock object's waiting queue. it just put the threads into the runnable state(or do nothing, just keep looping for trying to acquire the lock) so that they can be scheduled anytime for resume, maybe keep looping for acquiring the lock, maybe continue the inside part of the synchronized block after acquired the lock.

转载于:https://my.oschina.net/digerl/blog/33345