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.
See Also
.......
quite confusing!
Thread has 3 states: runnable, running, blocked.
'Wakes up ''s meaning is the key point to understand the whole mistery:
Generally, I think 'Waking up' a thread means putting it into the runnable state(thread list... and, of course, from the blocked state).
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.
来源：oschina
链接：https://my.oschina.net/u/109289/blog/33345