java wait源码_mybatis 源码系列(八) Java基础之wait()、notify()、notifyAll()方法

/**

* Causes the current thread to wait until another thread invokes the

* {@link java.lang.Object#notify()} method or the

* {@link java.lang.Object#notifyAll()} method for this object.

* In other words, this method behaves exactly as if it simply

* performs the call {@code wait(0)}.

*

* 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 {@code notify} method or the

* {@code notifyAll} method. The thread then waits until it can

* re-obtain ownership of the monitor and resumes execution.

*

* As in the one argument version, interrupts and spurious wakeups are

* possible, and this method should always be used in a loop:

*

* synchronized (obj) {

* while (<condition does not hold>)

* obj.wait();

* ... // Perform action appropriate to condition

* }

*

* This method should only be called by a thread that is the owner

* of this object's monitor. See the {@code notify} method for a

* description of the ways in which a thread can become the owner of

* a monitor.

*

* @throws IllegalMonitorStateException if the current thread is not

* the owner of the object's monitor.

* @throws InterruptedException if any thread interrupted the

* current thread before or while the current thread

* was waiting for a notification. The interrupted

* status of the current thread is cleared when

* this exception is thrown.

* @see java.lang.Object#notify()

* @see java.lang.Object#notifyAll()

*/

public final void wait() throws InterruptedException {

wait(0);

}

/**

* Wakes up a single thread that is waiting on this object's

* monitor. If any threads are waiting on this object, one of them

* is chosen to be awakened. The choice is arbitrary and occurs at

* the discretion of the implementation. A thread waits on an object's

* monitor by calling one of the {@code wait} methods.

*

* The awakened thread will not be able to proceed until the current

* thread relinquishes the lock on this object. The awakened thread will

* compete in the usual manner with any other threads that might be

* actively competing to synchronize on this object; for example, the

* awakened thread enjoys no reliable privilege or disadvantage in being

* the next thread to lock this object.

*

* 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 {@code synchronized} statement

* that synchronizes on the object.

*

For objects of type {@code Class,} by executing a

* synchronized static method of that class.

*

*

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

*

* @throws IllegalMonitorStateException if the current thread is not

* the owner of this object's monitor.

* @see java.lang.Object#notifyAll()

* @see java.lang.Object#wait()

*/

public final native void notify();