/** * Causes 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. * * <p>The current thread must own this object's monitor. * * <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: * * <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>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. * </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. * * <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. * * @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 another thread has interrupted the current thread. 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 void wait(long timeout) throws InterruptedException { if (timeout < 0) { throw new IllegalArgumentException(/*"timeout value is negative"*/ ); } com.sun.squawk.VMThread.monitorWait(this, timeout); }