Object.wait()

<span style="font-size:18px;">package JUC;/** * Causes the current thread to wait until either another thread invokes the  * {@link java.lang.Object#notify()} method or the  * {@link java.lang.Object#notifyAll()} method for this object, or a  * specified amount of time has elapsed.  * <Translate> * 引起当前线程等待阻塞直到其他线程调用  notify()方法或者notifyAll()方法，或者等待了足够长的时间 * <p> * The current thread must own this object's monitor. * <Translate> * 当前线程必须持有该对象的监视器  * <p> * This method causes the current thread (call it <var>T</var>) to  * place itself in the wait set for this object and then to relinquish  * any and all synchronization claims on this object. Thread <var>T</var>  * becomes disabled for thread scheduling purposes and lies dormant  * until one of four things happens: * <Translate> * 该方法引起当前线程 T 将自己放置在 该对象的 wait 集合中,并让出线程 T 在该对象上的所有锁。 * 线程 T 变为非就绪状态并保持睡眠状态,直到以下四种情况中的一种发生： * <ul> * <li>Some other thread invokes the <tt>notify</tt> method for this  * object and thread <var>T</var> happens to be arbitrarily chosen as  * the thread to be awakened.  * <li>Some other thread invokes the <tt>notifyAll</tt> method for this  * object.  * <li>Some other thread {@linkplain Thread#interrupt() interrupts}  * thread <var>T</var>.  * <li>The specified amount of real time has elapsed, more or less.  If  * <tt>timeout</tt> is zero, however, then real time is not taken into  * consideration and the thread simply waits until notified. * <Translate> * 1.其他线程调用了该对象的 notify() 方法，而且线程 T 碰巧被任意的（随机的）选择为被唤醒的线程； * 2.其他线程调用了该对象的 notifyAll() 方法； * 3.其他线程打断了(interrupt) 线程 T； * 4.线程 T 等待了几乎等于(timeout)的时间。如果 wait(timeout)  timeout=0,则， * 实际等待的时间被忽略，线程 T 就简单等待着，直到被唤醒(notified)。  * </ul> * The thread <var>T</var> is then removed from the wait set for this  * object and re-enabled for thread scheduling. It then competes in the  * usual manner with other threads for the right to synchronize on the  * object; once it has gained control of the object, all its  * synchronization claims on the object are restored to the status quo  * ante - that is, to the situation as of the time that the <tt>wait</tt>  * method was invoked. Thread <var>T</var> then returns from the  * invocation of the <tt>wait</tt> method. Thus, on return from the  * <tt>wait</tt> method, the synchronization state of the object and of  * thread <tt>T</tt> is exactly as it was when the <tt>wait</tt> method  * was invoked.  * <Translate> * 以上几种情况的其中一种发生之后，线程 T 从 该对象的 wait set（等待集合）中删除，并重新变为就绪状态（enable for thread scheduling）.  * 其次，该线程变得和其他拥有该对象锁的线程一样按照通常的方式完成。 * 一旦，线程 T 获取到了该对象的控制权（锁），该线程上所有基于该对象（锁）的同步被重新赋予 * quoante 状态，该状态是指 wait() 方法被调用时的环境状态。 * 最后，线程 T  从 wait() 方法调用中返回；从wait()方法返回之后，该对象上的同步状态 * 以及该线程的同步状态变回和wait()方法调用之前的一模一样。 * <p> * A thread can also wake up without being notified, interrupted, or * timing out, a so-called <i>spurious wakeup</i>.  While this will rarely * occur in practice, applications must guard against it by testing for * the condition that should have caused the thread to be awakened, and * continuing to wait if the condition is not satisfied.  In other words, * waits should always occur in loops, like this one: * <pre> *     synchronized (obj) { *         while (<condition does not hold>) *             obj.wait(timeout); *         ... // Perform action appropriate to condition *     } * </pre> *<Translate> *线程除了可以通过 notified, interrupted,timing out被唤醒还可以通过一种称为(spurious wakeup) *假装唤醒的方式被唤醒。 *这种情况在实际应用中很少出现，应用中必须通过测试线程被唤醒的环境是否满足，否则就继续等待； *换句话说，就是 wait 应该永远出现在loops中，就像下面这种； * synchronized (obj) { *         while (<condition does not hold>) *             obj.wait(timeout); *         ... // Perform action appropriate to condition *     } *  * (For more information on this topic, see Section 3.2.3 in Doug Lea's * "Concurrent Programming in Java (Second Edition)" (Addison-Wesley, * 2000), or Item 50 in Joshua Bloch's "Effective Java Programming * Language Guide" (Addison-Wesley, 2001). * * <p>If the current thread is {@linkplain java.lang.Thread#interrupt() * interrupted} by any thread before or while it is waiting, then an * <tt>InterruptedException</tt> is thrown.  This exception is not * thrown until the lock status of this object has been restored as * described above. *<Translate> *如果当前线程在 wait() 之前或者 wait() 过程中被其他线程打断(interrupted); *则，一个 InterruptedException 会被抛出 *这个异常不会抛出直到该对象的锁状态被重置为上述描述的情况。 * <p> * Note that the <tt>wait</tt> method, as it places the current thread  * into the wait set for this object, unlocks only this object; any  * other objects on which the current thread may be synchronized remain  * locked while the thread waits. * <p> * This method should only be called by a thread that is the owner  * of this object's monitor. See the <code>notify</code> method for a  * description of the ways in which a thread can become the owner of  * a monitor.  *<Translate> *注意： wait() 方法将当前进程放置到该对象的 wait set 中，该进程只会放弃在该对象上 的锁，该进程在其他对象上的锁保持不变。 *该方法应该只被拥有该对象的监视器(monitor)调用，一个线程可以通过哪几种方法成为一个monitor的描述在 notify() 方法中。 * * @param      timeout   the maximum time to wait in milliseconds. * @exception  IllegalArgumentException      if the value of timeout is *     negative. * @exception  IllegalMonitorStateException  if the current thread is not *               the owner of the object's monitor. * @exception  InterruptedException if any thread interrupted the *             current thread before or while the current thread *             was waiting for a notification.  The <i>interrupted *             status</i> of the current thread is cleared when *             this exception is thrown. * @see        java.lang.Object#notify() * @see        java.lang.Object#notifyAll() */public final native void wait(long timeout) throws InterruptedException;</span>